@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-6PJWXIFX.mjs

@@ -0,0 +1,357 @@
+import { avatarFace } from './chunk-Z3A3AFVU.mjs';
+
+// src/avatars/draw.ts
+var INK = [31, 26, 28], WHITE = [255, 255, 255], BLACK = [0, 0, 0], MOUTH = [122, 44, 52], BLUSH = [224, 106, 106], DEVICE = [201, 207, 214], COMIC_STROKE = 1.8, COMIC_STROKE_SMALL = 2.6, PRECISION = 100, BYTE_MAX = 255, HEX_RADIX = 16, MULBERRY_STEP = 1831565813, LUMA_R = 0.2126, LUMA_G = 0.7152, LUMA_B = 0.0722, HIGHLIGHT = 0.16, HIGHLIGHT_DARK = 0.1, SHADOW = 0.22, SHADOW_DARK = 0.06, DEPIGMENTED = [241, 216, 200], SCLERA = [251, 248, 244], UNIT = 4294967296;
+function round(value) {
+  return Math.round(value * (100)) / (100);
+}
+function hex(colour) {
+  let out = "#";
+  for (let channel of colour) {
+    let value = Math.max(0, Math.min((255), Math.round(channel)));
+    out += (value < (16) ? "0" : "") + value.toString((16));
+  }
+  return out;
+}
+function mix(a, b, t) {
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+}
+function shade(colour, t) {
+  return mix(colour, BLACK, t);
+}
+function tint(colour, t) {
+  return mix(colour, WHITE, t);
+}
+function luminance(colour) {
+  return ((0.2126) * colour[0] + (0.7152) * colour[1] + (0.0722) * colour[2]) / (255);
+}
+function random(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + (1831565813) >>> 0;
+    let t = state;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / (4294967296);
+  };
+}
+var Canvas = class {
+  constructor(style, small) {
+    this.style = style;
+    this.small = small;
+    this.defs = [];
+    this.body = [];
+    this.gradients = 0;
+  }
+  paint(colour, tip = null) {
+    if (this.style === "comic") return hex(colour);
+    let id = `g${this.gradients++}`;
+    if (tip !== null)
+      this.defs.push(
+        `<linearGradient id="${id}" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="${hex(tint(colour, 0.12))}"/><stop offset="0.6" stop-color="${hex(colour)}"/><stop offset="1" stop-color="${hex(tip)}"/></linearGradient>`
+      );
+    else {
+      let light = luminance(colour), lift = tint(colour, (0.16) + (0.1) * (1 - light)), fall = shade(colour, (0.06) + (0.22) * light);
+      this.defs.push(
+        `<radialGradient id="${id}" cx="0.35" cy="0.3" r="0.8"><stop offset="0" stop-color="${hex(lift)}"/><stop offset="0.55" stop-color="${hex(colour)}"/><stop offset="1" stop-color="${hex(fall)}"/></radialGradient>`
+      );
+    }
+    return `url(#${id})`;
+  }
+  ink() {
+    return this.style !== "comic" ? "" : ` stroke="${hex(INK)}" stroke-width="${this.small ? (2.6) : (1.8)}" stroke-linejoin="round"`;
+  }
+  clip(id, shape) {
+    this.defs.push(`<clipPath id="${id}">${shape}</clipPath>`);
+  }
+  add(element) {
+    this.body.push(element);
+  }
+  svg(size) {
+    let defs = this.defs.length === 0 ? "" : `<defs>${this.defs.join("")}</defs>`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="${size}" height="${size}">${defs}${this.body.join("")}</svg>`;
+  }
+};
+function hairBack(canvas, face, head, fill) {
+  if (!face.covered) {
+    if (face.hairShape === "afro") {
+      let r = head.rx + 5 + face.hairVolume * 9;
+      canvas.add(
+        `<circle cx="50" cy="${round(36)}" r="${round(r)}" fill="${fill}"${canvas.ink()}/>`
+      );
+      return;
+    }
+    if (face.hairShape === "long") {
+      let drop = round(63 + face.hairLength * 22), w = round(head.rx + 4);
+      canvas.add(
+        `<path d="M ${50 - w} 39 Q ${50 - w - 3} ${drop - 8} ${50 - w + 4} ${drop} L ${50 + w - 4} ${drop} Q ${50 + w + 3} ${drop - 8} ${50 + w} 39 Z" fill="${fill}"${canvas.ink()}/>`
+      );
+    }
+  }
+}
+function torso(canvas, face) {
+  canvas.add(
+    `<path d="M 12 100 C 14 80 31 73 50 73 C 69 73 86 80 88 100 Z" fill="${canvas.paint(face.outfit)}"${canvas.ink()}/>`
+  ), canvas.add(
+    `<rect x="42" y="60" width="16" height="15" rx="5" fill="${canvas.paint(shade(face.skin, 0.14))}"/>`
+  );
+}
+function ears(canvas, face, head, skin) {
+  for (let side of [-1, 1])
+    canvas.add(
+      `<ellipse cx="${round(50 + side * (head.rx - 0.5))}" cy="48" rx="4" ry="6" fill="${skin}"${canvas.ink()}/>`
+    );
+  if (face.hearing === null) return;
+  let sides = face.hearing === "both" || face.hearing === "centre" ? [-1, 1] : face.hearing === "left" ? [-1] : [1];
+  for (let side of sides)
+    canvas.add(
+      `<path d="M ${round(50 + side * (head.rx + 2))} 42 q ${side * 4} 2 ${side * 2} 9" fill="none" stroke="${hex(DEVICE)}" stroke-width="2.4" stroke-linecap="round"/>`
+    );
+}
+function headShape(canvas, face, head, skin) {
+  let ellipse = `<ellipse cx="50" cy="45" rx="${round(head.rx)}" ry="${round(head.ry)}"/>`;
+  if (canvas.clip("head", ellipse), canvas.add(
+    `<ellipse cx="50" cy="45" rx="${round(head.rx)}" ry="${round(head.ry)}" fill="${skin}"${canvas.ink()}/>`
+  ), canvas.style === "comic" && canvas.add(
+    `<ellipse cx="${round(50 + head.rx * 0.45)}" cy="${round(45 + head.ry * 0.35)}" rx="${round(head.rx * 0.75)}" ry="${round(head.ry * 0.7)}" fill="${hex(shade(face.skin, (0.06) + 0.08 * luminance(face.skin)))}" clip-path="url(#head)"/>`
+  ), face.patches > 0) {
+    let next = random(face.seed), patch = hex(mix(face.skin, DEPIGMENTED, 0.8));
+    for (let i = 0; i < face.patches; i++) {
+      let x = 50 + (next() - 0.5) * head.rx * 1.6, y = 45 + (next() - 0.5) * head.ry * 1.6, r = 2 + next() * 4;
+      canvas.add(
+        `<ellipse cx="${round(x)}" cy="${round(y)}" rx="${round(r * 1.3)}" ry="${round(r)}" fill="${patch}" clip-path="url(#head)"/>`
+      );
+    }
+  }
+}
+function capPath(head, lift, hairline, part) {
+  let left = round(50 - head.rx - lift), right = round(50 + head.rx + lift), top = round(head.ry + lift), side = round(43), line = round(45 - head.ry * hairline);
+  return `M ${left} ${side} A ${round(head.rx + lift)} ${top} 0 0 1 ${right} ${side} Q ${round(50 + part)} ${line} ${left} ${side} Z`;
+}
+function hairFront(canvas, face, head, fill) {
+  if (face.covered) {
+    let wrap = canvas.paint(face.accent);
+    canvas.add(`<path d="${capPath(head, 5, 0.25, 0)}" fill="${wrap}"${canvas.ink()}/>`), canvas.add(
+      `<ellipse cx="56" cy="${round(45 - head.ry - 4)}" rx="9" ry="6" fill="${wrap}"${canvas.ink()}/>`
+    );
+    return;
+  }
+  switch (face.hairShape) {
+    case "bald":
+      return;
+    case "crop":
+      canvas.add(`<path d="${capPath(head, 0.8, 0.62, 0)}" fill="${fill}" opacity="0.92"/>`);
+      return;
+    case "cap":
+    case "long":
+      canvas.add(`<path d="${capPath(head, 3, 0.5, -7)}" fill="${fill}"${canvas.ink()}/>`);
+      return;
+    case "curls": {
+      canvas.add(`<path d="${capPath(head, 3, 0.5, 0)}" fill="${fill}"${canvas.ink()}/>`);
+      let count = 7;
+      for (let i = 0; i < count; i++) {
+        let angle = Math.PI * (0.1 + 0.8 * i / (count - 1)), x = 50 - Math.cos(angle) * (head.rx + 2), y = 41 - Math.sin(angle) * (head.ry + 1);
+        canvas.add(
+          `<circle cx="${round(x)}" cy="${round(y)}" r="${round(4 + face.coily * 2)}" fill="${fill}"${canvas.ink()}/>`
+        );
+      }
+      return;
+    }
+    case "afro":
+      canvas.add(`<path d="${capPath(head, 2, 0.66, 0)}" fill="${fill}"/>`);
+      return;
+    case "buns": {
+      canvas.add(`<path d="${capPath(head, 2.5, 0.5, 0)}" fill="${fill}"${canvas.ink()}/>`);
+      let two = face.seed % 2 === 1, spots = two ? [-11, 11] : [0];
+      for (let dx of spots)
+        canvas.add(
+          `<circle cx="${50 + dx}" cy="${round(45 - head.ry - (two ? 1 : 5))}" r="${two ? 7 : 9}" fill="${fill}"${canvas.ink()}/>`
+        );
+    }
+  }
+}
+function brows(canvas, face, head) {
+  let y = round(45 - head.ry * 0.24), width = round(Math.min(3.6, 1.5 + face.brows * 0.5)), colour = hex(shade(face.hair, 0.1));
+  for (let side of [-1, 1]) {
+    let raised = face.pose === "playful" && side === 1 ? -2 : 0, arch = face.pose === "cool" ? 0.5 : 1.8, x = 50 + side * 8 * face.width;
+    canvas.add(
+      `<path d="M ${round(x - 4.5)} ${y + raised} Q ${round(x)} ${round(y - arch + raised)} ${round(x + 4.5)} ${y + raised}" fill="none" stroke="${colour}" stroke-width="${width}" stroke-linecap="round"/>`
+    );
+  }
+}
+function eyes(canvas, face) {
+  let pupil = hex(shade(face.eye, 0.6));
+  for (let side of [-1, 1]) {
+    let x = round(50 + side * 8 * face.width);
+    if (face.pose === "playful" && side === -1) {
+      canvas.add(
+        `<path d="M ${x - 3} 44 Q ${x} 41 ${x + 3} 44" fill="none" stroke="${pupil}" stroke-width="1.8" stroke-linecap="round"/>`
+      );
+      continue;
+    }
+    let ry = face.pose === "cool" ? 2 : 3.2;
+    canvas.small || canvas.add(`<ellipse cx="${x}" cy="44" rx="3.6" ry="${ry + 0.7}" fill="${hex(SCLERA)}"/>`), canvas.style === "toon_3d" && !canvas.small ? (canvas.add(`<ellipse cx="${x}" cy="44" rx="3" ry="${ry + 0.3}" fill="${hex(face.eye)}"/>`), canvas.add(`<ellipse cx="${x}" cy="44" rx="1.6" ry="${round(ry * 0.6)}" fill="${pupil}"/>`)) : canvas.add(`<ellipse cx="${x}" cy="44" rx="2.6" ry="${ry}" fill="${pupil}"/>`), canvas.small || canvas.add(`<circle cx="${x - 0.9}" cy="${44 - 1.1}" r="0.9" fill="#ffffff"/>`);
+  }
+}
+function glasses(canvas, face) {
+  if (!face.glasses) return;
+  let frame = hex(INK), width = canvas.small ? 2 : 1.4;
+  for (let side of [-1, 1]) {
+    let x = round(50 + side * 8 * face.width - 6.5);
+    canvas.add(
+      `<rect x="${x}" y="39" width="13" height="10" rx="3" fill="#ffffff" fill-opacity="0.15" stroke="${frame}" stroke-width="${width}"/>`
+    );
+  }
+  canvas.add(
+    `<path d="M ${round(50 - 8 * face.width + 6.5)} 43 Q 50 41 ${round(50 + 8 * face.width - 6.5)} 43" fill="none" stroke="${frame}" stroke-width="${width}"/>`
+  );
+}
+function facialHair(canvas, face, head) {
+  if (face.facialHair <= 0) return;
+  let colour = hex(face.hair), jaw = round(45 + head.ry);
+  if (face.facialHair === 1) {
+    canvas.add(
+      `<path d="M ${round(50 - head.rx + 2)} 49 Q 50 ${jaw + 6} ${round(50 + head.rx - 2)} 49 Q 50 ${jaw - 4} ${round(50 - head.rx + 2)} 49 Z" fill="${colour}" opacity="0.3" clip-path="url(#head)"/>`
+    );
+    return;
+  }
+  canvas.add(
+    `<path d="M 43 55 Q 50 52 57 55 Q 50 ${45 + 9.5} 43 55 Z" fill="${colour}" stroke="${colour}" stroke-width="1.6" stroke-linejoin="round"/>`
+  ), face.facialHair !== 2 && canvas.add(
+    `<path d="M ${round(50 - head.rx + 1)} 47 Q ${round(50 - head.rx + 2)} ${jaw + 4} 50 ${jaw + 5} Q ${round(50 + head.rx - 2)} ${jaw + 4} ${round(50 + head.rx - 1)} 47 Q 50 67 ${round(50 - head.rx + 1)} 47 Z" fill="${colour}"${canvas.ink()}/>`
+  );
+}
+function features(canvas, face) {
+  let nose = hex(shade(face.skin, 0.3));
+  canvas.small || canvas.add(
+    `<path d="M 49 48 Q ${50 + 2.5} 51 ${50 - 1.5} 52" fill="none" stroke="${nose}" stroke-width="1.2" stroke-linecap="round"/>`
+  );
+  let lip = hex(mix(face.skin, MOUTH, 0.6)), y = 57;
+  switch (face.pose) {
+    case "warm":
+      canvas.add(
+        `<path d="M 44 ${y - 1} Q 50 ${y + 5} 56 ${y - 1}" fill="none" stroke="${lip}" stroke-width="1.8" stroke-linecap="round"/>`
+      );
+      break;
+    case "playful":
+      canvas.add(
+        `<path d="M 43 ${y - 1} Q 50 ${y + 8} 57 ${y - 1} Z" fill="${hex(shade(MOUTH, 0.25))}" stroke="${lip}" stroke-width="1.2" stroke-linejoin="round"/>`
+      ), canvas.add(
+        `<path d="M 45 ${y - 0.4} L 55 ${y - 0.4} L 54 ${y + 1.6} L 46 ${y + 1.6} Z" fill="#ffffff"/>`
+      );
+      break;
+    case "cool":
+      canvas.add(
+        `<path d="M 45 ${y + 1} Q 51 ${y + 2} 56 ${y - 1}" fill="none" stroke="${lip}" stroke-width="1.8" stroke-linecap="round"/>`
+      );
+      break;
+    default:
+      canvas.add(
+        `<path d="M 45 ${y} Q 50 ${y + 2} 55 ${y}" fill="none" stroke="${lip}" stroke-width="1.8" stroke-linecap="round"/>`
+      );
+  }
+  if (canvas.style === "toon_3d" && (face.pose === "warm" || face.pose === "playful")) {
+    let blush = hex(mix(face.skin, BLUSH, 0.35));
+    for (let side of [-1, 1])
+      canvas.add(
+        `<ellipse cx="${round(50 + side * 12 * face.width)}" cy="52" rx="4" ry="2.4" fill="${blush}" opacity="0.5"/>`
+      );
+  }
+}
+function avatarSvg(face, options) {
+  let canvas = new Canvas(options.style, options.size < 36), head = { rx: 21 * face.width, ry: 25 * face.length };
+  options.backdrop !== false && canvas.add(`<circle cx="50" cy="50" r="50" fill="${hex(face.backdrop)}"/>`);
+  let hair = canvas.paint(face.hair, face.hairTip);
+  hairBack(canvas, face, head, hair), torso(canvas, face);
+  let skin = canvas.paint(face.skin);
+  return ears(canvas, face, head, skin), headShape(canvas, face, head, skin), hairFront(canvas, face, head, hair), brows(canvas, face, head), eyes(canvas, face), glasses(canvas, face), facialHair(canvas, face, head), features(canvas, face), canvas.svg(Math.max(1, Math.round(options.size)));
+}
+function avatarSvgUri(svg) {
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+
+// src/avatars/source.ts
+var RENDER_SIZES = [64, 128, 320, 512], RENDER_PENDING_HEADER = "x-avatar-render", RENDER_PENDING_VALUE = "pending", RENDER_PENDING_RETRY_MS = 5e3, RENDER_PENDING_TRIES = 6, MAX_KEPT_RENDERS = 256, DEFAULT_PIXEL_RATIO = 2, IDLE = { status: "idle", src: null }, LOADING = { status: "loading", src: null }, PENDING = { status: "pending", src: null }, FAILED = { status: "failed", src: null };
+function browserPorts() {
+  return {
+    fetch: (url) => fetch(url),
+    objectUrl: (blob) => URL.createObjectURL(blob),
+    revoke: (url) => URL.revokeObjectURL(url),
+    later: (run, ms) => {
+      setTimeout(run, ms);
+    }
+  };
+}
+var AvatarRenderCache = class {
+  constructor(ports = null) {
+    this.states = /* @__PURE__ */ new Map();
+    this.tries = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (listener) => (this.listeners.add(listener), () => {
+      this.listeners.delete(listener);
+    });
+    this.ports = ports;
+  }
+  state(url) {
+    return url === null ? FAILED : this.states.get(url) ?? IDLE;
+  }
+  request(url) {
+    this.state(url).status === "idle" && this.load(url);
+  }
+  clear() {
+    let ports = this.ports;
+    for (let state of this.states.values()) state.src !== null && ports?.revoke(state.src);
+    this.states.clear(), this.tries.clear(), this.notify();
+  }
+  load(url) {
+    let ports = this.ports ?? (this.ports = browserPorts());
+    this.set(url, LOADING), ports.fetch(url).then(
+      async (response) => {
+        if (!response.ok) return this.set(url, FAILED);
+        if (response.headers.get(RENDER_PENDING_HEADER) === RENDER_PENDING_VALUE)
+          return this.pending(url);
+        this.tries.delete(url), this.set(url, { status: "ready", src: ports.objectUrl(await response.blob()) });
+      },
+      () => this.set(url, FAILED)
+    );
+  }
+  pending(url) {
+    let tries = (this.tries.get(url) ?? 0) + 1;
+    this.tries.set(url, tries), this.set(url, PENDING), !(tries >= (6)) && this.ports?.later(() => {
+      this.state(url).status === "pending" && this.load(url);
+    }, (5e3));
+  }
+  set(url, state) {
+    let before = this.states.get(url);
+    for (before?.src !== null && before?.src !== void 0 && before.src !== state.src && this.ports?.revoke(before.src), this.states.delete(url), this.states.set(url, state); this.states.size > (256); ) {
+      let oldest = this.states.entries().next();
+      if (oldest.done === true) break;
+      let [key, value] = oldest.value;
+      value.src !== null && this.ports?.revoke(value.src), this.states.delete(key), this.tries.delete(key);
+    }
+    this.notify();
+  }
+  notify() {
+    for (let listener of this.listeners) listener();
+  }
+}, avatarRenders = new AvatarRenderCache();
+function renderSize(size, pixelRatio = (2)) {
+  let pixels = Math.ceil(size * pixelRatio);
+  return RENDER_SIZES.find((entry) => entry >= pixels) ?? RENDER_SIZES[RENDER_SIZES.length - 1];
+}
+function avatarRenderUrl(source, apiBase, options) {
+  if (source.hash === "") return null;
+  try {
+    let url = new URL(
+      `v1/avatars/${encodeURIComponent(source.hash)}/${options.kind ?? "portrait"}`,
+      apiBase.endsWith("/") ? apiBase : `${apiBase}/`
+    );
+    return url.searchParams.set("style", options.style), url.searchParams.set("size", String(renderSize(options.size, options.pixelRatio))), url.href;
+  } catch {
+    return null;
+  }
+}
+function drawnAvatarUri(source, options) {
+  let face = avatarFace(source);
+  return face === null ? null : avatarSvgUri(avatarSvg(face, options));
+}
+
+export { AvatarRenderCache, MAX_KEPT_RENDERS, RENDER_PENDING_HEADER, RENDER_PENDING_RETRY_MS, RENDER_PENDING_TRIES, RENDER_PENDING_VALUE, RENDER_SIZES, avatarRenderUrl, avatarRenders, avatarSvg, avatarSvgUri, drawnAvatarUri, renderSize };

package/dist/chunk-6SWKWCMS.js

@@ -0,0 +1,80 @@
+'use strict';
+
+// src/interactives/runtime/approved-wasm.ts
+var REAL = typeof WebAssembly > "u" ? null : WebAssembly, approved = /* @__PURE__ */ new WeakSet(), WasmGuardError = class extends Error {
+  constructor(member) {
+    super(`WebAssembly.${member} is not available to Interactives; only the platform's runtime modules instantiate`), this.name = "GuardError";
+  }
+}, withdrawn = false, sealed = null;
+function sealConstructors(real) {
+  return sealed ?? (sealed = {
+    Module: refusedClass("Module", real.Module.prototype, { imports: real.Module.imports, exports: real.Module.exports, customSections: real.Module.customSections }),
+    Instance: refusedClass("Instance", real.Instance.prototype, {})
+  }), sealed;
+}
+function withdrawWasm() {
+  withdrawn = true, REAL !== null && sealConstructors(REAL);
+}
+function wasmAvailable() {
+  return REAL !== null && !withdrawn;
+}
+async function compileApproved(bytes) {
+  if (REAL === null || withdrawn) throw new WasmGuardError("compile");
+  let module = await REAL.compile(bytes);
+  return approved.add(module), module;
+}
+async function approveCompiled(compiled) {
+  if (REAL === null || withdrawn) throw new WasmGuardError("compile");
+  let module = await compiled;
+  if (!(module instanceof REAL.Module)) throw new WasmGuardError("compile");
+  return approved.add(module), module;
+}
+function refuse(member) {
+  return () => {
+    throw new WasmGuardError(member);
+  };
+}
+function refusedClass(member, prototype, statics) {
+  let refused = function() {
+    throw new WasmGuardError(member);
+  };
+  for (let [name, value] of Object.entries(statics)) Object.defineProperty(refused, name, { value, writable: false, enumerable: true, configurable: false });
+  return Object.defineProperty(refused, "prototype", { value: prototype, writable: false, enumerable: false, configurable: false }), Object.defineProperty(prototype, "constructor", { value: refused, writable: false, enumerable: false, configurable: false }), Object.freeze(refused);
+}
+function checked(module, member) {
+  if (REAL === null || typeof module != "object" || module === null || !approved.has(module)) throw new WasmGuardError(member);
+  return module;
+}
+var guarded;
+function guardedWebAssembly() {
+  let real = REAL;
+  if (real !== null)
+    return guarded ?? (guarded = Object.freeze({
+      Memory: real.Memory,
+      Table: real.Table,
+      Global: real.Global,
+      CompileError: real.CompileError,
+      LinkError: real.LinkError,
+      RuntimeError: real.RuntimeError,
+      compile: refuse("compile"),
+      compileStreaming: refuse("compileStreaming"),
+      instantiateStreaming: refuse("instantiateStreaming"),
+      validate: refuse("validate"),
+      Module: sealConstructors(real).Module,
+      Instance: sealConstructors(real).Instance,
+      instantiate(module, imports) {
+        return real.instantiate(checked(module, "instantiate with bytes or an unapproved module"), imports);
+      }
+    })), guarded;
+}
+async function instantiateApproved(bytes, imports) {
+  let module = await compileApproved(bytes);
+  return REAL.instantiate(module, imports);
+}
+
+exports.approveCompiled = approveCompiled;
+exports.compileApproved = compileApproved;
+exports.guardedWebAssembly = guardedWebAssembly;
+exports.instantiateApproved = instantiateApproved;
+exports.wasmAvailable = wasmAvailable;
+exports.withdrawWasm = withdrawWasm;