confsmith 0.1.0

data/app/assets/builds/confsmith.js

@@ -0,0 +1,981 @@
+// node_modules/canvas-confetti/dist/confetti.module.mjs
+var module = {};
+(function main(global, module2, isWorker, workerSize) {
+  var canUseWorker = !!(global.Worker && global.Blob && global.Promise && global.OffscreenCanvas && global.OffscreenCanvasRenderingContext2D && global.HTMLCanvasElement && global.HTMLCanvasElement.prototype.transferControlToOffscreen && global.URL && global.URL.createObjectURL);
+  var canUsePaths = typeof Path2D === "function" && typeof DOMMatrix === "function";
+  var canDrawBitmap = function() {
+    if (!global.OffscreenCanvas) {
+      return false;
+    }
+    var canvas = new OffscreenCanvas(1, 1);
+    var ctx = canvas.getContext("2d");
+    ctx.fillRect(0, 0, 1, 1);
+    var bitmap = canvas.transferToImageBitmap();
+    try {
+      ctx.createPattern(bitmap, "no-repeat");
+    } catch (e2) {
+      return false;
+    }
+    return true;
+  }();
+  function noop() {
+  }
+  function promise(func) {
+    var ModulePromise = module2.exports.Promise;
+    var Prom = ModulePromise !== void 0 ? ModulePromise : global.Promise;
+    if (typeof Prom === "function") {
+      return new Prom(func);
+    }
+    func(noop, noop);
+    return null;
+  }
+  var bitmapMapper = /* @__PURE__ */ function(skipTransform, map) {
+    return {
+      transform: function(bitmap) {
+        if (skipTransform) {
+          return bitmap;
+        }
+        if (map.has(bitmap)) {
+          return map.get(bitmap);
+        }
+        var canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+        var ctx = canvas.getContext("2d");
+        ctx.drawImage(bitmap, 0, 0);
+        map.set(bitmap, canvas);
+        return canvas;
+      },
+      clear: function() {
+        map.clear();
+      }
+    };
+  }(canDrawBitmap, /* @__PURE__ */ new Map());
+  var raf = function() {
+    var TIME = Math.floor(1e3 / 60);
+    var frame, cancel;
+    var frames = {};
+    var lastFrameTime = 0;
+    if (typeof requestAnimationFrame === "function" && typeof cancelAnimationFrame === "function") {
+      frame = function(cb) {
+        var id = Math.random();
+        frames[id] = requestAnimationFrame(function onFrame(time) {
+          if (lastFrameTime === time || lastFrameTime + TIME - 1 < time) {
+            lastFrameTime = time;
+            delete frames[id];
+            cb();
+          } else {
+            frames[id] = requestAnimationFrame(onFrame);
+          }
+        });
+        return id;
+      };
+      cancel = function(id) {
+        if (frames[id]) {
+          cancelAnimationFrame(frames[id]);
+        }
+      };
+    } else {
+      frame = function(cb) {
+        return setTimeout(cb, TIME);
+      };
+      cancel = function(timer) {
+        return clearTimeout(timer);
+      };
+    }
+    return { frame, cancel };
+  }();
+  var getWorker = /* @__PURE__ */ function() {
+    var worker;
+    var prom;
+    var resolves = {};
+    function decorate(worker2) {
+      function execute(options, callback) {
+        worker2.postMessage({ options: options || {}, callback });
+      }
+      worker2.init = function initWorker(canvas) {
+        var offscreen = canvas.transferControlToOffscreen();
+        worker2.postMessage({ canvas: offscreen }, [offscreen]);
+      };
+      worker2.fire = function fireWorker(options, size, done) {
+        if (prom) {
+          execute(options, null);
+          return prom;
+        }
+        var id = Math.random().toString(36).slice(2);
+        prom = promise(function(resolve) {
+          function workerDone(msg) {
+            if (msg.data.callback !== id) {
+              return;
+            }
+            delete resolves[id];
+            worker2.removeEventListener("message", workerDone);
+            prom = null;
+            bitmapMapper.clear();
+            done();
+            resolve();
+          }
+          worker2.addEventListener("message", workerDone);
+          execute(options, id);
+          resolves[id] = workerDone.bind(null, { data: { callback: id } });
+        });
+        return prom;
+      };
+      worker2.reset = function resetWorker() {
+        worker2.postMessage({ reset: true });
+        for (var id in resolves) {
+          resolves[id]();
+          delete resolves[id];
+        }
+      };
+    }
+    return function() {
+      if (worker) {
+        return worker;
+      }
+      if (!isWorker && canUseWorker) {
+        var code = [
+          "var CONFETTI, SIZE = {}, module = {};",
+          "(" + main.toString() + ")(this, module, true, SIZE);",
+          "onmessage = function(msg) {",
+          "  if (msg.data.options) {",
+          "    CONFETTI(msg.data.options).then(function () {",
+          "      if (msg.data.callback) {",
+          "        postMessage({ callback: msg.data.callback });",
+          "      }",
+          "    });",
+          "  } else if (msg.data.reset) {",
+          "    CONFETTI && CONFETTI.reset();",
+          "  } else if (msg.data.resize) {",
+          "    SIZE.width = msg.data.resize.width;",
+          "    SIZE.height = msg.data.resize.height;",
+          "  } else if (msg.data.canvas) {",
+          "    SIZE.width = msg.data.canvas.width;",
+          "    SIZE.height = msg.data.canvas.height;",
+          "    CONFETTI = module.exports.create(msg.data.canvas);",
+          "  }",
+          "}"
+        ].join("\n");
+        try {
+          worker = new Worker(URL.createObjectURL(new Blob([code])));
+        } catch (e2) {
+          typeof console !== void 0 && typeof console.warn === "function" ? console.warn("\u{1F38A} Could not load worker", e2) : null;
+          return null;
+        }
+        decorate(worker);
+      }
+      return worker;
+    };
+  }();
+  var defaults = {
+    particleCount: 50,
+    angle: 90,
+    spread: 45,
+    startVelocity: 45,
+    decay: 0.9,
+    gravity: 1,
+    drift: 0,
+    ticks: 200,
+    x: 0.5,
+    y: 0.5,
+    shapes: ["square", "circle"],
+    zIndex: 100,
+    colors: [
+      "#26ccff",
+      "#a25afd",
+      "#ff5e7e",
+      "#88ff5a",
+      "#fcff42",
+      "#ffa62d",
+      "#ff36ff"
+    ],
+    // probably should be true, but back-compat
+    disableForReducedMotion: false,
+    scalar: 1
+  };
+  function convert(val, transform) {
+    return transform ? transform(val) : val;
+  }
+  function isOk(val) {
+    return !(val === null || val === void 0);
+  }
+  function prop(options, name, transform) {
+    return convert(
+      options && isOk(options[name]) ? options[name] : defaults[name],
+      transform
+    );
+  }
+  function onlyPositiveInt(number) {
+    return number < 0 ? 0 : Math.floor(number);
+  }
+  function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min)) + min;
+  }
+  function toDecimal(str) {
+    return parseInt(str, 16);
+  }
+  function colorsToRgb(colors) {
+    return colors.map(hexToRgb);
+  }
+  function hexToRgb(str) {
+    var val = String(str).replace(/[^0-9a-f]/gi, "");
+    if (val.length < 6) {
+      val = val[0] + val[0] + val[1] + val[1] + val[2] + val[2];
+    }
+    return {
+      r: toDecimal(val.substring(0, 2)),
+      g: toDecimal(val.substring(2, 4)),
+      b: toDecimal(val.substring(4, 6))
+    };
+  }
+  function getOrigin(options) {
+    var origin = prop(options, "origin", Object);
+    origin.x = prop(origin, "x", Number);
+    origin.y = prop(origin, "y", Number);
+    return origin;
+  }
+  function setCanvasWindowSize(canvas) {
+    canvas.width = document.documentElement.clientWidth;
+    canvas.height = document.documentElement.clientHeight;
+  }
+  function setCanvasRectSize(canvas) {
+    var rect = canvas.getBoundingClientRect();
+    canvas.width = rect.width;
+    canvas.height = rect.height;
+  }
+  function getCanvas(zIndex) {
+    var canvas = document.createElement("canvas");
+    canvas.style.position = "fixed";
+    canvas.style.top = "0px";
+    canvas.style.left = "0px";
+    canvas.style.pointerEvents = "none";
+    canvas.style.zIndex = zIndex;
+    return canvas;
+  }
+  function ellipse(context, x, y, radiusX, radiusY, rotation, startAngle, endAngle, antiClockwise) {
+    context.save();
+    context.translate(x, y);
+    context.rotate(rotation);
+    context.scale(radiusX, radiusY);
+    context.arc(0, 0, 1, startAngle, endAngle, antiClockwise);
+    context.restore();
+  }
+  function randomPhysics(opts) {
+    var radAngle = opts.angle * (Math.PI / 180);
+    var radSpread = opts.spread * (Math.PI / 180);
+    return {
+      x: opts.x,
+      y: opts.y,
+      wobble: Math.random() * 10,
+      wobbleSpeed: Math.min(0.11, Math.random() * 0.1 + 0.05),
+      velocity: opts.startVelocity * 0.5 + Math.random() * opts.startVelocity,
+      angle2D: -radAngle + (0.5 * radSpread - Math.random() * radSpread),
+      tiltAngle: (Math.random() * (0.75 - 0.25) + 0.25) * Math.PI,
+      color: opts.color,
+      shape: opts.shape,
+      tick: 0,
+      totalTicks: opts.ticks,
+      decay: opts.decay,
+      drift: opts.drift,
+      random: Math.random() + 2,
+      tiltSin: 0,
+      tiltCos: 0,
+      wobbleX: 0,
+      wobbleY: 0,
+      gravity: opts.gravity * 3,
+      ovalScalar: 0.6,
+      scalar: opts.scalar,
+      flat: opts.flat
+    };
+  }
+  function updateFetti(context, fetti) {
+    fetti.x += Math.cos(fetti.angle2D) * fetti.velocity + fetti.drift;
+    fetti.y += Math.sin(fetti.angle2D) * fetti.velocity + fetti.gravity;
+    fetti.velocity *= fetti.decay;
+    if (fetti.flat) {
+      fetti.wobble = 0;
+      fetti.wobbleX = fetti.x + 10 * fetti.scalar;
+      fetti.wobbleY = fetti.y + 10 * fetti.scalar;
+      fetti.tiltSin = 0;
+      fetti.tiltCos = 0;
+      fetti.random = 1;
+    } else {
+      fetti.wobble += fetti.wobbleSpeed;
+      fetti.wobbleX = fetti.x + 10 * fetti.scalar * Math.cos(fetti.wobble);
+      fetti.wobbleY = fetti.y + 10 * fetti.scalar * Math.sin(fetti.wobble);
+      fetti.tiltAngle += 0.1;
+      fetti.tiltSin = Math.sin(fetti.tiltAngle);
+      fetti.tiltCos = Math.cos(fetti.tiltAngle);
+      fetti.random = Math.random() + 2;
+    }
+    var progress = fetti.tick++ / fetti.totalTicks;
+    var x1 = fetti.x + fetti.random * fetti.tiltCos;
+    var y1 = fetti.y + fetti.random * fetti.tiltSin;
+    var x2 = fetti.wobbleX + fetti.random * fetti.tiltCos;
+    var y2 = fetti.wobbleY + fetti.random * fetti.tiltSin;
+    context.fillStyle = "rgba(" + fetti.color.r + ", " + fetti.color.g + ", " + fetti.color.b + ", " + (1 - progress) + ")";
+    context.beginPath();
+    if (canUsePaths && fetti.shape.type === "path" && typeof fetti.shape.path === "string" && Array.isArray(fetti.shape.matrix)) {
+      context.fill(transformPath2D(
+        fetti.shape.path,
+        fetti.shape.matrix,
+        fetti.x,
+        fetti.y,
+        Math.abs(x2 - x1) * 0.1,
+        Math.abs(y2 - y1) * 0.1,
+        Math.PI / 10 * fetti.wobble
+      ));
+    } else if (fetti.shape.type === "bitmap") {
+      var rotation = Math.PI / 10 * fetti.wobble;
+      var scaleX = Math.abs(x2 - x1) * 0.1;
+      var scaleY = Math.abs(y2 - y1) * 0.1;
+      var width = fetti.shape.bitmap.width * fetti.scalar;
+      var height = fetti.shape.bitmap.height * fetti.scalar;
+      var matrix = new DOMMatrix([
+        Math.cos(rotation) * scaleX,
+        Math.sin(rotation) * scaleX,
+        -Math.sin(rotation) * scaleY,
+        Math.cos(rotation) * scaleY,
+        fetti.x,
+        fetti.y
+      ]);
+      matrix.multiplySelf(new DOMMatrix(fetti.shape.matrix));
+      var pattern = context.createPattern(bitmapMapper.transform(fetti.shape.bitmap), "no-repeat");
+      pattern.setTransform(matrix);
+      context.globalAlpha = 1 - progress;
+      context.fillStyle = pattern;
+      context.fillRect(
+        fetti.x - width / 2,
+        fetti.y - height / 2,
+        width,
+        height
+      );
+      context.globalAlpha = 1;
+    } else if (fetti.shape === "circle") {
+      context.ellipse ? context.ellipse(fetti.x, fetti.y, Math.abs(x2 - x1) * fetti.ovalScalar, Math.abs(y2 - y1) * fetti.ovalScalar, Math.PI / 10 * fetti.wobble, 0, 2 * Math.PI) : ellipse(context, fetti.x, fetti.y, Math.abs(x2 - x1) * fetti.ovalScalar, Math.abs(y2 - y1) * fetti.ovalScalar, Math.PI / 10 * fetti.wobble, 0, 2 * Math.PI);
+    } else if (fetti.shape === "star") {
+      var rot = Math.PI / 2 * 3;
+      var innerRadius = 4 * fetti.scalar;
+      var outerRadius = 8 * fetti.scalar;
+      var x = fetti.x;
+      var y = fetti.y;
+      var spikes = 5;
+      var step = Math.PI / spikes;
+      while (spikes--) {
+        x = fetti.x + Math.cos(rot) * outerRadius;
+        y = fetti.y + Math.sin(rot) * outerRadius;
+        context.lineTo(x, y);
+        rot += step;
+        x = fetti.x + Math.cos(rot) * innerRadius;
+        y = fetti.y + Math.sin(rot) * innerRadius;
+        context.lineTo(x, y);
+        rot += step;
+      }
+    } else {
+      context.moveTo(Math.floor(fetti.x), Math.floor(fetti.y));
+      context.lineTo(Math.floor(fetti.wobbleX), Math.floor(y1));
+      context.lineTo(Math.floor(x2), Math.floor(y2));
+      context.lineTo(Math.floor(x1), Math.floor(fetti.wobbleY));
+    }
+    context.closePath();
+    context.fill();
+    return fetti.tick < fetti.totalTicks;
+  }
+  function animate(canvas, fettis, resizer, size, done) {
+    var animatingFettis = fettis.slice();
+    var context = canvas.getContext("2d");
+    var animationFrame;
+    var destroy;
+    var prom = promise(function(resolve) {
+      function onDone() {
+        animationFrame = destroy = null;
+        context.clearRect(0, 0, size.width, size.height);
+        bitmapMapper.clear();
+        done();
+        resolve();
+      }
+      function update() {
+        if (isWorker && !(size.width === workerSize.width && size.height === workerSize.height)) {
+          size.width = canvas.width = workerSize.width;
+          size.height = canvas.height = workerSize.height;
+        }
+        if (!size.width && !size.height) {
+          resizer(canvas);
+          size.width = canvas.width;
+          size.height = canvas.height;
+        }
+        context.clearRect(0, 0, size.width, size.height);
+        animatingFettis = animatingFettis.filter(function(fetti) {
+          return updateFetti(context, fetti);
+        });
+        if (animatingFettis.length) {
+          animationFrame = raf.frame(update);
+        } else {
+          onDone();
+        }
+      }
+      animationFrame = raf.frame(update);
+      destroy = onDone;
+    });
+    return {
+      addFettis: function(fettis2) {
+        animatingFettis = animatingFettis.concat(fettis2);
+        return prom;
+      },
+      canvas,
+      promise: prom,
+      reset: function() {
+        if (animationFrame) {
+          raf.cancel(animationFrame);
+        }
+        if (destroy) {
+          destroy();
+        }
+      }
+    };
+  }
+  function confettiCannon(canvas, globalOpts) {
+    var isLibCanvas = !canvas;
+    var allowResize = !!prop(globalOpts || {}, "resize");
+    var hasResizeEventRegistered = false;
+    var globalDisableForReducedMotion = prop(globalOpts, "disableForReducedMotion", Boolean);
+    var shouldUseWorker = canUseWorker && !!prop(globalOpts || {}, "useWorker");
+    var worker = shouldUseWorker ? getWorker() : null;
+    var resizer = isLibCanvas ? setCanvasWindowSize : setCanvasRectSize;
+    var initialized = canvas && worker ? !!canvas.__confetti_initialized : false;
+    var preferLessMotion = typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion)").matches;
+    var animationObj;
+    function fireLocal(options, size, done) {
+      var particleCount = prop(options, "particleCount", onlyPositiveInt);
+      var angle = prop(options, "angle", Number);
+      var spread = prop(options, "spread", Number);
+      var startVelocity = prop(options, "startVelocity", Number);
+      var decay = prop(options, "decay", Number);
+      var gravity = prop(options, "gravity", Number);
+      var drift = prop(options, "drift", Number);
+      var colors = prop(options, "colors", colorsToRgb);
+      var ticks = prop(options, "ticks", Number);
+      var shapes = prop(options, "shapes");
+      var scalar = prop(options, "scalar");
+      var flat = !!prop(options, "flat");
+      var origin = getOrigin(options);
+      var temp = particleCount;
+      var fettis = [];
+      var startX = canvas.width * origin.x;
+      var startY = canvas.height * origin.y;
+      while (temp--) {
+        fettis.push(
+          randomPhysics({
+            x: startX,
+            y: startY,
+            angle,
+            spread,
+            startVelocity,
+            color: colors[temp % colors.length],
+            shape: shapes[randomInt(0, shapes.length)],
+            ticks,
+            decay,
+            gravity,
+            drift,
+            scalar,
+            flat
+          })
+        );
+      }
+      if (animationObj) {
+        return animationObj.addFettis(fettis);
+      }
+      animationObj = animate(canvas, fettis, resizer, size, done);
+      return animationObj.promise;
+    }
+    function fire(options) {
+      var disableForReducedMotion = globalDisableForReducedMotion || prop(options, "disableForReducedMotion", Boolean);
+      var zIndex = prop(options, "zIndex", Number);
+      if (disableForReducedMotion && preferLessMotion) {
+        return promise(function(resolve) {
+          resolve();
+        });
+      }
+      if (isLibCanvas && animationObj) {
+        canvas = animationObj.canvas;
+      } else if (isLibCanvas && !canvas) {
+        canvas = getCanvas(zIndex);
+        document.body.appendChild(canvas);
+      }
+      if (allowResize && !initialized) {
+        resizer(canvas);
+      }
+      var size = {
+        width: canvas.width,
+        height: canvas.height
+      };
+      if (worker && !initialized) {
+        worker.init(canvas);
+      }
+      initialized = true;
+      if (worker) {
+        canvas.__confetti_initialized = true;
+      }
+      function onResize() {
+        if (worker) {
+          var obj = {
+            getBoundingClientRect: function() {
+              if (!isLibCanvas) {
+                return canvas.getBoundingClientRect();
+              }
+            }
+          };
+          resizer(obj);
+          worker.postMessage({
+            resize: {
+              width: obj.width,
+              height: obj.height
+            }
+          });
+          return;
+        }
+        size.width = size.height = null;
+      }
+      function done() {
+        animationObj = null;
+        if (allowResize) {
+          hasResizeEventRegistered = false;
+          global.removeEventListener("resize", onResize);
+        }
+        if (isLibCanvas && canvas) {
+          if (document.body.contains(canvas)) {
+            document.body.removeChild(canvas);
+          }
+          canvas = null;
+          initialized = false;
+        }
+      }
+      if (allowResize && !hasResizeEventRegistered) {
+        hasResizeEventRegistered = true;
+        global.addEventListener("resize", onResize, false);
+      }
+      if (worker) {
+        return worker.fire(options, size, done);
+      }
+      return fireLocal(options, size, done);
+    }
+    fire.reset = function() {
+      if (worker) {
+        worker.reset();
+      }
+      if (animationObj) {
+        animationObj.reset();
+      }
+    };
+    return fire;
+  }
+  var defaultFire;
+  function getDefaultFire() {
+    if (!defaultFire) {
+      defaultFire = confettiCannon(null, { useWorker: true, resize: true });
+    }
+    return defaultFire;
+  }
+  function transformPath2D(pathString, pathMatrix, x, y, scaleX, scaleY, rotation) {
+    var path2d = new Path2D(pathString);
+    var t1 = new Path2D();
+    t1.addPath(path2d, new DOMMatrix(pathMatrix));
+    var t2 = new Path2D();
+    t2.addPath(t1, new DOMMatrix([
+      Math.cos(rotation) * scaleX,
+      Math.sin(rotation) * scaleX,
+      -Math.sin(rotation) * scaleY,
+      Math.cos(rotation) * scaleY,
+      x,
+      y
+    ]));
+    return t2;
+  }
+  function shapeFromPath(pathData) {
+    if (!canUsePaths) {
+      throw new Error("path confetti are not supported in this browser");
+    }
+    var path, matrix;
+    if (typeof pathData === "string") {
+      path = pathData;
+    } else {
+      path = pathData.path;
+      matrix = pathData.matrix;
+    }
+    var path2d = new Path2D(path);
+    var tempCanvas = document.createElement("canvas");
+    var tempCtx = tempCanvas.getContext("2d");
+    if (!matrix) {
+      var maxSize = 1e3;
+      var minX = maxSize;
+      var minY = maxSize;
+      var maxX = 0;
+      var maxY = 0;
+      var width, height;
+      for (var x = 0; x < maxSize; x += 2) {
+        for (var y = 0; y < maxSize; y += 2) {
+          if (tempCtx.isPointInPath(path2d, x, y, "nonzero")) {
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+          }
+        }
+      }
+      width = maxX - minX;
+      height = maxY - minY;
+      var maxDesiredSize = 10;
+      var scale = Math.min(maxDesiredSize / width, maxDesiredSize / height);
+      matrix = [
+        scale,
+        0,
+        0,
+        scale,
+        -Math.round(width / 2 + minX) * scale,
+        -Math.round(height / 2 + minY) * scale
+      ];
+    }
+    return {
+      type: "path",
+      path,
+      matrix
+    };
+  }
+  function shapeFromText(textData) {
+    var text, scalar = 1, color = "#000000", fontFamily = '"Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji", "EmojiOne Color", "Android Emoji", "Twemoji Mozilla", "system emoji", sans-serif';
+    if (typeof textData === "string") {
+      text = textData;
+    } else {
+      text = textData.text;
+      scalar = "scalar" in textData ? textData.scalar : scalar;
+      fontFamily = "fontFamily" in textData ? textData.fontFamily : fontFamily;
+      color = "color" in textData ? textData.color : color;
+    }
+    var fontSize = 10 * scalar;
+    var font = "" + fontSize + "px " + fontFamily;
+    var canvas = new OffscreenCanvas(fontSize, fontSize);
+    var ctx = canvas.getContext("2d");
+    ctx.font = font;
+    var size = ctx.measureText(text);
+    var width = Math.ceil(size.actualBoundingBoxRight + size.actualBoundingBoxLeft);
+    var height = Math.ceil(size.actualBoundingBoxAscent + size.actualBoundingBoxDescent);
+    var padding = 2;
+    var x = size.actualBoundingBoxLeft + padding;
+    var y = size.actualBoundingBoxAscent + padding;
+    width += padding + padding;
+    height += padding + padding;
+    canvas = new OffscreenCanvas(width, height);
+    ctx = canvas.getContext("2d");
+    ctx.font = font;
+    ctx.fillStyle = color;
+    ctx.fillText(text, x, y);
+    var scale = 1 / scalar;
+    return {
+      type: "bitmap",
+      // TODO these probably need to be transfered for workers
+      bitmap: canvas.transferToImageBitmap(),
+      matrix: [scale, 0, 0, scale, -width * scale / 2, -height * scale / 2]
+    };
+  }
+  module2.exports = function() {
+    return getDefaultFire().apply(this, arguments);
+  };
+  module2.exports.reset = function() {
+    getDefaultFire().reset();
+  };
+  module2.exports.create = confettiCannon;
+  module2.exports.shapeFromPath = shapeFromPath;
+  module2.exports.shapeFromText = shapeFromText;
+})(function() {
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  return this || {};
+}(), module, false);
+var confetti_module_default = module.exports;
+var create = module.exports.create;
+
+// node_modules/stimulus-confetti/dist/stimulus_confetti.modern.js
+function e() {
+  return e = Object.assign ? Object.assign.bind() : function(t2) {
+    for (var e2 = 1; e2 < arguments.length; e2++) {
+      var r2 = arguments[e2];
+      for (var n2 in r2) Object.prototype.hasOwnProperty.call(r2, n2) && (t2[n2] = r2[n2]);
+    }
+    return t2;
+  }, e.apply(this, arguments);
+}
+function r(t2) {
+  return t2.replace(/(?:[_-])([a-z0-9])/g, (t3, e2) => e2.toUpperCase());
+}
+function n(t2) {
+  return t2.charAt(0).toUpperCase() + t2.slice(1);
+}
+function s(t2, e2) {
+  const r2 = i(t2);
+  return Array.from(r2.reduce((t3, r3) => (function(t4, e3) {
+    const r4 = t4[e3];
+    return Array.isArray(r4) ? r4 : [];
+  }(r3, e2).forEach((e3) => t3.add(e3)), t3), /* @__PURE__ */ new Set()));
+}
+function i(t2) {
+  const e2 = [];
+  for (; t2; ) e2.push(t2), t2 = Object.getPrototypeOf(t2);
+  return e2.reverse();
+}
+function o([t2, e2], n2) {
+  return function(t3) {
+    const e3 = `${s2 = t3.token, s2.replace(/([A-Z])/g, (t4, e4) => `-${e4.toLowerCase()}`)}-value`, n3 = function(t4) {
+      const e4 = function(t5) {
+        const e5 = a(t5.typeObject.type);
+        if (!e5) return;
+        const r3 = c(t5.typeObject.default);
+        if (e5 !== r3) throw new Error(`The specified default value for the Stimulus Value "${t5.controller ? `${t5.controller}.${t5.token}` : t5.token}" must match the defined type "${e5}". The provided default value of "${t5.typeObject.default}" is of type "${r3}".`);
+        return e5;
+      }({ controller: t4.controller, token: t4.token, typeObject: t4.typeDefinition }), r2 = c(t4.typeDefinition), n4 = a(t4.typeDefinition), s3 = e4 || r2 || n4;
+      if (s3) return s3;
+      throw new Error(`Unknown value type "${t4.controller ? `${t4.controller}.${t4.typeDefinition}` : t4.token}" for "${t4.token}" value`);
+    }(t3);
+    var s2;
+    return { type: n3, key: e3, name: r(e3), get defaultValue() {
+      return function(t4) {
+        const e4 = a(t4);
+        if (e4) return u[e4];
+        const r2 = t4.default;
+        return void 0 !== r2 ? r2 : t4;
+      }(t3.typeDefinition);
+    }, get hasCustomDefaultValue() {
+      return void 0 !== c(t3.typeDefinition);
+    }, reader: l[n3], writer: h[n3] || h.default };
+  }({ controller: n2, token: t2, typeDefinition: e2 });
+}
+function a(t2) {
+  switch (t2) {
+    case Array:
+      return "array";
+    case Boolean:
+      return "boolean";
+    case Number:
+      return "number";
+    case Object:
+      return "object";
+    case String:
+      return "string";
+  }
+}
+function c(t2) {
+  switch (typeof t2) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+  }
+  return Array.isArray(t2) ? "array" : "[object Object]" === Object.prototype.toString.call(t2) ? "object" : void 0;
+}
+(() => {
+  try {
+    !function() {
+      const t2 = function(t3) {
+        function e2() {
+          return Reflect.construct(t3, arguments, new.target);
+        }
+        return e2.prototype = Object.create(t3.prototype, { constructor: { value: e2 } }), Reflect.setPrototypeOf(e2, t3), e2;
+      }(function() {
+        this.a.call(this);
+      });
+      t2.prototype.a = function() {
+      }, new t2();
+    }();
+  } catch (t2) {
+    return (t3) => class extends t3 {
+    };
+  }
+})();
+var u = { get array() {
+  return [];
+}, boolean: false, number: 0, get object() {
+  return {};
+}, string: "" };
+var l = { array(t2) {
+  const e2 = JSON.parse(t2);
+  if (!Array.isArray(e2)) throw new TypeError(`expected value of type "array" but instead got value "${t2}" of type "${c(e2)}"`);
+  return e2;
+}, boolean: (t2) => !("0" == t2 || "false" == String(t2).toLowerCase()), number: (t2) => Number(t2), object(t2) {
+  const e2 = JSON.parse(t2);
+  if (null === e2 || "object" != typeof e2 || Array.isArray(e2)) throw new TypeError(`expected value of type "object" but instead got value "${t2}" of type "${c(e2)}"`);
+  return e2;
+}, string: (t2) => t2 };
+var h = { default: function(t2) {
+  return `${t2}`;
+}, array: d, object: d };
+function d(t2) {
+  return JSON.stringify(t2);
+}
+var p = class {
+  constructor(t2) {
+    this.context = t2;
+  }
+  static get shouldLoad() {
+    return true;
+  }
+  get application() {
+    return this.context.application;
+  }
+  get scope() {
+    return this.context.scope;
+  }
+  get element() {
+    return this.scope.element;
+  }
+  get identifier() {
+    return this.scope.identifier;
+  }
+  get targets() {
+    return this.scope.targets;
+  }
+  get classes() {
+    return this.scope.classes;
+  }
+  get data() {
+    return this.scope.data;
+  }
+  initialize() {
+  }
+  connect() {
+  }
+  disconnect() {
+  }
+  dispatch(t2, { target: e2 = this.element, detail: r2 = {}, prefix: n2 = this.identifier, bubbles: s2 = true, cancelable: i2 = true } = {}) {
+    const o2 = new CustomEvent(n2 ? `${n2}:${t2}` : t2, { detail: r2, bubbles: s2, cancelable: i2 });
+    return e2.dispatchEvent(o2), o2;
+  }
+};
+p.blessings = [function(t2) {
+  return s(t2, "classes").reduce((t3, e2) => {
+    return Object.assign(t3, { [`${r2 = e2}Class`]: { get() {
+      const { classes: t4 } = this;
+      if (t4.has(r2)) return t4.get(r2);
+      {
+        const e3 = t4.getAttributeName(r2);
+        throw new Error(`Missing attribute "${e3}"`);
+      }
+    } }, [`${r2}Classes`]: { get() {
+      return this.classes.getAll(r2);
+    } }, [`has${n(r2)}Class`]: { get() {
+      return this.classes.has(r2);
+    } } });
+    var r2;
+  }, {});
+}, function(t2) {
+  return s(t2, "targets").reduce((t3, e2) => {
+    return Object.assign(t3, { [`${r2 = e2}Target`]: { get() {
+      const t4 = this.targets.find(r2);
+      if (t4) return t4;
+      throw new Error(`Missing target element "${r2}" for "${this.identifier}" controller`);
+    } }, [`${r2}Targets`]: { get() {
+      return this.targets.findAll(r2);
+    } }, [`has${n(r2)}Target`]: { get() {
+      return this.targets.has(r2);
+    } } });
+    var r2;
+  }, {});
+}, function(t2) {
+  const e2 = function(t3, e3) {
+    return i(t3).reduce((t4, e4) => (t4.push(...function(t5, e5) {
+      const r3 = t5.values;
+      return r3 ? Object.keys(r3).map((t6) => [t6, r3[t6]]) : [];
+    }(e4)), t4), []);
+  }(t2), r2 = { valueDescriptorMap: { get() {
+    return e2.reduce((t3, e3) => {
+      const r3 = o(e3, this.identifier), n2 = this.data.getAttributeNameForKey(r3.key);
+      return Object.assign(t3, { [n2]: r3 });
+    }, {});
+  } } };
+  return e2.reduce((t3, e3) => Object.assign(t3, function(t4, e4) {
+    const r3 = o(t4, void 0), { key: s2, name: i2, reader: a2, writer: c2 } = r3;
+    return { [i2]: { get() {
+      const t5 = this.data.get(s2);
+      return null !== t5 ? a2(t5) : r3.defaultValue;
+    }, set(t5) {
+      void 0 === t5 ? this.data.delete(s2) : this.data.set(s2, c2(t5));
+    } }, [`has${n(i2)}`]: { get() {
+      return this.data.has(s2) || r3.hasCustomDefaultValue;
+    } } };
+  }(e3)), r2);
+}], p.targets = [], p.values = {};
+var f = (t2 = {}) => Object.keys(t2).map((e2) => `${e2}:${t2[e2]}`).join(";");
+var g = class extends p {
+  constructor(...t2) {
+    super(...t2), this.clicked = false, this.canvasElement = null;
+  }
+  get canvas() {
+    if (this.canvasElement) return this.canvasElement;
+    const t2 = document.createElement("canvas");
+    return t2.style.cssText = f({ position: "fixed", top: 0, right: 0, bottom: 0, left: 0, width: "100%", height: "100%", "pointer-events": "none", "z-index": "9999" }), document.body.appendChild(t2), this.canvasElement = t2, this.canvasElement;
+  }
+  get instance() {
+    return confetti_module_default.create(this.canvas, { resize: true, useWorker: true });
+  }
+  spray(t2) {
+    t2.preventDefault(), this.log("Spraying"), this.getStyle(t2).then(() => {
+      this.log("Finished animation"), this.followValue && (false === this.clicked && this.followLink(), this.clicked = true);
+    });
+  }
+  getStyle(t2) {
+    switch (this.animationValue) {
+      case "basic":
+      default:
+        return this.basic(t2);
+      case "school-pride":
+        return this.schoolPride(t2);
+      case "stars":
+        return this.stars(t2);
+    }
+  }
+  basic(t2) {
+    return this.log("Basic started"), this.instance({ particleCount: this.particleCountValue, startVelocity: this.startVelocityValue, spread: this.spreadValue, ticks: this.ticksValue, origin: { x: t2.clientX / window.innerWidth, y: t2.clientY / window.innerHeight } });
+  }
+  stars(t2) {
+    this.log("Stars started");
+    var r2 = { spread: this.spreadValue, ticks: 50, gravity: 0, decay: 0.94, startVelocity: this.startVelocityValue, shapes: ["star"], colors: ["FFE400", "FFBD00", "E89400", "FFCA6C", "FDFFB8"], origin: { x: t2.clientX / window.innerWidth, y: t2.clientY / window.innerHeight } };
+    return new Promise((t3) => {
+      setTimeout(() => {
+        this.instance(e({}, r2, { particleCount: this.particleCountValue, shapes: ["star"] }));
+      }, 70), this.instance(e({}, r2, { particleCount: this.particleCountValue, shapes: ["star"] })).then(() => {
+        this.log("Stars ended"), t3();
+      });
+    });
+  }
+  schoolPride(t2) {
+    return this.log("School pride started"), new Promise((t3) => {
+      var e2 = Date.now() + 1e3 * this.durationValue, r2 = [this.firstColorValue, this.secondColorValue];
+      const n2 = this;
+      !function s2() {
+        n2.instance({ particleCount: 2, angle: 60, spread: 55, origin: { x: 0 }, colors: r2 }), n2.instance({ particleCount: 2, angle: 120, spread: 55, origin: { x: 1 }, colors: r2 }), Date.now() < e2 ? requestAnimationFrame(s2) : (n2.log("School pride ended"), t3());
+      }();
+    });
+  }
+  followLink() {
+    this.log("Following link");
+    const t2 = document.createElement("a");
+    t2.style.cssText = f({ opacity: 0, display: "hidden" }), t2.href = this.context.element.href, t2.target = this.context.element.target, document.body.appendChild(t2), t2.click(), this.log("Followed link"), setTimeout(() => {
+      this.log("Reset state"), this.clicked = false;
+    }, 1);
+  }
+  log(t2) {
+    this.debugValue && console.log(`[Stimulus confetti] ${t2}`);
+  }
+};
+g.targets = ["element"], g.values = { follow: { type: Boolean, default: true }, animation: { type: String, default: "basic" }, duration: { type: Number, default: 5 }, firstColor: { type: String, default: "#0886DE" }, secondColor: { type: String, default: "#FF6154" }, particleCount: { type: Number, default: 100 }, startVelocity: { type: Number, default: 20 }, spread: { type: Number, default: 360 }, ticks: { type: Number, default: 90 }, debug: { type: Boolean, default: false } };
+
+// app/javascript/confsmith.js
+console.log("hi from confsmith");
+console.log(g);
+var t = async function() {
+  console.log("t");
+};
+await t();
+//# sourceMappingURL=/assets/confsmith.js.map