30:T1174,nodes = world.generator((w) => { try { const scenarios = w.scenarios() function dedupe(uses, fn, fallbackValue, collisionValue) { let value let collision = false for (const use of uses) { const v = fn(use) if (v === undefined) { continue } if (value === undefined) { value = v continue } if (value != v) { console.log("!!collision", value, "!=", v, fn, {use, uses, fallbackValue}) collision = true break } } if (collision) { value = collisionValue } if (value === undefined) { return fallbackValue } return value } if (scenarios.length === 0) { return [] } function asNumber(d) { const value = d === undefined ? d : +d if (typeof value === "number" && isNaN(value)) { console.warn(`Got NaN from ${d}`) } return value } const scenario = scenarios[0].ui const components = Array.from(scenario.components(), ({def, uses}) => { // Not a fan of the need to do this canonicalDef vs def business... if (def.canonicalDef) { def = def.canonicalDef } const users = [] const usesByUser = new Map() for (const use of uses) { if (use.user === undefined || use.user === scenario.rootUse) { continue } // Not a fan of the need to do this canonicalDef vs def business... const userTemps = (use.user.canonicalDef || use.user.def).temps let userUses = usesByUser.get(userTemps) if (userUses === undefined) { users.push(userTemps) usesByUser.set(userTemps, userUses = []) } userUses.push(use) } const stage = dedupe(uses, use => asNumber(use.attrs.stage), 0) const substage = dedupe(uses, use => asNumber(use.attrs.substage), 0.5) delete def.temps.stage Object.defineProperty(def.temps, 'stage', { get() { return stage }, configurable: true, set(v) { console.log("setting stage to", v) //, def.rawAttrs.stage.sourceLocation) return true }, }) delete def.temps.substage Object.defineProperty(def.temps, 'substage', { get() { return substage }, configurable: true, set(v) { console.log("setting substage to", v) //, def.rawAttrs.stage.sourceLocation) return true }, }) return Object.assign( def.temps, { key: def.key, name: def.name, meta: def.meta, uses, sourceLocation: def.sourceLocation, users, depth: dedupe(uses, use => asNumber(use.attrs.depth), 1), label: dedupe(uses, use => use.attrs.label, def.name), fill: dedupe(uses, use => use.attrs.fill, "white"), fontFamily: dedupe(uses, use => use.attrs.fontFamily, undefined), fontColor: dedupe(uses, use => use.attrs.fontColor, "#333"), fontWeight: dedupe(uses, use => asNumber(use.attrs.fontWeight), 500), fontStyle: dedupe(uses, use => asNumber(use.attrs.fontStyle), undefined), fontSize: dedupe(uses, use => asNumber(use.attrs.fontSize), undefined), stroke: dedupe(uses, use => use.attrs.stroke, "#333"), strokeWidth: dedupe(uses, use => asNumber(use.attrs.strokeWidth), 2), hidden: dedupe(uses, use => use.attrs.hidden, undefined), contour: dedupe(uses, use => use.attrs.contour, undefined), contourRadius: dedupe(uses, use => use.attrs.contourRadius, undefined), showVoronoi: dedupe(uses, use => asNumber(use.attrs.showVoronoi), false), showAnchor: dedupe(uses, use => asNumber(use.attrs.showAnchor), false), radius: dedupe(uses, use => asNumber(use.attrs.radius), 7), compactRadius: dedupe(uses, use => asNumber(use.attrs.compactRadius), 5), userEdges: Array.from(usesByUser, ([sourceDef, userUses]) => ({ target: def.temps, source: sourceDef, need: def.temps, user: sourceDef, label: dedupe(userUses, use => use.attrs.edgeLabel), stroke: dedupe(userUses, use => use.attrs.edgeStroke, "#777"), strokeOpacity: dedupe(userUses, use => asNumber(use.attrs.edgeStrokeOpacity), 0.3), strokeWidth: dedupe(userUses, use => asNumber(use.attrs.edgeStrokeWidth), 1.5), })), }) } ) return components } catch (e) { console.log(e); throw e } })31:T78e,wardleyAnchor = { let width, start, anchor, substageScale, type = "tick", substage = 0 const stops = [ {stage: 1, weight: 2, compactLabel: "I", label: "Genesis", substage, width, start, anchor, substageScale, type}, {stage: 2, weight: 2, compactLabel: "II", label: "Bespoke", substage, width, start, anchor, substageScale, type}, {stage: 3, weight: 3, compactLabel: "III", label: "Product", substage, width, start, anchor, substageScale, type}, {stage: 4, weight: 3, compactLabel: "IV", label: "Utility", substage, width, start, anchor, substageScale, type}, ] const indexClamp = clamp(1, 4) function find(stage) { return stops[indexClamp(stage) - 1] } let totalWeight = 0 for (const stop of stops) { totalWeight += stop.weight } const substageClamp = clamp(0, 1) let cumulativeStart = 0 for (const stop of stops) { let start = cumulativeStart let width = stop.weight / totalWeight stop.width = width stop.start = start stop.anchor = substage => start + substageClamp(substage) * width cumulativeStart = start + width } const totalWidth = xWidth const scaledMin = xMin function wardleyAnchor(d) { return totalWidth * find(d.stage || 1).anchor(d.substage) + scaledMin } let prevStop for (const stop of stops) { stop.x = wardleyAnchor(stop) if (prevStop) { prevStop.xNext = stop.x prevStop.xWidth = prevStop.xNext - prevStop.x } prevStop = stop } prevStop.xNext = xMax prevStop.xWidth = prevStop.xNext - prevStop.x wardleyAnchor.invert = function invert(x) { let stage = 0 let substage = 0.9 for (const stop of stops) { stage = stop.stage if (x >= stop.x && x < stop.xNext) { substage = Math.min(0.9, Math.round(10 * (x - stop.x) / stop.xWidth) / 10) break } } return {stage, substage} } wardleyAnchor.stops = stops return wardleyAnchor }32:T587,drag = (invertX, invertY) => { function dragged(d) { const xAnchor$ = viewof xAnchor.value const yAnchor$ = viewof yAnchor.value if (xAnchor$ && yAnchor$) { if (invertX) { const fdata = xAnchor$.invert(invertX(d3.event.x)) d.fdata = fdata viewof dragStage.value = fdata.stage viewof dragSubstage.value = fdata.substage const fx = xAnchor$(fdata) if (fx != null) { d.fx = fx } } if (invertY) { const fy = invertY(d3.event.y) if (fy != null) { d.fy = fy } } } } function dragstarted(d) { if (!d3.event.active) { simulation.alphaTarget(dragAlphaTarget).restart(); d.dragging = true dragset.add(d) } } function dragended(d) { if (d.fdata != null) { d.stage = d.fdata.stage d.substage = d.fdata.substage } delete d.fdata; if (d.fx != null) { d.x = d.fx; } delete d.fx; if (d.fy != null) { d.y = d.fy; } delete d.fy; if (!d3.event.active) { d.dragging = false dragset.delete(d) viewof dragStage.value = null viewof dragSubstage.value = null simulation.alphaTarget(0); refreshForces(); } } return d3.drag() .on("start", d => dragstarted(d)) .on("drag", d => dragged(d)) .on("end", d => dragended(d)); }33:T602,forceY = { const {constant} = forceHelpers return function forceY(y) { var posStrength = constant(0.1), negStrength = constant(0.1), nodes, posStrengths, negStrengths, yz; if (typeof y !== "function") y = constant(y == null ? 0 : +y); function force(alpha) { for (var i = 0, n = nodes.length, node; i < n; ++i) { node = nodes[i], node.vy += (yz[i] > node.y ? posStrengths[i] : negStrengths[i]) * (yz[i] - node.y) * alpha; } } function initialize() { if (!nodes) return; var i, n = nodes.length; posStrengths = new Array(n); negStrengths = new Array(n); yz = new Array(n); for (i = 0; i < n; ++i) { posStrengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +posStrength(nodes[i], i, nodes); negStrengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +negStrength(nodes[i], i, nodes); } } force.initialize = function(_) { nodes = _; initialize(); }; force.posStrength = function(_) { return arguments.length ? (posStrength = typeof _ === "function" ? _ : constant(+_), initialize(), force) : posStrength; }; force.negStrength = function(_) { return arguments.length ? (negStrength = typeof _ === "function" ? _ : constant(+_), initialize(), force) : negStrength; }; force.y = function(_) { return arguments.length ? (y = typeof _ === "function" ? _ : constant(+_), initialize(), force) : y; }; return force; } }34:Tfa8,forceManyBodySkew = { const {x, y, jiggle, constant} = forceHelpers const quadtree = d3.quadtree function forceManyBody() { var nodes, node, alpha, skewVX = 1, skewVY = 1, skewDistanceX = 1, skewDistanceY = 1, strength = constant(-30), strengths, distanceMin2 = 1, distanceMax2 = Infinity, theta2 = 0.81; function force(_) { var i, n = nodes.length, tree = quadtree(nodes, x, y).visitAfter(accumulate); for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply); } function initialize() { if (!nodes) return; var i, n = nodes.length, node; strengths = new Array(n); for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes); } function accumulate(quad) { var strength = 0, q, c, weight = 0, x, y, i; // For internal nodes, accumulate forces from child quadrants. if (quad.length) { for (x = y = i = 0; i < 4; ++i) { if ((q = quad[i]) && (c = Math.abs(q.value))) { strength += q.value, weight += c, x += c * q.x, y += c * q.y; } } quad.x = x / weight; quad.y = y / weight; } // For leaf nodes, accumulate forces from coincident quadrants. else { q = quad; q.x = q.data.x; q.y = q.data.y; do strength += strengths[q.data.index]; while (q = q.next); } quad.value = strength; } function apply(quad, x1, _, x2) { if (!quad.value) return true; var x = quad.x - node.x, y = quad.y - node.y, w = x2 - x1, l = skewDistanceX * x * x + skewDistanceY * y * y; // Apply the Barnes-Hut approximation if possible. // Limit forces for very close nodes; randomize direction if coincident. if (w * w / theta2 < l) { if (l < distanceMax2) { if (x === 0) x = jiggle(), l += x * x; if (y === 0) y = jiggle(), l += y * y; if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); node.vx += skewVX * x * quad.value * alpha / l; node.vy += skewVY * y * quad.value * alpha / l; } return true; } // Otherwise, process points directly. else if (quad.length || l >= distanceMax2) return; // Limit forces for very close nodes; randomize direction if coincident. if (quad.data !== node || quad.next) { if (x === 0) x = jiggle(), l += x * x; if (y === 0) y = jiggle(), l += y * y; if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); } do if (quad.data !== node) { w = strengths[quad.data.index] * alpha / l; node.vx += skewVX * x * w; node.vy += skewVY * y * w; } while (quad = quad.next); } force.initialize = function(_) { nodes = _; initialize(); }; force.strength = function(_) { return arguments.length ? (strength = typeof _ === "function" ? _ : constant(+_), initialize(), force) : strength; }; force.skewVX = function(_) { return arguments.length ? (skewVX = +_, force) : skewVX; }; force.skewVY = function(_) { return arguments.length ? (skewVY = +_, force) : skewVY; }; force.skewDistanceX = function(_) { return arguments.length ? (skewDistanceX = +_, force) : skewDistanceX; }; force.skewDistanceY = function(_) { return arguments.length ? (skewDistanceY = +_, force) : skewDistanceY; }; force.distanceMin = function(_) { return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2); }; force.distanceMax = function(_) { return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2); }; force.theta = function(_) { return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2); }; return force; } return forceManyBody }35:Tb0b,forceCollideSkew = { const {x, y, jiggle, constant} = forceHelpers const quadtree = d3.quadtree function forceCollideSkew(radius) { var nodes, radii, skewVX = 1, skewVY = 1, strength = 1, iterations = 1; if (typeof radius !== "function") radius = constant(radius == null ? 1 : +radius); function force() { var i, n = nodes.length, tree, node, xi, yi, ri, ri2; for (var k = 0; k < iterations; ++k) { tree = quadtree(nodes, x, y).visitAfter(prepare); for (i = 0; i < n; ++i) { node = nodes[i]; ri = radii[node.index], ri2 = ri * ri; xi = node.x + node.vx; yi = node.y + node.vy; tree.visit(apply); } } function apply(quad, x0, y0, x1, y1) { var data = quad.data, rj = quad.r, r = ri + rj; if (data) { if (data.index > node.index) { var x = xi - data.x - data.vx, y = yi - data.y - data.vy, l = x * x + y * y; if (l < r * r) { if (x === 0) x = jiggle(), l += x * x; if (y === 0) y = jiggle(), l += y * y; l = (r - (l = Math.sqrt(l))) / l * strength; node.vx += skewVX * (x *= l) * (r = (rj *= rj) / (ri2 + rj)); node.vy += skewVY * (y *= l) * r; data.vx -= skewVX * x * (r = 1 - r); data.vy -= skewVY * y * r; } } return; } return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r; } } function prepare(quad) { if (quad.data) return quad.r = radii[quad.data.index]; for (var i = quad.r = 0; i < 4; ++i) { if (quad[i] && quad[i].r > quad.r) { quad.r = quad[i].r; } } } function initialize() { if (!nodes) return; var i, n = nodes.length, node; radii = new Array(n); for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes); } force.initialize = function(_) { nodes = _; initialize(); }; force.iterations = function(_) { return arguments.length ? (iterations = +_, force) : iterations; }; force.strength = function(_) { return arguments.length ? (strength = +_, force) : strength; }; force.skewVX = function(_) { return arguments.length ? (skewVX = +_, force) : skewVX; }; force.skewVY = function(_) { return arguments.length ? (skewVY = +_, force) : skewVY; }; force.radius = function(_) { return arguments.length ? (radius = typeof _ === "function" ? _ : constant(+_), initialize(), force) : radius; }; return force; } return forceCollideSkew }36:T89b,updatePositions = { forces; const xAnchor = xAnchorUpdate; const yAnchor = yAnchorUpdate; // Set initial positions and decide whether or not layout is unchanged let noop = nodes.length === simulation.nodes().length for (const d of nodes) { const x = xAnchor(d) || (xWidth / 2) const y = yAnchor(d) || yMax // Avoid restarting the simulation if all nodes are in the same position as last time if (noop && (d.xAnchor !== x || (d.fx !== undefined && d.fx !== x) || (d.yAnchor !== y || (d.fy !== undefined && d.fy !== y)))) { noop = false } d.xAnchor = x if (d.x == null || isNaN(d.x)) { // console.log("initial x", x, d) d.x = x } d.yAnchor = y if (d.y == null || isNaN(d.y)) { d.y = y // console.log("initial y", y, d) } } if (noop) { if (simulation.alpha() < simulation.alphaMin()) { // console.log("returning early!!!", { // noop, // alpha: simulation.alpha(), // alphaTarget: simulation.alphaTarget(), // alphaMin: simulation.alphaMin(), // atTarget: simulation.alpha() == simulation.alphaTarget() // }) // Whether or not this was a noop, we should announce a single update to node positions. viewof positions.value = nodes viewof layout.value = ({ positions: viewof positions.value, xAnchor, yAnchor, meridians: viewof meridians.value, }) return } else { // console.log("almost returned early but simulation.alpha() >= simulation.alphaMin()", {alpha: simulation.alpha(), alphaMin: simulation.alphaMin(), alphaTarget: simulation.alphaTarget()}) } } refreshForces() simulation .nodes(nodes) ; simulation.on("tick", () => { viewof positions.value = nodes }) simulation.on("end", () => { viewof layout.value = ({ positions: viewof positions.value, xAnchor, yAnchor, meridians: viewof meridians.value, }) }) invalidation.then(() => { simulation.on("tick", null) }) simulation .alpha(initialAlphaTarget) .alphaTarget(0) .restart() viewof positions.value = nodes }37:[] 2e:{"title":"MapScript Map Layout","cells":[{"id":0,"value":"md`# MapScript Map Layout`","pinned":true,"hidden":false,"mode":"ojs"},{"id":32,"value":"import {World} from '6e557ad8d4923730'","pinned":true,"hidden":false,"mode":"ojs"},{"id":33,"value":"world = new World(['x', 'y'])","pinned":true,"hidden":false,"mode":"ojs"},{"id":30,"value":"function xAnchorIsUnknown(d) {\n return d.stage === 0\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":306,"value":"$30","pinned":true,"hidden":false,"mode":"ojs"},{"id":360,"value":"identity = {\n function identity(d) {\n return d\n }\n \n return Object.assign(identity, {invert: identity})\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":58,"value":"function pipe(...fns) {\n return Object.assign(\n d => {\n const r = fns.reduce((acc, fn) => {\n const v = fn(acc)\n return v\n }, d)\n return r\n },\n {\n invert: (d) => {\n let result = d\n for (let i = fns.length - 1; i >= 0; i--) {\n const fn = fns[i]\n const o = fn.invert(result)\n result = o\n }\n return result\n },\n },\n )\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":41,"value":"viewof yAnchor = new View()","pinned":true,"hidden":false,"mode":"ojs"},{"id":43,"value":"yAnchorUpdate = {\n const yGetter = d => d.depth\n const depthExtent = [0, d3.max([5, 2 + d3.max(nodes, yGetter)])]\n \n const yAnchorValue = Object.assign(\n pipe(\n yGetter,\n d3.scaleLinear(depthExtent, yExtent)\n .clamp(true),\n ),\n {\n title: d => \"Visible Value\",\n },\n )\n viewof yAnchor.value = yAnchorValue\n return yAnchorValue\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":46,"value":"update = { yAnchorUpdate; xAnchorUpdate; updateMeridians; updatePositions }","pinned":true,"hidden":false,"mode":"ojs"},{"id":77,"value":"sample = world.run() `\n\nt = 1\n\ncup-of-tea:\n\t-> hot-water:\n\t\tusage = 100 mL\n\ncup-of-tea:\n\t-> tea:\n\t\tusage = 2g\n\ntea:\n\tvarunit = kg\n\tvarunitcost = 200 usd\n\tstroke = \"green\"\n\tfill = \"red\"\n\nhot-water:\n\t-> kettle:\n\t\tusage = 2 kettle minute\n\t-> water\n\nhot-water:\n\tvarunit = L\n\nwater:\n\tvarunitcost = 0.1 usd\n\tvarunit = L\n\nkettle:\n\t-> power:\n\t\tusage = 1 kW\n\tstage = 3\n\npower:\n\tvarunitcost = 0.1 usd / hour\n\tvarunit = kW\n\tstage = 4\n `","pinned":true,"hidden":false,"mode":"ojs"},{"id":70,"value":"yMax = yExtent[1]","pinned":true,"hidden":false,"mode":"ojs"},{"id":114,"value":"yMin = yExtent[0]","pinned":true,"hidden":false,"mode":"ojs"},{"id":123,"value":"yExtent = [0, 100]","pinned":true,"hidden":false,"mode":"ojs"},{"id":116,"value":"xMax = xExtent[1]","pinned":true,"hidden":false,"mode":"ojs"},{"id":118,"value":"xMin = xExtent[0]","pinned":true,"hidden":false,"mode":"ojs"},{"id":642,"value":"xWidth = xExtent[1] - xExtent[0]","pinned":true,"hidden":false,"mode":"ojs"},{"id":120,"value":"xExtent = [0, 100]","pinned":true,"hidden":false,"mode":"ojs"},{"id":125,"value":"dragAlphaTarget = 0.2","pinned":true,"hidden":false,"mode":"ojs"},{"id":127,"value":"initialAlphaTarget = 1.0","pinned":true,"hidden":false,"mode":"ojs"},{"id":55,"value":"viewof xAnchor = new View()","pinned":true,"hidden":false,"mode":"ojs"},{"id":630,"value":"function clamp(min, max) {\n return d => Math.min(Math.max(min, d), max)\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":614,"value":"noAnchor = {\n function noAnchor(d) {\n return d.x\n }\n noAnchor.invert = function invert(v) { return {x: v} }\n noAnchor.stops = []\n return noAnchor\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":612,"value":"$31","pinned":true,"hidden":false,"mode":"ojs"},{"id":659,"value":"onlyShowUnknownRegion = {\n let onlyShowUnknownRegion = true\n for (const node of nodes) {\n if (!xAnchorIsUnknown(node)) {\n onlyShowUnknownRegion = false\n }\n }\n \n return onlyShowUnknownRegion\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":49,"value":"xAnchorUpdate = {\n const xAnchorValue = onlyShowUnknownRegion ? noAnchor : wardleyAnchor\n viewof xAnchor.value = xAnchorValue\n return xAnchorValue\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":99,"value":"simulation = {\n let simulation = d3.forceSimulation()\n\n invalidation.then(() => simulation.stop());\n \n return simulation\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":104,"value":"function refreshForces() {\n simulation.force(\"x\", simulation.force(\"x\"))\n simulation.force(\"y\", simulation.force(\"y\"))\n simulation.force(\"nocollide\", simulation.force(\"nocollide\"))\n simulation.force(\"nostackx\", simulation.force(\"nostackx\"))\n simulation.force(\"nostacky\", simulation.force(\"nostacky\"))\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":238,"value":"dragset = new Set()","pinned":true,"hidden":false,"mode":"ojs"},{"id":824,"value":"viewof layout = new View()","pinned":true,"hidden":false,"mode":"ojs"},{"id":240,"value":"viewof dragStage = new View(null)","pinned":true,"hidden":false,"mode":"ojs"},{"id":266,"value":"viewof dragSubstage = new View(null)","pinned":true,"hidden":false,"mode":"ojs"},{"id":169,"value":"viewof meridians = new View([])","pinned":true,"hidden":false,"mode":"ojs"},{"id":107,"value":"$32","pinned":true,"hidden":false,"mode":"ojs"},{"id":109,"value":"viewof positions = new View([])","pinned":true,"hidden":false,"mode":"ojs"},{"id":315,"value":"positions","pinned":true,"hidden":false,"mode":"ojs"},{"id":112,"value":"forces = {\n const yStrength = 0.3\n const xStrength = 0.3\n\n simulation\n .force(\"y\", forceY().y(yAnchor).posStrength(2 * yStrength).negStrength(yStrength))\n\n if (onlyShowUnknownRegion) {\n simulation\n .force(\"link\", d3.forceLink().strength(0.1))\n .force(\"x\", d3.forceX().x((xExtent[0] + xExtent[1]) / 2).strength(.02))\n .force(\"nostackx\", forceManyBodyX().strength(-1).distanceMax(5))\n .force(\"nostacky\", forceManyBodyY().strength(-1).distanceMax(5))\n .force(\"nocollide\", forceManyBodySkew().skewVX(0.4).strength(-2.5).distanceMax(20))\n } else {\n simulation\n .force(\"link\", null)\n .force(\"x\", d3.forceX().x(xAnchor).strength(xStrength))\n .force(\"nostackx\", forceManyBodyX().strength(-0.05).distanceMax(20))\n .force(\"nocollide\", forceManyBodySkew().skewVX(0.1).strength(-2.5).distanceMax(20))\n }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":591,"value":"seedrandom = require('https://bundle.run/seedrandom@3.0.1')","pinned":true,"hidden":false,"mode":"ojs"},{"id":573,"value":"forceHelpers = {\n // NB: Use a fixed seed to create reproducible layouts in the face of jitter\n const random = seedrandom.alea('someseed')\n return {\n x(d) {\n return d.x\n },\n y(d) {\n return d.y\n },\n jiggle() {\n return (random() - 0.5) * 1e-6;\n },\n constant(x) {\n return function() {\n return x;\n };\n },\n }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":686,"value":"$33","pinned":true,"hidden":false,"mode":"ojs"},{"id":707,"value":"function forceManyBodyX() {\n return forceManyBodySkew().skewVY(0).skewDistanceY(0)\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":805,"value":"function forceManyBodyY() {\n return forceManyBodySkew().skewVX(0).skewDistanceX(0)\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":552,"value":"$34","pinned":true,"hidden":false,"mode":"ojs"},{"id":570,"value":"$35","pinned":true,"hidden":false,"mode":"ojs"},{"id":842,"value":"updateMeridians = {\n const dragMeridians = []\n if (dragStage != null && dragStage !== 0) {\n for (let substage = 0; substage < 10; substage++) {\n const o = {\n stage: dragStage,\n substage: substage / 10,\n type: substage / 10 == dragSubstage ? \"dragsubstage\" : \"dragstage\",\n }\n o.x = xAnchor(o)\n dragMeridians.push(o)\n }\n }\n\n viewof meridians.value = [\n ...xAnchor.stops,\n ...dragMeridians,\n ]\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":102,"value":"$36","pinned":true,"hidden":false,"mode":"ojs"},{"id":51,"value":"d3 = require(\"d3@5\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":53,"value":"class View {\n constructor(value) {\n Object.defineProperties(this, {\n _list: {value: [], writable: true},\n _value: {value, writable: true}\n });\n }\n get value() {\n return this._value;\n }\n set value(value) {\n this._value = value;\n this.dispatchEvent({type: \"input\", value});\n }\n addEventListener(type, listener) {\n if (type != \"input\" || this._list.includes(listener)) return;\n this._list = [listener].concat(this._list);\n }\n removeEventListener(type, listener) {\n if (type != \"input\") return;\n this._list = this._list.filter(l => l !== listener);\n }\n dispatchEvent(event) {\n const p = Promise.resolve(event);\n this._list.forEach(l => p.then(l));\n }\n}","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W37","stdlib":"1","titling":"auto"}