31:T42e,cvs = { z, reliefStrength, shadowStrength, aoStrength, timeOffset, loc, drawLoop; const lerp = (a, b, x) => a * (1 - x) + b * x; const ctx = DOM.context2d((shape[0] - 1) / 2, (shape[1] - 1) / 2, 2); const imageData = ctx.getImageData(0, 0, shape[0] - 2, shape[1] - 2); const px = imageData.data; px.set(aoPixels.slice(0, 512 * 512 * 4)); for (let i = 0; i < 512; i++) { for (let j = 0; j < 512; j++) { const idx = 4 * (i + 512 * j); const shadow = shadowStrength * (1 - px[idx + 3] / 255); const zero = 95; px[idx + 1] = ((px[idx + 1] - zero) * 2.0 * aoStrength) / (1 - aoStrength) + zero; px[idx + 0] = ((px[idx + 0] - 127) * reliefStrength) / (1 - reliefStrength) + 127; px[idx + 2] = ((px[idx + 2] - 127) * reliefStrength) / (1 - reliefStrength) + 127; px[idx] = lerp(px[idx], 0, shadow); px[idx + 1] = lerp(px[idx + 1], 0, shadow); px[idx + 2] = lerp(px[idx + 2], 0, shadow); px[idx + 3] = 255; } } ctx.putImageData(imageData, 0, 0); return ctx.canvas; }32:Te76,function scanline( out, elevation, [w, h], [dx, dy], normalization, pixelSize, isHardShadow, lightSlope = Math.PI / 4 ) { let i, j, z, horizon, d, l, l2, shift, t, f; let s0, s1, idx0, idx1, a, b, di, dj, de; if (dx === 0 && dy === 0) return out; const EPSILON = 1e-8; const flipX = dx < 0; const flipY = dy < 0; dx = Math.abs(dx); dy = Math.abs(dy); const g = gcd(dx, dy); dx /= g; dy /= g; const transpose = dy > dx; const count = scanlineCount([w, h], [dx, dy]); if (!Number.isFinite(count)) throw new Error("Invalid count"); // Compute the slope of the line, transposed so that it's always // less than 45 degrees const rise = transpose ? dx : dy; const run = transpose ? dy : dx; const slope = rise / run; // Compute the direction of interpolation const iInterpDelta = transpose ? (flipX ? -1 : 1) : 0; const jInterpDelta = transpose ? 0 : flipY ? -1 : 1; // Ndarray strides (mostly unused; I transposed inside the loop // rather than via strides, but this would be more efficient) const stride0 = 1; const stride1 = w; const limit0 = w - 1; const limit1 = h - 1; const iStack = new Float32Array(1024); const jStack = new Float32Array(1024); const eStack = new Float32Array(1024); let ptr; for (let scan = 0; scan <= count; scan++) { ptr = -1; shift = -Math.floor((transpose ? h : w) * slope) + scan + EPSILON; let iter = rise === 0 ? 0 : Math.max(0, -Math.floor(EPSILON + shift / slope)); let c = 0; while (++c) { a = iter; b = shift + slope * a; i = (transpose ? b : a) | 0; j = (transpose ? a : b) | 0; if (i > w - 1 || j > h - 1 || i < 0 || j < 0) break; if (flipX) i = w - 1 - i; if (flipY) j = h - 1 - j; const ip = i + iInterpDelta; const jp = j + jInterpDelta; idx0 = i * stride0 + j * stride1; idx1 = Math.min(limit0, Math.max(0, ip)) * stride0 + Math.min(limit1, Math.max(0, jp)) * stride1; t = b - (b | 0); z = elevation[idx0] * (1 - t) + elevation[idx1] * t; let iInterp = i * (1 - t) + ip * t; let jInterp = j * (1 - t) + jp * t; if (c === 1) { iStack[ptr] = iInterp; jStack[ptr] = jInterp; eStack[ptr] = z; ptr++; } let di = iStack[ptr] - iInterp; let dj = jStack[ptr] - jInterp; let de = eStack[ptr] - z; s0 = de * de; s0 /= di * di + dj * dj + s0; s0 = de > 0 ? s0 : -s0; while (ptr > 0) { di = iStack[ptr - 1] - iInterp; dj = jStack[ptr - 1] - jInterp; de = eStack[ptr - 1] - z; s1 = de * de; let l2 = di * di + dj * dj; s1 /= l2 + s1; s1 = de > 0 ? s1 : -s1; if (s0 > s1) break; s0 = s1; ptr--; } di = (iStack[ptr] - iInterp) * pixelSize; dj = (jStack[ptr] - jInterp) * pixelSize; de = eStack[ptr] - z; l = de / Math.sqrt(di * di + dj * dj); if (isHardShadow) { f = smoothstep(l - 0.004, l + 0.004, lightSlope); //f = l < lightSlope ? 1 : 0; //l < lightSlope ? 1 : 0; } else { f = Math.min(1, Math.exp(-l)); //let f = 1 / (1 + l * l); } // Split the contribution between two pixels. If the pixel gets // (1 - t) contribution from this scanline, it will get exactly // t contribution from the next. out[idx0] += (1 - t) * normalization * f; // * falloff); out[idx1] += t * normalization * f; //out[idx0] += normalization * f; // * falloff); ptr++; iStack[ptr] = iInterp; jStack[ptr] = jInterp; eStack[ptr] = z; iter++; } } }33:T8c0,function computeNormals(out, { x, y, z }, elevations, tileSize, buffer) { const A = 6378137.0; const MAXEXTENT = 20037508.342789244; const inWidth = tileSize + 2 * buffer; const inHeight = tileSize + 2 * buffer; const dim = 2 ** z; for (let i = 0; i < tileSize; i++) { const im = Math.max(i - 1, -buffer); const ip = Math.min(i + 1, tileSize - 1 + buffer); const mercatorY = (y + (i + 0.5) / tileSize) / dim; const mercatorScaleFactor = 1 / Math.cos( 2 * Math.atan(Math.exp(Math.PI * (mercatorY * 2 - 1))) - 0.5 * Math.PI ); const dx = (MAXEXTENT * 2) / (mercatorScaleFactor * tileSize * 2 ** z); for (let j = 0; j < tileSize; j++) { const jm = Math.max(j - 1, -buffer); const jp = Math.min(j + 1, tileSize - 1 + buffer); const eN = elevations[buffer + i + inHeight * (buffer + jp)]; const eS = elevations[buffer + i + inHeight * (buffer + jm)]; const eE = elevations[buffer + ip + inHeight * (buffer + j)]; const eW = elevations[buffer + im + inHeight * (buffer + j)]; // Compute the cross product in three dimensions using the four // adjacent elevation samples. It's basically just the gradient, // but it really does come from a proper three-dimensional // computation. And note the mercator scale factor which makes // it (I hope/believe but haven't strictly validated) // dimensionally correct. let nx = (eW - eE) / ((ip - im) * dx); let ny = (eS - eN) / ((jp - jm) * dx); let nz = 1; const nmag = Math.sqrt(nx * nx + ny * ny + 1); nx /= nmag; ny /= nmag; nz /= nmag; // ChatGPT told me webp puts the most precision in the green channel, // so I've used that for ambient occlusion. Thus, the two normal // vector components go in red/blue. The third component can be // reconstructed since it's a unit vector. And of course, lossy is // just fine. const fx = 0.5 - 0.5 * nx; const fy = 0.5 + 0.5 * ny; const idx = (i + tileSize * j) * 4; out[idx + 0] = Math.max(0, Math.min(255, Math.floor(fy * 255))); out[idx + 2] = Math.max(0, Math.min(255, Math.floor(fx * 255))); } } return out; }34:T858,drawTexture = regl({ vert: ` precision highp float; attribute vec2 xy; varying vec2 uv; void main () { uv = 0.5 + 0.5 * xy; gl_Position = vec4(xy, 0, 1); }`, frag: ` precision highp float; uniform sampler2D src, satellite; uniform float aoStrength, reliefStrength, shadowStrength, satelliteOpacity, saturation, brightness; varying vec2 uv; uniform vec3 sunVector; ${glslColor.src} float tanh (float x) { float e2x = exp(2.0 * x); return (e2x - 1.0) / (e2x + 1.0); } void main () { vec4 c = texture2D(src, uv); gl_FragColor = vec4(1.0); vec4 sat = texture2D(satellite, uv); float ao = c.g; float shadow = c.a; vec3 normal = vec3(c.rb * 2.0 - 1.0, 0); normal.z = sqrt(max(0.0, 1.0 - dot(normal.xy, normal.xy))); float daytime = smoothstep(-0.1, 0.3, sunVector.z); float diffuse = (dot(sunVector, normal) - sunVector.z); diffuse *= daytime; float value = 0.5; value += 0.5 * diffuse * reliefStrength / (1.0 - reliefStrength); value += (mix(0.5, ao + 0.04, aoStrength / (1.0 - aoStrength)) - 0.6); value -= (1.0 - mix(0.0, shadow, sqrt(sqrt(sqrt(daytime))))) * shadowStrength; value += brightness; value = 0.5 + 0.5 * tanh(value - 0.50); vec3 col = rgb2lab(sat.rgb); col = mix(vec3(50.0, 0., 0.), col, satelliteOpacity); col.x /= 100.0; col.x = blendOverlay(col.x + value - 0.5, value); col.x *= 100.0; col.yz *= saturation * (0.2 + 0.8 * sqrt(value)); // desaturate at night gl_FragColor.rgb = lab2rgb(col); }`, attributes: { xy: [-4, -4, 4, -4, 0, 4] }, uniforms: { src: regl.prop("src"), sunVector: regl.prop("sunVector"), aoStrength: regl.prop("aoStrength"), reliefStrength: regl.prop("reliefStrength"), shadowStrength: regl.prop("shadowStrength"), satelliteOpacity: regl.prop("satelliteOpacity"), saturation: regl.prop("saturation"), satellite: regl.prop("satelliteTexture"), brightness: regl.prop("brightness") }, depth: { enable: false }, count: 3 })35:[] 2f:{"title":"Line Sweep Terrain Lighting","cells":[{"id":0,"value":"# Line Sweep Terrain Lighting\n\nAn extension of [Line-Sweep Ambient Occlusion](https://observablehq.com/@rreusser/line-sweep-ambient-occlusion) to arbitrary directions. In addition to ambient occlusion and relief shading, this notebook features the addition of physically realistic shadows.","pinned":false,"hidden":false,"mode":"md"},{"id":4767,"value":"A visual representation of the RGBA texture which powers rendering is shown below. Strictly speaking, the strength of the effects is handled in the final shader rather than this texture, but for visual clarity, the strength of the effects is baked into the visual output below.","pinned":false,"hidden":false,"mode":"md"},{"id":1227,"value":"viewof loc = Inputs.select(Object.keys(locationPresets), {\n value: \"West Mitten Butte, Monument Valley Navajo Tribal Park, Arizona, USA\" //\"Mount Saint Helens, WA, USA\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1321,"value":"viewof z = Inputs.range([0, 14], { value: 12, label: \"Zoom level\", step: 1 })","pinned":false,"hidden":false,"mode":"ojs"},{"id":3795,"value":"viewof reliefStrength = Inputs.range([0, 0.99], {\n value: 0.65,\n label: \"Relief strength\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":3797,"value":"viewof shadowStrength = Inputs.range([0, 0.99], {\n value: 0.5,\n label: \"Shadow strength\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":3799,"value":"viewof aoStrength = Inputs.range([0, 0.99], {\n value: 0.4,\n label: \"AO strength\"\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1285,"value":"viewof brightness = Inputs.range([-1, 1], {\n value: 0.1,\n label: \"Brightness adjustment\",\n step: 0.01\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":3108,"value":"viewof timeOffset = Scrubber(\n [...Array(30 * 24).keys()].map((i) => i * 2 - 12 * 60),\n {\n format: (minutes) => `${(minutes / 60).toFixed(2)} hours from solar noon`\n }\n)","pinned":false,"hidden":false,"mode":"ojs"},{"id":59,"value":"viewof regl = {\n const w = Math.min(width, 512);\n const el = reglCanvas(this, {\n width: w,\n height: w,\n extensions: [\"OES_texture_float\"],\n attributes: { preserveDrawingBuffer: true }\n });\n el.style.border = \"1px solid #ccc\";\n return el;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3927,"value":"viewof satelliteOpacity = Inputs.range([0, 1], {\n value: 0.9,\n label: \"Satellite opacity\",\n step: 0.01\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":3972,"value":"viewof saturation = Inputs.range([0, 2], {\n value: 1.25,\n label: \"Saturation\",\n step: 0.01\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":1973,"value":"viewof numAngles = Inputs.range([1, 32], {\n label: \"AO passes\",\n value: 32,\n step: 1\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":4681,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":287,"value":"mutable executionTimeMS = 0","pinned":false,"hidden":false,"mode":"ojs"},{"id":339,"value":"function scanlineCount([w, h], [dx, dy]) {\n // I think this function is off by one in rare instances, so I've\n // overshot the mark by one when iterating to make sure we don't\n // miss a scanline. It just bails instantly as out-of-bounds anyway,\n // though this is not ideal.\n dx = dx === Infinity ? 0 : Math.abs(dx);\n dy = dy === Infinity ? 0 : Math.abs(dy);\n\n // Dividing by the GCD isn't so relevant if the inputs aren't\n // integer offsets.\n const g = gcd(dx, dy);\n dx /= g;\n dy /= g;\n\n const corner = dx !== 0 && dy !== 0 ? 1 : 0;\n if (dx > dy) {\n return h + Math.ceil(Math.abs(dy / dx) * w) - corner;\n } else {\n return w + Math.ceil(Math.abs(dx / dy) * h) - corner;\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3250,"value":"`${timeWithOffset.toLocaleTimeString()} ${timeWithOffset.toLocaleDateString()}`","pinned":false,"hidden":false,"mode":"ojs"},{"id":3241,"value":"tileCenter = {\n const [l, b, r, t] = tilebelt.tileToBBOX([xyz.x, xyz.y, xyz.z]);\n\n return { lon: 0.5 * (l + r), lat: 0.5 * (b + t) };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3238,"value":"timeWithOffset = {\n const times = SunCalc.getTimes(new Date(), tileCenter.lat, tileCenter.lon);\n\n const months = 1000 * 60 * 60 * 24 * 30;\n return new Date(+times.solarNoon + 1000 * 60 * timeOffset - 0 * months);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3035,"value":"sunVector = {\n let { azimuth, altitude } = SunCalc.getPosition(\n timeWithOffset,\n tileCenter.lat,\n tileCenter.lon\n );\n return [\n Math.cos(azimuth) * Math.cos(altitude),\n Math.sin(azimuth) * Math.cos(altitude),\n Math.sin(altitude)\n ];\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3,"value":"$32","pinned":true,"hidden":false,"mode":"ojs"},{"id":93,"value":"elevation = {\n const [width, height] = shape;\n const el = new Float32Array(width * height);\n for (let j = 0; j < height; j++) {\n for (let i = 0; i < width; i++) {\n const eidx = i + width * j;\n el[eidx] = terrainPixels[i + terrainTile.width * j];\n //let x = (i / (h - 1)) * 2 - 1;\n //let y = (j / (w - 1)) * 2 - 1;\n //let r2 = x * x + y * y;\n //el[idx] = Math.exp(-((r2 / radius ** 2) ** 4));\n }\n }\n return el;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":24,"value":"function computeLSAO(\n out,\n elevation,\n [w, h],\n { numAngles = 8, pixelSize = 1, z = 0 } = {}\n) {\n out.fill(0);\n for (let i = 0; i < numAngles; i++) {\n const theta = (i / numAngles) * Math.PI * 2;\n scanline(\n out,\n elevation,\n [w, h],\n [Math.sin(theta), -Math.cos(theta)],\n 1 / numAngles,\n pixelSize,\n false,\n 0\n );\n }\n return out;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":130,"value":"ao = {\n const t0 = performance.now();\n\n const MAXEXTENT = 20037508.342789244;\n const k = 1 / Math.cos(tileCenter.lat * (Math.PI / 180));\n const pixelSize =\n (2 * MAXEXTENT) / terrainTile.tileSize / Math.pow(2, xyz.z) / k;\n\n const [width, height] = shape;\n const ao = new Float32Array(width * height);\n computeLSAO(ao, elevation, shape, { numAngles, pixelSize, z: xyz.z });\n console.log(ao);\n\n mutable executionTimeMS = Math.round((performance.now() - t0) * 10) / 10;\n return ao;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3599,"value":"function computeShadow(out, elevation, [w, h], { pixelSize = 1, z = 0 } = {}) {\n const slope = sunVector[2] / vec2length([sunVector[0], sunVector[1]]);\n const theta = Math.atan2(sunVector[1], sunVector[0]);\n scanline(\n out,\n elevation,\n [w, h],\n [Math.sin(theta), -Math.cos(theta)],\n 1,\n pixelSize,\n true,\n slope\n );\n return out;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3613,"value":"shadow = {\n const MAXEXTENT = 20037508.342789244;\n const k = 1 / Math.cos(tileCenter.lat * (Math.PI / 180));\n const pixelSize =\n (2 * MAXEXTENT) / terrainTile.tileSize / Math.pow(2, xyz.z) / k;\n\n const [width, height] = shape;\n const shadow = new Float32Array(width * height);\n computeShadow(shadow, elevation, shape, { pixelSize, z: xyz.z });\n return shadow;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":90,"value":"shape = [514, 514]","pinned":false,"hidden":false,"mode":"ojs"},{"id":2992,"value":"xyz = {\n const { x, y, z: z0 } = locationPresets[loc];\n const d = 2 ** (14 - z);\n return { x: Math.floor(x / d), y: Math.floor(y / d), z };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":2988,"value":"terrainTile = getTerrainTile(xyz)","pinned":false,"hidden":false,"mode":"ojs"},{"id":1232,"value":"terrainPixels = decodeTerrainData(readImageData(terrainTile.img))","pinned":false,"hidden":false,"mode":"ojs"},{"id":98,"value":"elevationTexture = {\n const [width, height] = shape;\n const elPixels = new Float32Array(width * height * 4);\n for (let j = 0; j < height; j++) {\n for (let i = 0; i < width; i++) {\n const eidx = i + width * j;\n const tidx = i + terrainTile.width * j;\n elPixels[4 * eidx] = terrainPixels[tidx];\n }\n }\n const tex = regl.texture({\n data: elPixels,\n width,\n height,\n flipY: true\n });\n invalidation.then(() => tex.destroy());\n return tex;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3893,"value":"satelliteTile = getSatelliteTile(xyz)","pinned":false,"hidden":false,"mode":"ojs"},{"id":3891,"value":"satelliteTexture = {\n const buf = regl.texture({\n ...satelliteTile,\n data: satelliteTile.img,\n format: \"rgba\",\n type: \"uint8\",\n min: regl.hasExtension(\"OES_texture_float_linear\") ? \"linear\" : \"nearest\",\n mag: regl.hasExtension(\"OES_texture_float_linear\") ? \"linear\" : \"nearest\",\n flipY: true\n });\n invalidation.then(() => buf.destroy());\n return buf;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":3425,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":4667,"value":"aoPixels = new Uint8Array(shape[0] * shape[1] * 4)","pinned":false,"hidden":false,"mode":"ojs"},{"id":3436,"value":"aoTexture = {\n const [width, height] = shape;\n for (let j = 0; j < 512; j++) {\n for (let i = 0; i < 512; i++) {\n const aoIdx = i + 1 + 514 * (j + 1);\n const outIndex = i + 512 * j;\n\n let val = ao[aoIdx] - 0.5;\n val = Math.max(0, Math.min(Math.floor(val * 255)));\n\n aoPixels[outIndex * 4 + 1] = val;\n }\n }\n\n computeNormals(\n aoPixels,\n xyz,\n elevation,\n terrainTile.tileSize,\n terrainTile.buffer\n );\n\n for (let j = 0; j < 512; j++) {\n for (let i = 0; i < 512; i++) {\n const aoIdx = i + 1 + shape[0] * (j + 1);\n const tIdx = i + 512 * j;\n const s = shadow[aoIdx] * 255;\n aoPixels[tIdx * 4 + 3] = s;\n }\n }\n\n aoTextureInit.subimage(aoPixels);\n return aoTextureInit;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":140,"value":"aoTextureInit = {\n const [width, height] = shape;\n const tex = regl.texture({\n type: \"uint8\",\n format: \"rgba\",\n width: 512,\n height: 512,\n min: \"linear\",\n mag: \"linear\",\n flipY: true\n });\n invalidation.then(() => tex.destroy());\n return tex;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":68,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":66,"value":"drawLoop = {\n regl.poll();\n drawTexture({\n src: aoTexture,\n sunVector,\n aoStrength,\n brightness,\n reliefStrength,\n shadowStrength,\n satelliteTexture,\n satelliteOpacity,\n saturation\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":45,"value":"computeSlope = (a, b) => (b[2] - a[2]) / vec3length(vec3sub([], b, a))","pinned":false,"hidden":false,"mode":"ojs"},{"id":595,"value":"function gcd(a, b) {\n return b === 0 ? a : gcd(b, a % b);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":2328,"value":"function smoothstep(edge0, edge1, x) {\n x = Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));\n return x * x * (3.0 - 2.0 * x);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":4568,"value":"function linearstep(edge0, edge1, x) {\n return Math.min(1, Math.max(0, (x - edge0) / (edge1 - edge0)));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":57,"value":"import { reglCanvas } from \"@rreusser/regl-canvas\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":3069,"value":"import { vec2length } from \"@rreusser/gl-vec2\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":12,"value":"import {\n vec3length,\n vec3sub,\n vec3cross,\n vec3dot,\n vec3normalize,\n vec3copy,\n vec3scaleAndAdd\n} from \"@rreusser/gl-vec3\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":74,"value":"import { ColorScaleSelector } from \"@rreusser/regl-color-scale-selector\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":515,"value":"import { xySlider, theme_default as xySliderTheme } from \"@mootari/2d-slider\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":1221,"value":"import {\n getTerrainTile,\n decodeTerrainData,\n readImageData,\n locationPresets,\n getSatelliteTile,\n glslColor\n} from \"@rreusser/line-sweep-ambient-occlusion\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":3030,"value":"SunCalc = require(\"suncalc\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":3038,"value":"tilebelt = (await import(\"https://cdn.skypack.dev/tilebelt\")).default","pinned":false,"hidden":false,"mode":"ojs"},{"id":4157,"value":"import { encodeMP4 } from \"@rreusser/encode-mp4\"","pinned":false,"hidden":false,"mode":"ojs"},{"id":4524,"value":"import { Scrubber } from \"@mbostock/scrubber\"","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W35","stdlib":"1","titling":"auto"}