workbench.glass.main.js · part 182

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/out/vs/workbench/workbench.glass.main.js, part 182. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

ui-19aaqeu ui-1t93vz6 ui-t6ogrd

ui-jbqb8w ui-1834tr1 ui-d9g367

ui-19aaqeu ui-1qp4pc4 ui-1gfq6vl

use strict

ui-jyslct ui-6s0dn4 ui-l56j7k ui-1a6rlst ui-972fbf ui-1ejq31n ui-1b4hy2t ui-gfja2r ui-11pwa6s ui-1ws9gjp ui-1qhh985 ui-1sy0etr ui-1tnzt7h ui-yj58a3 ui-1b16gh4 ui-1pjslub ui-exx8yu ui-17v7654 ui-18d9i69 ui-1lfpczk ui-1e1y6u3 ui-jb2p0i ui-y5h43f ui-1yl5bsf ui-19ji09o ui-18cvvyg ui-1ypdohk ui-s2xxs2 ui-gv8wjl ui-11udeeo ui-uxw1ft ui-1k57tk5 ui-1l9t207 ui-1x65lqo ui-1t137rt ui-hlp2gg ui-i5y0ii ui-1uczgqu ui-1xwnvu1 ui-z2lg3n ui-1gnnqk1 ui-r9r2s9 ui-1xk3k8f ui-pk4wdd ui-8pshft ui-3ctksj ui-1tfasdq ui-qvire7 ui-3nfvp2 ui-11twubx ui-2lah0s

ui-filter-tab-bar__tab ui-filter-tab-bar__tab--selected ui-filter-tab-bar__tab--dropdown-trigger

Filter by scope

Select filter

Select filter

ui-filter-tab-bar__tabs ui-filter-tab-bar__tabs--wrap

Filter by scope

use strict

use strict

Video player

ui-1lliihq ui-193iq5w ui-mz0i5r ui-14atkfc ui-t7dq6l ui-ack27t ui-8x9d4c ui-19kjcj4

Pause video

Play video

ui-10l6tqk ui-10a8y8t ui-h8yej3 ui-5yr21d ui-dj266r ui-1yf7rl7 ui-at24cr ui-j3b58b ui-exx8yu ui-1xpa7k ui-18d9i69 ui-1uhho1l ui-972fbf ui-gfja2r ui-1qhh985 ui-yj58a3 ui-jbqb8w ui-1ypdohk

ui-10l6tqk ui-10a8y8t ui-47corl

ui-1n2onr6 ui-1rg5ohu ui-193iq5w ui-mz0i5r ui-l5c6n8 ui-b3r6kr ui-1m7fhj7 ui-42x0ya ui-14ju556

use strict

use strict

data:image/svg+xml;charset=utf-8,${encodeURIComponent('<svg width="100" height="114" viewBox="0 0 100 114" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M98.0053 26.9829L52.3674 0.634708C50.9019 -0.211569 49.0937 -0.211569 47.6282 0.634708L1.99248 26.9829C0.760534 27.6942 -6.10352e-05 29.0096 -6.10352e-05 30.4344V83.5656C-6.10352e-05 84.9882 0.760534 86.3058 1.99248 87.0171L47.6303 113.365C49.0958 114.212 50.9041 114.212 52.3696 113.365L98.0074 87.0171C99.2393 86.3058 99.9999 84.9904 99.9999 83.5656V30.4344C99.9999 29.0118 99.2372 27.6942 98.0053 26.9829ZM95.1386 32.564L51.0819 108.87C50.7841 109.385 49.9978 109.175 49.9978 108.579V58.6144C49.9978 57.616 49.4643 56.6926 48.5987 56.1912L5.32839 31.21C4.81418 30.9122 5.02415 30.1259 5.61977 30.1259H93.7331C94.9843 30.1259 95.7642 31.4799 95.1386 32.564Z" fill="white" fill-opacity="0.2"/></svg>')}

<svg width="100" height="114" viewBox="0 0 100 114" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M98.0053 26.9829L52.3674 0.634708C50.9019 -0.211569 49.0937 -0.211569 47.6282 0.634708L1.99248 26.9829C0.760534 27.6942 -6.10352e-05 29.0096 -6.10352e-05 30.4344V83.5656C-6.10352e-05 84.9882 0.760534 86.3058 1.99248 87.0171L47.6303 113.365C49.0958 114.212 50.9041 114.212 52.3696 113.365L98.0074 87.0171C99.2393 86.3058 99.9999 84.9904 99.9999 83.5656V30.4344C99.9999 29.0118 99.2372 27.6942 98.0053 26.9829ZM95.1386 32.564L51.0819 108.87C50.7841 109.385 49.9978 109.175 49.9978 108.579V58.6144C49.9978 57.616 49.4643 56.6926 48.5987 56.1912L5.32839 31.21C4.81418 30.9122 5.02415 30.1259 5.61977 30.1259H93.7331C94.9843 30.1259 95.7642 31.4799 95.1386 32.564Z" fill="white" fill-opacity="0.2"/></svg>

#version 300 es
precision mediump float;

layout(location = 0) in vec4 a_position;

uniform vec2 u_resolution;
uniform float u_pixelRatio;
uniform float u_imageAspectRatio;
uniform float u_originX;
uniform float u_originY;
uniform float u_worldWidth;
uniform float u_worldHeight;
uniform float u_fit;
uniform float u_scale;
uniform float u_rotation;
uniform float u_offsetX;
uniform float u_offsetY;

out vec2 v_objectUV;
out vec2 v_objectBoxSize;
out vec2 v_responsiveUV;
out vec2 v_responsiveBoxGivenSize;
out vec2 v_patternUV;
out vec2 v_patternBoxSize;
out vec2 v_imageUV;

vec3 getBoxSize(float boxRatio, vec2 givenBoxSize) {
  vec2 box = vec2(0.);
  // fit = none
  box.x = boxRatio * min(givenBoxSize.x / boxRatio, givenBoxSize.y);
  float noFitBoxWidth = box.x;
  if (u_fit == 1.) { // fit = contain
    box.x = boxRatio * min(u_resolution.x / boxRatio, u_resolution.y);
  } else if (u_fit == 2.) { // fit = cover
    box.x = boxRatio * max(u_resolution.x / boxRatio, u_resolution.y);
  }
  box.y = box.x / boxRatio;
  return vec3(box, noFitBoxWidth);
}

void main() {
  gl_Position = a_position;

  vec2 uv = gl_Position.xy * .5;
  vec2 boxOrigin = vec2(.5 - u_originX, u_originY - .5);
  vec2 givenBoxSize = vec2(u_worldWidth, u_worldHeight);
  givenBoxSize = max(givenBoxSize, vec2(1.)) * u_pixelRatio;
  float r = u_rotation * 3.14159265358979323846 / 180.;
  mat2 graphicRotation = mat2(cos(r), sin(r), -sin(r), cos(r));
  vec2 graphicOffset = vec2(-u_offsetX, u_offsetY);


  // ===================================================

  float fixedRatio = 1.;
  vec2 fixedRatioBoxGivenSize = vec2(
  (u_worldWidth == 0.) ? u_resolution.x : givenBoxSize.x,
  (u_worldHeight == 0.) ? u_resolution.y : givenBoxSize.y
  );

  v_objectBoxSize = getBoxSize(fixedRatio, fixedRatioBoxGivenSize).xy;
  vec2 objectWorldScale = u_resolution.xy / v_objectBoxSize;

  v_objectUV = uv;
  v_objectUV *= objectWorldScale;
  v_objectUV += boxOrigin * (objectWorldScale - 1.);
  v_objectUV += graphicOffset;
  v_objectUV /= u_scale;
  v_objectUV = graphicRotation * v_objectUV;

  // ===================================================

  v_responsiveBoxGivenSize = vec2(
  (u_worldWidth == 0.) ? u_resolution.x : givenBoxSize.x,
  (u_worldHeight == 0.) ? u_resolution.y : givenBoxSize.y
  );
  float responsiveRatio = v_responsiveBoxGivenSize.x / v_responsiveBoxGivenSize.y;
  vec2 responsiveBoxSize = getBoxSize(responsiveRatio, v_responsiveBoxGivenSize).xy;
  vec2 responsiveBoxScale = u_resolution.xy / responsiveBoxSize;

  #ifdef ADD_HELPERS
  v_responsiveHelperBox = uv;
  v_responsiveHelperBox *= responsiveBoxScale;
  v_responsiveHelperBox += boxOrigin * (responsiveBoxScale - 1.);
  #endif

  v_responsiveUV = uv;
  v_responsiveUV *= responsiveBoxScale;
  v_responsiveUV += boxOrigin * (responsiveBoxScale - 1.);
  v_responsiveUV += graphicOffset;
  v_responsiveUV /= u_scale;
  v_responsiveUV.x *= responsiveRatio;
  v_responsiveUV = graphicRotation * v_responsiveUV;
  v_responsiveUV.x /= responsiveRatio;

  // ===================================================

  float patternBoxRatio = givenBoxSize.x / givenBoxSize.y;
  vec2 patternBoxGivenSize = vec2(
  (u_worldWidth == 0.) ? u_resolution.x : givenBoxSize.x,
  (u_worldHeight == 0.) ? u_resolution.y : givenBoxSize.y
  );
  patternBoxRatio = patternBoxGivenSize.x / patternBoxGivenSize.y;

  vec3 boxSizeData = getBoxSize(patternBoxRatio, patternBoxGivenSize);
  v_patternBoxSize = boxSizeData.xy;
  float patternBoxNoFitBoxWidth = boxSizeData.z;
  vec2 patternBoxScale = u_resolution.xy / v_patternBoxSize;

  v_patternUV = uv;
  v_patternUV += graphicOffset / patternBoxScale;
  v_patternUV += boxOrigin;
  v_patternUV -= boxOrigin / patternBoxScale;
  v_patternUV *= u_resolution.xy;
  v_patternUV /= u_pixelRatio;
  if (u_fit > 0.) {
    v_patternUV *= (patternBoxNoFitBoxWidth / v_patternBoxSize.x);
  }
  v_patternUV /= u_scale;
  v_patternUV = graphicRotation * v_patternUV;
  v_patternUV += boxOrigin / patternBoxScale;
  v_patternUV -= boxOrigin;
  // x100 is a default multiplier between vertex and fragmant shaders
  // we use it to avoid UV presision issues
  v_patternUV *= .01;

  // ===================================================

  vec2 imageBoxSize;
  if (u_fit == 1.) { // contain
    imageBoxSize.x = min(u_resolution.x / u_imageAspectRatio, u_resolution.y) * u_imageAspectRatio;
  } else if (u_fit == 2.) { // cover
    imageBoxSize.x = max(u_resolution.x / u_imageAspectRatio, u_resolution.y) * u_imageAspectRatio;
  } else {
    imageBoxSize.x = min(10.0, 10.0 / u_imageAspectRatio * u_imageAspectRatio);
  }
  imageBoxSize.y = imageBoxSize.x / u_imageAspectRatio;
  vec2 imageBoxScale = u_resolution.xy / imageBoxSize;

  v_imageUV = uv;
  v_imageUV *= imageBoxScale;
  v_imageUV += boxOrigin * (imageBoxScale - 1.);
  v_imageUV += graphicOffset;
  v_imageUV /= u_scale;
  v_imageUV.x *= u_imageAspectRatio;
  v_imageUV = graphicRotation * v_imageUV;
  v_imageUV.x /= u_imageAspectRatio;

  v_imageUV += .5;
  v_imageUV.y = 1. - v_imageUV.y;
}

An error occurred compiling the shaders: 

precision highp float;

precision highp float

Unable to initialize the shader program: 

Tried to render before program or gl was initialized

Paper Shaders: image for uniform ${d} must be fully loaded

Paper Shaders: WebGL error when uploading texture:

Uniform location for ${h} not found

All child arrays must be the same length for ${h}

Unsupported uniform array length: ${b}

Unsupported uniform type for ${h}: ${typeof p}

Paper Shaders: parent element must be an HTMLElement

Paper Shaders: WebGL is not supported in this browser

@layer paper-shaders {
  :where([data-paper-shader]) {
    isolation: isolate;
    position: relative;

    & canvas {
      contain: strict;
      display: block;
      position: absolute;
      inset: 0;
      z-index: -1;
      width: 100%;
      height: 100%;
      border-radius: inherit;
      corner-shape: inherit;
    }
  }
}

#define TWO_PI 6.28318530718
#define PI 3.14159265358979323846

vec2 rotate(vec2 uv, float th) {
  return mat2(cos(th), sin(th), -sin(th), cos(th)) * uv;
}

  color += 1. / 256. * (fract(sin(dot(.014 * gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453123) - .5);

vec3 permute(vec3 x) { return mod(((x * 34.0) + 1.0) * x, 289.0); }
float snoise(vec2 v) {
  const vec4 C = vec4(0.211324865405187, 0.366025403784439,
    -0.577350269189626, 0.024390243902439);
  vec2 i = floor(v + dot(v, C.yy));
  vec2 x0 = v - i + dot(i, C.xx);
  vec2 i1;
  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
  vec4 x12 = x0.xyxy + C.xxzz;
  x12.xy -= i1;
  i = mod(i, 289.0);
  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))
    + i.x + vec3(0.0, i1.x, 1.0));
  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy),
      dot(x12.zw, x12.zw)), 0.0);
  m = m * m;
  m = m * m;
  vec3 x = 2.0 * fract(p * C.www) - 1.0;
  vec3 h = abs(x) - 0.5;
  vec3 ox = floor(x + 0.5);
  vec3 a0 = x - ox;
  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
  vec3 g;
  g.x = a0.x * x0.x + h.x * x0.y;
  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
  return 130.0 * dot(m, g);
}

Invalid file or canvas context

[Processing Mode]

  Original: ${d}×${h}

  Working: ${_}×${b} (${(f*100).toFixed(1)}% scale)

  Speedup: ~${Math.round(1/(f*f))}×

[Mask Building] Time: ${(performance.now()-w).toFixed(2)}ms

  Shape pixels: ${R} / ${_*b} (${(R/(_*b)*100).toFixed(1)}%)

  Interior pixels: ${L.length}

  Boundary pixels: ${P.length}

[Poisson Solve] Time: ${(performance.now()-B).toFixed(2)}ms

Failed to create PNG blob

[Total Processing Time] ${ee.toFixed(2)}ms

[Estimated time at full resolution] ~${te.toFixed(0)}ms

[Time saved] ~${(te-ee).toFixed(0)}ms (${Math.round(te/ee)}× faster)

Failed to load image

[Optimized Poisson Solver (SOR ω=${h})]

  Working size: ${i}×${r}