@overlastic/svelte 0.8.1 → 0.8.3

package/dist/index.global.js

@@ -4,6 +4,7 @@ var OverlaysSvelte = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,16 +18,35 @@ var OverlaysSvelte = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
   // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  var index_exports = {};
+  __export(index_exports, {
     Overlay: () => Overlay,
     defineOverlay: () => defineOverlay,
     renderOverlay: () => renderOverlay,
-    useExtendOverlay: () => useExtendOverlay
+    useDisclosure: () => useDisclosure
   });
 
+  // ../@core/src/deferred.ts
+  function createDeferred() {
+    let confirm, cancel;
+    const promise = new Promise((_confirm, _cancel) => {
+      confirm = _confirm;
+      cancel = _cancel;
+    });
+    promise.confirm = (v) => {
+      confirm(v);
+      return promise;
+    };
+    promise.close = () => {
+      confirm();
+    };
+    promise.cancel = cancel;
+    return promise;
+  }
+
   // ../@core/src/define/global.ts
   var UnifiedOverlayProviderID = "unified-overlay";
   function defineGlobalElement(id = "", root = document.body) {
@@ -56,21 +76,6 @@ var OverlaysSvelte = (() => {
     return context.spaces[id] || 0;
   }
 
-  // ../@core/src/deferred.ts
-  function createDeferred() {
-    let resolve, reject;
-    const promise = new Promise((_resolve, _reject) => {
-      resolve = _resolve;
-      reject = _reject;
-    });
-    promise.resolve = (v) => {
-      resolve(v);
-      return promise;
-    };
-    promise.reject = reject;
-    return promise;
-  }
-
   // ../@core/src/events/index.ts
   function watchClickPosition() {
     if (typeof window === "undefined" && typeof document === "undefined")
@@ -132,63 +137,372 @@ var OverlaysSvelte = (() => {
 
   // ../@core/src/utils/util.ts
   function delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+    return new Promise((confirm) => setTimeout(confirm, milliseconds));
   }
 
-  // src/internal/index.ts
-  var injectOverlayKey = Symbol("overlays:svelte");
-  var injectOptionsKey = Symbol("overlays:options");
+  // ../../node_modules/.pnpm/svelte@4.2.19/node_modules/svelte/src/runtime/internal/globals.js
+  var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : (
+    // @ts-ignore Node typings have this
+    global
+  );
 
-  // src/define/constructor.ts
-  var constructor = createConstructor((Inst, props, options) => {
-    const { container, deferred, context: _context = /* @__PURE__ */ new Map() } = options;
-    function vanish() {
-      app.$destroy();
-      container.remove();
+  // ../../node_modules/.pnpm/svelte@4.2.19/node_modules/svelte/src/runtime/internal/ResizeObserverSingleton.js
+  var ResizeObserverSingleton = class _ResizeObserverSingleton {
+    /** @param {ResizeObserverOptions} options */
+    constructor(options) {
+      /**
+       * @private
+       * @readonly
+       * @type {WeakMap<Element, import('./private.js').Listener>}
+       */
+      __publicField(this, "_listeners", "WeakMap" in globals ? /* @__PURE__ */ new WeakMap() : void 0);
+      /**
+       * @private
+       * @type {ResizeObserver}
+       */
+      __publicField(this, "_observer");
+      /** @type {ResizeObserverOptions} */
+      __publicField(this, "options");
+      this.options = options;
     }
-    const context2 = new Map([..._context.entries()]);
-    context2.set(injectOverlayKey, {
-      resolve: deferred.resolve,
-      reject: deferred.reject,
-      deferred,
-      visible: false,
-      vanish
-    });
-    const app = new Inst({
-      target: container,
-      props,
-      context: context2
-    });
-  });
+    /**
+     * @param {Element} element
+     * @param {import('./private.js').Listener} listener
+     * @returns {() => void}
+     */
+    observe(element2, listener) {
+      this._listeners.set(element2, listener);
+      this._getObserver().observe(element2, this.options);
+      return () => {
+        this._listeners.delete(element2);
+        this._observer.unobserve(element2);
+      };
+    }
+    /**
+     * @private
+     */
+    _getObserver() {
+      var _a;
+      return (_a = this._observer) != null ? _a : this._observer = new ResizeObserver((entries) => {
+        var _a2;
+        for (const entry of entries) {
+          _ResizeObserverSingleton.entries.set(entry.target, entry);
+          (_a2 = this._listeners.get(entry.target)) == null ? void 0 : _a2(entry);
+        }
+      });
+    }
+  };
+  ResizeObserverSingleton.entries = "WeakMap" in globals ? /* @__PURE__ */ new WeakMap() : void 0;
 
-  // src/define/index.ts
-  var defineOverlay = constructor.define;
-  var renderOverlay = constructor.render;
+  // ../../node_modules/.pnpm/svelte@4.2.19/node_modules/svelte/src/runtime/internal/dom.js
+  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 get_custom_elements_slots(element2) {
+    const result = {};
+    element2.childNodes.forEach(
+      /** @param {Element} node */
+      (node) => {
+        result[node.slot || "default"] = true;
+      }
+    );
+    return result;
+  }
+
+  // ../../node_modules/.pnpm/svelte@4.2.19/node_modules/svelte/src/runtime/internal/lifecycle.js
+  var current_component;
+  function get_current_component() {
+    if (!current_component) throw new Error("Function called outside component initialization");
+    return current_component;
+  }
+  function setContext(key, context2) {
+    get_current_component().$$.context.set(key, context2);
+    return context2;
+  }
+  function getContext(key) {
+    return get_current_component().$$.context.get(key);
+  }
+
+  // ../../node_modules/.pnpm/svelte@4.2.19/node_modules/svelte/src/shared/boolean_attributes.js
+  var _boolean_attributes = (
+    /** @type {const} */
+    [
+      "allowfullscreen",
+      "allowpaymentrequest",
+      "async",
+      "autofocus",
+      "autoplay",
+      "checked",
+      "controls",
+      "default",
+      "defer",
+      "disabled",
+      "formnovalidate",
+      "hidden",
+      "inert",
+      "ismap",
+      "loop",
+      "multiple",
+      "muted",
+      "nomodule",
+      "novalidate",
+      "open",
+      "playsinline",
+      "readonly",
+      "required",
+      "reversed",
+      "selected"
+    ]
+  );
+  var boolean_attributes = /* @__PURE__ */ new Set([..._boolean_attributes]);
+
+  // ../../node_modules/.pnpm/svelte@4.2.19/node_modules/svelte/src/runtime/internal/Component.js
+  var SvelteElement;
+  if (typeof HTMLElement === "function") {
+    SvelteElement = class extends HTMLElement {
+      constructor($$componentCtor, $$slots, use_shadow_dom) {
+        super();
+        /** The Svelte component constructor */
+        __publicField(this, "$$ctor");
+        /** Slots */
+        __publicField(this, "$$s");
+        /** The Svelte component instance */
+        __publicField(this, "$$c");
+        /** Whether or not the custom element is connected */
+        __publicField(this, "$$cn", false);
+        /** Component props data */
+        __publicField(this, "$$d", {});
+        /** `true` if currently in the process of reflecting component props back to attributes */
+        __publicField(this, "$$r", false);
+        /** @type {Record<string, CustomElementPropDefinition>} Props definition (name, reflected, type etc) */
+        __publicField(this, "$$p_d", {});
+        /** @type {Record<string, Function[]>} Event listeners */
+        __publicField(this, "$$l", {});
+        /** @type {Map<Function, Function>} Event listener unsubscribe functions */
+        __publicField(this, "$$l_u", /* @__PURE__ */ new Map());
+        this.$$ctor = $$componentCtor;
+        this.$$s = $$slots;
+        if (use_shadow_dom) {
+          this.attachShadow({ mode: "open" });
+        }
+      }
+      addEventListener(type, listener, options) {
+        this.$$l[type] = this.$$l[type] || [];
+        this.$$l[type].push(listener);
+        if (this.$$c) {
+          const unsub = this.$$c.$on(type, listener);
+          this.$$l_u.set(listener, unsub);
+        }
+        super.addEventListener(type, listener, options);
+      }
+      removeEventListener(type, listener, options) {
+        super.removeEventListener(type, listener, options);
+        if (this.$$c) {
+          const unsub = this.$$l_u.get(listener);
+          if (unsub) {
+            unsub();
+            this.$$l_u.delete(listener);
+          }
+        }
+      }
+      async connectedCallback() {
+        this.$$cn = true;
+        if (!this.$$c) {
+          let create_slot3 = function(name) {
+            return () => {
+              let node;
+              const obj = {
+                c: function create() {
+                  node = element("slot");
+                  if (name !== "default") {
+                    attr(node, "name", name);
+                  }
+                },
+                /**
+                 * @param {HTMLElement} target
+                 * @param {HTMLElement} [anchor]
+                 */
+                m: function mount(target, anchor) {
+                  insert(target, node, anchor);
+                },
+                d: function destroy(detaching) {
+                  if (detaching) {
+                    detach(node);
+                  }
+                }
+              };
+              return obj;
+            };
+          };
+          var create_slot2 = create_slot3;
+          await Promise.resolve();
+          if (!this.$$cn || this.$$c) {
+            return;
+          }
+          const $$slots = {};
+          const existing_slots = get_custom_elements_slots(this);
+          for (const name of this.$$s) {
+            if (name in existing_slots) {
+              $$slots[name] = [create_slot3(name)];
+            }
+          }
+          for (const attribute of this.attributes) {
+            const name = this.$$g_p(attribute.name);
+            if (!(name in this.$$d)) {
+              this.$$d[name] = get_custom_element_value(name, attribute.value, this.$$p_d, "toProp");
+            }
+          }
+          for (const key in this.$$p_d) {
+            if (!(key in this.$$d) && this[key] !== void 0) {
+              this.$$d[key] = this[key];
+              delete this[key];
+            }
+          }
+          this.$$c = new this.$$ctor({
+            target: this.shadowRoot || this,
+            props: {
+              ...this.$$d,
+              $$slots,
+              $$scope: {
+                ctx: []
+              }
+            }
+          });
+          const reflect_attributes = () => {
+            this.$$r = true;
+            for (const key in this.$$p_d) {
+              this.$$d[key] = this.$$c.$$.ctx[this.$$c.$$.props[key]];
+              if (this.$$p_d[key].reflect) {
+                const attribute_value = get_custom_element_value(
+                  key,
+                  this.$$d[key],
+                  this.$$p_d,
+                  "toAttribute"
+                );
+                if (attribute_value == null) {
+                  this.removeAttribute(this.$$p_d[key].attribute || key);
+                } else {
+                  this.setAttribute(this.$$p_d[key].attribute || key, attribute_value);
+                }
+              }
+            }
+            this.$$r = false;
+          };
+          this.$$c.$$.after_update.push(reflect_attributes);
+          reflect_attributes();
+          for (const type in this.$$l) {
+            for (const listener of this.$$l[type]) {
+              const unsub = this.$$c.$on(type, listener);
+              this.$$l_u.set(listener, unsub);
+            }
+          }
+          this.$$l = {};
+        }
+      }
+      // We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte
+      // and setting attributes through setAttribute etc, this is helpful
+      attributeChangedCallback(attr2, _oldValue, newValue) {
+        var _a;
+        if (this.$$r) return;
+        attr2 = this.$$g_p(attr2);
+        this.$$d[attr2] = get_custom_element_value(attr2, newValue, this.$$p_d, "toProp");
+        (_a = this.$$c) == null ? void 0 : _a.$set({ [attr2]: this.$$d[attr2] });
+      }
+      disconnectedCallback() {
+        this.$$cn = false;
+        Promise.resolve().then(() => {
+          if (!this.$$cn && this.$$c) {
+            this.$$c.$destroy();
+            this.$$c = void 0;
+          }
+        });
+      }
+      $$g_p(attribute_name) {
+        return Object.keys(this.$$p_d).find(
+          (key) => this.$$p_d[key].attribute === attribute_name || !this.$$p_d[key].attribute && key.toLowerCase() === attribute_name
+        ) || attribute_name;
+      }
+    };
+  }
+  function get_custom_element_value(prop, value, props_definition, transform) {
+    var _a;
+    const type = (_a = props_definition[prop]) == null ? void 0 : _a.type;
+    value = type === "Boolean" && typeof value !== "boolean" ? value != null : value;
+    if (!transform || !props_definition[prop]) {
+      return value;
+    } else if (transform === "toAttribute") {
+      switch (type) {
+        case "Object":
+        case "Array":
+          return value == null ? null : JSON.stringify(value);
+        case "Boolean":
+          return value ? "" : null;
+        case "Number":
+          return value == null ? null : value;
+        default:
+          return value;
+      }
+    } else {
+      switch (type) {
+        case "Object":
+        case "Array":
+          return value && JSON.parse(value);
+        case "Boolean":
+          return value;
+        // conversion already handled above
+        case "Number":
+          return value != null ? +value : value;
+        default:
+          return value;
+      }
+    }
+  }
+
+  // ../../node_modules/.pnpm/svelte@4.2.19/node_modules/svelte/src/runtime/ssr.js
+  function onMount2() {
+  }
 
-  // ../../node_modules/.pnpm/svelte@3.57.0/node_modules/svelte/internal/index.mjs
-  function noop() {
+  // src/components/index.ts
+  var __defProp2 = Object.defineProperty;
+  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? `${key}` : key, value);
+  function noop2() {
   }
   function assign(tar, src) {
-    for (const k in src)
-      tar[k] = src[k];
-    return tar;
+    for (const k in src) tar[k] = src[k];
+    return (
+      /** @type {T & S} */
+      tar
+    );
   }
-  function run(fn) {
+  function run2(fn) {
     return fn();
   }
-  function blank_object() {
+  function blank_object2() {
     return /* @__PURE__ */ Object.create(null);
   }
-  function run_all(fns) {
-    fns.forEach(run);
+  function run_all2(fns) {
+    fns.forEach(run2);
   }
-  function is_function(thing) {
+  function is_function2(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");
+    return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
   }
-  function is_empty(obj) {
+  function is_empty2(obj) {
     return Object.keys(obj).length === 0;
   }
   function create_slot(definition, ctx, $$scope, fn) {
@@ -201,21 +515,8 @@ var OverlaysSvelte = (() => {
     return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx;
   }
   function get_slot_changes(definition, $$scope, dirty, fn) {
-    if (definition[2] && fn) {
-      const lets = definition[2](fn(dirty));
-      if ($$scope.dirty === void 0) {
-        return lets;
-      }
-      if (typeof lets === "object") {
-        const merged = [];
-        const len = Math.max($$scope.dirty.length, lets.length);
-        for (let i = 0; i < len; i += 1) {
-          merged[i] = $$scope.dirty[i] | lets[i];
-        }
-        return merged;
-      }
-      return $$scope.dirty | lets;
-    }
+    if (definition[2] && fn)
+      ;
     return $$scope.dirty;
   }
   function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {
@@ -235,17 +536,10 @@ var OverlaysSvelte = (() => {
     }
     return -1;
   }
-  var is_hydrating = false;
-  function start_hydrating() {
-    is_hydrating = true;
-  }
-  function end_hydrating() {
-    is_hydrating = false;
-  }
-  function insert(target, node, anchor) {
+  function insert2(target, node, anchor) {
     target.insertBefore(node, anchor || null);
   }
-  function detach(node) {
+  function detach2(node) {
     if (node.parentNode) {
       node.parentNode.removeChild(node);
     }
@@ -256,65 +550,52 @@ var OverlaysSvelte = (() => {
   function empty() {
     return text("");
   }
-  function children(element) {
-    return Array.from(element.childNodes);
+  function children2(element2) {
+    return Array.from(element2.childNodes);
   }
-  var current_component;
-  function set_current_component(component) {
-    current_component = component;
+  var current_component2;
+  function set_current_component2(component) {
+    current_component2 = component;
   }
-  function get_current_component() {
-    if (!current_component)
-      throw new Error("Function called outside component initialization");
-    return current_component;
-  }
-  function setContext(key, context2) {
-    get_current_component().$$.context.set(key, context2);
-    return context2;
-  }
-  function getContext(key) {
-    return get_current_component().$$.context.get(key);
-  }
-  var dirty_components = [];
+  var dirty_components2 = [];
   var binding_callbacks = [];
   var render_callbacks = [];
   var flush_callbacks = [];
   var resolved_promise = /* @__PURE__ */ Promise.resolve();
   var update_scheduled = false;
-  function schedule_update() {
+  function schedule_update2() {
     if (!update_scheduled) {
       update_scheduled = true;
-      resolved_promise.then(flush);
+      resolved_promise.then(flush2);
     }
   }
-  function add_render_callback(fn) {
+  function add_render_callback2(fn) {
     render_callbacks.push(fn);
   }
   var seen_callbacks = /* @__PURE__ */ new Set();
   var flushidx = 0;
-  function flush() {
+  function flush2() {
     if (flushidx !== 0) {
       return;
     }
-    const saved_component = current_component;
+    const saved_component = current_component2;
     do {
       try {
-        while (flushidx < dirty_components.length) {
-          const component = dirty_components[flushidx];
+        while (flushidx < dirty_components2.length) {
+          const component = dirty_components2[flushidx];
           flushidx++;
-          set_current_component(component);
+          set_current_component2(component);
           update(component.$$);
         }
       } catch (e) {
-        dirty_components.length = 0;
+        dirty_components2.length = 0;
         flushidx = 0;
         throw e;
       }
-      set_current_component(null);
-      dirty_components.length = 0;
+      set_current_component2(null);
+      dirty_components2.length = 0;
       flushidx = 0;
-      while (binding_callbacks.length)
-        binding_callbacks.pop()();
+      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)) {
@@ -323,34 +604,34 @@ var OverlaysSvelte = (() => {
         }
       }
       render_callbacks.length = 0;
-    } while (dirty_components.length);
+    } while (dirty_components2.length);
     while (flush_callbacks.length) {
       flush_callbacks.pop()();
     }
     update_scheduled = false;
     seen_callbacks.clear();
-    set_current_component(saved_component);
+    set_current_component2(saved_component);
   }
   function update($$) {
     if ($$.fragment !== null) {
       $$.update();
-      run_all($$.before_update);
+      run_all2($$.before_update);
       const dirty = $$.dirty;
       $$.dirty = [-1];
       $$.fragment && $$.fragment.p($$.ctx, dirty);
-      $$.after_update.forEach(add_render_callback);
+      $$.after_update.forEach(add_render_callback2);
     }
   }
-  function flush_render_callbacks(fns) {
+  function flush_render_callbacks2(fns) {
     const filtered = [];
     const targets = [];
-    render_callbacks.forEach((c) => fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c));
+    render_callbacks.forEach((c) => !fns.includes(c) ? filtered.push(c) : targets.push(c));
     targets.forEach((c) => c());
     render_callbacks = filtered;
   }
   var outroing = /* @__PURE__ */ new Set();
   var outros;
-  function group_outros() {
+  function group_outros2() {
     outros = {
       r: 0,
       c: [],
@@ -358,19 +639,19 @@ var OverlaysSvelte = (() => {
       // parent group
     };
   }
-  function check_outros() {
+  function check_outros2() {
     if (!outros.r) {
-      run_all(outros.c);
+      run_all2(outros.c);
     }
     outros = outros.p;
   }
-  function transition_in(block, local) {
+  function transition_in2(block, local) {
     if (block && block.i) {
       outroing.delete(block);
       block.i(local);
     }
   }
-  function transition_out(block, local, detach2, callback) {
+  function transition_out2(block, local, detach22, callback) {
     if (block && block.o) {
       if (outroing.has(block))
         return;
@@ -378,7 +659,7 @@ var OverlaysSvelte = (() => {
       outros.c.push(() => {
         outroing.delete(block);
         if (callback) {
-          if (detach2)
+          if (detach22)
             block.d(1);
           callback();
         }
@@ -388,57 +669,25 @@ var OverlaysSvelte = (() => {
       callback();
     }
   }
-  var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : global;
-  var _boolean_attributes = [
-    "allowfullscreen",
-    "allowpaymentrequest",
-    "async",
-    "autofocus",
-    "autoplay",
-    "checked",
-    "controls",
-    "default",
-    "defer",
-    "disabled",
-    "formnovalidate",
-    "hidden",
-    "inert",
-    "ismap",
-    "itemscope",
-    "loop",
-    "multiple",
-    "muted",
-    "nomodule",
-    "novalidate",
-    "open",
-    "playsinline",
-    "readonly",
-    "required",
-    "reversed",
-    "selected"
-  ];
-  var boolean_attributes = /* @__PURE__ */ new Set([..._boolean_attributes]);
-  function mount_component(component, target, anchor, customElement) {
+  function mount_component(component, target, anchor) {
     const { fragment, after_update } = component.$$;
     fragment && fragment.m(target, anchor);
-    if (!customElement) {
-      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);
+    add_render_callback2(() => {
+      const new_on_destroy = component.$$.on_mount.map(run2).filter(is_function2);
+      if (component.$$.on_destroy) {
+        component.$$.on_destroy.push(...new_on_destroy);
+      } else {
+        run_all2(new_on_destroy);
+      }
+      component.$$.on_mount = [];
+    });
+    after_update.forEach(add_render_callback2);
   }
   function destroy_component(component, detaching) {
     const $$ = component.$$;
     if ($$.fragment !== null) {
-      flush_render_callbacks($$.after_update);
-      run_all($$.on_destroy);
+      flush_render_callbacks2($$.after_update);
+      run_all2($$.on_destroy);
       $$.fragment && $$.fragment.d(detaching);
       $$.on_destroy = $$.fragment = null;
       $$.ctx = [];
@@ -446,23 +695,23 @@ var OverlaysSvelte = (() => {
   }
   function make_dirty(component, i) {
     if (component.$$.dirty[0] === -1) {
-      dirty_components.push(component);
-      schedule_update();
+      dirty_components2.push(component);
+      schedule_update2();
       component.$$.dirty.fill(0);
     }
     component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
   }
-  function init(component, options, instance2, create_fragment2, not_equal, props, append_styles, dirty = [-1]) {
-    const parent_component = current_component;
-    set_current_component(component);
+  function init(component, options, instance2, create_fragment2, not_equal, props, append_styles = null, dirty = [-1]) {
+    const parent_component = current_component2;
+    set_current_component2(component);
     const $$ = component.$$ = {
       fragment: null,
       ctx: [],
       // state
       props,
-      update: noop,
+      update: noop2,
       not_equal,
-      bound: blank_object(),
+      bound: blank_object2(),
       // lifecycle
       on_mount: [],
       on_destroy: [],
@@ -471,7 +720,7 @@ var OverlaysSvelte = (() => {
       after_update: [],
       context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
       // everything else
-      callbacks: blank_object(),
+      callbacks: blank_object2(),
       dirty,
       skip_bound: false,
       root: options.target || parent_component.$$.root
@@ -490,78 +739,42 @@ var OverlaysSvelte = (() => {
     }) : [];
     $$.update();
     ready = true;
-    run_all($$.before_update);
+    run_all2($$.before_update);
     $$.fragment = create_fragment2 ? create_fragment2($$.ctx) : false;
     if (options.target) {
       if (options.hydrate) {
-        start_hydrating();
-        const nodes = children(options.target);
+        const nodes = children2(options.target);
         $$.fragment && $$.fragment.l(nodes);
-        nodes.forEach(detach);
+        nodes.forEach(detach2);
       } else {
         $$.fragment && $$.fragment.c();
       }
       if (options.intro)
-        transition_in(component.$$.fragment);
-      mount_component(component, options.target, options.anchor, options.customElement);
-      end_hydrating();
-      flush();
+        transition_in2(component.$$.fragment);
+      mount_component(component, options.target, options.anchor);
+      flush2();
     }
-    set_current_component(parent_component);
+    set_current_component2(parent_component);
   }
-  var SvelteElement;
-  if (typeof HTMLElement === "function") {
-    SvelteElement = class extends HTMLElement {
-      constructor() {
-        super();
-        this.attachShadow({ mode: "open" });
-      }
-      connectedCallback() {
-        const { on_mount } = this.$$;
-        this.$$.on_disconnect = on_mount.map(run).filter(is_function);
-        for (const key in this.$$.slotted) {
-          this.appendChild(this.$$.slotted[key]);
-        }
-      }
-      attributeChangedCallback(attr, _oldValue, newValue) {
-        this[attr] = newValue;
-      }
-      disconnectedCallback() {
-        run_all(this.$$.on_disconnect);
-      }
-      $destroy() {
-        destroy_component(this, 1);
-        this.$destroy = noop;
-      }
-      $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);
-        };
-      }
-      $set($$props) {
-        if (this.$$set && !is_empty($$props)) {
-          this.$$.skip_bound = true;
-          this.$$set($$props);
-          this.$$.skip_bound = false;
-        }
-      }
-    };
-  }
-  var SvelteComponent = class {
+  var SvelteComponent2 = class {
+    constructor() {
+      __publicField2(this, "$$");
+      __publicField2(this, "$$set");
+    }
+    /** @returns {void} */
     $destroy() {
       destroy_component(this, 1);
-      this.$destroy = noop;
+      this.$destroy = noop2;
     }
+    /**
+     * @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;
+      if (!is_function2(callback)) {
+        return noop2;
       }
       const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
       callbacks.push(callback);
@@ -571,49 +784,23 @@ var OverlaysSvelte = (() => {
           callbacks.splice(index, 1);
       };
     }
-    $set($$props) {
-      if (this.$$set && !is_empty($$props)) {
+    /**
+     * @param {Partial<Props>} props
+     * @returns {void}
+     */
+    $set(props) {
+      if (this.$$set && !is_empty2(props)) {
         this.$$.skip_bound = true;
-        this.$$set($$props);
+        this.$$set(props);
         this.$$.skip_bound = false;
       }
     }
   };
-  var SvelteComponentDev = class extends SvelteComponent {
-    constructor(options) {
-      if (!options || !options.target && !options.$$inline) {
-        throw new Error("'target' is a required option");
-      }
-      super();
-    }
-    $destroy() {
-      super.$destroy();
-      this.$destroy = () => {
-        console.warn("Component was already destroyed");
-      };
-    }
-    $capture_state() {
-    }
-    $inject_state() {
-    }
-  };
-  var SvelteComponentTyped = class extends SvelteComponentDev {
-    constructor(options) {
-      super(options);
-    }
-  };
-
-  // ../../node_modules/.pnpm/svelte@3.57.0/node_modules/svelte/ssr.mjs
-  function onMount() {
-  }
-
-  // src/composable/define.ts
-  function useExtendOverlay(options = {}) {
-    setContext(injectOptionsKey, options);
-    return getContext(injectOverlayKey);
-  }
-
-  // src/components/index.ts
+  var PUBLIC_VERSION = "4";
+  if (typeof window !== "undefined")
+    (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(PUBLIC_VERSION);
+  var injectOverlayKey = Symbol("overlays:svelte");
+  var injectOptionsKey = Symbol("overlays:options");
   function create_if_block(ctx) {
     let current;
     const default_slot_template = (
@@ -633,8 +820,9 @@ var OverlaysSvelte = (() => {
           default_slot.c();
       },
       m(target, anchor) {
-        if (default_slot)
+        if (default_slot) {
           default_slot.m(target, anchor);
+        }
         current = true;
       },
       p(ctx2, dirty) {
@@ -664,11 +852,11 @@ var OverlaysSvelte = (() => {
       i(local) {
         if (current)
           return;
-        transition_in(default_slot, local);
+        transition_in2(default_slot, local);
         current = true;
       },
       o(local) {
-        transition_out(default_slot, local);
+        transition_out2(default_slot, local);
         current = false;
       },
       d(detaching) {
@@ -693,7 +881,7 @@ var OverlaysSvelte = (() => {
       m(target, anchor) {
         if (if_block)
           if_block.m(target, anchor);
-        insert(target, if_block_anchor, anchor);
+        insert2(target, if_block_anchor, anchor);
         current = true;
       },
       p(ctx2, [dirty]) {
@@ -703,53 +891,53 @@ var OverlaysSvelte = (() => {
         ) {
           if (if_block) {
             if_block.p(ctx2, dirty);
-            if (dirty & 1)
-              transition_in(if_block, 1);
+            if (dirty & 1) {
+              transition_in2(if_block, 1);
+            }
           } else {
             if_block = create_if_block(ctx2);
             if_block.c();
-            transition_in(if_block, 1);
+            transition_in2(if_block, 1);
             if_block.m(if_block_anchor.parentNode, if_block_anchor);
           }
         } else if (if_block) {
-          group_outros();
-          transition_out(if_block, 1, 1, () => {
+          group_outros2();
+          transition_out2(if_block, 1, 1, () => {
             if_block = null;
           });
-          check_outros();
+          check_outros2();
         }
       },
-      i() {
+      i(local) {
         if (current)
           return;
-        transition_in(if_block);
+        transition_in2(if_block);
         current = true;
       },
-      o() {
-        transition_out(if_block);
+      o(local) {
+        transition_out2(if_block);
         current = false;
       },
       d(detaching) {
+        if (detaching) {
+          detach2(if_block_anchor);
+        }
         if (if_block)
           if_block.d(detaching);
-        if (detaching)
-          detach(if_block_anchor);
       }
     };
   }
   function instance($$self, $$props, $$invalidate) {
     let { $$slots: slots = {}, $$scope } = $$props;
     let { visible = false } = $$props;
-    const { duration = 0, immediate = true } = getContext(injectOptionsKey) || {};
+    const { duration = 0 } = getContext(injectOptionsKey) || {};
     const { deferred, vanish } = getContext(injectOverlayKey);
-    async function destroy() {
+    deferred == null ? void 0 : deferred.finally(async () => {
       $$invalidate(0, visible = false);
       await delay(duration);
-      vanish == null ? void 0 : vanish();
-      return Promise.resolve();
-    }
-    onMount(() => immediate && $$invalidate(0, visible = true));
-    deferred == null ? void 0 : deferred.then(destroy).catch(destroy);
+      vanish();
+    });
+    onMount2(() => $$invalidate(0, visible = true));
     $$self.$$set = ($$props2) => {
       if ("visible" in $$props2)
         $$invalidate(0, visible = $$props2.visible);
@@ -758,11 +946,48 @@ var OverlaysSvelte = (() => {
     };
     return [visible, $$scope, slots];
   }
-  var Overlay = class extends SvelteComponentTyped {
+  var _Overlay = class extends SvelteComponent2 {
     constructor(options) {
-      super(options);
-      init(this, options, instance, create_fragment, safe_not_equal, { visible: 0 }, noop);
+      super();
+      init(this, options, instance, create_fragment, safe_not_equal, { visible: 0 });
     }
   };
-  return __toCommonJS(src_exports);
+  var Overlay = _Overlay;
+
+  // src/internal/index.ts
+  var injectOverlayKey2 = Symbol("overlays:svelte");
+  var injectOptionsKey2 = Symbol("overlays:options");
+
+  // src/composable/define.ts
+  function useDisclosure(options = {}) {
+    setContext(injectOptionsKey2, options);
+    return getContext(injectOverlayKey2);
+  }
+
+  // src/define/constructor.ts
+  var constructor = createConstructor((Inst, props, options) => {
+    const { container, deferred, context: _context = /* @__PURE__ */ new Map() } = options;
+    function vanish() {
+      app.$destroy();
+      container.remove();
+    }
+    const context2 = new Map([..._context.entries()]);
+    context2.set(injectOverlayKey2, {
+      confirm: deferred.confirm,
+      cannel: deferred.cancel,
+      deferred,
+      visible: false,
+      vanish
+    });
+    const app = new Inst({
+      target: container,
+      props,
+      context: context2
+    });
+  });
+
+  // src/define/index.ts
+  var defineOverlay = constructor.define;
+  var renderOverlay = constructor.render;
+  return __toCommonJS(index_exports);
 })();