lit-toaster 0.1.0 → 0.1.2

package/README.md

@@ -15,6 +15,14 @@
 <div align="center">Simple, lightweight, and easy to integrate.</div>
 <br />
 
+<div align="center">
+<a href="https://lit-toaster.com/">Website</a> 
+<span> · </span>
+<a href="https://github.com/brysonbw/lit-toaster/blob/main/docs/api-reference/README.md">Documentation</a> 
+<span> · </span>
+<a href="https://www.npmjs.com/package/lit-toaster">NPM Package</a> 
+</div>
+
 ## Installation
 
 ```bash

package/dist/index.d.ts

@@ -48,7 +48,5 @@ declare global {
     }
 }
 
-declare const GUID: () => string;
-
-export { GUID, ToastEmitter, ToastEmitterEvent, ToasterElement, toast };
+export { ToastEmitterEvent, ToasterElement, toast };
 export type { Toast, ToastKind, ToastPosition };

package/dist/lit-toaster.js

@@ -1,5 +1,6 @@
-/*! lit-toaster v0.1.0 Copyright (c) 2025 Bryson Ward and contributors MIT License*/
+/*! lit-toaster v0.1.2 Copyright (c) 2025 Bryson Ward and contributors MIT License*/
 import { css, LitElement, html } from 'lit';
+import { property, state, customElement } from 'lit/decorators.js';
 
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -12,708 +13,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const customElement = (tagName) => (classOrTarget, context) => {
-    if (context !== undefined) {
-        context.addInitializer(() => {
-            customElements.define(tagName, classOrTarget);
-        });
-    }
-    else {
-        customElements.define(tagName, classOrTarget);
-    }
-};
-
-const NODE_MODE = false;
-const global$1 = globalThis;
-const supportsAdoptingStyleSheets = global$1.ShadowRoot &&
-    (global$1.ShadyCSS === undefined || global$1.ShadyCSS.nativeShadow) &&
-    'adoptedStyleSheets' in Document.prototype &&
-    'replace' in CSSStyleSheet.prototype;
-const constructionToken = Symbol();
-const cssTagCache = new WeakMap();
-class CSSResult {
-    constructor(cssText, strings, safeToken) {
-        this['_$cssResult$'] = true;
-        if (safeToken !== constructionToken) {
-            throw new Error('CSSResult is not constructable. Use `unsafeCSS` or `css` instead.');
-        }
-        this.cssText = cssText;
-        this._strings = strings;
-    }
-    get styleSheet() {
-        let styleSheet = this._styleSheet;
-        const strings = this._strings;
-        if (supportsAdoptingStyleSheets && styleSheet === undefined) {
-            const cacheable = strings !== undefined && strings.length === 1;
-            if (cacheable) {
-                styleSheet = cssTagCache.get(strings);
-            }
-            if (styleSheet === undefined) {
-                (this._styleSheet = styleSheet = new CSSStyleSheet()).replaceSync(this.cssText);
-                if (cacheable) {
-                    cssTagCache.set(strings, styleSheet);
-                }
-            }
-        }
-        return styleSheet;
-    }
-    toString() {
-        return this.cssText;
-    }
-}
-const unsafeCSS = (value) => new CSSResult(typeof value === 'string' ? value : String(value), undefined, constructionToken);
-const adoptStyles = (renderRoot, styles) => {
-    if (supportsAdoptingStyleSheets) {
-        renderRoot.adoptedStyleSheets = styles.map((s) => s instanceof CSSStyleSheet ? s : s.styleSheet);
-    }
-    else {
-        for (const s of styles) {
-            const style = document.createElement('style');
-            const nonce = global$1['litNonce'];
-            if (nonce !== undefined) {
-                style.setAttribute('nonce', nonce);
-            }
-            style.textContent = s.cssText;
-            renderRoot.appendChild(style);
-        }
-    }
-};
-const cssResultFromStyleSheet = (sheet) => {
-    let cssText = '';
-    for (const rule of sheet.cssRules) {
-        cssText += rule.cssText;
-    }
-    return unsafeCSS(cssText);
-};
-const getCompatibleStyle = supportsAdoptingStyleSheets ||
-    (NODE_MODE)
-    ? (s) => s
-    : (s) => s instanceof CSSStyleSheet ? cssResultFromStyleSheet(s) : s;
-
-const { is, defineProperty, getOwnPropertyDescriptor, getOwnPropertyNames, getOwnPropertySymbols, getPrototypeOf, } = Object;
-const global = globalThis;
-let issueWarning$1;
-const trustedTypes = global
-    .trustedTypes;
-const emptyStringForBooleanAttribute = trustedTypes
-    ? trustedTypes.emptyScript
-    : '';
-const polyfillSupport = global.reactiveElementPolyfillSupportDevMode
-    ;
-{
-    global.litIssuedWarnings ??= new Set();
-    issueWarning$1 = (code, warning) => {
-        warning += ` See https://lit.dev/msg/${code} for more information.`;
-        if (!global.litIssuedWarnings.has(warning) &&
-            !global.litIssuedWarnings.has(code)) {
-            console.warn(warning);
-            global.litIssuedWarnings.add(warning);
-        }
-    };
-    queueMicrotask(() => {
-        issueWarning$1('dev-mode', `Lit is in dev mode. Not recommended for production!`);
-        if (global.ShadyDOM?.inUse && polyfillSupport === undefined) {
-            issueWarning$1('polyfill-support-missing', `Shadow DOM is being polyfilled via \`ShadyDOM\` but ` +
-                `the \`polyfill-support\` module has not been loaded.`);
-        }
-    });
-}
-const debugLogEvent = (event) => {
-        const shouldEmit = global
-            .emitLitDebugLogEvents;
-        if (!shouldEmit) {
-            return;
-        }
-        global.dispatchEvent(new CustomEvent('lit-debug', {
-            detail: event,
-        }));
-    }
-    ;
-const JSCompiler_renameProperty = (prop, _obj) => prop;
-const defaultConverter = {
-    toAttribute(value, type) {
-        switch (type) {
-            case Boolean:
-                value = value ? emptyStringForBooleanAttribute : null;
-                break;
-            case Object:
-            case Array:
-                value = value == null ? value : JSON.stringify(value);
-                break;
-        }
-        return value;
-    },
-    fromAttribute(value, type) {
-        let fromValue = value;
-        switch (type) {
-            case Boolean:
-                fromValue = value !== null;
-                break;
-            case Number:
-                fromValue = value === null ? null : Number(value);
-                break;
-            case Object:
-            case Array:
-                try {
-                    fromValue = JSON.parse(value);
-                }
-                catch (e) {
-                    fromValue = null;
-                }
-                break;
-        }
-        return fromValue;
-    },
-};
-const notEqual = (value, old) => !is(value, old);
-const defaultPropertyDeclaration$1 = {
-    attribute: true,
-    type: String,
-    converter: defaultConverter,
-    reflect: false,
-    useDefault: false,
-    hasChanged: notEqual,
-};
-Symbol.metadata ??= Symbol('metadata');
-global.litPropertyMetadata ??= new WeakMap();
-class ReactiveElement
- extends HTMLElement {
-    static addInitializer(initializer) {
-        this.__prepare();
-        (this._initializers ??= []).push(initializer);
-    }
-    static get observedAttributes() {
-        this.finalize();
-        return (this.__attributeToPropertyMap && [...this.__attributeToPropertyMap.keys()]);
-    }
-    static createProperty(name, options = defaultPropertyDeclaration$1) {
-        if (options.state) {
-            options.attribute = false;
-        }
-        this.__prepare();
-        if (this.prototype.hasOwnProperty(name)) {
-            options = Object.create(options);
-            options.wrapped = true;
-        }
-        this.elementProperties.set(name, options);
-        if (!options.noAccessor) {
-            const key = Symbol.for(`${String(name)} (@property() cache)`)
-                ;
-            const descriptor = this.getPropertyDescriptor(name, key, options);
-            if (descriptor !== undefined) {
-                defineProperty(this.prototype, name, descriptor);
-            }
-        }
-    }
-    static getPropertyDescriptor(name, key, options) {
-        const { get, set } = getOwnPropertyDescriptor(this.prototype, name) ?? {
-            get() {
-                return this[key];
-            },
-            set(v) {
-                this[key] = v;
-            },
-        };
-        if (get == null) {
-            if ('value' in (getOwnPropertyDescriptor(this.prototype, name) ?? {})) {
-                throw new Error(`Field ${JSON.stringify(String(name))} on ` +
-                    `${this.name} was declared as a reactive property ` +
-                    `but it's actually declared as a value on the prototype. ` +
-                    `Usually this is due to using @property or @state on a method.`);
-            }
-            issueWarning$1('reactive-property-without-getter', `Field ${JSON.stringify(String(name))} on ` +
-                `${this.name} was declared as a reactive property ` +
-                `but it does not have a getter. This will be an error in a ` +
-                `future version of Lit.`);
-        }
-        return {
-            get,
-            set(value) {
-                const oldValue = get?.call(this);
-                set?.call(this, value);
-                this.requestUpdate(name, oldValue, options);
-            },
-            configurable: true,
-            enumerable: true,
-        };
-    }
-    static getPropertyOptions(name) {
-        return this.elementProperties.get(name) ?? defaultPropertyDeclaration$1;
-    }
-    static __prepare() {
-        if (this.hasOwnProperty(JSCompiler_renameProperty('elementProperties'))) {
-            return;
-        }
-        const superCtor = getPrototypeOf(this);
-        superCtor.finalize();
-        if (superCtor._initializers !== undefined) {
-            this._initializers = [...superCtor._initializers];
-        }
-        this.elementProperties = new Map(superCtor.elementProperties);
-    }
-    static finalize() {
-        if (this.hasOwnProperty(JSCompiler_renameProperty('finalized'))) {
-            return;
-        }
-        this.finalized = true;
-        this.__prepare();
-        if (this.hasOwnProperty(JSCompiler_renameProperty('properties'))) {
-            const props = this.properties;
-            const propKeys = [
-                ...getOwnPropertyNames(props),
-                ...getOwnPropertySymbols(props),
-            ];
-            for (const p of propKeys) {
-                this.createProperty(p, props[p]);
-            }
-        }
-        const metadata = this[Symbol.metadata];
-        if (metadata !== null) {
-            const properties = litPropertyMetadata.get(metadata);
-            if (properties !== undefined) {
-                for (const [p, options] of properties) {
-                    this.elementProperties.set(p, options);
-                }
-            }
-        }
-        this.__attributeToPropertyMap = new Map();
-        for (const [p, options] of this.elementProperties) {
-            const attr = this.__attributeNameForProperty(p, options);
-            if (attr !== undefined) {
-                this.__attributeToPropertyMap.set(attr, p);
-            }
-        }
-        this.elementStyles = this.finalizeStyles(this.styles);
-        {
-            if (this.hasOwnProperty('createProperty')) {
-                issueWarning$1('no-override-create-property', 'Overriding ReactiveElement.createProperty() is deprecated. ' +
-                    'The override will not be called with standard decorators');
-            }
-            if (this.hasOwnProperty('getPropertyDescriptor')) {
-                issueWarning$1('no-override-get-property-descriptor', 'Overriding ReactiveElement.getPropertyDescriptor() is deprecated. ' +
-                    'The override will not be called with standard decorators');
-            }
-        }
-    }
-    static finalizeStyles(styles) {
-        const elementStyles = [];
-        if (Array.isArray(styles)) {
-            const set = new Set(styles.flat(Infinity).reverse());
-            for (const s of set) {
-                elementStyles.unshift(getCompatibleStyle(s));
-            }
-        }
-        else if (styles !== undefined) {
-            elementStyles.push(getCompatibleStyle(styles));
-        }
-        return elementStyles;
-    }
-    static __attributeNameForProperty(name, options) {
-        const attribute = options.attribute;
-        return attribute === false
-            ? undefined
-            : typeof attribute === 'string'
-                ? attribute
-                : typeof name === 'string'
-                    ? name.toLowerCase()
-                    : undefined;
-    }
-    constructor() {
-        super();
-        this.__instanceProperties = undefined;
-        this.isUpdatePending = false;
-        this.hasUpdated = false;
-        this.__reflectingProperty = null;
-        this.__initialize();
-    }
-    __initialize() {
-        this.__updatePromise = new Promise((res) => (this.enableUpdating = res));
-        this._$changedProperties = new Map();
-        this.__saveInstanceProperties();
-        this.requestUpdate();
-        this.constructor._initializers?.forEach((i) => i(this));
-    }
-    addController(controller) {
-        (this.__controllers ??= new Set()).add(controller);
-        if (this.renderRoot !== undefined && this.isConnected) {
-            controller.hostConnected?.();
-        }
-    }
-    removeController(controller) {
-        this.__controllers?.delete(controller);
-    }
-    __saveInstanceProperties() {
-        const instanceProperties = new Map();
-        const elementProperties = this.constructor
-            .elementProperties;
-        for (const p of elementProperties.keys()) {
-            if (this.hasOwnProperty(p)) {
-                instanceProperties.set(p, this[p]);
-                delete this[p];
-            }
-        }
-        if (instanceProperties.size > 0) {
-            this.__instanceProperties = instanceProperties;
-        }
-    }
-    createRenderRoot() {
-        const renderRoot = this.shadowRoot ??
-            this.attachShadow(this.constructor.shadowRootOptions);
-        adoptStyles(renderRoot, this.constructor.elementStyles);
-        return renderRoot;
-    }
-    connectedCallback() {
-        this.renderRoot ??=
-            this.createRenderRoot();
-        this.enableUpdating(true);
-        this.__controllers?.forEach((c) => c.hostConnected?.());
-    }
-    enableUpdating(_requestedUpdate) { }
-    disconnectedCallback() {
-        this.__controllers?.forEach((c) => c.hostDisconnected?.());
-    }
-    attributeChangedCallback(name, _old, value) {
-        this._$attributeToProperty(name, value);
-    }
-    __propertyToAttribute(name, value) {
-        const elemProperties = this.constructor.elementProperties;
-        const options = elemProperties.get(name);
-        const attr = this.constructor.__attributeNameForProperty(name, options);
-        if (attr !== undefined && options.reflect === true) {
-            const converter = options.converter?.toAttribute !==
-                undefined
-                ? options.converter
-                : defaultConverter;
-            const attrValue = converter.toAttribute(value, options.type);
-            if (this.constructor.enabledWarnings.includes('migration') &&
-                attrValue === undefined) {
-                issueWarning$1('undefined-attribute-value', `The attribute value for the ${name} property is ` +
-                    `undefined on element ${this.localName}. The attribute will be ` +
-                    `removed, but in the previous version of \`ReactiveElement\`, ` +
-                    `the attribute would not have changed.`);
-            }
-            this.__reflectingProperty = name;
-            if (attrValue == null) {
-                this.removeAttribute(attr);
-            }
-            else {
-                this.setAttribute(attr, attrValue);
-            }
-            this.__reflectingProperty = null;
-        }
-    }
-    _$attributeToProperty(name, value) {
-        const ctor = this.constructor;
-        const propName = ctor.__attributeToPropertyMap.get(name);
-        if (propName !== undefined && this.__reflectingProperty !== propName) {
-            const options = ctor.getPropertyOptions(propName);
-            const converter = typeof options.converter === 'function'
-                ? { fromAttribute: options.converter }
-                : options.converter?.fromAttribute !== undefined
-                    ? options.converter
-                    : defaultConverter;
-            this.__reflectingProperty = propName;
-            const convertedValue = converter.fromAttribute(value, options.type);
-            this[propName] =
-                convertedValue ??
-                    this.__defaultValues?.get(propName) ??
-                    convertedValue;
-            this.__reflectingProperty = null;
-        }
-    }
-    requestUpdate(name, oldValue, options) {
-        if (name !== undefined) {
-            if (name instanceof Event) {
-                issueWarning$1(``, `The requestUpdate() method was called with an Event as the property name. This is probably a mistake caused by binding this.requestUpdate as an event listener. Instead bind a function that will call it with no arguments: () => this.requestUpdate()`);
-            }
-            const ctor = this.constructor;
-            const newValue = this[name];
-            options ??= ctor.getPropertyOptions(name);
-            const changed = (options.hasChanged ?? notEqual)(newValue, oldValue) ||
-                (options.useDefault &&
-                    options.reflect &&
-                    newValue === this.__defaultValues?.get(name) &&
-                    !this.hasAttribute(ctor.__attributeNameForProperty(name, options)));
-            if (changed) {
-                this._$changeProperty(name, oldValue, options);
-            }
-            else {
-                return;
-            }
-        }
-        if (this.isUpdatePending === false) {
-            this.__updatePromise = this.__enqueueUpdate();
-        }
-    }
-    _$changeProperty(name, oldValue, { useDefault, reflect, wrapped }, initializeValue) {
-        if (useDefault && !(this.__defaultValues ??= new Map()).has(name)) {
-            this.__defaultValues.set(name, initializeValue ?? oldValue ?? this[name]);
-            if (wrapped !== true || initializeValue !== undefined) {
-                return;
-            }
-        }
-        if (!this._$changedProperties.has(name)) {
-            if (!this.hasUpdated && !useDefault) {
-                oldValue = undefined;
-            }
-            this._$changedProperties.set(name, oldValue);
-        }
-        if (reflect === true && this.__reflectingProperty !== name) {
-            (this.__reflectingProperties ??= new Set()).add(name);
-        }
-    }
-    async __enqueueUpdate() {
-        this.isUpdatePending = true;
-        try {
-            await this.__updatePromise;
-        }
-        catch (e) {
-            Promise.reject(e);
-        }
-        const result = this.scheduleUpdate();
-        if (result != null) {
-            await result;
-        }
-        return !this.isUpdatePending;
-    }
-    scheduleUpdate() {
-        const result = this.performUpdate();
-        if (this.constructor.enabledWarnings.includes('async-perform-update') &&
-            typeof result?.then ===
-                'function') {
-            issueWarning$1('async-perform-update', `Element ${this.localName} returned a Promise from performUpdate(). ` +
-                `This behavior is deprecated and will be removed in a future ` +
-                `version of ReactiveElement.`);
-        }
-        return result;
-    }
-    performUpdate() {
-        if (!this.isUpdatePending) {
-            return;
-        }
-        debugLogEvent?.({ kind: 'update' });
-        if (!this.hasUpdated) {
-            this.renderRoot ??=
-                this.createRenderRoot();
-            {
-                const ctor = this.constructor;
-                const shadowedProperties = [...ctor.elementProperties.keys()].filter((p) => this.hasOwnProperty(p) && p in getPrototypeOf(this));
-                if (shadowedProperties.length) {
-                    throw new Error(`The following properties on element ${this.localName} will not ` +
-                        `trigger updates as expected because they are set using class ` +
-                        `fields: ${shadowedProperties.join(', ')}. ` +
-                        `Native class fields and some compiled output will overwrite ` +
-                        `accessors used for detecting changes. See ` +
-                        `https://lit.dev/msg/class-field-shadowing ` +
-                        `for more information.`);
-                }
-            }
-            if (this.__instanceProperties) {
-                for (const [p, value] of this.__instanceProperties) {
-                    this[p] = value;
-                }
-                this.__instanceProperties = undefined;
-            }
-            const elementProperties = this.constructor
-                .elementProperties;
-            if (elementProperties.size > 0) {
-                for (const [p, options] of elementProperties) {
-                    const { wrapped } = options;
-                    const value = this[p];
-                    if (wrapped === true &&
-                        !this._$changedProperties.has(p) &&
-                        value !== undefined) {
-                        this._$changeProperty(p, undefined, options, value);
-                    }
-                }
-            }
-        }
-        let shouldUpdate = false;
-        const changedProperties = this._$changedProperties;
-        try {
-            shouldUpdate = this.shouldUpdate(changedProperties);
-            if (shouldUpdate) {
-                this.willUpdate(changedProperties);
-                this.__controllers?.forEach((c) => c.hostUpdate?.());
-                this.update(changedProperties);
-            }
-            else {
-                this.__markUpdated();
-            }
-        }
-        catch (e) {
-            shouldUpdate = false;
-            this.__markUpdated();
-            throw e;
-        }
-        if (shouldUpdate) {
-            this._$didUpdate(changedProperties);
-        }
-    }
-    willUpdate(_changedProperties) { }
-    _$didUpdate(changedProperties) {
-        this.__controllers?.forEach((c) => c.hostUpdated?.());
-        if (!this.hasUpdated) {
-            this.hasUpdated = true;
-            this.firstUpdated(changedProperties);
-        }
-        this.updated(changedProperties);
-        if (this.isUpdatePending &&
-            this.constructor.enabledWarnings.includes('change-in-update')) {
-            issueWarning$1('change-in-update', `Element ${this.localName} scheduled an update ` +
-                `(generally because a property was set) ` +
-                `after an update completed, causing a new update to be scheduled. ` +
-                `This is inefficient and should be avoided unless the next update ` +
-                `can only be scheduled as a side effect of the previous update.`);
-        }
-    }
-    __markUpdated() {
-        this._$changedProperties = new Map();
-        this.isUpdatePending = false;
-    }
-    get updateComplete() {
-        return this.getUpdateComplete();
-    }
-    getUpdateComplete() {
-        return this.__updatePromise;
-    }
-    shouldUpdate(_changedProperties) {
-        return true;
-    }
-    update(_changedProperties) {
-        this.__reflectingProperties &&= this.__reflectingProperties.forEach((p) => this.__propertyToAttribute(p, this[p]));
-        this.__markUpdated();
-    }
-    updated(_changedProperties) { }
-    firstUpdated(_changedProperties) { }
-}
-ReactiveElement.elementStyles = [];
-ReactiveElement.shadowRootOptions = { mode: 'open' };
-ReactiveElement[JSCompiler_renameProperty('elementProperties')] = new Map();
-ReactiveElement[JSCompiler_renameProperty('finalized')] = new Map();
-polyfillSupport?.({ ReactiveElement });
-{
-    ReactiveElement.enabledWarnings = [
-        'change-in-update',
-        'async-perform-update',
-    ];
-    const ensureOwnWarnings = function (ctor) {
-        if (!ctor.hasOwnProperty(JSCompiler_renameProperty('enabledWarnings'))) {
-            ctor.enabledWarnings = ctor.enabledWarnings.slice();
-        }
-    };
-    ReactiveElement.enableWarning = function (warning) {
-        ensureOwnWarnings(this);
-        if (!this.enabledWarnings.includes(warning)) {
-            this.enabledWarnings.push(warning);
-        }
-    };
-    ReactiveElement.disableWarning = function (warning) {
-        ensureOwnWarnings(this);
-        const i = this.enabledWarnings.indexOf(warning);
-        if (i >= 0) {
-            this.enabledWarnings.splice(i, 1);
-        }
-    };
-}
-(global.reactiveElementVersions ??= []).push('2.1.1');
-if (global.reactiveElementVersions.length > 1) {
-    queueMicrotask(() => {
-        issueWarning$1('multiple-versions', `Multiple versions of Lit loaded. Loading multiple versions ` +
-            `is not recommended.`);
-    });
-}
-
-let issueWarning;
-{
-    globalThis.litIssuedWarnings ??= new Set();
-    issueWarning = (code, warning) => {
-        warning += ` See https://lit.dev/msg/${code} for more information.`;
-        if (!globalThis.litIssuedWarnings.has(warning) &&
-            !globalThis.litIssuedWarnings.has(code)) {
-            console.warn(warning);
-            globalThis.litIssuedWarnings.add(warning);
-        }
-    };
-}
-const legacyProperty = (options, proto, name) => {
-    const hasOwnProperty = proto.hasOwnProperty(name);
-    proto.constructor.createProperty(name, options);
-    return hasOwnProperty
-        ? Object.getOwnPropertyDescriptor(proto, name)
-        : undefined;
-};
-const defaultPropertyDeclaration = {
-    attribute: true,
-    type: String,
-    converter: defaultConverter,
-    reflect: false,
-    hasChanged: notEqual,
-};
-const standardProperty = (options = defaultPropertyDeclaration, target, context) => {
-    const { kind, metadata } = context;
-    if (metadata == null) {
-        issueWarning('missing-class-metadata', `The class ${target} is missing decorator metadata. This ` +
-            `could mean that you're using a compiler that supports decorators ` +
-            `but doesn't support decorator metadata, such as TypeScript 5.1. ` +
-            `Please update your compiler.`);
-    }
-    let properties = globalThis.litPropertyMetadata.get(metadata);
-    if (properties === undefined) {
-        globalThis.litPropertyMetadata.set(metadata, (properties = new Map()));
-    }
-    if (kind === 'setter') {
-        options = Object.create(options);
-        options.wrapped = true;
-    }
-    properties.set(context.name, options);
-    if (kind === 'accessor') {
-        const { name } = context;
-        return {
-            set(v) {
-                const oldValue = target.get.call(this);
-                target.set.call(this, v);
-                this.requestUpdate(name, oldValue, options);
-            },
-            init(v) {
-                if (v !== undefined) {
-                    this._$changeProperty(name, undefined, options, v);
-                }
-                return v;
-            },
-        };
-    }
-    else if (kind === 'setter') {
-        const { name } = context;
-        return function (value) {
-            const oldValue = this[name];
-            target.call(this, value);
-            this.requestUpdate(name, oldValue, options);
-        };
-    }
-    throw new Error(`Unsupported decorator location: ${kind}`);
-};
-function property(options) {
-    return (protoOrTarget, nameOrContext
-    ) => {
-        return (typeof nameOrContext === 'object'
-            ? standardProperty(options, protoOrTarget, nameOrContext)
-            : legacyProperty(options, protoOrTarget, nameOrContext));
-    };
-}
-
-function state(options) {
-    return property({
-        ...options,
-        state: true,
-        attribute: false,
-    });
-}
-
-{
-    globalThis.litIssuedWarnings ??= new Set();
-}
-
 var ToastEmitterEvent;
 (function (ToastEmitterEvent) {
     ToastEmitterEvent["QUEUE_LIMIT_CHANGE"] = "queue-limit-change";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lit-toaster",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "engines": {
     "node": ">=20",
     "npm": ">=9.6.3",
@@ -47,10 +47,13 @@
   "bugs": {
     "url": "https://github.com/brysonbw/lit-toaster/issues"
   },
-  "homepage": "https://github.com/brysonbw/lit-toaster",
+  "homepage": "https://lit-toaster.com/",
   "contributors": [
     "Bryson Ward (https://github.com/brysonbw)"
   ],
+  "peerDependencies": {
+    "lit": "^3.3.1"
+  },
   "dependencies": {
     "lit": "^3.3.1"
   },
@@ -77,7 +80,6 @@
     "rollup-plugin-delete": "^3.0.1",
     "rollup-plugin-dts": "^6.2.1",
     "size-limit": "^11.2.0",
-    "tslib": "^2.8.1",
     "typedoc": "^0.28.10",
     "typedoc-plugin-markdown": "^4.8.1",
     "typescript": "^5.9.2",
@@ -127,7 +129,7 @@
     {
       "path": "dist/lit-toaster.js",
       "name": "Browser build (ESM)",
-      "limit": "10kB",
+      "limit": "5kB",
       "gzip": true
     }
   ]