@ilokesto/utilinent 1.0.14 → 1.1.0

package/dist/components/For.js

@@ -1,48 +1,12 @@
-import { Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { createElement, forwardRef } from "react";
-import { htmlTags } from "../constants/htmlTags";
-import { PluginManager } from "../core/PluginManager";
-function BaseFor({ each, children, fallback = null, before, after, }) {
-    const content = each && each.length > 0 ? each.map(children) : fallback;
-    return (_jsxs(_Fragment, { children: [before, content, after] }));
+import { createTagProxy } from "../core/createTagProxy";
+function BaseFor({ each, children, fallback = null, }) {
+    return each && each.length > 0 ? each.map(children) : fallback;
 }
 const renderForTag = (tag) => 
 // forward ref so consumers can attach a ref to the underlying DOM element
-forwardRef(({ each, children, fallback = null, before, after, ...props }, ref) => {
-    const content = each && each.length > 0 ? each.map(children) : fallback;
-    return createElement(tag, { ...props, ref }, before, content, after);
-});
-// HTML 태그들을 등록
-const tagEntries = htmlTags.reduce((acc, tag) => {
-    acc[tag] = renderForTag(tag);
-    return acc;
-}, {});
-// Proxy를 사용하여 동적으로 플러그인 조회
-export const For = new Proxy(Object.assign(BaseFor, tagEntries), {
-    get(target, prop) {
-        // 기존 속성이 있으면 반환
-        if (prop in target) {
-            return target[prop];
-        }
-        // 플러그인에서 동적으로 조회
-        const propName = String(prop);
-        // 'for' 카테고리에서 먼저 찾기
-        if (PluginManager.has('for', propName)) {
-            const component = PluginManager.get('for', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 'base' 카테고리에서 찾기
-        if (PluginManager.has('base', propName)) {
-            const component = PluginManager.get('base', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 찾지 못하면 undefined 반환
-        return undefined;
-    }
+forwardRef(({ each, children, fallback = null, ...props }, ref) => {
+    const content = BaseFor({ each, children, fallback });
+    return createElement(tag, { ...props, ref }, content);
 });
+export const For = createTagProxy(BaseFor, renderForTag, "for");

package/dist/components/Mount.d.ts

@@ -0,0 +1,2 @@
+import type { MountType } from "../types/mount";
+export declare const Mount: MountType;

package/dist/components/Mount.js

@@ -0,0 +1,70 @@
+import { createElement, forwardRef, useEffect, useLayoutEffect, useRef, useState, } from "react";
+import { createTagProxy } from "../core/createTagProxy";
+const isPromiseLike = (value) => (typeof value === "object" || typeof value === "function") &&
+    value !== null &&
+    typeof value.then === "function";
+const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+function BaseMount({ children, fallback = null, onError }) {
+    const isFunction = typeof children === "function";
+    const [resolvedChildren, setResolvedChildren] = useState(() => isFunction ? fallback : children);
+    const [status, setStatus] = useState(() => isFunction ? "fallback" : "resolved");
+    const callIdRef = useRef(0);
+    useIsomorphicLayoutEffect(() => {
+        const callId = ++callIdRef.current;
+        let canceled = false;
+        if (typeof children !== "function") {
+            setResolvedChildren(children);
+            setStatus("resolved");
+            return () => {
+                canceled = true;
+            };
+        }
+        let result;
+        try {
+            result = children();
+        }
+        catch (error) {
+            setStatus("fallback");
+            console.error("Mount children threw:", error);
+            onError?.(error);
+            return () => {
+                canceled = true;
+            };
+        }
+        if (isPromiseLike(result)) {
+            setStatus("fallback");
+            result
+                .then((value) => {
+                if (canceled || callId !== callIdRef.current) {
+                    return;
+                }
+                setResolvedChildren(value);
+                setStatus("resolved");
+            })
+                .catch((error) => {
+                if (canceled || callId !== callIdRef.current) {
+                    return;
+                }
+                setStatus("fallback");
+                console.error("Mount children promise rejected:", error);
+                onError?.(error);
+            });
+            return () => {
+                canceled = true;
+            };
+        }
+        setResolvedChildren(result);
+        setStatus("resolved");
+        return () => {
+            canceled = true;
+        };
+    }, [children, onError]);
+    return status === "resolved" ? resolvedChildren : fallback;
+}
+const renderForTag = (tag) => 
+// forward ref so consumers can attach a ref to the underlying DOM element
+forwardRef(function Render({ children, fallback = null, onError, ...props }, ref) {
+    const content = BaseMount({ children, fallback, onError });
+    return createElement(tag, { ...props, ref }, content);
+});
+export const Mount = createTagProxy(BaseMount, renderForTag, "mount");

package/dist/components/OptionalWrapper.d.ts

@@ -1,2 +1,2 @@
 import { OptionalWrapperProps } from "../types";
-export declare function OptionalWrapper({ when, children, wrapper, fallback }: OptionalWrapperProps): React.ReactNode;
+export declare function OptionalWrapper<T>({ when, children, wrapper, fallback }: OptionalWrapperProps<T>): React.ReactNode;

package/dist/components/Repeat.js

@@ -1,52 +1,16 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { createElement, forwardRef } from "react";
-import { htmlTags } from "../constants/htmlTags";
-import { PluginManager } from "../core/PluginManager";
-import { For } from "./For";
+import { createTagProxy } from "../core/createTagProxy";
 function BaseRepeat({ times, children, fallback = null }) {
-    if (!times || times <= 0 || !Number.isInteger(times)) {
-        return fallback ?? null;
-    }
-    return _jsx(For, { each: Array.from({ length: times }, (_, i) => i), children: children });
+    const content = times && times > 0 && Number.isInteger(times)
+        ? Array.from({ length: times }, (_, i) => children(i))
+        : fallback ?? null;
+    return _jsx(_Fragment, { children: content });
 }
 const renderForTag = (tag) => 
 // forward ref so consumers can attach a ref to the underlying DOM element
 forwardRef(({ times, children, fallback = null, ...props }, ref) => {
-    const content = times && times > 0 && Number.isInteger(times)
-        ? Array.from({ length: times }, (_, i) => children(i))
-        : fallback ?? null;
+    const content = BaseRepeat({ times, children, fallback });
     return createElement(tag, { ...props, ref }, content);
 });
-// HTML 태그들을 등록
-const tagEntries = htmlTags.reduce((acc, tag) => {
-    acc[tag] = renderForTag(tag);
-    return acc;
-}, {});
-export const Repeat = new Proxy(Object.assign(BaseRepeat, tagEntries), {
-    get(target, prop) {
-        // 기존 속성이 있으면 반환
-        if (prop in target) {
-            return target[prop];
-        }
-        // 플러그인에서 동적으로 조회
-        const propName = String(prop);
-        // 'repeat' 카테고리에서 먼저 찾기
-        if (PluginManager.has('repeat', propName)) {
-            const component = PluginManager.get('repeat', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 'base' 카테고리에서 찾기
-        if (PluginManager.has('base', propName)) {
-            const component = PluginManager.get('base', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 찾지 못하면 undefined 반환
-        return undefined;
-    }
-});
+export const Repeat = createTagProxy(BaseRepeat, renderForTag, "repeat");

package/dist/components/Show.js

@@ -1,8 +1,8 @@
 import { createElement, forwardRef } from "react";
-import { htmlTags } from "../constants/htmlTags";
-import { PluginManager } from "../core/PluginManager";
+import { createTagProxy } from "../core/createTagProxy";
+import { resolveWhen } from "../utils/resolveWhen";
 const BaseShow = ({ when, children, fallback = null }) => {
-    const shouldRender = Array.isArray(when) ? when.every(Boolean) : !!when;
+    const shouldRender = resolveWhen(when);
     return shouldRender
         ? typeof children === "function"
             ? children(when)
@@ -12,44 +12,7 @@ const BaseShow = ({ when, children, fallback = null }) => {
 const renderForTag = (tag) => 
 // forward ref so consumers like Observer can pass a ref to the real DOM element
 forwardRef(function Render({ when, children, fallback = null, ...props }, ref) {
-    const shouldRender = Array.isArray(when) ? when.every(Boolean) : !!when;
-    const content = shouldRender
-        ? typeof children === "function"
-            ? children(when)
-            : children
-        : fallback;
+    const content = BaseShow({ when, children, fallback });
     return createElement(tag, { ...props, ref }, content);
 });
-// HTML 태그들을 등록
-const tagEntries = htmlTags.reduce((acc, tag) => {
-    acc[tag] = renderForTag(tag);
-    return acc;
-}, {});
-export const Show = new Proxy(Object.assign(BaseShow, tagEntries), {
-    get(target, prop) {
-        // 기존 속성이 있으면 반환
-        if (prop in target) {
-            return target[prop];
-        }
-        // 플러그인에서 동적으로 조회
-        const propName = String(prop);
-        // 'show' 카테고리에서 먼저 찾기
-        if (PluginManager.has('show', propName)) {
-            const component = PluginManager.get('show', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 'base' 카테고리에서 찾기
-        if (PluginManager.has('base', propName)) {
-            const component = PluginManager.get('base', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 찾지 못하면 undefined 반환
-        return undefined;
-    }
-});
+export const Show = createTagProxy(BaseShow, renderForTag, "show");

package/dist/components/Switch.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from "react";
+import type { MatchProps, SwitchType } from "../types/switch";
+export declare const Switch: SwitchType;
+export declare function Match<T>({ when, children }: MatchProps<T>): ReactNode;

package/dist/components/Switch.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Children, Fragment, createElement, forwardRef, isValidElement, } from "react";
+import { createTagProxy } from "../core/createTagProxy";
+import { resolveWhen } from "../utils/resolveWhen";
+const flattenChildren = (nodes) => Children.toArray(nodes).flatMap((child) => {
+    if (isValidElement(child) && child.type === Fragment) {
+        return flattenChildren(child.props.children);
+    }
+    return [child];
+});
+const isMatchElement = (child) => isValidElement(child) && child.type === Match;
+function BaseSwitch({ children, fallback = null }) {
+    const childArray = flattenChildren(children);
+    for (const child of childArray) {
+        if (!isMatchElement(child)) {
+            continue;
+        }
+        const { when } = child.props;
+        if (!resolveWhen(when)) {
+            continue;
+        }
+        return child;
+    }
+    return fallback;
+}
+const renderForTag = (tag) => 
+// forward ref so consumers can attach a ref to the underlying DOM element
+forwardRef(function Render({ children, fallback = null, ...props }, ref) {
+    return createElement(tag, { ...props, ref }, _jsx(BaseSwitch, { fallback: fallback, children: children }));
+});
+export const Switch = createTagProxy(BaseSwitch, renderForTag, "switch");
+export function Match({ when, children }) {
+    if (!resolveWhen(when)) {
+        return null;
+    }
+    return typeof children === "function"
+        ? children(when)
+        : children;
+}

package/dist/core/PluginManager.d.ts

@@ -1,9 +1,10 @@
+import type { TagProxyCategory } from "./tagProxyTypes";
 /**
  * 플러그인 등록을 위한 타입
  * Register 인터페이스의 각 카테고리에 대해 부분적으로 등록 가능
  */
 type PluginRegistration = {
-    [K in "show" | "for" | "repeat" | "base"]?: Record<string, any>;
+    [K in TagProxyCategory]?: Record<string, any>;
 };
 /**
  * 플러그인 컴포넌트를 등록하고 관리하는 싱글턴 클래스
@@ -71,18 +72,18 @@ export declare class PluginManager {
     /**
      * 등록된 플러그인 컴포넌트를 가져옵니다 (내부용)
      */
-    static get<K extends "show" | "for" | "repeat" | "base">(category: K, name: string): any;
+    static get<K extends TagProxyCategory>(category: K, name: string): any;
     /**
      * 특정 카테고리의 모든 플러그인을 가져옵니다 (내부용)
      */
-    static getAll<K extends "show" | "for" | "repeat" | "base">(category: K): Map<string, any>;
+    static getAll<K extends TagProxyCategory>(category: K): Map<string, any>;
     /**
      * 플러그인이 등록되어 있는지 확인합니다
      */
-    static has<K extends "show" | "for" | "repeat" | "base">(category: K, name: string): boolean;
+    static has<K extends TagProxyCategory>(category: K, name: string): boolean;
     /**
      * 플러그인을 제거합니다
      */
-    static unregister<K extends "show" | "for" | "repeat" | "base">(category: K, name: string): boolean;
+    static unregister<K extends TagProxyCategory>(category: K, name: string): boolean;
 }
 export {};

package/dist/core/PluginManager.js

@@ -36,6 +36,8 @@ export class PluginManager {
         show: new Map(),
         for: new Map(),
         repeat: new Map(),
+        mount: new Map(),
+        switch: new Map(),
         base: new Map(),
     };
     constructor() {

package/dist/core/createTagProxy.d.ts

@@ -0,0 +1,3 @@
+import type { TagProxyCategory } from "./tagProxyTypes";
+export type { TagProxyCategory } from "./tagProxyTypes";
+export declare function createTagProxy<TProxy extends object, TBase extends object = TProxy>(base: TBase, renderForTag: (tag: any) => any, category: TagProxyCategory): TProxy;

package/dist/core/createTagProxy.js

@@ -0,0 +1,30 @@
+import { htmlTags } from "../constants/htmlTags";
+import { PluginManager } from "./PluginManager";
+export function createTagProxy(base, renderForTag, category) {
+    const tagEntries = htmlTags.reduce((acc, tag) => {
+        acc[tag] = renderForTag(tag);
+        return acc;
+    }, {});
+    const target = Object.assign(base, tagEntries);
+    return new Proxy(target, {
+        get(currentTarget, prop) {
+            if (prop in currentTarget) {
+                return currentTarget[prop];
+            }
+            const propName = String(prop);
+            if (PluginManager.has(category, propName)) {
+                const component = PluginManager.get(category, propName);
+                const specialized = renderForTag(component);
+                currentTarget[prop] = specialized;
+                return specialized;
+            }
+            if (PluginManager.has("base", propName)) {
+                const component = PluginManager.get("base", propName);
+                const specialized = renderForTag(component);
+                currentTarget[prop] = specialized;
+                return specialized;
+            }
+            return undefined;
+        },
+    });
+}

package/dist/core/tagProxyTypes.d.ts

@@ -0,0 +1 @@
+export type TagProxyCategory = "show" | "for" | "repeat" | "mount" | "switch" | "base";

package/dist/core/tagProxyTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 export * from './components/For';
+export * from './components/Mount';
 export * from './components/Observer';
 export * from './components/OptionalWrapper';
 export * from './components/Repeat';
 export * from './components/Show';
+export * from './components/Switch';
 export * from './components/Slacker';
 export * from './components/Slot';
 export * from './hooks/useIntersectionObserver';

package/dist/index.js

@@ -1,8 +1,10 @@
 export * from './components/For';
+export * from './components/Mount';
 export * from './components/Observer';
 export * from './components/OptionalWrapper';
 export * from './components/Repeat';
 export * from './components/Show';
+export * from './components/Switch';
 export * from './components/Slacker';
 export * from './components/Slot';
 export * from './hooks/useIntersectionObserver';

package/dist/types/for.d.ts

@@ -4,8 +4,6 @@ import { UtilinentRegisterBase, UtilinentRegisterFor } from "./register";
 export interface ForProps<T extends Array<unknown>> extends Fallback {
     each: T | null | undefined;
     children: (item: T[number], index: number) => React.ReactNode;
-    before?: React.ReactNode;
-    after?: React.ReactNode;
 }
 type ForTagHelper<K extends HtmlTag> = {
     <const T extends Array<unknown>>(props: ForProps<T> & Omit<React.ComponentPropsWithRef<K>, 'children'>): React.ReactNode;

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
-import type { ReactElement } from "react";
 export type { UtilinentRegister } from "./register";
 export interface Fallback {
     fallback?: React.ReactNode;
@@ -6,8 +5,8 @@ export interface Fallback {
 export type NonNullableElements<T extends readonly any[]> = {
     -readonly [P in keyof T]: NonNullable<T[P]>;
 };
-export interface OptionalWrapperProps {
-    when: boolean;
+export interface OptionalWrapperProps<T = unknown> {
+    when: T;
     children: React.ReactNode;
     wrapper: (children: React.ReactNode) => React.ReactNode;
     fallback?: (children: React.ReactNode) => React.ReactNode;
@@ -19,12 +18,9 @@ export interface ObserverProps extends Fallback {
     triggerOnce?: boolean;
     onIntersect?: (isIntersecting: boolean, entry: IntersectionObserverEntry) => void;
 }
-export interface SwitchProps<T, K extends LiteralKeys<T>> extends Fallback {
-    children: Array<ReactElement>;
-    when: K;
-}
 export interface MountProps extends Fallback {
     children: React.ReactNode | (() => React.ReactNode | Promise<React.ReactNode>);
+    onError?: (error: unknown) => void;
 }
 export type ExtractValues<T, K extends keyof T> = T extends any ? T[K] : never;
 type IsUnion<T, U = T> = T extends any ? [U] extends [T] ? false : true : false;

package/dist/types/mount.d.ts

@@ -0,0 +1,20 @@
+import { ComponentPropsWithRef } from "react";
+import { HtmlTag } from "../constants/htmlTags";
+import { MountProps } from ".";
+import { UtilinentRegisterBase, UtilinentRegisterMount } from "./register";
+type MountTagHelper<K extends HtmlTag> = {
+    (props: MountProps & Omit<ComponentPropsWithRef<K>, "children">): React.ReactNode;
+};
+type MountRegisterHelper<C> = C extends React.ComponentType<infer P> ? {
+    (props: Omit<P, "children"> & MountProps): React.ReactNode;
+} : C;
+export type MountType = {
+    (props: MountProps): React.ReactNode;
+} & {
+    [K in HtmlTag]: MountTagHelper<K>;
+} & {
+    [K in keyof UtilinentRegisterMount]: MountRegisterHelper<UtilinentRegisterMount[K]>;
+} & {
+    [K in keyof UtilinentRegisterBase]: MountRegisterHelper<UtilinentRegisterBase[K]>;
+};
+export {};

package/dist/types/mount.js

@@ -0,0 +1 @@
+export {};

package/dist/types/register.d.ts

@@ -12,3 +12,9 @@ export type UtilinentRegisterFor = UtilinentRegister extends {
 export type UtilinentRegisterRepeat = UtilinentRegister extends {
     repeat: infer Repeat;
 } ? Repeat : never;
+export type UtilinentRegisterMount = UtilinentRegister extends {
+    mount: infer Mount;
+} ? Mount : never;
+export type UtilinentRegisterSwitch = UtilinentRegister extends {
+    switch: infer Switch;
+} ? Switch : never;

package/dist/types/switch.d.ts

@@ -0,0 +1,27 @@
+import { ComponentPropsWithRef } from "react";
+import { HtmlTag } from "../constants/htmlTags";
+import { Fallback } from ".";
+import { UtilinentRegisterBase, UtilinentRegisterSwitch } from "./register";
+export interface MatchProps<T = unknown> {
+    when: T | null | undefined | false;
+    children: React.ReactNode | ((item: NonNullable<T>) => React.ReactNode);
+}
+export interface SwitchProps extends Fallback {
+    children: React.ReactNode;
+}
+type SwitchTagHelper<K extends HtmlTag> = {
+    (props: SwitchProps & Omit<ComponentPropsWithRef<K>, "children">): React.ReactNode;
+};
+type SwitchRegisterHelper<C> = C extends React.ComponentType<infer P> ? {
+    (props: Omit<P, "children"> & SwitchProps): React.ReactNode;
+} : C;
+export type SwitchType = {
+    (props: SwitchProps): React.ReactNode;
+} & {
+    [K in HtmlTag]: SwitchTagHelper<K>;
+} & {
+    [K in keyof UtilinentRegisterSwitch]: SwitchRegisterHelper<UtilinentRegisterSwitch[K]>;
+} & {
+    [K in keyof UtilinentRegisterBase]: SwitchRegisterHelper<UtilinentRegisterBase[K]>;
+};
+export {};

package/dist/types/switch.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/resolveWhen.d.ts

@@ -0,0 +1 @@
+export declare const resolveWhen: (value: unknown) => boolean;

package/dist/utils/resolveWhen.js

@@ -0,0 +1 @@
+export const resolveWhen = (value) => Array.isArray(value) ? value.every(Boolean) : !!value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilokesto/utilinent",
-  "version": "1.0.14",
+  "version": "1.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ilokesto/utilinent.git"
@@ -13,10 +13,6 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
-    },
-    "./experimental": {
-      "import": "./dist/experimental.js",
-      "types": "./dist/experimental.d.ts"
     }
   },
   "files": [

package/dist/experimental/Mount.d.ts

@@ -1,2 +0,0 @@
-import type { MountProps } from "../types";
-export declare function Mount({ children, fallback }: MountProps): import("react").ReactNode;

package/dist/experimental/Mount.js

@@ -1,8 +0,0 @@
-import { useEffect, useState } from "react";
-export function Mount({ children, fallback = null }) {
-    const [resolvedChildren, setResolvedChildren] = useState(fallback);
-    useEffect(() => {
-        (async () => setResolvedChildren(typeof children === "function" ? await children() : children))();
-    }, [children]);
-    return resolvedChildren;
-}

package/dist/experimental/Switch.d.ts

@@ -1,8 +0,0 @@
-import type { ExtractByKeyValue, ExtractValues, LiteralKeys, SwitchProps } from "../types";
-export declare function createSwitcher<T, K extends LiteralKeys<T>>(data: T): {
-    Switch: ({ children, when, fallback }: SwitchProps<T, K>) => string | number | boolean | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null;
-    Match: <V extends ExtractValues<T, K>>({ children }: {
-        case: V;
-        children: (props: ExtractByKeyValue<T, K, V>) => React.ReactNode;
-    }) => import("react").ReactNode;
-};

package/dist/experimental/Switch.js

@@ -1,21 +0,0 @@
-export function createSwitcher(data) {
-    function Switch({ children, when, fallback = null }) {
-        children.reduce((acc, { type, props }) => {
-            if (type !== Match)
-                throw new Error("Match 컴포넌트만 사용할 수 있습니다.");
-            if (props.case) {
-                if (acc.includes(props.case))
-                    throw new Error(`Duplicate Match key: ${props.case}`);
-                else
-                    acc.push(props.case);
-            }
-            return acc;
-        }, []);
-        return children.find(({ props }) => props.case === data[when]) ?? fallback;
-    }
-    function Match({ children }) {
-        return children(data);
-    }
-    ;
-    return { Switch, Match };
-}

package/dist/experimental.d.ts

@@ -1,2 +0,0 @@
-export * from './experimental/Mount';
-export * from './experimental/Switch';

package/dist/experimental.js

@@ -1,2 +0,0 @@
-export * from './experimental/Mount';
-export * from './experimental/Switch';