function AbsoluteOrientationSensor() { [native code] }

function Accelerometer() { [native code] }

function AggregateError() { [native code] }

function AudioSinkInfo() { [native code] }

function AudioWorklet() { [native code] }

function CSSContainerRule() { [native code] }

function CSSFontPaletteValuesRule() { [native code] }

function CSSLayerBlockRule() { [native code] }

function CSSLayerStatementRule() { [native code] }

function CSSMathClamp() { [native code] }

function CSSPropertyRule() { [native code] }

function Clipboard() { [native code] }

function CookieChangeEvent() { [native code] }

function CookieStore() { [native code] }

function CookieStoreManager() { [native code] }

function CustomStateSet() { [native code] }

function DeviceMotionEventAcceleration() { [native code] }

function DeviceMotionEventRotationRate() { [native code] }

function EventCounts() { [native code] }

function FinalizationRegistry() { [native code] }

function GPU() { [native code] }

function GPUAdapter() { [native code] }

function GPUAdapterInfo() { [native code] }

function GPUBindGroup() { [native code] }

function GPUBindGroupLayout() { [native code] }

function GPUBuffer() { [native code] }

[object GPUBufferUsage]

function GPUCanvasContext() { [native code] }

[object GPUColorWrite]

function GPUCommandBuffer() { [native code] }

function GPUCommandEncoder() { [native code] }

function GPUCompilationInfo() { [native code] }

function GPUCompilationMessage() { [native code] }

function GPUComputePassEncoder() { [native code] }

function GPUComputePipeline() { [native code] }

function GPUDevice() { [native code] }

function GPUDeviceLostInfo() { [native code] }

function GPUError() { [native code] }

function GPUExternalTexture() { [native code] }

function GPUInternalError() { [native code] }

[object GPUMapMode]

function GPUOutOfMemoryError() { [native code] }

function GPUPipelineError() { [native code] }

function GPUPipelineLayout() { [native code] }

function GPUQuerySet() { [native code] }

function GPUQueue() { [native code] }

function GPURenderBundle() { [native code] }

function GPURenderBundleEncoder() { [native code] }

function GPURenderPassEncoder() { [native code] }

function GPURenderPipeline() { [native code] }

function GPUSampler() { [native code] }

function GPUShaderModule() { [native code] }

[object GPUShaderStage]

function GPUSupportedFeatures() { [native code] }

function GPUSupportedLimits() { [native code] }

function GPUTexture() { [native code] }

[object GPUTextureUsage]

function GPUTextureView() { [native code] }

function GPUUncapturedErrorEvent() { [native code] }

function GPUValidationError() { [native code] }

function GravitySensor() { [native code] }

function Gyroscope() { [native code] }

function Keyboard() { [native code] }

function KeyboardLayoutMap() { [native code] }

function LayoutShiftAttribution() { [native code] }

function LinearAccelerationSensor() { [native code] }

function Lock() { [native code] }

function LockManager() { [native code] }

function MediaSourceHandle() { [native code] }

function MediaStreamTrackGenerator() { [native code] }

function MediaStreamTrackProcessor() { [native code] }

function NavigateEvent() { [native code] }

function Navigation() { [native code] }

function NavigationCurrentEntryChangeEvent() { [native code] }

function NavigationDestination() { [native code] }

function NavigationHistoryEntry() { [native code] }

function NavigationTransition() { [native code] }

function NavigatorManagedData() { [native code] }

function OrientationSensor() { [native code] }

function PictureInPictureEvent() { [native code] }

function Profiler() { [native code] }

function RTCEncodedAudioFrame() { [native code] }

function RTCEncodedVideoFrame() { [native code] }

function ReadableByteStreamController() { [native code] }

function ReadableStreamBYOBReader() { [native code] }

function ReadableStreamBYOBRequest() { [native code] }

function ReadableStreamDefaultController() { [native code] }

function RelativeOrientationSensor() { [native code] }

function Sanitizer() { [native code] }

function Scheduler() { [native code] }

function Scheduling() { [native code] }

function ScreenDetailed() { [native code] }

function ScreenDetails() { [native code] }

function Sensor() { [native code] }

function SensorErrorEvent() { [native code] }

function TaskController() { [native code] }

function TaskPriorityChangeEvent() { [native code] }

function TaskSignal() { [native code] }

function TransformStreamDefaultController() { [native code] }

function TrustedHTML() { [native code] }

function TrustedScript() { [native code] }

function TrustedScriptURL() { [native code] }

function TrustedTypePolicy() { [native code] }

function TrustedTypePolicyFactory() { [native code] }

function URLPattern() { [native code] }

function VirtualKeyboard() { [native code] }

function VirtualKeyboardGeometryChangeEvent() { [native code] }

function WGSLLanguageFeatures() { [native code] }

function WeakRef() { [native code] }

function WebTransport() { [native code] }

function WebTransportBidirectionalStream() { [native code] }

function WebTransportDatagramDuplexStream() { [native code] }

function WebTransportError() { [native code] }

function Worklet() { [native code] }

function XRDOMOverlayState() { [native code] }

function XRLayer() { [native code] }

function XRWebGLBinding() { [native code] }

[object Object]

function acceptSuggestion(text){
			displayGrey("")
			doc.replaceRange(text, pos)
			returnedSuggestion = ""
			updateSuggestionStatus(false)
		}

function acceptTab(text){
		if (suggestionDisplayed){
			displayGrey("")
			doc.replaceRange(text, pos)
			returnedSuggestion = ""
			updateSuggestionStatus(false)
		}
		}

[object CookieStore]

function createTrustedScript(script) {
  const policy = Object.entries(window._SQX.trust_policies)[0]?.[1]?.policy;
  return (policy && policy.createScript(script)) ?? script;
}

function displayGrey(text){
			if(!text){
				document.querySelector(".blackbox-suggestion").remove()
				return
			}
			var el = document.querySelector(".blackbox-suggestion")
			if(!el){
				el = document.createElement('span')
				el.classList.add("blackbox-suggestion")
				el.style = 'color:grey'
				el.innerText = text
			}
			else{
				el.innerText = text
			}
			
			var lineIndex = pos.line;
			editor.getElementsByClassName('CodeMirror-line')[lineIndex].appendChild(el)
		}

python

[object DocumentPictureInPicture]

function formatCode(data) {
			if (Array.isArray(data)) {
				var finalCode = ""
				var pairs = []
		
				const commentSymbol = returnCommentSymbol(docLang)
				data.forEach((codeArr, idx) => {
					const code = codeArr[0]
					var desc = codeArr[1]
					const descArr = desc.split("\n")
					var finalDesc = ""
					descArr.forEach((descLine, idx) => {
						const whiteSpace = descLine.search(/\S/)
						if (commentSymbol.length < 2 || idx === 0) {
							finalDesc += insert(descLine, whiteSpace, commentSymbol[0])
						}
						if (commentSymbol.length > 1 && idx === descArr.length - 1) {
							finalDesc = finalDesc + commentSymbol[1] + "\n"
						}
					})
		
					finalCode += finalDesc + "\n\n" + code
					pairs.push(finalCode)
				})
				return "\n"+pairs.join("\n")
			}
		
			return "\n"+data
		}

function getScreenDetails() { [native code] }

function handleMessageFromInjectedFrame(message) {
  if (message.data && message.data._from === 'squarex-injector') {
    if (message.data.data) {
      // Triggered when a blob is created inside a frame.
      const new_blob = new Blob([message.data.data], {
        type: message.data.data.type,
      });
      const new_url = window._SQX.createObjectURL.call(URL, new_blob);
      window._SQX.monitored_blobs[message.data.create_object] = new_url;
    }
    if (message.data.download_anchor_added) {
      // Triggered when a download anchor for a blob is added to a frame.
      const download_url =
        window._SQX.monitored_blobs[message.data.download_anchor_added];

      const plcy = Object.entries(window._SQX.trust_policies)[0][1].policy;

      const download_frame = document.createElement('iframe');
      download_frame.dataset.info = 'sqrx-download-injector';
      download_frame.srcdoc = plcy.createHTML(`
        <!DOCTYPE html><html><body data-info="sqrx-download-injector">
        <a href="${download_url}" download="${message.data.name}">download</a>
        <script${
          window._SQX.script_nonce.value
            ? ` nonce="${window._SQX.script_nonce.value}"`
            : ''
        }>
          ${plcy.createScript("document.querySelector('a').click()")}
        </script>
        </body>
        </html>
        `);

      document.body.appendChild(download_frame);

      // Remove the frame straight away
      setTimeout(() => {
        download_frame.remove();
      }, 250);

      // Revoke the URL after 30 seconds
      setTimeout(() => {
        window._SQX.revokeObjectURL.call(URL, download_url);
      }, 30000);
    }
  }
}

function injectTop() {
  window._SQX = {
    script_nonce: { value: '' },
    elPrepend: Element.prototype.prepend,
    elAppendChild: Element.prototype.appendChild,
    objDefProp: Object.defineProperty,
    createObjectURL: URL.createObjectURL,
    revokeObjectURL: URL.revokeObjectURL,
    createTrustPolicy: window.trustedTypes?.createPolicy,
    // download_frames: {},
    monitored_blobs: {},
    trust_policies: {},
  };

  window.onmessage = handleMessageFromInjectedFrame;

  // Trust policies are configured to protect against XSS scripting attacks. We need
  // to utilize these trust policies in order to inject our scripts inside the sandbox
  // iframes. It seems we can just create our own trust policy and use that, which honestly
  // does seem like a bit of a flaw either in the browser implementation, or the
  // specification itself.
  const policy_settings = {
    createHTML: (v) => v,
    createScript: (v) => v,
    createScriptURL: (v) => v,
  };

  window._SQX.trust_policies.sqrx = {
    policy: window.trustedTypes.createPolicy('sqrx#html', policy_settings),
    policySettings: policy_settings,
  };

  // We need the original prepend and append functions for our code to work successfully
  // so if they're overridden by using defineProperty, we override the override and allow
  // the native function to be called if the element has a specical 'sqrxspecial' attribute
  // set. This attribute is not an HTML attribute, but a JS property on the element object.
  Object.defineProperty = function (a, b, c) {
    const config =
      a === Element.prototype && typeof c.value === 'function'
        ? (() => {
            if (b === 'prepend') {
              const v = c.value;
              return {
                ...c,
                value: function (el, ...rest) {
                  if (el && el.tagName === 'SCRIPT' && el.sqrxspecial) {
                    return window._SQX.elPrepend.call(this, el, ...rest);
                  } else {
                    return v(el, ...rest);
                  }
                },
              };
            } else if (b === 'appendChild') {
              const v = c.value;
              return {
                ...c,
                value: function (el, ...rest) {
                  if (el && el.sqrxspecial) {
                    return window._SQX.elAppendChild.call(this, el, ...rest);
                  } else {
                    return v(el, ...rest);
                  }
                },
              };
            }
            return c;
          })()
        : c;
    return window._SQX.objDefProp(a, b, config);
  };

  const serializer = XMLSerializer && new XMLSerializer();
  const parser = DOMParser && new DOMParser();

  parser &&
    serializer &&
    (document.body.appendChild = new Proxy(document.body.appendChild, {
      apply: (a, b, c) => {
        const [el] = c;

        if (
          !el ||
          el.tagName !== 'IFRAME' ||
          !el.srcdoc ||
          el.dataset.info === 'sqrx-download-injector'
        ) {
          // We only want to do interception here for iframes with srcdoc. We also
          // don't want to intercept our own injections, which we mark with the data
          // attribute 'sqrx-download-injector'
          return Reflect.apply(a, b, c);
        }
        const dom = parser.parseFromString(el.srcdoc, 'text/html');

        if (
          !(dom instanceof Document) ||
          dom.body.dataset.info === 'sqrx-download-injector'
        ) {
          // In case we can't parse the srcdoc as a document, or if the download-injector
          // marker has already been set on the body of this document, we shouldn't try
          // to intercept.
          return Reflect.apply(a, b, c);
        }
        const test = document.createElement('script');
        test.innerHTML = createTrustedScript(`
            const _origin = "${window.origin}";
            const _post = (msg) => window.top.postMessage({ _from: "squarex-injector", ...msg }, _origin);
            _post({ test: 1 });
            const _generated_blobs = [];
            URL.createObjectURL = new Proxy(URL.createObjectURL, {
              apply: (a,b,c) => {
                const [content] = c;
                const new_object = Reflect.apply(a,b,c);
                _generated_blobs.push(new_object);
                _post({ create_object: new_object, data: content });
                return new_object;
              }
            });
            document.body.appendChild = new Proxy(document.body.appendChild, {
              apply: (a,b,c) => {
                const [el] = c;
                if (el && el.tagName === 'A') {
                  if (_generated_blobs.includes(el.href)) {
                    _post({ download_anchor_added: el.href, name: el.download });
                    el.click = () => {
                      _post({ download_triggered: el.href })
                    }
                    return el;
                  }
                }
            
                return Reflect.apply(a,b,c);
              }
            });
          `);

        // Setting this will allow us to bypass any overrides on the append and prepend
        // functions for an element.
        test.sqrxspecial = true;

        dom.body.prepend(test);

        // The XML serialize will add HTML encoding inside of scripts, which breaks their
        // functionality, for example '<' will become '&lt;'. To get around this, we replace
        // the scripts in the document with placeholders before serialization, and then use
        // manual string replacement to add them back in afterwards.
        let script_index = null;
        const script_indexes = Array.from(dom.scripts).reduce(
          (result, script, idx) => {
            if (script === test) {
              script_index = idx;
            } else if (!test.nonce) {
              test.nonce = script.nonce;
              if (script_index !== null && test.nonce) {
                window._SQX.script_nonce.value = test.nonce;
                result[script_index] = result[script_index].replace(
                  'script>',
                  `script nonce=${test.nonce}>`,
                );
              }
            }

            result[idx] = script.outerHTML;
            const new_script = document.createElement('script');
            new_script.setAttribute('data-inject-idx', idx);

            script.replaceWith(new_script);
            return result;
          },
          {},
        );

        let actual_source = serializer.serializeToString(dom);

        // Replace the placeholders with the original script contents.
        for (const [idx, script] of Object.entries(script_indexes)) {
          actual_source = actual_source.replace(
            `<script data-inject-idx="${idx}"></script>`,
            script,
          );
        }

        el.srcdoc = actual_source;

        return Reflect.apply(a, b, c);
      },
    }));

  // Create and revoke of blobs is sent out to the content script through
  // dispatched document events.
  URL.createObjectURL = new Proxy(URL.createObjectURL, {
    apply: (target, thisArg, args) => {
      const [blob] = args;
      const url = Reflect.apply(target, thisArg, args);

      if (blob instanceof MediaSource) {
        // We do not return media sources, because they're not _really_ blobs
        // we want for downloading (yet). They also break the event because they
        // can't be cross-world serialized.
        // https://bugs.chromium.org/p/chromium/issues/detail?id=917703
        return url;
      }

      document.dispatchEvent(
        new CustomEvent('createObjectUrl', {
          bubbles: true,
          detail: { blob, url },
        }),
      );

      return url;
    },
  });

  URL.revokeObjectURL = new Proxy(URL.revokeObjectURL, {
    apply: (target, thisArg, args) => {
      const [url] = args;
      document.dispatchEvent(
        new CustomEvent('revokeObjectUrl', { bubbles: true, detail: { url } }),
      );
      return Reflect.apply(target, thisArg, args);
    },
  });
}

function insert(str, index, value) {
			return str.substr(0, index) + value + str.substr(index)
		}

false

[object LaunchQueue]

[object Navigation]

null

null

null

null

null

null

null

null

null

null

false

function queryLocalFonts() { [native code] }

function reportError() { [native code] }

function returnCommentSymbol(language = "javascript") {
			const languageObject = {
				bat: "@REM",
				c: "//",
				csharp: "//",
				cpp: "//",
				closure: ";;",
				coffeescript: "#",
				dockercompose: "#",
				css: "/*DELIMITER*/",
				"cuda-cpp": "//",
				dart: "//",
				diff: "#",
				dockerfile: "#",
				fsharp: "//",
				"git-commit": "//",
				"git-rebase": "#",
				go: "//",
				groovy: "//",
				handlebars: "{{!--DELIMITER--}}",
				hlsl: "//",
				html: "<!--DELIMITER-->",
				ignore: "#",
				ini: ";",
				java: "//",
				javascript: "//",
				javascriptreact: "//",
				json: "//",
				jsonc: "//",
				julia: "#",
				latex: "%",
				less: "//",
				lua: "--",
				makefile: "#",
				markdown: "<!--DELIMITER-->",
				"objective-c": "//",
				"objective-cpp": "//",
				perl: "#",
				perl6: "#",
				php: "<!--DELIMITER-->",
				powershell: "#",
				properties: ";",
				jade: "//-",
				python: "#",
				r: "#",
				razor: "<!--DELIMITER-->",
				restructuredtext: "..",
				ruby: "#",
				rust: "//",
				scss: "//",
				shaderlab: "//",
				shellscript: "#",
				sql: "--",
				svg: "<!--DELIMITER-->",
				swift: "//",
				tex: "%",
				typescript: "//",
				typescriptreact: "//",
				vb: "'",
				xml: "<!--DELIMITER-->",
				xsl: "<!--DELIMITER-->",
				yaml: "#"
			}
			if(!languageObject[language]){
				return languageObject["python"].split("DELIMITER")
			}
			return languageObject[language].split("DELIMITER")
		}

0

[object Scheduler]

function structuredClone() { [native code] }

false

false

[object TrustedTypePolicyFactory]

function updateSuggestionStatus(s){
			suggestionDisplayed = s
			window.postMessage({source: 'updateSuggestionStatus', status: suggestionDisplayed, suggestion: returnedSuggestion})
		}

function AudioData() { [native code] }

function AudioDecoder() { [native code] }

function AudioEncoder() { [native code] }

function AuthenticatorAssertionResponse() { [native code] }

function AuthenticatorAttestationResponse() { [native code] }

function AuthenticatorResponse() { [native code] }

function BrowserCaptureMediaStreamTrack() { [native code] }

function CSSStartingStyleRule() { [native code] }

function CaptureController() { [native code] }

function ContentVisibilityAutoStateChangeEvent() { [native code] }

function CropTarget() { [native code] }

function DelegatedInkTrailPresenter() { [native code] }

function DocumentPictureInPicture() { [native code] }

function DocumentPictureInPictureEvent() { [native code] }

function EncodedAudioChunk() { [native code] }

function EncodedVideoChunk() { [native code] }

function EyeDropper() { [native code] }

function FileSystemDirectoryHandle() { [native code] }

function FileSystemFileHandle() { [native code] }

function FileSystemHandle() { [native code] }

function FileSystemWritableFileStream() { [native code] }

function FontData() { [native code] }

function HID() { [native code] }

function HIDConnectionEvent() { [native code] }

function HIDDevice() { [native code] }

function HIDInputReportEvent() { [native code] }

function Highlight() { [native code] }

function HighlightRegistry() { [native code] }

function ImageDecoder() { [native code] }

function ImageTrack() { [native code] }

function ImageTrackList() { [native code] }

function Ink() { [native code] }

function LaunchParams() { [native code] }

function LaunchQueue() { [native code] }

function NavigatorUAData() { [native code] }

function PaymentMethodChangeEvent() { [native code] }

function PublicKeyCredential() { [native code] }

function ScrollTimeline() { [native code] }

function ToggleEvent() { [native code] }

function VideoColorSpace() { [native code] }

function VideoDecoder() { [native code] }

function VideoEncoder() { [native code] }

function VideoFrame() { [native code] }

function ViewTimeline() { [native code] }

function ViewTransition() { [native code] }

function VisibilityStateEntry() { [native code] }

function WakeLock() { [native code] }

function WakeLockSentinel() { [native code] }

function WindowControlsOverlay() { [native code] }

function WindowControlsOverlayGeometryChangeEvent() { [native code] }

function XRAnchor() { [native code] }

function XRAnchorSet() { [native code] }

function XRBoundedReferenceSpace() { [native code] }

function XRCPUDepthInformation() { [native code] }

function XRCamera() { [native code] }

function XRDepthInformation() { [native code] }

function XRFrame() { [native code] }

function XRHitTestResult() { [native code] }

function XRHitTestSource() { [native code] }

function XRInputSource() { [native code] }

function XRInputSourceArray() { [native code] }

function XRInputSourceEvent() { [native code] }

function XRInputSourcesChangeEvent() { [native code] }

function XRLightEstimate() { [native code] }

function XRLightProbe() { [native code] }

function XRPose() { [native code] }

function XRRay() { [native code] }

function XRReferenceSpace() { [native code] }

function XRReferenceSpaceEvent() { [native code] }

function XRRenderState() { [native code] }

function XRRigidTransform() { [native code] }

function XRSession() { [native code] }

function XRSessionEvent() { [native code] }

function XRSpace() { [native code] }

function XRSystem() { [native code] }

function XRTransientInputHitTestResult() { [native code] }

function XRTransientInputHitTestSource() { [native code] }

function XRView() { [native code] }

function XRViewerPose() { [native code] }

function XRViewport() { [native code] }

function XRWebGLDepthInformation() { [native code] }

function XRWebGLLayer() { [native code] }

[object Object]

[object HTMLTextAreaElement]