@browserless.io/browserless 2.2.0-beta-8 → 2.2.0

package/static/devtools/sources_test_runner/EditorTestRunner.js

@@ -0,0 +1,237 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * @fileoverview using private properties isn't a Closure violation in tests.
+ */
+self.SourcesTestRunner = self.SourcesTestRunner || {};
+
+SourcesTestRunner.createTestEditor = function(clientHeight, textEditorDelegate) {
+  const textEditor =
+      new SourceFrame.SourcesTextEditor(textEditorDelegate || new SourceFrame.SourcesTextEditorDelegate());
+  clientHeight = clientHeight || 100;
+  textEditor.element.style.height = clientHeight + 'px';
+  textEditor.element.style.flex = 'none';
+  textEditor.show(self.UI.inspectorView.element);
+  return textEditor;
+};
+
+function textWithSelection(text, selections) {
+  if (!selections.length) {
+    return text;
+  }
+
+  function lineWithCursor(line, column, cursorChar) {
+    return line.substring(0, column) + cursorChar + line.substring(column);
+  }
+
+  const lines = text.split('\n');
+  selections.sort(TextUtils.TextRange.comparator);
+
+  for (let i = selections.length - 1; i >= 0; --i) {
+    let selection = selections[i];
+    selection = selection.normalize();
+    const endCursorChar = (selection.isEmpty() ? '|' : '<');
+    lines[selection.endLine] = lineWithCursor(lines[selection.endLine], selection.endColumn, endCursorChar);
+
+    if (!selection.isEmpty()) {
+      lines[selection.startLine] = lineWithCursor(lines[selection.startLine], selection.startColumn, '>');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+SourcesTestRunner.dumpTextWithSelection = function(textEditor, dumpWhiteSpaces) {
+  let text = textWithSelection(textEditor.text(), textEditor.selections());
+
+  if (dumpWhiteSpaces) {
+    text = text.replace(/ /g, '.');
+  }
+
+  TestRunner.addResult(text);
+};
+
+SourcesTestRunner.setLineSelections = function(editor, selections) {
+  const coords = [];
+
+  for (let i = 0; i < selections.length; ++i) {
+    const selection = selections[i];
+
+    if (typeof selection.column === 'number') {
+      selection.from = selection.column;
+      selection.to = selection.column;
+    }
+
+    coords.push(new TextUtils.TextRange(selection.line, selection.from, selection.line, selection.to));
+  }
+
+  editor.setSelections(coords);
+};
+
+SourcesTestRunner.typeIn = function(editor, typeText, callback) {
+  callback = callback || new Function();
+  const noop = new Function();
+
+  for (let charIndex = 0; charIndex < typeText.length; ++charIndex) {
+    const iterationCallback = (charIndex + 1 === typeText.length ? callback : noop);
+
+    switch (typeText[charIndex]) {
+      case '\n':
+        SourcesTestRunner.fakeKeyEvent(editor, 'Enter', null, iterationCallback);
+        break;
+      case 'L':
+        SourcesTestRunner.fakeKeyEvent(editor, 'ArrowLeft', null, iterationCallback);
+        break;
+      case 'R':
+        SourcesTestRunner.fakeKeyEvent(editor, 'ArrowRight', null, iterationCallback);
+        break;
+      case 'U':
+        SourcesTestRunner.fakeKeyEvent(editor, 'ArrowUp', null, iterationCallback);
+        break;
+      case 'D':
+        SourcesTestRunner.fakeKeyEvent(editor, 'ArrowDown', null, iterationCallback);
+        break;
+      default:
+        SourcesTestRunner.fakeKeyEvent(editor, typeText[charIndex], null, iterationCallback);
+    }
+  }
+};
+
+const eventCodes = {
+  Enter: 13,
+  Home: 36,
+  ArrowLeft: 37,
+  ArrowUp: 38,
+  ArrowRight: 39,
+  ArrowDown: 40
+};
+
+function createCodeMirrorFakeEvent(editor, eventType, code, charCode, modifiers) {
+  function eventPreventDefault() {
+    this._handled = true;
+  }
+
+  const event = {
+    _handled: false,
+    type: eventType,
+    keyCode: code,
+    charCode: charCode,
+    preventDefault: eventPreventDefault,
+    stopPropagation: function() {},
+    target: editor._codeMirror.display.input.textarea
+  };
+
+  if (modifiers) {
+    for (let i = 0; i < modifiers.length; ++i) {
+      event[modifiers[i]] = true;
+    }
+  }
+
+  return event;
+}
+
+function fakeCodeMirrorKeyEvent(editor, eventType, code, charCode, modifiers) {
+  const event = createCodeMirrorFakeEvent(editor, eventType, code, charCode, modifiers);
+
+  switch (eventType) {
+    case 'keydown':
+      editor._codeMirror.triggerOnKeyDown(event);
+      break;
+    case 'keypress':
+      editor._codeMirror.triggerOnKeyPress(event);
+      break;
+    case 'keyup':
+      editor._codeMirror.triggerOnKeyUp(event);
+      break;
+    default:
+      throw new Error('Unknown KeyEvent type');
+  }
+
+  return event._handled;
+}
+
+function fakeCodeMirrorInputEvent(editor, character) {
+  if (typeof character !== 'string') {
+    return;
+  }
+  const input = editor._codeMirror.display.input;
+  const value = input.textarea.value;
+  const newValue =
+      value.substring(0, input.textarea.selectionStart) + character + value.substring(input.textarea.selectionEnd);
+  const caretPosition = input.textarea.selectionStart + character.length;
+  input.textarea.value = newValue;
+  input.textarea.setSelectionRange(caretPosition, caretPosition);
+  input.poll();
+}
+
+SourcesTestRunner.fakeKeyEvent = function(editor, originalCode, modifiers, callback) {
+  modifiers = modifiers || [];
+  let code;
+  let charCode;
+
+  if (originalCode === '\'') {
+    code = 222;
+    charCode = 0;
+  } else if (originalCode === '"') {
+    code = 222;
+    modifiers.push('shiftKey');
+    charCode = 34;
+  } else if (originalCode === '(') {
+    code = '9'.charCodeAt(0);
+    modifiers.push('shiftKey');
+    charCode = originalCode.charCodeAt(0);
+  }
+
+  code = code || eventCodes[originalCode] || originalCode;
+
+  if (typeof code === 'string') {
+    code = code.charCodeAt(0);
+  }
+
+  if (fakeCodeMirrorKeyEvent(editor, 'keydown', code, charCode, modifiers)) {
+    callback();
+    return;
+  }
+
+  if (fakeCodeMirrorKeyEvent(editor, 'keypress', code, charCode, modifiers)) {
+    callback();
+    return;
+  }
+
+  const inputReadPromise = new Promise(x => editor._codeMirror.on('inputRead', x));
+  fakeCodeMirrorInputEvent(editor, originalCode);
+  fakeCodeMirrorKeyEvent(editor, 'keyup', code, charCode, modifiers);
+  inputReadPromise.then(callback);
+};
+
+SourcesTestRunner.dumpSelectionStats = function(textEditor) {
+  const listHashMap = {};
+  const sortedKeys = [];
+  const selections = textEditor.selections();
+
+  for (let i = 0; i < selections.length; ++i) {
+    const selection = selections[i];
+    const text = textEditor.text(selection);
+
+    if (!listHashMap[text]) {
+      listHashMap[text] = 1;
+      sortedKeys.push(text);
+    } else {
+      ++listHashMap[text];
+    }
+  }
+
+  for (let i = 0; i < sortedKeys.length; ++i) {
+    let keyName = sortedKeys[i];
+
+    if (!keyName.length) {
+      keyName = '<Empty string>';
+    } else {
+      keyName = '\'' + keyName + '\'';
+    }
+
+    TestRunner.addResult(keyName + ': ' + listHashMap[sortedKeys[i]]);
+  }
+};

package/static/devtools/sources_test_runner/LiveEditTestRunner.js

@@ -0,0 +1,33 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * @fileoverview using private properties isn't a Closure violation in tests.
+ */
+self.SourcesTestRunner = self.SourcesTestRunner || {};
+
+SourcesTestRunner.replaceInSource = function(sourceFrame, string, replacement) {
+  sourceFrame._textEditor.setReadOnly(false);
+
+  for (let i = 0; i < sourceFrame._textEditor.linesCount; ++i) {
+    const line = sourceFrame._textEditor.line(i);
+    const column = line.indexOf(string);
+
+    if (column === -1) {
+      continue;
+    }
+
+    const range = new TextUtils.TextRange(i, column, i, column + string.length);
+    sourceFrame._textEditor.editRange(range, replacement);
+    break;
+  }
+};
+
+SourcesTestRunner.commitSource = function(sourceFrame) {
+  sourceFrame.commitEditing();
+};
+
+SourcesTestRunner.undoSourceEditing = function(sourceFrame) {
+  sourceFrame._textEditor.undo();
+};

package/static/devtools/sources_test_runner/SearchTestRunner.js

@@ -0,0 +1,158 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * @fileoverview using private properties isn't a Closure violation in tests.
+ */
+self.SourcesTestRunner = self.SourcesTestRunner || {};
+
+SourcesTestRunner.dumpSearchResults = function(searchResults) {
+  function comparator(a, b) {
+    a.url.localeCompare(b.url);
+  }
+
+  searchResults.sort(comparator);
+  TestRunner.addResult('Search results: ');
+
+  for (let i = 0; i < searchResults.length; i++) {
+    TestRunner.addResult(
+        'url: ' + searchResults[i].url.replace(/VM\d+/, 'VMXX') + ', matchesCount: ' + searchResults[i].matchesCount);
+  }
+
+  TestRunner.addResult('');
+};
+
+SourcesTestRunner.dumpSearchMatches = function(searchMatches) {
+  TestRunner.addResult('Search matches: ');
+
+  for (let i = 0; i < searchMatches.length; i++) {
+    TestRunner.addResult(
+        'lineNumber: ' + searchMatches[i].lineNumber + ', line: \'' + searchMatches[i].lineContent + '\'');
+  }
+
+  TestRunner.addResult('');
+};
+
+SourcesTestRunner.runSearchAndDumpResults = function(scope, searchConfig, callback) {
+  const searchResults = [];
+  const progress = new Common.Progress();
+  scope.performSearch(searchConfig, progress, searchResultCallback, searchFinishedCallback);
+
+  function searchResultCallback(searchResult) {
+    searchResults.push(searchResult);
+  }
+
+  function searchFinishedCallback() {
+    function comparator(searchResultA, searchResultB) {
+      const aUrl = searchResultA._uiSourceCode.url();
+      const bUrl = searchResultB._uiSourceCode.url();
+      return aUrl > bUrl ? 1 : bUrl > aUrl ? -1 : 0;
+    }
+
+    searchResults.sort(comparator);
+
+    for (let i = 0; i < searchResults.length; ++i) {
+      const searchResult = searchResults[i];
+      const uiSourceCode = searchResult._uiSourceCode;
+      const searchMatches = searchResult._searchMatches;
+
+      if (!searchMatches.length) {
+        continue;
+      }
+
+      TestRunner.addResult(
+          'Search result #' + (i + 1) + ': uiSourceCode.url = ' + uiSourceCode.url().replace(/VM\d+/, 'VMXX'));
+
+      for (let j = 0; j < searchMatches.length; ++j) {
+        const lineNumber = searchMatches[j].lineNumber;
+        const lineContent = searchMatches[j].lineContent;
+        TestRunner.addResult(
+            '  search match #' + (j + 1) + ': lineNumber = ' + lineNumber + ', lineContent = \'' + lineContent + '\'');
+      }
+    }
+
+    callback();
+  }
+};
+
+SourcesTestRunner.replaceAndDumpChange = function(sourceFrame, searchConfig, replacement, replaceAll) {
+  const modifiers = [];
+
+  if (searchConfig.isRegex) {
+    modifiers.push('regex');
+  }
+
+  if (searchConfig.caseSensitive) {
+    modifiers.push('caseSensitive');
+  }
+
+  if (replaceAll) {
+    modifiers.push('replaceAll');
+  }
+
+  const modifiersString = (modifiers.length ? ' (' + modifiers.join(', ') + ')' : '');
+  TestRunner.addResult(
+      'Running replace test for /' + searchConfig.query + '/' + replacement + '/ ' + modifiersString + ':');
+  const editor = sourceFrame._textEditor;
+  const oldLines = [];
+
+  for (let i = 0; i < editor.linesCount; ++i) {
+    oldLines.push(editor.line(i));
+  }
+
+  const searchableView = UI.panels.sources.sourcesView().searchableView();
+  searchableView.showSearchField();
+  searchableView._caseSensitiveButton.setToggled(searchConfig.caseSensitive);
+  searchableView._regexButton.setToggled(searchConfig.isRegex);
+  searchableView._searchInputElement.value = searchConfig.query;
+  searchableView._replaceToggleButton.setToggled(true);
+  searchableView._updateSecondRowVisibility();
+  searchableView._replaceInputElement.value = replacement;
+  searchableView._performSearch(true, true);
+
+  if (replaceAll) {
+    searchableView._replaceAll();
+  } else {
+    searchableView._replace();
+  }
+
+  const newLines = [];
+
+  for (let i = 0; i < editor.linesCount; ++i) {
+    newLines.push(editor.line(i));
+  }
+
+  for (let i = 0; i < newLines.length; ++i) {
+    if (oldLines[i] === newLines[i]) {
+      continue;
+    }
+
+    const oldLine = oldLines[i];
+    const newLine = newLines[i];
+    let prefixLength = 0;
+
+    for (let j = 0; j < oldLine.length && j < newLine.length && newLine[j] === oldLine[j]; ++j) {
+      ++prefixLength;
+    }
+
+    let postfixLength = 0;
+
+    for (let j = 0; j < oldLine.length && j < newLine.length &&
+         newLine[newLine.length - j - 1] === oldLine[oldLine.length - j - 1];
+         ++j) {
+      ++postfixLength;
+    }
+
+    const prefix = oldLine.substring(0, prefixLength);
+    const removed = oldLine.substring(prefixLength, oldLine.length - postfixLength);
+    const added = newLine.substring(prefixLength, newLine.length - postfixLength);
+    const postfix = oldLine.substring(oldLine.length - postfixLength);
+    TestRunner.addResult('  - ' + prefix + '#' + removed + '#' + added + '#' + postfix);
+  }
+};
+
+TestRunner.deprecatedInitAsync(`
+  if (window.GCController)
+    GCController.collect();
+`);

package/static/devtools/sources_test_runner/SourcesTestRunner.js

@@ -0,0 +1,173 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * @fileoverview using private properties isn't a Closure violation in tests.
+ */
+self.SourcesTestRunner = self.SourcesTestRunner || {};
+
+/**
+ * @param {!Sources.NavigatorView} navigatorView
+ * @param {boolean=} dumpIcons
+ */
+SourcesTestRunner.dumpNavigatorView = function(navigatorView, dumpIcons) {
+  dumpNavigatorTreeOutline(navigatorView._scriptsTree);
+
+  /**
+   * @param {string} prefix
+   * @param {!UI.TreeElement} treeElement
+   */
+  function dumpNavigatorTreeElement(prefix, treeElement) {
+    let titleText = '';
+    if (treeElement._leadingIconsElement && dumpIcons) {
+      let icons = treeElement._leadingIconsElement.querySelectorAll('[is=ui-icon]');
+      icons = Array.prototype.slice.call(icons);
+      const iconTypes = icons.map(icon => icon._iconType);
+      if (iconTypes.length) {
+        titleText = titleText + '[' + iconTypes.join(', ') + '] ';
+      }
+    }
+    titleText += treeElement.title;
+    if (treeElement._nodeType === Sources.NavigatorView.Types.FileSystem ||
+        treeElement._nodeType === Sources.NavigatorView.Types.FileSystemFolder) {
+      const hasMappedFiles = treeElement.listItemElement.classList.contains('has-mapped-files');
+      if (!hasMappedFiles) {
+        titleText += ' [dimmed]';
+      }
+    }
+    TestRunner.addResult(prefix + titleText);
+    treeElement.expand();
+    const children = treeElement.children();
+    for (let i = 0; i < children.length; ++i) {
+      dumpNavigatorTreeElement(prefix + '  ', children[i]);
+    }
+  }
+
+  /**
+   * @param {!UI.TreeOutline} treeOutline
+   */
+  function dumpNavigatorTreeOutline(treeOutline) {
+    const children = treeOutline.rootElement().children();
+    for (let i = 0; i < children.length; ++i) {
+      dumpNavigatorTreeElement('', children[i]);
+    }
+  }
+};
+
+/**
+ * @param {!Sources.NavigatorView} view
+ */
+SourcesTestRunner.dumpNavigatorViewInAllModes = function(view) {
+  ['frame', 'frame/domain', 'frame/domain/folder', 'domain', 'domain/folder'].forEach(
+      SourcesTestRunner.dumpNavigatorViewInMode.bind(TestRunner, view));
+};
+
+/**
+ * @param {!Sources.NavigatorView} view
+ * @param {string} mode
+ */
+SourcesTestRunner.dumpNavigatorViewInMode = function(view, mode) {
+  TestRunner.addResult(view instanceof Sources.NetworkNavigatorView ? 'Sources:' : 'Content Scripts:');
+  view._groupByFrame = mode.includes('frame');
+  view._groupByDomain = mode.includes('domain');
+  view._groupByFolder = mode.includes('folder');
+  view._resetForTest();
+  TestRunner.addResult('-------- Setting mode: [' + mode + ']');
+  SourcesTestRunner.dumpNavigatorView(view);
+};
+
+/**
+ * @param {string} url
+ * @param {string} content
+ * @param {boolean=} isContentScript
+ * @param {number=} worldId
+ * @return {!Promise}
+ */
+SourcesTestRunner.addScriptUISourceCode = function(url, content, isContentScript, worldId) {
+  content += '\n//# sourceURL=' + url;
+  if (isContentScript) {
+    content = `testRunner.evaluateScriptInIsolatedWorld(${worldId}, \`${content}\`)`;
+  }
+  TestRunner.evaluateInPageAnonymously(content);
+  return TestRunner.waitForUISourceCode(url);
+};
+
+function testSourceMapping(text1, text2, mapping, testToken) {
+  const originalPosition = text1.indexOf(testToken);
+  TestRunner.assertTrue(originalPosition !== -1);
+
+  const text1LineEndings = TestRunner.findLineEndingIndexes(text1);
+  const text2LineEndings = TestRunner.findLineEndingIndexes(text2);
+
+  const originalLocation = Formatter.Formatter.positionToLocation(text1LineEndings, originalPosition);
+  const formattedLocation = mapping.originalToFormatted(originalLocation[0], originalLocation[1]);
+  const formattedPosition =
+      Formatter.Formatter.locationToPosition(text2LineEndings, formattedLocation[0], formattedLocation[1]);
+  const expectedFormattedPosition = text2.indexOf(testToken);
+
+  if (expectedFormattedPosition === formattedPosition) {
+    TestRunner.addResult(String.sprintf('Correct mapping for <%s>', testToken));
+  } else {
+    TestRunner.addResult(String.sprintf('ERROR: Wrong mapping for <%s>', testToken));
+  }
+}
+
+SourcesTestRunner.testPrettyPrint = function(mimeType, text, mappingQueries, next) {
+  new Formatter.ScriptFormatter(mimeType, text, didFormatContent);
+
+  function didFormatContent(formattedSource, mapping) {
+    TestRunner.addResult('====== 8< ------');
+    TestRunner.addResult(formattedSource);
+    TestRunner.addResult('------ >8 ======');
+
+    while (mappingQueries && mappingQueries.length) {
+      testSourceMapping(text, formattedSource, mapping, mappingQueries.shift());
+    }
+
+    next();
+  }
+};
+
+SourcesTestRunner.testJavascriptOutline = function(text) {
+  let fulfill;
+  const promise = new Promise(x => {
+    fulfill = x;
+  });
+  Formatter.formatterWorkerPool().javaScriptOutline(text, onChunk);
+  const items = [];
+  return promise;
+
+  function onChunk(isLastChunk, outlineItems) {
+    items.push(...outlineItems);
+
+    if (!isLastChunk) {
+      return;
+    }
+
+    TestRunner.addResult('Text:');
+    TestRunner.addResult(text.split('\n').map(line => '    ' + line).join('\n'));
+    TestRunner.addResult('Outline:');
+
+    for (const item of items) {
+      TestRunner.addResult('    ' + item.name + (item.arguments || '') + ':' + item.line + ':' + item.column);
+    }
+
+    fulfill();
+  }
+};
+
+SourcesTestRunner.dumpSwatchPositions = function(sourceFrame, bookmarkType) {
+  const textEditor = sourceFrame.textEditor;
+  const markers = textEditor.bookmarks(textEditor.fullRange(), bookmarkType);
+
+  for (let i = 0; i < markers.length; i++) {
+    const position = markers[i].position();
+    const swatch = markers[i]._marker.widgetNode.firstChild;
+    let text = swatch.textContent;
+    if (swatch.localName === 'devtools-color-swatch') {
+      text = swatch.color.asString(swatch.format);
+    }
+    TestRunner.addResult('Line ' + position.startLine + ', Column ' + position.startColumn + ': ' + text);
+  }
+};

package/static/devtools/sources_test_runner/sources_test_runner.js

@@ -0,0 +1,10 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import './SourcesTestRunner.js';
+import './DebuggerTestRunner.js';
+import './LiveEditTestRunner.js';
+import './SearchTestRunner.js';
+import './EditorTestRunner.js';
+import './AutocompleteTestRunner.js';

package/static/devtools/startup/startup.js

@@ -0,0 +1 @@
+import{Runtime as o}from"../root/root.js";import"../platform/platform.js";import{App as e,AppProvider as t,Color as r,Console as n,EventTarget as i,JavaScriptMetaData as m,Linkifier as s,ObjectWrapper as a,ParsedURL as l,Progress as c,QueryParamHandler as C,ResourceType as p,Revealer as u,SegmentedRange as R,Settings as T,StringOutputStream as d,Throttler as g,Trie as x,UIString as S}from"../common/common.js";import{ContentProvider as f,StaticContentProvider as U,Text as P,TextCursor as v,TextRange as h,TextUtils as y}from"../text_utils/text_utils.js";async function F(e){console.timeStamp("Root.Runtime.startApplication");const t={};for(let o=0;o<Root.allDescriptors.length;++o){const e=Root.allDescriptors[o];t[e.name]=e}const r=Root.applicationDescriptor.modules,n=[],i=[];for(let o=0;o<r.length;++o){const e=r[o],m=e.name;n.push(t[m]),"autostart"===e.type&&i.push(m)}for(let o=0;o<n.length;++o)n[o].name=r[o].name,n[o].condition=r[o].condition;const m=o.Runtime.instance({forceNew:!0,moduleDescriptors:n});self.runtime=m,i&&await m.loadAutoStartModules(i),o.appStartedPromiseCallback()}self.Root=self.Root||{},Root=Root||{},Root.Runtime=o.Runtime,Root.Runtime.experiments=o.experiments,Root.Runtime.queryParam=o.Runtime.queryParam,Root.runtime,Root.Runtime.loadResourcePromise=o.loadResourcePromise,Root.Runtime.Extension=o.Extension,Root.Runtime.Module=o.Module,self.Common=self.Common||{},Common=Common||{},Common.App=e.App,Common.AppProvider=t.AppProvider,Common.Color=r.Color,Common.Color.Format=r.Format,Common.Color.Nicknames=r.Nicknames,Common.console=n.Console.instance(),Common.Console=n.Console,Common.EventTarget=i.EventTarget,Common.JavaScriptMetadata=m.JavaScriptMetaData,Common.Linkifier=s.Linkifier,Common.Object=a.ObjectWrapper,Common.ParsedURL=l.ParsedURL,Common.Progress=c.Progress,Common.CompositeProgress=c.CompositeProgress,Common.QueryParamHandler=C.QueryParamHandler,Common.resourceTypes=p.resourceTypes,Common.Revealer=u.Revealer,Common.Revealer.reveal=u.reveal,Common.Revealer.setRevealForTest=u.setRevealForTest,Common.Segment=R.Segment,Common.SegmentedRange=R.SegmentedRange,Common.Settings=T.Settings,Common.Settings.detectColorFormat=T.detectColorFormat,Common.Setting=T.Setting,Common.settingForTest=T.settingForTest,Common.VersionController=T.VersionController,Common.moduleSetting=T.moduleSetting,Common.StringOutputStream=d.StringOutputStream,Common.Throttler=g.Throttler,Common.Trie=x.Trie,Common.UIString=S.UIString,Common.localize=S.localize,Common.settings,self.ls=S.ls,self.TextUtils=self.TextUtils||{},TextUtils=TextUtils||{},TextUtils.ContentProvider=f.ContentProvider,TextUtils.ContentProvider.SearchMatch=f.SearchMatch,TextUtils.ContentProvider.contentAsDataURL=f.contentAsDataURL,TextUtils.StaticContentProvider=U.StaticContentProvider,TextUtils.Text=P.Text,TextUtils.TextCursor=v.TextCursor,TextUtils.TextRange=h.TextRange,TextUtils.SourceRange=h.SourceRange,TextUtils.SourceEdit=h.SourceEdit,TextUtils.TextUtils=y.Utils,TextUtils.FilterParser=y.FilterParser,TextUtils.BalancedJSONTokenizer=y.BalancedJSONTokenizer,TextUtils.TokenizerFactory=y.TokenizerFactory,TextUtils.isMinified=y.isMinified,self.Runtime=self.Runtime||{},Runtime=Runtime||{},Root.allDescriptors=Root.allDescriptors||[],Root.applicationDescriptor=Root.applicationDescriptor||void 0;var k=Object.freeze({__proto__:null,startApplication:F,startWorker:async function(o){return F().then((function(){self.postMessage("workerReady")}))}});export{k as RuntimeInstantiator};