@synergy-design-system/components 0.1.0

package/dist/chunks/chunk.Z6AW3P62.js

@@ -0,0 +1,317 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk.PM7NIY3M.js";
+
+// src/internal/form.ts
+var formCollections = /* @__PURE__ */ new WeakMap();
+var reportValidityOverloads = /* @__PURE__ */ new WeakMap();
+var userInteractedControls = /* @__PURE__ */ new WeakSet();
+var interactions = /* @__PURE__ */ new WeakMap();
+var FormControlController = class {
+  constructor(host, options) {
+    this.handleFormData = (event) => {
+      const disabled = this.options.disabled(this.host);
+      const name = this.options.name(this.host);
+      const value = this.options.value(this.host);
+      const isButton = this.host.tagName.toLowerCase() === "syn-button";
+      if (!disabled && !isButton && typeof name === "string" && name.length > 0 && typeof value !== "undefined") {
+        if (Array.isArray(value)) {
+          value.forEach((val) => {
+            event.formData.append(name, val.toString());
+          });
+        } else {
+          event.formData.append(name, value.toString());
+        }
+      }
+    };
+    this.handleFormSubmit = (event) => {
+      var _a;
+      const disabled = this.options.disabled(this.host);
+      const reportValidity = this.options.reportValidity;
+      if (this.form && !this.form.noValidate) {
+        (_a = formCollections.get(this.form)) == null ? void 0 : _a.forEach((control) => {
+          this.setUserInteracted(control, true);
+        });
+      }
+      if (this.form && !this.form.noValidate && !disabled && !reportValidity(this.host)) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+      }
+    };
+    this.handleFormReset = () => {
+      this.options.setValue(this.host, this.options.defaultValue(this.host));
+      this.setUserInteracted(this.host, false);
+      interactions.set(this.host, []);
+    };
+    this.handleInteraction = (event) => {
+      const emittedEvents = interactions.get(this.host);
+      if (!emittedEvents.includes(event.type)) {
+        emittedEvents.push(event.type);
+      }
+      if (emittedEvents.length === this.options.assumeInteractionOn.length) {
+        this.setUserInteracted(this.host, true);
+      }
+    };
+    this.reportFormValidity = () => {
+      if (this.form && !this.form.noValidate) {
+        const elements = this.form.querySelectorAll("*");
+        for (const element of elements) {
+          if (typeof element.reportValidity === "function") {
+            if (!element.reportValidity()) {
+              return false;
+            }
+          }
+        }
+      }
+      return true;
+    };
+    (this.host = host).addController(this);
+    this.options = __spreadValues({
+      form: (input) => {
+        if (input.hasAttribute("form") && input.getAttribute("form") !== "") {
+          const root = input.getRootNode();
+          const formId = input.getAttribute("form");
+          if (formId) {
+            return root.getElementById(formId);
+          }
+        }
+        return input.closest("form");
+      },
+      name: (input) => input.name,
+      value: (input) => input.value,
+      defaultValue: (input) => input.defaultValue,
+      disabled: (input) => {
+        var _a;
+        return (_a = input.disabled) != null ? _a : false;
+      },
+      reportValidity: (input) => typeof input.reportValidity === "function" ? input.reportValidity() : true,
+      setValue: (input, value) => input.value = value,
+      assumeInteractionOn: ["syn-input"]
+    }, options);
+  }
+  hostConnected() {
+    const form = this.options.form(this.host);
+    if (form) {
+      this.attachForm(form);
+    }
+    interactions.set(this.host, []);
+    this.options.assumeInteractionOn.forEach((event) => {
+      this.host.addEventListener(event, this.handleInteraction);
+    });
+  }
+  hostDisconnected() {
+    this.detachForm();
+    interactions.delete(this.host);
+    this.options.assumeInteractionOn.forEach((event) => {
+      this.host.removeEventListener(event, this.handleInteraction);
+    });
+  }
+  hostUpdated() {
+    const form = this.options.form(this.host);
+    if (!form) {
+      this.detachForm();
+    }
+    if (form && this.form !== form) {
+      this.detachForm();
+      this.attachForm(form);
+    }
+    if (this.host.hasUpdated) {
+      this.setValidity(this.host.validity.valid);
+    }
+  }
+  attachForm(form) {
+    if (form) {
+      this.form = form;
+      if (formCollections.has(this.form)) {
+        formCollections.get(this.form).add(this.host);
+      } else {
+        formCollections.set(this.form, /* @__PURE__ */ new Set([this.host]));
+      }
+      this.form.addEventListener("formdata", this.handleFormData);
+      this.form.addEventListener("submit", this.handleFormSubmit);
+      this.form.addEventListener("reset", this.handleFormReset);
+      if (!reportValidityOverloads.has(this.form)) {
+        reportValidityOverloads.set(this.form, this.form.reportValidity);
+        this.form.reportValidity = () => this.reportFormValidity();
+      }
+    } else {
+      this.form = void 0;
+    }
+  }
+  detachForm() {
+    var _a;
+    if (this.form) {
+      (_a = formCollections.get(this.form)) == null ? void 0 : _a.delete(this.host);
+      this.form.removeEventListener("formdata", this.handleFormData);
+      this.form.removeEventListener("submit", this.handleFormSubmit);
+      this.form.removeEventListener("reset", this.handleFormReset);
+      if (reportValidityOverloads.has(this.form)) {
+        this.form.reportValidity = reportValidityOverloads.get(this.form);
+        reportValidityOverloads.delete(this.form);
+      }
+    }
+    this.form = void 0;
+  }
+  setUserInteracted(el, hasInteracted) {
+    if (hasInteracted) {
+      userInteractedControls.add(el);
+    } else {
+      userInteractedControls.delete(el);
+    }
+    el.requestUpdate();
+  }
+  doAction(type, submitter) {
+    if (this.form) {
+      const button = document.createElement("button");
+      button.type = type;
+      button.style.position = "absolute";
+      button.style.width = "0";
+      button.style.height = "0";
+      button.style.clipPath = "inset(50%)";
+      button.style.overflow = "hidden";
+      button.style.whiteSpace = "nowrap";
+      if (submitter) {
+        button.name = submitter.name;
+        button.value = submitter.value;
+        ["formaction", "formenctype", "formmethod", "formnovalidate", "formtarget"].forEach((attr) => {
+          if (submitter.hasAttribute(attr)) {
+            button.setAttribute(attr, submitter.getAttribute(attr));
+          }
+        });
+      }
+      this.form.append(button);
+      button.click();
+      button.remove();
+    }
+  }
+  /** Returns the associated `<form>` element, if one exists. */
+  getForm() {
+    var _a;
+    return (_a = this.form) != null ? _a : null;
+  }
+  /** Resets the form, restoring all the control to their default value */
+  reset(submitter) {
+    this.doAction("reset", submitter);
+  }
+  /** Submits the form, triggering validation and form data injection. */
+  submit(submitter) {
+    this.doAction("submit", submitter);
+  }
+  /**
+   * Synchronously sets the form control's validity. Call this when you know the future validity but need to update
+   * the host element immediately, i.e. before Lit updates the component in the next update.
+   */
+  setValidity(isValid) {
+    const host = this.host;
+    const hasInteracted = Boolean(userInteractedControls.has(host));
+    const required = Boolean(host.required);
+    host.toggleAttribute("data-required", required);
+    host.toggleAttribute("data-optional", !required);
+    host.toggleAttribute("data-invalid", !isValid);
+    host.toggleAttribute("data-valid", isValid);
+    host.toggleAttribute("data-user-invalid", !isValid && hasInteracted);
+    host.toggleAttribute("data-user-valid", isValid && hasInteracted);
+  }
+  /**
+   * Updates the form control's validity based on the current value of `host.validity.valid`. Call this when anything
+   * that affects constraint validation changes so the component receives the correct validity states.
+   */
+  updateValidity() {
+    const host = this.host;
+    this.setValidity(host.validity.valid);
+  }
+  /**
+   * Dispatches a non-bubbling, cancelable custom event of type `syn-invalid`.
+   * If the `syn-invalid` event will be cancelled then the original `invalid`
+   * event (which may have been passed as argument) will also be cancelled.
+   * If no original `invalid` event has been passed then the `syn-invalid`
+   * event will be cancelled before being dispatched.
+   */
+  emitInvalidEvent(originalInvalidEvent) {
+    const slInvalidEvent = new CustomEvent("syn-invalid", {
+      bubbles: false,
+      composed: false,
+      cancelable: true,
+      detail: {}
+    });
+    if (!originalInvalidEvent) {
+      slInvalidEvent.preventDefault();
+    }
+    if (!this.host.dispatchEvent(slInvalidEvent)) {
+      originalInvalidEvent == null ? void 0 : originalInvalidEvent.preventDefault();
+    }
+  }
+};
+var validValidityState = Object.freeze({
+  badInput: false,
+  customError: false,
+  patternMismatch: false,
+  rangeOverflow: false,
+  rangeUnderflow: false,
+  stepMismatch: false,
+  tooLong: false,
+  tooShort: false,
+  typeMismatch: false,
+  valid: true,
+  valueMissing: false
+});
+var valueMissingValidityState = Object.freeze(__spreadProps(__spreadValues({}, validValidityState), {
+  valid: false,
+  valueMissing: true
+}));
+var customErrorValidityState = Object.freeze(__spreadProps(__spreadValues({}, validValidityState), {
+  valid: false,
+  customError: true
+}));
+
+// src/internal/slot.ts
+var HasSlotController = class {
+  constructor(host, ...slotNames) {
+    this.slotNames = [];
+    this.handleSlotChange = (event) => {
+      const slot = event.target;
+      if (this.slotNames.includes("[default]") && !slot.name || slot.name && this.slotNames.includes(slot.name)) {
+        this.host.requestUpdate();
+      }
+    };
+    (this.host = host).addController(this);
+    this.slotNames = slotNames;
+  }
+  hasDefaultSlot() {
+    return [...this.host.childNodes].some((node) => {
+      if (node.nodeType === node.TEXT_NODE && node.textContent.trim() !== "") {
+        return true;
+      }
+      if (node.nodeType === node.ELEMENT_NODE) {
+        const el = node;
+        const tagName = el.tagName.toLowerCase();
+        if (tagName === "syn-visually-hidden") {
+          return false;
+        }
+        if (!el.hasAttribute("slot")) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  hasNamedSlot(name) {
+    return this.host.querySelector(`:scope > [slot="${name}"]`) !== null;
+  }
+  test(slotName) {
+    return slotName === "[default]" ? this.hasDefaultSlot() : this.hasNamedSlot(slotName);
+  }
+  hostConnected() {
+    this.host.shadowRoot.addEventListener("slotchange", this.handleSlotChange);
+  }
+  hostDisconnected() {
+    this.host.shadowRoot.removeEventListener("slotchange", this.handleSlotChange);
+  }
+};
+
+export {
+  FormControlController,
+  validValidityState,
+  HasSlotController
+};

package/dist/components/button/button.component.d.ts

@@ -0,0 +1,132 @@
+import SynergyElement from '../../internal/synergy-element.js';
+import SynIcon from '../icon/icon.component.js';
+import SynSpinner from '../spinner/spinner.component.js';
+import type { CSSResultGroup } from 'lit';
+import type { SynergyFormControl } from '../../internal/synergy-element.js';
+/**
+ * @summary Buttons represent actions that are available to the user.
+ * @documentation https://synergy.style/components/button
+ * @status stable
+ * @since 2.0
+ *
+ * @dependency syn-icon
+ * @dependency syn-spinner
+ *
+ * @event syn-blur - Emitted when the button loses focus.
+ * @event syn-focus - Emitted when the button gains focus.
+ * @event syn-invalid - Emitted when the form control has been checked for validity and its constraints aren't satisfied.
+ *
+ * @slot - The button's label.
+ * @slot prefix - A presentational prefix icon or similar element.
+ * @slot suffix - A presentational suffix icon or similar element.
+ *
+ * @csspart base - The component's base wrapper.
+ * @csspart prefix - The container that wraps the prefix.
+ * @csspart label - The button's label.
+ * @csspart suffix - The container that wraps the suffix.
+ * @csspart caret - The button's caret icon, an `<syn-icon>` element.
+ * @csspart spinner - The spinner that shows when the button is in the loading state.
+ */
+export default class SynButton extends SynergyElement implements SynergyFormControl {
+    static styles: CSSResultGroup;
+    static dependencies: {
+        'syn-icon': typeof SynIcon;
+        'syn-spinner': typeof SynSpinner;
+    };
+    private readonly formControlController;
+    private readonly hasSlotController;
+    private readonly localize;
+    button: HTMLButtonElement | HTMLLinkElement;
+    private hasFocus;
+    invalid: boolean;
+    title: string;
+    /** The button's theme variant. */
+    variant: 'default' | 'primary' | 'success' | 'neutral' | 'warning' | 'danger' | 'text';
+    /** The button's size. */
+    size: 'small' | 'medium' | 'large';
+    /** Draws the button with a caret. Used to indicate that the button triggers a dropdown menu or similar behavior. */
+    caret: boolean;
+    /** Disables the button. */
+    disabled: boolean;
+    /** Draws the button in a loading state. */
+    loading: boolean;
+    /** Draws an outlined button. */
+    outline: boolean;
+    /** Draws a pill-style button with rounded edges. */
+    pill: boolean;
+    /**
+     * Draws a circular icon button. When this attribute is present, the button expects a single `<syn-icon>` in the
+     * default slot.
+     */
+    circle: boolean;
+    /**
+     * The type of button. Note that the default value is `button` instead of `submit`, which is opposite of how native
+     * `<button>` elements behave. When the type is `submit`, the button will submit the surrounding form.
+     */
+    type: 'button' | 'submit' | 'reset';
+    /**
+     * The name of the button, submitted as a name/value pair with form data, but only when this button is the submitter.
+     * This attribute is ignored when `href` is present.
+     */
+    name: string;
+    /**
+     * The value of the button, submitted as a pair with the button's name as part of the form data, but only when this
+     * button is the submitter. This attribute is ignored when `href` is present.
+     */
+    value: string;
+    /** When set, the underlying button will be rendered as an `<a>` with this `href` instead of a `<button>`. */
+    href: string;
+    /** Tells the browser where to open the link. Only used when `href` is present. */
+    target: '_blank' | '_parent' | '_self' | '_top';
+    /**
+     * When using `href`, this attribute will map to the underlying link's `rel` attribute. Unlike regular links, the
+     * default is `noreferrer noopener` to prevent security exploits. However, if you're using `target` to point to a
+     * specific tab/window, this will prevent that from working correctly. You can remove or change the default value by
+     * setting the attribute to an empty string or a value of your choice, respectively.
+     */
+    rel: string;
+    /** Tells the browser to download the linked file as this filename. Only used when `href` is present. */
+    download?: string;
+    /**
+     * The "form owner" to associate the button with. If omitted, the closest containing form will be used instead. The
+     * value of this attribute must be an id of a form in the same document or shadow root as the button.
+     */
+    form: string;
+    /** Used to override the form owner's `action` attribute. */
+    formAction: string;
+    /** Used to override the form owner's `enctype` attribute.  */
+    formEnctype: 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/plain';
+    /** Used to override the form owner's `method` attribute.  */
+    formMethod: 'post' | 'get';
+    /** Used to override the form owner's `novalidate` attribute. */
+    formNoValidate: boolean;
+    /** Used to override the form owner's `target` attribute. */
+    formTarget: '_self' | '_blank' | '_parent' | '_top' | string;
+    /** Gets the validity state object */
+    get validity(): ValidityState;
+    /** Gets the validation message */
+    get validationMessage(): string;
+    firstUpdated(): void;
+    private handleBlur;
+    private handleFocus;
+    private handleClick;
+    private handleInvalid;
+    private isButton;
+    private isLink;
+    handleDisabledChange(): void;
+    /** Simulates a click on the button. */
+    click(): void;
+    /** Sets focus on the button. */
+    focus(options?: FocusOptions): void;
+    /** Removes focus from the button. */
+    blur(): void;
+    /** Checks for validity but does not show a validation message. Returns `true` when valid and `false` when invalid. */
+    checkValidity(): boolean;
+    /** Gets the associated form, if one exists. */
+    getForm(): HTMLFormElement | null;
+    /** Checks for validity and shows the browser's validation message if the control is invalid. */
+    reportValidity(): boolean;
+    /** Sets a custom validation message. Pass an empty string to restore validity. */
+    setCustomValidity(message: string): void;
+    render(): import("lit").TemplateResult;
+}

package/dist/components/button/button.component.js

@@ -0,0 +1,21 @@
+import {
+  SynButton
+} from "../../chunks/chunk.HSF5YXAS.js";
+import "../../chunks/chunk.Q5SD5LHE.js";
+import "../../chunks/chunk.Y5USHY74.js";
+import "../../chunks/chunk.QPNUJNT5.js";
+import "../../chunks/chunk.Z6AW3P62.js";
+import "../../chunks/chunk.NBKDLFEY.js";
+import "../../chunks/chunk.SVIWEI6P.js";
+import "../../chunks/chunk.2DA7CIOQ.js";
+import "../../chunks/chunk.7XI5LKCC.js";
+import "../../chunks/chunk.VRTJZYIC.js";
+import "../../chunks/chunk.2CFEYJLE.js";
+import "../../chunks/chunk.2A3352EO.js";
+import "../../chunks/chunk.MAS2SHYD.js";
+import "../../chunks/chunk.HQUF2ZAX.js";
+import "../../chunks/chunk.4NMNW5OM.js";
+import "../../chunks/chunk.PM7NIY3M.js";
+export {
+  SynButton as default
+};

package/dist/components/button/button.d.ts

@@ -0,0 +1,8 @@
+import SynButton from './button.component.js';
+export * from './button.component.js';
+export default SynButton;
+declare global {
+    interface HTMLElementTagNameMap {
+        'syn-button': SynButton;
+    }
+}

package/dist/components/button/button.js

@@ -0,0 +1,25 @@
+import {
+  SynButton
+} from "../../chunks/chunk.HSF5YXAS.js";
+import "../../chunks/chunk.Q5SD5LHE.js";
+import "../../chunks/chunk.Y5USHY74.js";
+import "../../chunks/chunk.QPNUJNT5.js";
+import "../../chunks/chunk.Z6AW3P62.js";
+import "../../chunks/chunk.NBKDLFEY.js";
+import "../../chunks/chunk.SVIWEI6P.js";
+import "../../chunks/chunk.2DA7CIOQ.js";
+import "../../chunks/chunk.7XI5LKCC.js";
+import "../../chunks/chunk.VRTJZYIC.js";
+import "../../chunks/chunk.2CFEYJLE.js";
+import "../../chunks/chunk.2A3352EO.js";
+import "../../chunks/chunk.MAS2SHYD.js";
+import "../../chunks/chunk.HQUF2ZAX.js";
+import "../../chunks/chunk.4NMNW5OM.js";
+import "../../chunks/chunk.PM7NIY3M.js";
+
+// src/components/button/button.ts
+var button_default = SynButton;
+SynButton.define("syn-button");
+export {
+  button_default as default
+};

package/dist/components/button/button.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("lit").CSSResult;
+export default _default;

package/dist/components/button/button.styles.js

@@ -0,0 +1,8 @@
+import {
+  button_styles_default
+} from "../../chunks/chunk.Q5SD5LHE.js";
+import "../../chunks/chunk.4NMNW5OM.js";
+import "../../chunks/chunk.PM7NIY3M.js";
+export {
+  button_styles_default as default
+};

package/dist/components/icon/icon.component.d.ts

@@ -0,0 +1,42 @@
+import SynergyElement from '../../internal/synergy-element.js';
+import type { CSSResultGroup, HTMLTemplateResult } from 'lit';
+/**
+ * @summary Icons are symbols that can be used to represent various options within an application.
+ * @documentation https://synergy.style/components/icon
+ * @status stable
+ * @since 2.0
+ *
+ * @event syn-load - Emitted when the icon has loaded. When using `spriteSheet: true` this will not emit.
+ * @event syn-error - Emitted when the icon fails to load due to an error. When using `spriteSheet: true` this will not emit.
+ *
+ * @csspart svg - The internal SVG element.
+ * @csspart use - The <use> element generated when using `spriteSheet: true`
+ */
+export default class SynIcon extends SynergyElement {
+    static styles: CSSResultGroup;
+    private initialRender;
+    /** Given a URL, this function returns the resulting SVG element or an appropriate error symbol. */
+    private resolveIcon;
+    private svg;
+    /** The name of the icon to draw. Available names depend on the icon library being used. */
+    name?: string;
+    /**
+     * An external URL of an SVG file. Be sure you trust the content you are including, as it will be executed as code and
+     * can result in XSS attacks.
+     */
+    src?: string;
+    /**
+     * An alternate description to use for assistive devices. If omitted, the icon will be considered presentational and
+     * ignored by assistive devices.
+     */
+    label: string;
+    /** The name of a registered custom icon library. */
+    library: string;
+    connectedCallback(): void;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    private getIconSource;
+    handleLabelChange(): void;
+    setIcon(): Promise<void>;
+    render(): SVGElement | HTMLTemplateResult | null;
+}

package/dist/components/icon/icon.component.js

@@ -0,0 +1,14 @@
+import {
+  SynIcon
+} from "../../chunks/chunk.NBKDLFEY.js";
+import "../../chunks/chunk.SVIWEI6P.js";
+import "../../chunks/chunk.2DA7CIOQ.js";
+import "../../chunks/chunk.7XI5LKCC.js";
+import "../../chunks/chunk.VRTJZYIC.js";
+import "../../chunks/chunk.2CFEYJLE.js";
+import "../../chunks/chunk.HQUF2ZAX.js";
+import "../../chunks/chunk.4NMNW5OM.js";
+import "../../chunks/chunk.PM7NIY3M.js";
+export {
+  SynIcon as default
+};

package/dist/components/icon/icon.d.ts

@@ -0,0 +1,8 @@
+import SynIcon from './icon.component.js';
+export * from './icon.component.js';
+export default SynIcon;
+declare global {
+    interface HTMLElementTagNameMap {
+        'syn-icon': SynIcon;
+    }
+}

package/dist/components/icon/icon.js

@@ -0,0 +1,18 @@
+import {
+  SynIcon
+} from "../../chunks/chunk.NBKDLFEY.js";
+import "../../chunks/chunk.SVIWEI6P.js";
+import "../../chunks/chunk.2DA7CIOQ.js";
+import "../../chunks/chunk.7XI5LKCC.js";
+import "../../chunks/chunk.VRTJZYIC.js";
+import "../../chunks/chunk.2CFEYJLE.js";
+import "../../chunks/chunk.HQUF2ZAX.js";
+import "../../chunks/chunk.4NMNW5OM.js";
+import "../../chunks/chunk.PM7NIY3M.js";
+
+// src/components/icon/icon.ts
+var icon_default = SynIcon;
+SynIcon.define("syn-icon");
+export {
+  icon_default as default
+};

package/dist/components/icon/icon.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("lit").CSSResult;
+export default _default;

package/dist/components/icon/icon.styles.js

@@ -0,0 +1,8 @@
+import {
+  icon_styles_default
+} from "../../chunks/chunk.SVIWEI6P.js";
+import "../../chunks/chunk.4NMNW5OM.js";
+import "../../chunks/chunk.PM7NIY3M.js";
+export {
+  icon_styles_default as default
+};

package/dist/components/icon/library.d.ts

@@ -0,0 +1,19 @@
+import type SynIcon from '../icon/icon.js';
+export type IconLibraryResolver = (name: string) => string;
+export type IconLibraryMutator = (svg: SVGElement) => void;
+export interface IconLibrary {
+    name: string;
+    resolver: IconLibraryResolver;
+    mutator?: IconLibraryMutator;
+    spriteSheet?: boolean;
+}
+/** Adds an icon to the list of watched icons. */
+export declare function watchIcon(icon: SynIcon): void;
+/** Removes an icon from the list of watched icons. */
+export declare function unwatchIcon(icon: SynIcon): void;
+/** Returns a library from the registry. */
+export declare function getIconLibrary(name?: string): IconLibrary | undefined;
+/** Adds an icon library to the registry, or overrides an existing one. */
+export declare function registerIconLibrary(name: string, options: Omit<IconLibrary, 'name'>): void;
+/** Removes an icon library from the registry. */
+export declare function unregisterIconLibrary(name: string): void;

package/dist/components/icon/library.default.d.ts

@@ -0,0 +1,3 @@
+import type { IconLibrary } from './library.js';
+declare const library: IconLibrary;
+export default library;

package/dist/components/icon/library.default.js

@@ -0,0 +1,8 @@
+import {
+  library_default_default
+} from "../../chunks/chunk.7XI5LKCC.js";
+import "../../chunks/chunk.2CFEYJLE.js";
+import "../../chunks/chunk.PM7NIY3M.js";
+export {
+  library_default_default as default
+};

package/dist/components/icon/library.js

@@ -0,0 +1,18 @@
+import {
+  getIconLibrary,
+  registerIconLibrary,
+  unregisterIconLibrary,
+  unwatchIcon,
+  watchIcon
+} from "../../chunks/chunk.2DA7CIOQ.js";
+import "../../chunks/chunk.7XI5LKCC.js";
+import "../../chunks/chunk.VRTJZYIC.js";
+import "../../chunks/chunk.2CFEYJLE.js";
+import "../../chunks/chunk.PM7NIY3M.js";
+export {
+  getIconLibrary,
+  registerIconLibrary,
+  unregisterIconLibrary,
+  unwatchIcon,
+  watchIcon
+};