mbeditor 0.9.0 → 0.10.0

data/app/assets/javascripts/mbeditor/components/ProblemsPanel.js

@@ -0,0 +1,217 @@
+'use strict';
+
+// ProblemsPanel — bottom drawer listing the diagnostics Monaco is holding for
+// the files you have open: rubocop and ruby-lsp for Ruby, the TypeScript
+// worker's syntax errors for JS/JSX, and anything else that writes markers.
+//
+// Scope is deliberately "open tabs", not the workspace: markers only exist for
+// models Monaco has loaded, so a count over anything wider would be a lie.
+// Closing a tab drops its problems, same as VS Code with an unopened file.
+var ProblemsPanel = (function () {
+  var SEVERITY_ERROR = 8;
+  var SEVERITY_WARNING = 4;
+  // Long enough to recognise the statement, short enough not to push the
+  // location off the end of the row.
+  var CODE_PREVIEW_LIMIT = 120;
+
+  // The offending source line, trimmed, for display beside the message. Markers
+  // can outlive the edit that invalidated them by a frame, so a line number
+  // past the end of the buffer yields nothing rather than throwing.
+  function codePreview(model, lineNumber) {
+    if (!lineNumber || lineNumber < 1 || lineNumber > model.getLineCount()) return '';
+
+    var text = model.getLineContent(lineNumber).trim();
+    return text.length > CODE_PREVIEW_LIMIT ? text.slice(0, CODE_PREVIEW_LIMIT) + '…' : text;
+  }
+
+  // Reading markers means walking every model, so callers that only want the
+  // counts share this one pass. Exposed on the component for the status bar.
+  function collect() {
+    var monaco = window.monaco;
+    if (!monaco || !monaco.editor) return { errors: [], warnings: [], byFile: [] };
+
+    var errors = [];
+    var warnings = [];
+    var byFile = [];
+
+    monaco.editor.getModels().forEach(function (model) {
+      var path = model._mbeditorPath;
+      if (!path || model.isDisposed()) return;
+
+      var markers = monaco.editor.getModelMarkers({ resource: model.uri }).filter(function (m) {
+        return m.severity === SEVERITY_ERROR || m.severity === SEVERITY_WARNING;
+      });
+      if (markers.length === 0) return;
+
+      markers.sort(function (a, b) { return a.startLineNumber - b.startLineNumber; });
+
+      // Carry the source line alongside the marker: read here, while the model
+      // is in hand, rather than looking the model up again at render time.
+      var entries = markers.map(function (m) {
+        (m.severity === SEVERITY_ERROR ? errors : warnings).push(m);
+        return { marker: m, code: codePreview(model, m.startLineNumber) };
+      });
+
+      byFile.push({ path: path, markers: entries });
+    });
+
+    byFile.sort(function (a, b) { return a.path < b.path ? -1 : a.path > b.path ? 1 : 0; });
+    return { errors: errors, warnings: warnings, byFile: byFile };
+  }
+
+  function counts() {
+    var all = collect();
+    return { errors: all.errors.length, warnings: all.warnings.length };
+  }
+
+  var Panel = function ProblemsPanelComponent(_ref) {
+    var onClose = _ref.onClose;
+    var onOpenFile = _ref.onOpenFile;
+
+    var _problems = React.useState(collect);
+    var problems = _problems[0], setProblems = _problems[1];
+    var _filter = React.useState('');
+    var filter = _filter[0], setFilter = _filter[1];
+
+    var MIN_HEIGHT = 120;
+    var _height = React.useState(function () {
+      var saved = parseInt(window.localStorage.getItem('mbeditorProblemsHeight'), 10);
+      return (saved && saved >= MIN_HEIGHT) ? saved : 240;
+    });
+    var height = _height[0], setHeight = _height[1];
+    var heightRef = React.useRef(height);
+    heightRef.current = height;
+
+    // Same delta-based resize as the log drawer.
+    var onResizeMouseDown = function (e) {
+      e.preventDefault();
+      var startY = e.clientY;
+      var startHeight = heightRef.current;
+      var onMove = function (ev) {
+        var vh = window.innerHeight || document.documentElement.clientHeight || 0;
+        var maxH = vh > 0 ? Math.round(vh * 0.85) : Infinity;
+        setHeight(Math.min(maxH, Math.max(MIN_HEIGHT, startHeight + (startY - ev.clientY))));
+      };
+      var onUp = function () {
+        document.removeEventListener('mousemove', onMove);
+        document.removeEventListener('mouseup', onUp);
+        window.localStorage.setItem('mbeditorProblemsHeight', String(heightRef.current));
+      };
+      document.addEventListener('mousemove', onMove);
+      document.addEventListener('mouseup', onUp);
+    };
+
+    React.useEffect(function () {
+      if (!window.monaco || !window.monaco.editor) return;
+      var refresh = function () { setProblems(collect()); };
+      var sub = window.monaco.editor.onDidChangeMarkers(refresh);
+      refresh();
+      return function () { sub.dispose(); };
+    }, []);
+
+    var needle = filter.trim().toLowerCase();
+    var shown = needle
+      ? problems.byFile.map(function (entry) {
+          return {
+            path: entry.path,
+            markers: entry.markers.filter(function (item) {
+              return (item.marker.message + ' ' + item.code + ' ' + entry.path)
+                .toLowerCase().indexOf(needle) !== -1;
+            })
+          };
+        }).filter(function (entry) { return entry.markers.length > 0; })
+      : problems.byFile;
+
+    var total = problems.errors.length + problems.warnings.length;
+
+    return React.createElement(
+      'div',
+      { className: 'ide-problems-drawer', style: { height: height + 'px' } },
+      React.createElement('div', {
+        className: 'ide-problems-resize',
+        title: 'Drag to resize',
+        onMouseDown: onResizeMouseDown
+      }),
+      React.createElement(
+        'div',
+        { className: 'ide-problems-header' },
+        React.createElement('i', { className: 'fas fa-bug' }),
+        React.createElement('span', { className: 'ide-problems-title' }, 'Problems'),
+        React.createElement(
+          'span',
+          { className: 'ide-problems-summary' },
+          problems.errors.length + ' error' + (problems.errors.length === 1 ? '' : 's') +
+            ', ' + problems.warnings.length + ' warning' + (problems.warnings.length === 1 ? '' : 's') +
+            ' in open files'
+        ),
+        React.createElement('input', {
+          className: 'ide-problems-filter',
+          type: 'text',
+          placeholder: 'Filter…',
+          value: filter,
+          onChange: function (e) { setFilter(e.target.value); }
+        }),
+        React.createElement('button', {
+          type: 'button', className: 'ide-problems-btn',
+          title: 'Close', onClick: onClose
+        }, React.createElement('i', { className: 'fas fa-times' }))
+      ),
+      React.createElement(
+        'div',
+        { className: 'ide-problems-body' },
+        total === 0
+          ? React.createElement('div', { className: 'ide-problems-empty' }, 'No problems in the open files')
+          : shown.length === 0
+            ? React.createElement('div', { className: 'ide-problems-empty' }, 'No problems match the filter')
+            : shown.map(function (entry) {
+                return React.createElement(
+                  'div',
+                  { className: 'ide-problems-file', key: entry.path },
+                  React.createElement(
+                    'div',
+                    { className: 'ide-problems-file-name' },
+                    entry.path,
+                    React.createElement('span', { className: 'ide-problems-file-count' }, entry.markers.length)
+                  ),
+                  entry.markers.map(function (item, index) {
+                    var marker = item.marker;
+                    var isError = marker.severity === SEVERITY_ERROR;
+                    return React.createElement(
+                      'button',
+                      {
+                        type: 'button',
+                        className: 'ide-problems-item ide-problems-item-' + (isError ? 'error' : 'warning'),
+                        key: entry.path + ':' + marker.startLineNumber + ':' + index,
+                        'aria-label': (isError ? 'Error' : 'Warning') + ': ' + marker.message +
+                          ', ' + entry.path + ' line ' + marker.startLineNumber +
+                          (item.code ? ', source: ' + item.code : ''),
+                        onClick: function () {
+                          if (onOpenFile) onOpenFile(entry.path, marker.startLineNumber, marker.startColumn);
+                        }
+                      },
+                      React.createElement('i', {
+                        className: 'fas ' + (isError ? 'fa-bug' : 'fa-exclamation-triangle') + ' ide-problems-icon',
+                        'aria-hidden': 'true'
+                      }),
+                      React.createElement('span', { className: 'ide-problems-msg' }, marker.message),
+                      item.code && React.createElement('code', { className: 'ide-problems-code' }, item.code),
+                      marker.source && React.createElement('span', { className: 'ide-problems-source' }, marker.source),
+                      React.createElement(
+                        'span',
+                        { className: 'ide-problems-loc' },
+                        '[' + marker.startLineNumber + ', ' + marker.startColumn + ']'
+                      )
+                    );
+                  })
+                );
+              })
+      )
+    );
+  };
+
+  Panel.collect = collect;
+  Panel.counts = counts;
+  return Panel;
+})();
+
+window.ProblemsPanel = ProblemsPanel;

data/app/assets/javascripts/mbeditor/components/QuickOpenDialog.js

@@ -94,6 +94,20 @@ var QuickOpenDialog = function QuickOpenDialog(_ref) {
     return 50;
   }
 
+  // Recently opened files, most recent first, as a path -> rank lookup. Built
+  // once per query rather than per comparison, since the sort calls this for
+  // every pair.
+  function recentRanks() {
+    var ranks = {};
+    var recent = (typeof TabManager !== 'undefined' && TabManager.getRecentFiles)
+      ? TabManager.getRecentFiles() : [];
+    recent.forEach(function (entry, index) {
+      var path = typeof entry === 'string' ? entry : (entry && entry.path);
+      if (path && !(path in ranks)) ranks[path] = index;
+    });
+    return ranks;
+  }
+
   // Match relevance within a priority tier: exact basename > prefix > substring > other.
   function getMatchRelevance(result, q) {
     if (!q) return 3;
@@ -128,13 +142,30 @@ var QuickOpenDialog = function QuickOpenDialog(_ref) {
     var res = SearchService.searchFiles(query);
     // Filter by type: always include files; include dirs only when showFolders is on
     var filtered = showFolders ? res : res.filter(function(r) { return r.type !== 'dir'; });
-    // Sort: files always beat dirs; within the same tier exact basename > prefix > substring > other.
-    // JS sort is stable in modern engines so MiniSearch relevance score order is the tiebreaker
-    // when match relevance is equal.
+    // Sort, in order of precedence:
+    //   1. match quality — exact basename > prefix > substring > other, so a
+    //      worse match can never jump the queue however recently it was opened
+    //   2. how recently the file was opened, most recent first
+    //   3. the static file-type tier (controller > model > … > noise)
+    //
+    // Recency sits above the type tier deliberately: when two files match a
+    // query equally well, the one you were just working in is almost always
+    // the one you meant, and that beats a guess made from the directory name.
+    // Files never opened all tie here and fall through to the type tier, which
+    // is what orders the bulk of a cold result list.
+    //
+    // Directories keep their +100 penalty inside the type tier so files still
+    // come first. JS sort is stable in modern engines, so MiniSearch's own
+    // relevance order remains the final tiebreaker.
+    var ranks = recentRanks();
+    var NEVER_OPENED = Infinity;
     filtered.sort(function(a, b) {
       var aRelevance = getMatchRelevance(a, query);
       var bRelevance = getMatchRelevance(b, query);
       if (aRelevance !== bRelevance) return aRelevance - bRelevance;
+      var aRecent = a.path in ranks ? ranks[a.path] : NEVER_OPENED;
+      var bRecent = b.path in ranks ? ranks[b.path] : NEVER_OPENED;
+      if (aRecent !== bRecent) return aRecent - bRecent;
       var aPriority = getFilePriority(a.path) + (a.type === 'dir' ? 100 : 0);
       var bPriority = getFilePriority(b.path) + (b.type === 'dir' ? 100 : 0);
       return aPriority - bPriority;

data/app/assets/javascripts/mbeditor/editor_plugins.js

@@ -714,21 +714,11 @@
       monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
         noSemanticValidation: false,
         noSyntaxValidation: false,
-        noSuggestionDiagnostics: false,
-        // JSX/JS here is untyped and frequently reads data whose shape is only
-        // known at runtime (server props, state seeded with `{}`). TypeScript
-        // infers those as type `{}` and flags every property/element access as
-        // an error (2339 "Property X does not exist on type '{}'", 2551 its
-        // "did you mean" variant, 7053 dynamic index access). Suppress that
-        // false-positive family while keeping genuinely useful checks such as
-        // 2304 "Cannot find name" (undefined variables/typos).
-        //
-        // A plain-JS component that reads `props.foo` gives TS no way to know
-        // `foo` is optional, so it infers every referenced prop as REQUIRED and
-        // flags call sites that omit it (2741 "Property X is missing … but
-        // required", 2739 its multi-property form). Since optional props can't
-        // be expressed without JSDoc/TS, suppress that family too.
-        diagnosticCodesToIgnore: [2339, 2551, 7053, 2739, 2741]
+        noSuggestionDiagnostics: false
+        // No diagnosticCodesToIgnore here on purpose: JS/JSX markers are
+        // filtered by category in the marker patcher below (see JS_KEEP_CODES),
+        // which is a closed rule rather than a list that grows by one code
+        // every time a new false positive turns up.
       });
       monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
         target: monaco.languages.typescript.ScriptTarget.ES2020,
@@ -875,28 +865,49 @@
         loadWorkspaceGlobals(monaco);
       });
 
-      // Downgrade certain TypeScript diagnostic codes from Error to Warning.
-      // TypeScript has no built-in way to emit these as warnings, so we intercept
-      // the marker set after the worker fires and re-apply with lower severity.
+      // Patch the TypeScript worker's markers after it fires.
       //
-      // Patch markers after the TypeScript worker fires:
-      // - JS files: downgrade TS2304 ("Cannot find name") to Warning — host-app
-      //   globals injected at runtime are invisible to the language service, so
-      //   hard errors are almost always false positives. Downgrading keeps the
-      //   signal without blocking genuine undefined-variable detection.
-      // - Both: downgrade TS6133 ("declared but never read") from Error to Warning.
-      // - JS/JSX: suppress TS2300 ("Duplicate identifier") — in Sprockets apps all
-      //   open files share a global script context in Monaco's TS worker, so a
-      //   component defined in file_a.jsx looks like a redeclaration when file_b.jsx
-      //   is also open. This is a structural false positive, not a real error.
-      // TS2403 ("Subsequent variable declarations must have the same type")
-      // joins the suppress list because the ambient `declare var Foo: any`
-      // from workspace-globals.d.ts coexists with the real `function Foo()`
-      // when its defining file is open — inherently a false positive in the
-      // shared-global-scope model.
-      var JS_SUPPRESS_CODES = { '2300': true, '2451': true, '2403': true };
-      var JS_WARN_CODES    = { '2304': true, '6133': true };
-      var TS_WARN_CODES    = { '6133': true };
+      // ── JS/JSX: keep only the diagnostics that are sound without types ──────
+      // Plain JS/JSX is untyped, so every *type* diagnostic TypeScript emits is
+      // an inference guess, and which way it guesses is arbitrary: state seeded
+      // with `useState({})` infers `{}` and errors on every key, while the same
+      // object from `JSON.parse` infers `any` and stays silent. Identical code,
+      // opposite verdicts. Denylisting each false-positive code as it turned up
+      // never converged — it reached eight codes and still leaked (2322 on a
+      // spread with an extra prop), because the tail is every code TypeScript
+      // has. So invert it: keep the categories below and drop the rest.
+      //
+      //   • syntax errors — always real. Their codes are 1xxx (and 17xxx for
+      //     the JSX-specific ones, e.g. 17008 "no corresponding closing tag"),
+      //     which is why the ranges rather than a code list are matched.
+      //   • 2304 "Cannot find name" — scope resolution, not type checking.
+      //     Downgraded to Warning below and auto-resolved against the workspace,
+      //     since host-app globals are invisible to the language service.
+      //   • 6133 "declared but never read" — a lint. Downgraded to Warning.
+      //   • anything below Error severity — hints and suggestions render faint
+      //     and cost nothing, so they pass through untouched.
+      //
+      // Deliberately dropped along with the type errors: 2300 "Duplicate
+      // identifier" and 2403 "Subsequent variable declarations…", which are
+      // structural false positives in the Sprockets model — every open file
+      // shares one global script context, so a component in file_a.jsx looks
+      // like a redeclaration once file_b.jsx is open, and the ambient
+      // `declare var Foo: any` from workspace-globals.d.ts collides with the
+      // real `function Foo()` when its defining file is open.
+      //
+      // .ts/.tsx keeps full checking: there the types are hand-written, so a
+      // type error is a statement about code the author actually wrote.
+      var JS_KEEP_CODES  = { '2304': true, '6133': true };
+      var JS_SYNTAX_CODE = /^(?:1\d{3}|17\d{3})$/;
+      var JS_WARN_CODES  = { '2304': true, '6133': true };
+      var TS_WARN_CODES  = { '6133': true };
+
+      function keepJsMarker(marker) {
+        if (marker.severity !== monaco.MarkerSeverity.Error) return true;
+        var code = String(marker.code == null ? '' : marker.code);
+        return JS_KEEP_CODES[code] === true || JS_SYNTAX_CODE.test(code);
+      }
+
       var _severityPatchActive = false;
       monaco.editor.onDidChangeMarkers(function(uris) {
         if (_severityPatchActive) return;
@@ -906,22 +917,23 @@
             var model = monaco.editor.getModel(uri);
             if (!model) return;
             [
-              { owner: 'javascript', suppress: JS_SUPPRESS_CODES, warn: JS_WARN_CODES },
-              { owner: 'typescript', suppress: {},                 warn: TS_WARN_CODES }
+              { owner: 'javascript', keep: keepJsMarker, warn: JS_WARN_CODES },
+              { owner: 'typescript', keep: null,         warn: TS_WARN_CODES }
             ].forEach(function(entry) {
               var markers = monaco.editor.getModelMarkers({ resource: uri, owner: entry.owner });
-              var needsPatch = markers.some(function(m) {
-                var code = String(m.code);
-                return (m.severity === monaco.MarkerSeverity.Error && (entry.suppress[code] || entry.warn[code]));
-              });
-              if (!needsPatch) return;
-              monaco.editor.setModelMarkers(model, entry.owner, markers.filter(function(m) {
-                return !entry.suppress[String(m.code)];
+              var patched = markers.filter(function(m) {
+                return entry.keep ? entry.keep(m) : true;
               }).map(function(m) {
                 return (m.severity === monaco.MarkerSeverity.Error && entry.warn[String(m.code)])
                   ? Object.assign({}, m, { severity: monaco.MarkerSeverity.Warning })
                   : m;
-              }));
+              });
+              // Re-applying an unchanged set would re-enter this handler
+              // forever, so only write when the patch actually changed something.
+              var changed = patched.length !== markers.length || patched.some(function(m, i) {
+                return m.severity !== markers[i].severity;
+              });
+              if (changed) monaco.editor.setModelMarkers(model, entry.owner, patched);
             });
           });
         } finally {
@@ -1370,12 +1382,51 @@
       }).catch(function() {});
     });
 
+    // Target of the command links the backend rewrites ruby-lsp's file://
+    // "Definitions" links into (see EditorsController#rewrite_lsp_hover_links).
+    monaco.editor.registerCommand('mbeditor.openDefinition', function(_accessor, path, line) {
+      if (!path) return;
+      if (typeof TabManager === 'undefined' || !TabManager.openTab) return;
+      TabManager.openTab(path, String(path).split('/').pop(), line || 1);
+    });
+
     // Ruby method definition hover provider.
     // Calls the backend /definition endpoint (Ripper-based) and renders
     // the method signature and any preceding # comments as hover markdown.
     // Results are cached client-side for 60 s to make re-hovers instantaneous.
     var hoverCache = {};
     var HOVER_CACHE_TTL_MS = 60000;
+    var HOVER_MEMBER_LIMIT = 20;
+
+    // ruby-lsp's hover for a constant is a title, a Definitions link and any
+    // doc comments — it never lists what the class/module defines. Keep the
+    // /module_members breakdown that the legacy hover showed, appended below.
+    // Resolves to '' (never rejects) for anything that isn't a constant.
+    function moduleMembersMarkdown(word) {
+      if (!/^[A-Z]/.test(word)) return Promise.resolve('');
+      if (typeof FileService === 'undefined' || !FileService.getModuleMembers) return Promise.resolve('');
+
+      var key = '__members__' + word;
+      var cached = hoverCache[key];
+      if (cached && (Date.now() - cached.ts) < HOVER_CACHE_TTL_MS) return Promise.resolve(cached.markdown);
+
+      return FileService.getModuleMembers(word, {}).then(function(data) {
+        var methods = (data && data.methods) || [];
+        var markdown = '';
+        if (methods.length > 0) {
+          var lines = ['', '---', '**Methods**', ''];
+          methods.slice(0, HOVER_MEMBER_LIMIT).forEach(function(m) {
+            lines.push('- `' + (m.signature || m.name) + '`');
+          });
+          if (methods.length > HOVER_MEMBER_LIMIT) {
+            lines.push('- _' + (methods.length - HOVER_MEMBER_LIMIT) + ' more_');
+          }
+          markdown = '\n\n' + lines.join('\n');
+        }
+        hoverCache[key] = { ts: Date.now(), markdown: markdown };
+        return markdown;
+      }).catch(function() { return ''; });
+    }
 
     // Registered for 'erb' as well as 'ruby'. In ERB the provider only fires
     // inside <% %> and always uses the workspace (grep/Ripper) services:
@@ -1409,12 +1460,15 @@
             return tryRubyLsp('hover', model, position).then(function (lsp) {
               if (token && token.isCancellationRequested) return null;
               if (lsp && lsp.markdown) {
-                var lspResult = {
-                  range: new monaco.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn),
-                  contents: [{ value: lsp.markdown, isTrusted: true }]
-                };
-                hoverCache[lspKey] = { ts: Date.now(), result: lspResult };
-                return lspResult;
+                return moduleMembersMarkdown(word).then(function (members) {
+                  if (token && token.isCancellationRequested) return null;
+                  var lspResult = {
+                    range: new monaco.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn),
+                    contents: [{ value: lsp.markdown + members, isTrusted: true }]
+                  };
+                  hoverCache[lspKey] = { ts: Date.now(), result: lspResult };
+                  return lspResult;
+                });
               }
               hoverCache[lspKey] = { ts: Date.now(), result: null };
               return legacyRubyHover(model, position, token, wordInfo);

data/app/assets/javascripts/mbeditor/git_service.js

@@ -114,6 +114,13 @@ var GitService = (function () {
     });
   }
 
+  // Per-line add/modify/delete ranges for one file, used to tint line numbers.
+  function fetchLineDiff(path) {
+    return axios.get(window.mbeditorBasePath() + '/git/line_diff?file=' + encodeURIComponent(path)).then(function(res) {
+      return res.data;
+    });
+  }
+
   function fetchFileHistory(path) {
     return axios.get(window.mbeditorBasePath() + '/git/file_history?file=' + encodeURIComponent(path)).then(function(res) {
       return res.data;
@@ -138,6 +145,7 @@ var GitService = (function () {
     fetchInfo: fetchInfo,
     fetchDiff: fetchDiff,
     fetchBlame: fetchBlame,
+    fetchLineDiff: fetchLineDiff,
     fetchFileHistory: fetchFileHistory,
     fetchCommitGraph: fetchCommitGraph,
     fetchCommitDetail: fetchCommitDetail

data/app/assets/javascripts/mbeditor/js_outline.js

@@ -0,0 +1,110 @@
+'use strict';
+
+// Outline entries for JS/JSX/TS from TypeScript's own navigation tree.
+//
+// Monaco's TypeScript worker already parses these files for diagnostics and
+// completion, and `getNavigationTree` hands back the symbol tree it built —
+// so unlike the Ruby outline there is no lexer here, only a translation of
+// that tree into the entry shape the dropdown renders.
+//
+// The raw tree needs three fixes before it is useful as an outline:
+//   • children arrive alphabetised, not in source order
+//   • it includes every local, object-literal key and anonymous callback
+//   • an arrow function assigned to a variable is labelled 'const', exactly
+//     like `const total = 5`
+var JsOutline = (function () {
+  var MAX_ENTRIES = 5000;
+
+  var CONTAINER_KINDS = {
+    'class': true, 'local class': true, 'interface': true,
+    'enum': true, 'module': true, 'type': true
+  };
+  var CALLABLE_KINDS = {
+    'function': true, 'local function': true, 'method': true,
+    'constructor': true, 'getter': true, 'setter': true
+  };
+  var VARIABLE_KINDS = { 'const': true, 'let': true, 'var': true };
+
+  // `= function`, `= async () =>`, `= x =>`, `= async function*`. Anchored on
+  // the assignment so a call like `const rows = build(() => 1)` stays out.
+  var FUNCTION_INITIALIZER =
+    /=\s*(?:async\s+)?(?:function\b|\(\s*[^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/;
+
+  // TypeScript names anonymous callbacks after their caller: "then() callback",
+  // "React.useEffect() callback". They have no nameSpan, and neither does
+  // `export default Foo`. A constructor has no nameSpan either but is worth
+  // listing, so it is admitted by kind rather than by name.
+  function isAnonymous(item) {
+    return !item.nameSpan && item.kind !== 'constructor';
+  }
+
+  // 'constructor' is a TypeScript kind and also an Object.prototype key, so a
+  // bare `MAP[kind]` lookup answers truthy for it against every map.
+  function listed(map, kind) {
+    return Object.prototype.hasOwnProperty.call(map, kind);
+  }
+
+  function entryKind(item, declarationText) {
+    if (listed(CONTAINER_KINDS, item.kind)) return 'suite';
+    if (listed(CALLABLE_KINDS, item.kind)) return 'method';
+    if (listed(VARIABLE_KINDS, item.kind) && FUNCTION_INITIALIZER.test(declarationText)) return 'method';
+    return null;
+  }
+
+  function spanStart(item) {
+    var span = item && item.spans && item.spans[0];
+    return span ? span.start : 0;
+  }
+
+  function inSourceOrder(items) {
+    return items.slice().sort(function (a, b) { return spanStart(a) - spanStart(b); });
+  }
+
+  // ctx.lineAt(offset) -> 1-based line number
+  // ctx.textAt(offset, length) -> source text for a span
+  function collect(items, depth, ctx, entries) {
+    var ordered = inSourceOrder(items || []);
+
+    for (var i = 0; i < ordered.length; i++) {
+      var item = ordered[i];
+      var span = item.spans && item.spans[0];
+      if (!span) continue;
+
+      // Only the declaration's own head is needed to spot an initializer, and
+      // a multi-line arrow body can be arbitrarily long.
+      var kind = isAnonymous(item) ? null : entryKind(item, ctx.textAt(span.start, Math.min(span.length, 200)));
+
+      // A skipped node still contributes its children — a component assigned
+      // to an unrecognised wrapper shouldn't take its methods down with it.
+      if (!kind) {
+        if (!collect(item.childItems, depth, ctx, entries)) return false;
+        continue;
+      }
+
+      if (entries.length >= MAX_ENTRIES) return false;
+      entries.push({
+        line: ctx.lineAt(span.start),
+        name: item.text,
+        kind: kind,
+        depth: depth,
+        visibility: null
+      });
+
+      if (!collect(item.childItems, depth + 1, ctx, entries)) return false;
+    }
+
+    return true;
+  }
+
+  // The root is the file itself ('<global>' for a script, the module name for
+  // a module), so only its children are outlined.
+  function fromNavigationTree(root, ctx) {
+    var entries = [];
+    var completed = root ? collect(root.childItems, 0, ctx, entries) : true;
+    return { entries: entries, truncated: !completed };
+  }
+
+  return { fromNavigationTree: fromNavigationTree, MAX_ENTRIES: MAX_ENTRIES };
+})();
+
+window.JsOutline = JsOutline;