masoneffect 1.0.26 → 1.0.28

package/dist/svelte/index.mjs

@@ -0,0 +1,924 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { createEventDispatcher, onMount, onDestroy } from "svelte";
+function noop() {
+}
+function run(fn) {
+  return fn();
+}
+function blank_object() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function run_all(fns) {
+  fns.forEach(run);
+}
+function is_function(thing) {
+  return typeof thing === "function";
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
+}
+function is_empty(obj) {
+  return Object.keys(obj).length === 0;
+}
+function insert(target, node, anchor) {
+  target.insertBefore(node, anchor || null);
+}
+function detach(node) {
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+}
+function element(name) {
+  return document.createElement(name);
+}
+function attr(node, attribute, value) {
+  if (value == null) node.removeAttribute(attribute);
+  else if (node.getAttribute(attribute) !== value) node.setAttribute(attribute, value);
+}
+function children(element2) {
+  return Array.from(element2.childNodes);
+}
+let current_component;
+function set_current_component(component) {
+  current_component = component;
+}
+const dirty_components = [];
+const binding_callbacks = [];
+let render_callbacks = [];
+const flush_callbacks = [];
+const resolved_promise = /* @__PURE__ */ Promise.resolve();
+let update_scheduled = false;
+function schedule_update() {
+  if (!update_scheduled) {
+    update_scheduled = true;
+    resolved_promise.then(flush);
+  }
+}
+function add_render_callback(fn) {
+  render_callbacks.push(fn);
+}
+const seen_callbacks = /* @__PURE__ */ new Set();
+let flushidx = 0;
+function flush() {
+  if (flushidx !== 0) {
+    return;
+  }
+  const saved_component = current_component;
+  do {
+    try {
+      while (flushidx < dirty_components.length) {
+        const component = dirty_components[flushidx];
+        flushidx++;
+        set_current_component(component);
+        update(component.$$);
+      }
+    } catch (e) {
+      dirty_components.length = 0;
+      flushidx = 0;
+      throw e;
+    }
+    set_current_component(null);
+    dirty_components.length = 0;
+    flushidx = 0;
+    while (binding_callbacks.length) binding_callbacks.pop()();
+    for (let i = 0; i < render_callbacks.length; i += 1) {
+      const callback = render_callbacks[i];
+      if (!seen_callbacks.has(callback)) {
+        seen_callbacks.add(callback);
+        callback();
+      }
+    }
+    render_callbacks.length = 0;
+  } while (dirty_components.length);
+  while (flush_callbacks.length) {
+    flush_callbacks.pop()();
+  }
+  update_scheduled = false;
+  seen_callbacks.clear();
+  set_current_component(saved_component);
+}
+function update($$) {
+  if ($$.fragment !== null) {
+    $$.update();
+    run_all($$.before_update);
+    const dirty = $$.dirty;
+    $$.dirty = [-1];
+    $$.fragment && $$.fragment.p($$.ctx, dirty);
+    $$.after_update.forEach(add_render_callback);
+  }
+}
+function flush_render_callbacks(fns) {
+  const filtered = [];
+  const targets = [];
+  render_callbacks.forEach((c) => fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c));
+  targets.forEach((c) => c());
+  render_callbacks = filtered;
+}
+const outroing = /* @__PURE__ */ new Set();
+function transition_in(block, local) {
+  if (block && block.i) {
+    outroing.delete(block);
+    block.i(local);
+  }
+}
+function mount_component(component, target, anchor) {
+  const { fragment, after_update } = component.$$;
+  fragment && fragment.m(target, anchor);
+  add_render_callback(() => {
+    const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
+    if (component.$$.on_destroy) {
+      component.$$.on_destroy.push(...new_on_destroy);
+    } else {
+      run_all(new_on_destroy);
+    }
+    component.$$.on_mount = [];
+  });
+  after_update.forEach(add_render_callback);
+}
+function destroy_component(component, detaching) {
+  const $$ = component.$$;
+  if ($$.fragment !== null) {
+    flush_render_callbacks($$.after_update);
+    run_all($$.on_destroy);
+    $$.fragment && $$.fragment.d(detaching);
+    $$.on_destroy = $$.fragment = null;
+    $$.ctx = [];
+  }
+}
+function make_dirty(component, i) {
+  if (component.$$.dirty[0] === -1) {
+    dirty_components.push(component);
+    schedule_update();
+    component.$$.dirty.fill(0);
+  }
+  component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
+}
+function init(component, options, instance, create_fragment2, not_equal, props, append_styles = null, dirty = [-1]) {
+  const parent_component = current_component;
+  set_current_component(component);
+  const $$ = component.$$ = {
+    fragment: null,
+    ctx: [],
+    // state
+    props,
+    update: noop,
+    not_equal,
+    bound: blank_object(),
+    // lifecycle
+    on_mount: [],
+    on_destroy: [],
+    on_disconnect: [],
+    before_update: [],
+    after_update: [],
+    context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
+    // everything else
+    callbacks: blank_object(),
+    dirty,
+    skip_bound: false,
+    root: options.target || parent_component.$$.root
+  };
+  append_styles && append_styles($$.root);
+  let ready = false;
+  $$.ctx = instance ? instance(component, options.props || {}, (i, ret, ...rest) => {
+    const value = rest.length ? rest[0] : ret;
+    if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
+      if (!$$.skip_bound && $$.bound[i]) $$.bound[i](value);
+      if (ready) make_dirty(component, i);
+    }
+    return ret;
+  }) : [];
+  $$.update();
+  ready = true;
+  run_all($$.before_update);
+  $$.fragment = create_fragment2 ? create_fragment2($$.ctx) : false;
+  if (options.target) {
+    if (options.hydrate) {
+      const nodes = children(options.target);
+      $$.fragment && $$.fragment.l(nodes);
+      nodes.forEach(detach);
+    } else {
+      $$.fragment && $$.fragment.c();
+    }
+    if (options.intro) transition_in(component.$$.fragment);
+    mount_component(component, options.target, options.anchor);
+    flush();
+  }
+  set_current_component(parent_component);
+}
+class SvelteComponent {
+  constructor() {
+    /**
+     * ### PRIVATE API
+     *
+     * Do not use, may change at any time
+     *
+     * @type {any}
+     */
+    __publicField(this, "$$");
+    /**
+     * ### PRIVATE API
+     *
+     * Do not use, may change at any time
+     *
+     * @type {any}
+     */
+    __publicField(this, "$$set");
+  }
+  /** @returns {void} */
+  $destroy() {
+    destroy_component(this, 1);
+    this.$destroy = noop;
+  }
+  /**
+   * @template {Extract<keyof Events, string>} K
+   * @param {K} type
+   * @param {((e: Events[K]) => void) | null | undefined} callback
+   * @returns {() => void}
+   */
+  $on(type, callback) {
+    if (!is_function(callback)) {
+      return noop;
+    }
+    const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
+    callbacks.push(callback);
+    return () => {
+      const index = callbacks.indexOf(callback);
+      if (index !== -1) callbacks.splice(index, 1);
+    };
+  }
+  /**
+   * @param {Partial<Props>} props
+   * @returns {void}
+   */
+  $set(props) {
+    if (this.$$set && !is_empty(props)) {
+      this.$$.skip_bound = true;
+      this.$$set(props);
+      this.$$.skip_bound = false;
+    }
+  }
+}
+const PUBLIC_VERSION = "4";
+if (typeof window !== "undefined")
+  (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(PUBLIC_VERSION);
+function debounce(func, wait) {
+  let timeout = null;
+  return function executedFunction(...args) {
+    const later = () => {
+      timeout = null;
+      func.apply(this, args);
+    };
+    if (timeout !== null) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(later, wait);
+  };
+}
+class MasonEffect {
+  constructor(container, options = {}) {
+    this.container = typeof container === "string" ? document.querySelector(container) : container;
+    if (!this.container) {
+      throw new Error("Container element not found");
+    }
+    this.config = {
+      text: options.text || "mason effect",
+      densityStep: options.densityStep ?? 2,
+      maxParticles: options.maxParticles ?? 3200,
+      pointSize: options.pointSize ?? 0.5,
+      ease: options.ease ?? 0.05,
+      repelRadius: options.repelRadius ?? 150,
+      repelStrength: options.repelStrength ?? 1,
+      particleColor: options.particleColor || "#fff",
+      fontFamily: options.fontFamily || "Inter, system-ui, Arial",
+      fontSize: options.fontSize || null,
+      width: options.width || null,
+      height: options.height || null,
+      devicePixelRatio: options.devicePixelRatio ?? null,
+      onReady: options.onReady || null,
+      onUpdate: options.onUpdate || null
+    };
+    this.canvas = document.createElement("canvas");
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("Canvas context not available");
+    }
+    this.ctx = ctx;
+    this.container.appendChild(this.canvas);
+    this.canvas.style.display = "block";
+    this.offCanvas = document.createElement("canvas");
+    const offCtx = this.offCanvas.getContext("2d");
+    if (!offCtx) {
+      throw new Error("Offscreen canvas context not available");
+    }
+    this.offCtx = offCtx;
+    this.W = 0;
+    this.H = 0;
+    this.DPR = this.config.devicePixelRatio || Math.min(window.devicePixelRatio || 1, 1.8);
+    this.particles = [];
+    this.mouse = { x: 0, y: 0, down: false };
+    this.animationId = null;
+    this.isRunning = false;
+    this.isVisible = false;
+    this.intersectionObserver = null;
+    this.debounceDelay = options.debounceDelay ?? 150;
+    const boundHandleResize = this.handleResize.bind(this);
+    this.handleResize = debounce(boundHandleResize, this.debounceDelay);
+    this.handleMouseMove = this.handleMouseMove.bind(this);
+    this.handleMouseLeave = this.handleMouseLeave.bind(this);
+    this.handleMouseDown = this.handleMouseDown.bind(this);
+    this.handleMouseUp = this.handleMouseUp.bind(this);
+    this._debouncedMorph = debounce(this._morphInternal.bind(this), this.debounceDelay);
+    this._debouncedUpdateConfig = debounce(this._updateConfigInternal.bind(this), this.debounceDelay);
+    this.init();
+  }
+  init() {
+    this.resize();
+    this.setupEventListeners();
+    this.setupIntersectionObserver();
+    if (this.config.onReady) {
+      this.config.onReady(this);
+    }
+  }
+  setupIntersectionObserver() {
+    if (typeof window === "undefined" || typeof window.IntersectionObserver === "undefined") {
+      this.isVisible = true;
+      this.start();
+      return;
+    }
+    if (this.intersectionObserver) {
+      return;
+    }
+    this.intersectionObserver = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.target !== this.container) continue;
+          if (entry.isIntersecting) {
+            this.isVisible = true;
+            this.start();
+          } else {
+            this.isVisible = false;
+            this.stop();
+          }
+        }
+      },
+      {
+        threshold: 0.1
+        // 10% 이상 보일 때 동작
+      }
+    );
+    this.intersectionObserver.observe(this.container);
+  }
+  resize() {
+    const width = this.config.width || this.container.clientWidth || window.innerWidth;
+    const height = this.config.height || this.container.clientHeight || window.innerHeight * 0.7;
+    if (width <= 0 || height <= 0) {
+      return;
+    }
+    this.W = Math.floor(width * this.DPR);
+    this.H = Math.floor(height * this.DPR);
+    const MAX_CANVAS_SIZE = 4096;
+    if (this.W > MAX_CANVAS_SIZE || this.H > MAX_CANVAS_SIZE) {
+      const scale = Math.min(MAX_CANVAS_SIZE / this.W, MAX_CANVAS_SIZE / this.H);
+      this.W = Math.floor(this.W * scale);
+      this.H = Math.floor(this.H * scale);
+      this.DPR = this.DPR * scale;
+    }
+    this.canvas.width = this.W;
+    this.canvas.height = this.H;
+    this.canvas.style.width = width + "px";
+    this.canvas.style.height = height + "px";
+    if (this.W > 0 && this.H > 0) {
+      this.buildTargets();
+      if (!this.particles.length) {
+        this.initParticles();
+      }
+    }
+  }
+  /**
+   * 텍스트가 영역 안에 들어가는지 확인하는 헬퍼 함수 (줄바꿈 지원)
+   * @param fontSize 확인할 폰트 크기
+   * @param text 텍스트 (\n으로 줄바꿈 구분)
+   * @param maxWidth 최대 너비
+   * @param maxHeight 최대 높이
+   * @returns { width: number, height: number, fits: boolean }
+   */
+  measureTextFit(fontSize, text, maxWidth, maxHeight) {
+    this.offCtx.font = `400 ${fontSize}px ${this.config.fontFamily}`;
+    const lines = text.split("\n");
+    const lineHeight = fontSize;
+    const lineSpacing = fontSize * 0.1;
+    const spacing = fontSize * 0.05;
+    let maxLineWidth = 0;
+    for (const line of lines) {
+      if (line.length === 0) continue;
+      const textWidth = this.offCtx.measureText(line).width;
+      const totalWidth = textWidth + spacing * (line.length > 0 ? line.length - 1 : 0);
+      maxLineWidth = Math.max(maxLineWidth, totalWidth);
+    }
+    const totalHeight = lines.length > 0 ? lineHeight * lines.length + lineSpacing * (lines.length - 1) : lineHeight;
+    return {
+      width: maxLineWidth,
+      height: totalHeight,
+      fits: maxLineWidth <= maxWidth && totalHeight <= maxHeight
+    };
+  }
+  /**
+   * 이진 검색을 사용하여 적절한 폰트 크기를 찾는 최적화된 함수
+   * 반복 횟수를 O(log n)으로 줄여 성능 개선 (최대 15회 반복, 기존 최대 100회에서 대폭 감소)
+   */
+  findOptimalFontSize(text, maxWidth, maxHeight, initialFontSize) {
+    const minFontSize = 12;
+    const initialMeasure = this.measureTextFit(initialFontSize, text, maxWidth, maxHeight);
+    if (initialMeasure.fits) {
+      return initialFontSize;
+    }
+    if (initialFontSize <= minFontSize) {
+      return minFontSize;
+    }
+    let low = minFontSize;
+    let high = initialFontSize;
+    let bestSize = minFontSize;
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const measure = this.measureTextFit(mid, text, maxWidth, maxHeight);
+      if (measure.fits) {
+        bestSize = mid;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return bestSize;
+  }
+  buildTargets() {
+    if (this.W <= 0 || this.H <= 0) {
+      return;
+    }
+    const text = this.config.text;
+    this.offCanvas.width = this.W;
+    this.offCanvas.height = this.H;
+    this.offCtx.clearRect(0, 0, this.offCanvas.width, this.offCanvas.height);
+    const base = Math.min(this.W, this.H);
+    const initialFontSize = this.config.fontSize || Math.max(80, Math.floor(base * 0.18));
+    const padding = 40;
+    const maxWidth = this.W - padding * 2;
+    const maxHeight = this.H - padding * 2;
+    const fontSize = this.findOptimalFontSize(text, maxWidth, maxHeight, initialFontSize);
+    this.offCtx.fillStyle = "#ffffff";
+    this.offCtx.textAlign = "center";
+    this.offCtx.textBaseline = "middle";
+    this.offCtx.font = `400 ${fontSize}px ${this.config.fontFamily}`;
+    const lines = text.split("\n");
+    const lineHeight = fontSize;
+    const lineSpacing = fontSize * 0.1;
+    const spacing = fontSize * 0.05;
+    const totalTextHeight = lines.length > 0 ? lineHeight * lines.length + lineSpacing * (lines.length - 1) : lineHeight;
+    let startY = this.H / 2 - totalTextHeight / 2 + lineHeight / 2;
+    for (const line of lines) {
+      if (line.length === 0) {
+        startY += lineHeight + lineSpacing;
+        continue;
+      }
+      const chars = line.split("");
+      const totalWidth = this.offCtx.measureText(line).width + spacing * (chars.length - 1);
+      let x = this.W / 2 - totalWidth / 2;
+      for (const ch of chars) {
+        this.offCtx.fillText(ch, x + this.offCtx.measureText(ch).width / 2, startY);
+        x += this.offCtx.measureText(ch).width + spacing;
+      }
+      startY += lineHeight + lineSpacing;
+    }
+    const step = Math.max(2, this.config.densityStep);
+    const img = this.offCtx.getImageData(0, 0, this.W, this.H).data;
+    const targets = [];
+    for (let y = 0; y < this.H; y += step) {
+      for (let x = 0; x < this.W; x += step) {
+        const i = (y * this.W + x) * 4;
+        if (img[i] + img[i + 1] + img[i + 2] > 600) {
+          targets.push({ x, y });
+        }
+      }
+    }
+    while (targets.length > this.config.maxParticles) {
+      targets.splice(Math.floor(Math.random() * targets.length), 1);
+    }
+    if (this.particles.length < targets.length) {
+      const need = targets.length - this.particles.length;
+      for (let i = 0; i < need; i++) {
+        this.particles.push(this.makeParticle());
+      }
+    } else if (this.particles.length > targets.length) {
+      this.particles.length = targets.length;
+    }
+    for (let i = 0; i < this.particles.length; i++) {
+      const p = this.particles[i];
+      const t = targets[i];
+      p.tx = t.x;
+      p.ty = t.y;
+    }
+  }
+  makeParticle() {
+    const sx = Math.random() * this.W;
+    const sy = Math.random() * this.H;
+    return {
+      x: sx,
+      y: sy,
+      vx: 0,
+      vy: 0,
+      tx: sx,
+      ty: sy,
+      initialX: sx,
+      // 초기 위치 저장 (scatter 시 돌아갈 위치)
+      initialY: sy,
+      j: Math.random() * Math.PI * 2
+    };
+  }
+  initParticles() {
+    for (const p of this.particles) {
+      const sx = Math.random() * this.W;
+      const sy = Math.random() * this.H;
+      p.x = sx;
+      p.y = sy;
+      p.vx = p.vy = 0;
+      p.initialX = sx;
+      p.initialY = sy;
+    }
+  }
+  scatter() {
+    for (const p of this.particles) {
+      if (p.initialX !== void 0 && p.initialY !== void 0) {
+        p.tx = p.initialX;
+        p.ty = p.initialY;
+      } else {
+        p.initialX = p.x;
+        p.initialY = p.y;
+        p.tx = p.initialX;
+        p.ty = p.initialY;
+      }
+    }
+  }
+  morph(textOrOptions) {
+    this._debouncedMorph(textOrOptions);
+  }
+  _morphInternal(textOrOptions) {
+    if (this.W === 0 || this.H === 0) {
+      this.resize();
+    }
+    if (typeof textOrOptions === "string") {
+      this.config.text = textOrOptions;
+      this.buildTargets();
+    } else if (textOrOptions && typeof textOrOptions === "object") {
+      const needsRebuild = textOrOptions.text !== void 0;
+      this.config = { ...this.config, ...textOrOptions };
+      if (needsRebuild) {
+        this.buildTargets();
+      }
+    } else {
+      this.buildTargets();
+    }
+  }
+  update() {
+    this.ctx.clearRect(0, 0, this.W, this.H);
+    for (const p of this.particles) {
+      let ax = (p.tx - p.x) * this.config.ease;
+      let ay = (p.ty - p.y) * this.config.ease;
+      if (this.mouse.x || this.mouse.y) {
+        const dx = p.x - this.mouse.x;
+        const dy = p.y - this.mouse.y;
+        const d2 = dx * dx + dy * dy;
+        const r2 = this.config.repelRadius * this.DPR;
+        if (d2 < r2 * r2) {
+          const d = Math.sqrt(d2) + 1e-4;
+          const f = (this.mouse.down ? -1 : 1) * this.config.repelStrength * (1 - d / r2);
+          ax += dx / d * f * 6;
+          ay += dy / d * f * 6;
+        }
+      }
+      p.j += 2;
+      ax += Math.cos(p.j) * 0.05;
+      ay += Math.sin(p.j * 1.3) * 0.05;
+      p.vx = (p.vx + ax) * Math.random();
+      p.vy = (p.vy + ay) * Math.random();
+      p.x += p.vx;
+      p.y += p.vy;
+    }
+    this.ctx.fillStyle = this.config.particleColor;
+    const r = this.config.pointSize * this.DPR;
+    for (const p of this.particles) {
+      this.ctx.beginPath();
+      this.ctx.arc(p.x, p.y, r, 0, Math.PI * 2);
+      this.ctx.fill();
+    }
+    if (this.config.onUpdate) {
+      this.config.onUpdate(this);
+    }
+  }
+  animate() {
+    if (!this.isRunning) return;
+    this.update();
+    this.animationId = requestAnimationFrame(() => this.animate());
+  }
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.animate();
+  }
+  stop() {
+    this.isRunning = false;
+    if (this.animationId) {
+      cancelAnimationFrame(this.animationId);
+      this.animationId = null;
+    }
+  }
+  setupEventListeners() {
+    window.addEventListener("resize", this.handleResize);
+    this.canvas.addEventListener("mousemove", this.handleMouseMove);
+    this.canvas.addEventListener("mouseleave", this.handleMouseLeave);
+    this.canvas.addEventListener("mousedown", this.handleMouseDown);
+    window.addEventListener("mouseup", this.handleMouseUp);
+  }
+  removeEventListeners() {
+    window.removeEventListener("resize", this.handleResize);
+    this.canvas.removeEventListener("mousemove", this.handleMouseMove);
+    this.canvas.removeEventListener("mouseleave", this.handleMouseLeave);
+    this.canvas.removeEventListener("mousedown", this.handleMouseDown);
+    window.removeEventListener("mouseup", this.handleMouseUp);
+  }
+  handleResize() {
+    this.resize();
+  }
+  handleMouseMove(e) {
+    const rect = this.canvas.getBoundingClientRect();
+    this.mouse.x = (e.clientX - rect.left) * this.DPR;
+    this.mouse.y = (e.clientY - rect.top) * this.DPR;
+  }
+  handleMouseLeave() {
+    this.mouse.x = this.mouse.y = 0;
+  }
+  handleMouseDown() {
+    this.mouse.down = true;
+  }
+  handleMouseUp() {
+    this.mouse.down = false;
+  }
+  // 설정 업데이트
+  updateConfig(newConfig) {
+    this._debouncedUpdateConfig(newConfig);
+  }
+  _updateConfigInternal(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+    if (newConfig.text) {
+      this.buildTargets();
+    }
+  }
+  // 파괴 및 정리
+  destroy() {
+    this.stop();
+    this.removeEventListeners();
+    if (this.intersectionObserver) {
+      this.intersectionObserver.disconnect();
+      this.intersectionObserver = null;
+    }
+    if (this.canvas && this.canvas.parentNode) {
+      this.canvas.parentNode.removeChild(this.canvas);
+    }
+  }
+}
+function create_fragment(ctx) {
+  let div;
+  return {
+    c() {
+      div = element("div");
+      attr(
+        div,
+        "class",
+        /*className*/
+        ctx[0]
+      );
+      attr(
+        div,
+        "style",
+        /*style*/
+        ctx[1]
+      );
+    },
+    m(target, anchor) {
+      insert(target, div, anchor);
+      ctx[21](div);
+    },
+    p(ctx2, [dirty]) {
+      if (dirty & /*className*/
+      1) {
+        attr(
+          div,
+          "class",
+          /*className*/
+          ctx2[0]
+        );
+      }
+      if (dirty & /*style*/
+      2) {
+        attr(
+          div,
+          "style",
+          /*style*/
+          ctx2[1]
+        );
+      }
+    },
+    i: noop,
+    o: noop,
+    d(detaching) {
+      if (detaching) {
+        detach(div);
+      }
+      ctx[21](null);
+    }
+  };
+}
+function instance_1($$self, $$props, $$invalidate) {
+  let { text = "mason effect" } = $$props;
+  let { densityStep = 2 } = $$props;
+  let { maxParticles = 3200 } = $$props;
+  let { pointSize = 0.5 } = $$props;
+  let { ease = 0.05 } = $$props;
+  let { repelRadius = 150 } = $$props;
+  let { repelStrength = 1 } = $$props;
+  let { particleColor = "#fff" } = $$props;
+  let { fontFamily = "Inter, system-ui, Arial" } = $$props;
+  let { fontSize = null } = $$props;
+  let { width = null } = $$props;
+  let { height = null } = $$props;
+  let { devicePixelRatio = null } = $$props;
+  let { className = "" } = $$props;
+  let { style = {} } = $$props;
+  const dispatch = createEventDispatcher();
+  let container;
+  let instance = null;
+  onMount(() => {
+    if (!container) return;
+    const options = {
+      text,
+      densityStep,
+      maxParticles,
+      pointSize,
+      ease,
+      repelRadius,
+      repelStrength,
+      particleColor,
+      fontFamily,
+      fontSize,
+      width,
+      height,
+      devicePixelRatio,
+      onReady: (inst) => {
+        dispatch("ready", inst);
+      },
+      onUpdate: (inst) => {
+        dispatch("update", inst);
+      }
+    };
+    $$invalidate(20, instance = new MasonEffect(container, options));
+  });
+  onDestroy(() => {
+    if (instance) {
+      instance.destroy();
+      $$invalidate(20, instance = null);
+    }
+  });
+  function morph(textOrOptions) {
+    if (instance) {
+      instance.morph(textOrOptions);
+    }
+  }
+  function scatter() {
+    if (instance) {
+      instance.scatter();
+    }
+  }
+  function updateConfig(config) {
+    if (instance) {
+      instance.updateConfig(config);
+    }
+  }
+  function destroy() {
+    if (instance) {
+      instance.destroy();
+      $$invalidate(20, instance = null);
+    }
+  }
+  function div_binding($$value) {
+    binding_callbacks[$$value ? "unshift" : "push"](() => {
+      container = $$value;
+      $$invalidate(2, container);
+    });
+  }
+  $$self.$$set = ($$props2) => {
+    if ("text" in $$props2) $$invalidate(3, text = $$props2.text);
+    if ("densityStep" in $$props2) $$invalidate(4, densityStep = $$props2.densityStep);
+    if ("maxParticles" in $$props2) $$invalidate(5, maxParticles = $$props2.maxParticles);
+    if ("pointSize" in $$props2) $$invalidate(6, pointSize = $$props2.pointSize);
+    if ("ease" in $$props2) $$invalidate(7, ease = $$props2.ease);
+    if ("repelRadius" in $$props2) $$invalidate(8, repelRadius = $$props2.repelRadius);
+    if ("repelStrength" in $$props2) $$invalidate(9, repelStrength = $$props2.repelStrength);
+    if ("particleColor" in $$props2) $$invalidate(10, particleColor = $$props2.particleColor);
+    if ("fontFamily" in $$props2) $$invalidate(11, fontFamily = $$props2.fontFamily);
+    if ("fontSize" in $$props2) $$invalidate(12, fontSize = $$props2.fontSize);
+    if ("width" in $$props2) $$invalidate(13, width = $$props2.width);
+    if ("height" in $$props2) $$invalidate(14, height = $$props2.height);
+    if ("devicePixelRatio" in $$props2) $$invalidate(15, devicePixelRatio = $$props2.devicePixelRatio);
+    if ("className" in $$props2) $$invalidate(0, className = $$props2.className);
+    if ("style" in $$props2) $$invalidate(1, style = $$props2.style);
+  };
+  $$self.$$.update = () => {
+    if ($$self.$$.dirty & /*instance, text, densityStep, maxParticles, pointSize, ease, repelRadius, repelStrength, particleColor, fontFamily, fontSize, width, height, devicePixelRatio*/
+    1114104) {
+      {
+        if (instance) {
+          instance.updateConfig({
+            text,
+            densityStep,
+            maxParticles,
+            pointSize,
+            ease,
+            repelRadius,
+            repelStrength,
+            particleColor,
+            fontFamily,
+            fontSize,
+            width,
+            height,
+            devicePixelRatio
+          });
+        }
+      }
+    }
+  };
+  return [
+    className,
+    style,
+    container,
+    text,
+    densityStep,
+    maxParticles,
+    pointSize,
+    ease,
+    repelRadius,
+    repelStrength,
+    particleColor,
+    fontFamily,
+    fontSize,
+    width,
+    height,
+    devicePixelRatio,
+    morph,
+    scatter,
+    updateConfig,
+    destroy,
+    instance,
+    div_binding
+  ];
+}
+class MasonEffect_1 extends SvelteComponent {
+  constructor(options) {
+    super();
+    init(this, options, instance_1, create_fragment, safe_not_equal, {
+      text: 3,
+      densityStep: 4,
+      maxParticles: 5,
+      pointSize: 6,
+      ease: 7,
+      repelRadius: 8,
+      repelStrength: 9,
+      particleColor: 10,
+      fontFamily: 11,
+      fontSize: 12,
+      width: 13,
+      height: 14,
+      devicePixelRatio: 15,
+      className: 0,
+      style: 1,
+      morph: 16,
+      scatter: 17,
+      updateConfig: 18,
+      destroy: 19
+    });
+  }
+  get morph() {
+    return this.$$.ctx[16];
+  }
+  get scatter() {
+    return this.$$.ctx[17];
+  }
+  get updateConfig() {
+    return this.$$.ctx[18];
+  }
+  get destroy() {
+    return this.$$.ctx[19];
+  }
+}
+export {
+  MasonEffect_1 as default
+};