@esmx/router 3.0.0-rc.18 → 3.0.0-rc.20

package/dist/router-guards-cleanup.test.mjs

@@ -0,0 +1,437 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { Router } from "./router.mjs";
+import { RouterMode } from "./types.mjs";
+import { removeFromArray } from "./util.mjs";
+describe("Router Guards Cleanup Tests", () => {
+  let router;
+  beforeEach(async () => {
+    router = new Router({
+      mode: RouterMode.memory,
+      base: new URL("http://localhost:3000/"),
+      routes: [
+        {
+          path: "/",
+          component: () => "Home"
+        },
+        {
+          path: "/test1",
+          component: () => "Test1"
+        },
+        {
+          path: "/test2",
+          component: () => "Test2"
+        },
+        {
+          path: "/test3",
+          component: () => "Test3"
+        }
+      ]
+    });
+    await router.replace("/");
+  });
+  afterEach(() => {
+    router.destroy();
+  });
+  describe("\u{1F525} Guard Cleanup Effect Verification", () => {
+    describe("beforeEach cleanup effects", () => {
+      test("guard should not execute after cleanup", async () => {
+        const spy = vi.fn();
+        const unregister = router.beforeEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(1);
+        unregister();
+        await router.push("/test2");
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+      test("guard should not execute after cleanup for multiple navigations", async () => {
+        const spy = vi.fn();
+        const unregister = router.beforeEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(1);
+        unregister();
+        await router.push("/test2");
+        await router.push("/test3");
+        await router.push("/");
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+      test("async guard should not execute after cleanup", async () => {
+        const spy = vi.fn();
+        const asyncGuard = async (to, from) => {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          spy(to, from);
+        };
+        const unregister = router.beforeEach(asyncGuard);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(1);
+        unregister();
+        await router.push("/test2");
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+    });
+    describe("afterEach cleanup effects", () => {
+      test("guard should not execute after cleanup", async () => {
+        const spy = vi.fn();
+        const unregister = router.afterEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(1);
+        unregister();
+        await router.push("/test2");
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+      test("guard should not execute after cleanup for multiple navigations", async () => {
+        const spy = vi.fn();
+        const unregister = router.afterEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(1);
+        unregister();
+        await router.push("/test2");
+        await router.push("/test3");
+        await router.push("/");
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+    });
+  });
+  describe("\u26A1 Multiple Guards Independent Cleanup", () => {
+    describe("beforeEach multiple guards cleanup", () => {
+      test("cleaning single guard should not affect other guards", async () => {
+        const spy1 = vi.fn();
+        const spy2 = vi.fn();
+        const spy3 = vi.fn();
+        const unregister1 = router.beforeEach(spy1);
+        const unregister2 = router.beforeEach(spy2);
+        const unregister3 = router.beforeEach(spy3);
+        await router.push("/test1");
+        expect(spy1).toHaveBeenCalledTimes(1);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        expect(spy3).toHaveBeenCalledTimes(1);
+        unregister2();
+        await router.push("/test2");
+        expect(spy1).toHaveBeenCalledTimes(2);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        expect(spy3).toHaveBeenCalledTimes(2);
+        unregister1();
+        unregister3();
+      });
+      test("cleaning multiple guards should work correctly", async () => {
+        const spy1 = vi.fn();
+        const spy2 = vi.fn();
+        const spy3 = vi.fn();
+        const spy4 = vi.fn();
+        const unregister1 = router.beforeEach(spy1);
+        const unregister2 = router.beforeEach(spy2);
+        const unregister3 = router.beforeEach(spy3);
+        const unregister4 = router.beforeEach(spy4);
+        await router.push("/test1");
+        expect(spy1).toHaveBeenCalledTimes(1);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        expect(spy3).toHaveBeenCalledTimes(1);
+        expect(spy4).toHaveBeenCalledTimes(1);
+        unregister1();
+        unregister3();
+        spy1.mockClear();
+        spy2.mockClear();
+        spy3.mockClear();
+        spy4.mockClear();
+        await router.push("/test2");
+        expect(spy1).not.toHaveBeenCalled();
+        expect(spy2).toHaveBeenCalledTimes(1);
+        expect(spy3).not.toHaveBeenCalled();
+        expect(spy4).toHaveBeenCalledTimes(1);
+        unregister2();
+        unregister4();
+      });
+      test("guard execution order should remain correct after cleanup", async () => {
+        const executionOrder = [];
+        const guard1 = () => {
+          executionOrder.push("guard1");
+        };
+        const guard2 = () => {
+          executionOrder.push("guard2");
+        };
+        const guard3 = () => {
+          executionOrder.push("guard3");
+        };
+        router.beforeEach(guard1);
+        const unregister2 = router.beforeEach(guard2);
+        router.beforeEach(guard3);
+        await router.push("/test1");
+        expect(executionOrder).toEqual(["guard1", "guard2", "guard3"]);
+        executionOrder.length = 0;
+        unregister2();
+        await router.push("/test2");
+        expect(executionOrder).toEqual(["guard1", "guard3"]);
+      });
+    });
+    describe("afterEach multiple guards cleanup", () => {
+      test("cleaning single afterEach guard should not affect other guards", async () => {
+        const spy1 = vi.fn();
+        const spy2 = vi.fn();
+        const spy3 = vi.fn();
+        const unregister1 = router.afterEach(spy1);
+        const unregister2 = router.afterEach(spy2);
+        const unregister3 = router.afterEach(spy3);
+        await router.push("/test1");
+        expect(spy1).toHaveBeenCalledTimes(1);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        expect(spy3).toHaveBeenCalledTimes(1);
+        unregister2();
+        await router.push("/test2");
+        expect(spy1).toHaveBeenCalledTimes(2);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        expect(spy3).toHaveBeenCalledTimes(2);
+        unregister1();
+        unregister3();
+      });
+      test("afterEach guard execution order should remain correct after cleanup", async () => {
+        const executionOrder = [];
+        const guard1 = () => {
+          executionOrder.push("after1");
+        };
+        const guard2 = () => {
+          executionOrder.push("after2");
+        };
+        const guard3 = () => {
+          executionOrder.push("after3");
+        };
+        router.afterEach(guard1);
+        const unregister2 = router.afterEach(guard2);
+        router.afterEach(guard3);
+        await router.push("/test1");
+        expect(executionOrder).toEqual(["after1", "after2", "after3"]);
+        executionOrder.length = 0;
+        unregister2();
+        await router.push("/test2");
+        expect(executionOrder).toEqual(["after1", "after3"]);
+      });
+    });
+    describe("mixed guards cleanup", () => {
+      test("beforeEach and afterEach guards should cleanup independently", async () => {
+        const beforeSpy = vi.fn();
+        const afterSpy = vi.fn();
+        const unregisterBefore = router.beforeEach(beforeSpy);
+        const unregisterAfter = router.afterEach(afterSpy);
+        await router.push("/test1");
+        expect(beforeSpy).toHaveBeenCalledTimes(1);
+        expect(afterSpy).toHaveBeenCalledTimes(1);
+        unregisterBefore();
+        await router.push("/test2");
+        expect(beforeSpy).toHaveBeenCalledTimes(1);
+        expect(afterSpy).toHaveBeenCalledTimes(2);
+        unregisterAfter();
+        await router.push("/test3");
+        expect(beforeSpy).toHaveBeenCalledTimes(1);
+        expect(afterSpy).toHaveBeenCalledTimes(2);
+      });
+    });
+  });
+  describe("\u{1F6E1}\uFE0F Edge Cases Testing", () => {
+    describe("repeated cleanup safety", () => {
+      test("repeated cleanup function calls should be safe", () => {
+        const spy = vi.fn();
+        const unregister = router.beforeEach(spy);
+        expect(() => {
+          unregister();
+          unregister();
+          unregister();
+        }).not.toThrow();
+      });
+      test("guard should still not execute after repeated cleanup", async () => {
+        const spy = vi.fn();
+        const unregister = router.beforeEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(1);
+        unregister();
+        unregister();
+        unregister();
+        await router.push("/test2");
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+    });
+    describe("cleanup and re-registration", () => {
+      test("can re-register same guard after cleanup", async () => {
+        const spy = vi.fn();
+        const unregister1 = router.beforeEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(1);
+        unregister1();
+        const unregister2 = router.beforeEach(spy);
+        await router.push("/test2");
+        expect(spy).toHaveBeenCalledTimes(2);
+        unregister2();
+      });
+      test("re-registration after cleanup should work normally", async () => {
+        const spy = vi.fn();
+        let unregister = router.beforeEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(1);
+        unregister();
+        unregister = router.beforeEach(spy);
+        await router.push("/test2");
+        expect(spy).toHaveBeenCalledTimes(2);
+        unregister();
+        unregister = router.beforeEach(spy);
+        await router.push("/test3");
+        expect(spy).toHaveBeenCalledTimes(3);
+        unregister();
+      });
+    });
+    describe("same guard multiple registrations", () => {
+      test("same guard function registered multiple times should handle correctly", async () => {
+        const spy = vi.fn();
+        const unregister1 = router.beforeEach(spy);
+        const unregister2 = router.beforeEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(2);
+        unregister1();
+        await router.push("/test2");
+        expect(spy).toHaveBeenCalledTimes(3);
+        unregister2();
+        await router.push("/test3");
+        expect(spy).toHaveBeenCalledTimes(3);
+      });
+      test("complex scenario with same guard multiple registrations and cleanups", async () => {
+        const spy = vi.fn();
+        const unregister1 = router.beforeEach(spy);
+        const unregister2 = router.beforeEach(spy);
+        const unregister3 = router.beforeEach(spy);
+        await router.push("/test1");
+        expect(spy).toHaveBeenCalledTimes(3);
+        unregister2();
+        await router.push("/test2");
+        expect(spy).toHaveBeenCalledTimes(5);
+        unregister1();
+        unregister3();
+        await router.push("/test3");
+        expect(spy).toHaveBeenCalledTimes(5);
+      });
+    });
+    describe("empty array and non-existent element handling", () => {
+      test("removing element from empty array should be safe", () => {
+        const emptyArray = [];
+        const element = vi.fn();
+        expect(() => {
+          removeFromArray(emptyArray, element);
+        }).not.toThrow();
+        expect(emptyArray).toEqual([]);
+      });
+      test("removing non-existent element should be safe", () => {
+        const array = [vi.fn(), vi.fn(), vi.fn()];
+        const nonExistentElement = vi.fn();
+        const originalLength = array.length;
+        expect(() => {
+          removeFromArray(array, nonExistentElement);
+        }).not.toThrow();
+        expect(array).toHaveLength(originalLength);
+      });
+    });
+    describe("special value handling", () => {
+      test("removeFromArray should handle NaN values correctly", () => {
+        const arr = [1, Number.NaN, 3, Number.NaN, 5];
+        removeFromArray(arr, Number.NaN);
+        expect(arr).toEqual([1, 3, Number.NaN, 5]);
+      });
+      test("removeFromArray should handle function references correctly", () => {
+        const func1 = () => "func1";
+        const func2 = () => "func2";
+        const func3 = () => "func3";
+        const arr = [func1, func2, func3];
+        removeFromArray(arr, func2);
+        expect(arr).toEqual([func1, func3]);
+      });
+      test("removeFromArray should handle object references correctly", () => {
+        const obj1 = { id: 1 };
+        const obj2 = { id: 2 };
+        const obj3 = { id: 3 };
+        const arr = [obj1, obj2, obj3];
+        removeFromArray(arr, obj2);
+        expect(arr).toEqual([obj1, obj3]);
+      });
+    });
+    describe("memory leak protection", () => {
+      test("large number of guard registrations and cleanups should not cause memory leaks", () => {
+        const unregisters = [];
+        for (let i = 0; i < 100; i++) {
+          const guard = vi.fn();
+          const unregister = router.beforeEach(guard);
+          unregisters.push(unregister);
+        }
+        expect(router.transition.guards.beforeEach).toHaveLength(100);
+        unregisters.forEach((unregister) => unregister());
+        expect(router.transition.guards.beforeEach).toHaveLength(0);
+      });
+      test("mixed registration and cleanup should not cause memory leaks", () => {
+        const guards = [];
+        const unregisters = [];
+        for (let i = 0; i < 50; i++) {
+          const guard = vi.fn();
+          guards.push(guard);
+          const unregister = router.beforeEach(guard);
+          unregisters.push(unregister);
+          if (i % 5 === 0 && i > 0) {
+            unregisters[i - 5]();
+          }
+        }
+        unregisters.forEach((unregister) => unregister());
+        expect(router.transition.guards.beforeEach).toHaveLength(0);
+        expect(router.transition.guards.afterEach).toHaveLength(0);
+      });
+    });
+    describe("concurrent cleanup safety", () => {
+      test("cleaning guard during navigation should be safe", async () => {
+        let unregister = null;
+        let guardExecuted = false;
+        const guard = async () => {
+          guardExecuted = true;
+          unregister == null ? void 0 : unregister();
+          await new Promise((resolve) => setTimeout(resolve, 10));
+        };
+        unregister = router.beforeEach(guard);
+        await expect(router.push("/test1")).resolves.toBeDefined();
+        expect(guardExecuted).toBe(true);
+        guardExecuted = false;
+        await router.push("/test2");
+        expect(guardExecuted).toBe(false);
+      });
+      test("cleaning multiple guards simultaneously should be safe", async () => {
+        const guards = Array.from({ length: 10 }, () => vi.fn());
+        const unregisters = guards.map(
+          (guard) => router.beforeEach(guard)
+        );
+        await router.push("/test1");
+        guards.forEach(
+          (guard) => expect(guard).toHaveBeenCalledTimes(1)
+        );
+        unregisters.forEach((unregister) => unregister());
+        await router.push("/test2");
+        guards.forEach(
+          (guard) => expect(guard).toHaveBeenCalledTimes(1)
+        );
+      });
+    });
+  });
+  describe("\u{1F527} Router destroy cleanup verification", () => {
+    test("Router destroy should cleanup all guards", async () => {
+      const beforeSpy = vi.fn();
+      const afterSpy = vi.fn();
+      router.beforeEach(beforeSpy);
+      router.afterEach(afterSpy);
+      await router.push("/test1");
+      expect(beforeSpy).toHaveBeenCalledTimes(1);
+      expect(afterSpy).toHaveBeenCalledTimes(1);
+      router.destroy();
+      const newRouter = new Router({
+        mode: RouterMode.memory,
+        base: new URL("http://localhost:3000/"),
+        routes: [
+          { path: "/", component: () => "Home" },
+          { path: "/test", component: () => "Test" }
+        ]
+      });
+      await newRouter.replace("/");
+      await newRouter.push("/test");
+      expect(beforeSpy).toHaveBeenCalledTimes(1);
+      expect(afterSpy).toHaveBeenCalledTimes(1);
+      newRouter.destroy();
+    });
+  });
+});

package/dist/router-link.d.ts

@@ -0,0 +1,10 @@
+import type { Router } from './router';
+import type { RouterLinkProps, RouterLinkResolved } from './types';
+/**
+ * Framework-agnostic link resolver
+ *
+ * @param router Router instance
+ * @param props Link configuration
+ * @returns Resolution result
+ */
+export declare function createLinkResolver(router: Router, props: RouterLinkProps): RouterLinkResolved;

package/dist/router-link.mjs

@@ -0,0 +1,126 @@
+const CSS_CLASSES = {
+  BASE: "router-link",
+  ACTIVE: "router-link-active",
+  EXACT_ACTIVE: "router-link-exact-active"
+};
+function normalizeNavigationType(props) {
+  if (props.replace) {
+    console.warn(
+      '[RouterLink] The `replace` property is deprecated and will be removed in a future version.\nPlease use `type="replace"` instead.\nBefore: <RouterLink replace={true} />\nAfter:  <RouterLink type="replace" />'
+    );
+    return "replace";
+  }
+  return props.type || "push";
+}
+function getEventTypeList(eventType) {
+  const events = Array.isArray(eventType) ? eventType : [eventType];
+  const validEvents = events.filter((type) => typeof type === "string").map((type) => type.trim()).filter(Boolean);
+  return validEvents.length ? validEvents : ["click"];
+}
+function guardEvent(e) {
+  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return false;
+  if (e.defaultPrevented) return false;
+  if (e.button !== void 0 && e.button !== 0) return false;
+  if (e.preventDefault) e.preventDefault();
+  return true;
+}
+async function executeNavigation(router, props, linkType) {
+  const { to, layerOptions } = props;
+  switch (linkType) {
+    case "push":
+      await router.push(to);
+      break;
+    case "replace":
+      await router.replace(to);
+      break;
+    case "pushWindow":
+      await router.pushWindow(to);
+      break;
+    case "replaceWindow":
+      await router.replaceWindow(to);
+      break;
+    case "pushLayer":
+      await router.pushLayer(
+        layerOptions ? typeof to === "string" ? { path: to, layer: layerOptions } : { ...to, layer: layerOptions } : to
+      );
+      break;
+    default:
+      await router.push(to);
+  }
+}
+function createNavigateFunction(router, props, navigationType) {
+  return async (e) => {
+    if (e && !guardEvent(e)) {
+      return;
+    }
+    await executeNavigation(router, props, navigationType);
+  };
+}
+function computeAttributes(href, navigationType, isExternal, isActive, isExactActive, activeClass) {
+  const isNewWindow = navigationType === "pushWindow";
+  const classes = [CSS_CLASSES.BASE];
+  if (isActive) {
+    classes.push(activeClass || CSS_CLASSES.ACTIVE);
+  }
+  if (isExactActive) {
+    classes.push(CSS_CLASSES.EXACT_ACTIVE);
+  }
+  const attributes = {
+    href,
+    class: classes.join(" ")
+  };
+  if (isNewWindow) {
+    attributes.target = "_blank";
+  }
+  const relParts = [];
+  if (isNewWindow) {
+    relParts.push("noopener", "noreferrer");
+  }
+  if (isExternal) {
+    relParts.push("external", "nofollow");
+  }
+  if (relParts.length > 0) {
+    attributes.rel = relParts.join(" ");
+  }
+  return attributes;
+}
+function createEventHandlersGenerator(navigate, eventTypes) {
+  return (nameTransform) => {
+    const handlers = {};
+    eventTypes.forEach((eventType) => {
+      const eventName = nameTransform ? nameTransform(eventType) : eventType.toLowerCase();
+      handlers[eventName] = navigate;
+    });
+    return handlers;
+  };
+}
+export function createLinkResolver(router, props) {
+  const route = router.resolve(props.to);
+  const type = normalizeNavigationType(props);
+  const href = route.url.href;
+  const isActive = router.isRouteMatched(route, props.exact);
+  const isExactActive = router.isRouteMatched(route, "exact");
+  const isExternal = route.url.origin !== router.route.url.origin;
+  const navigate = createNavigateFunction(router, props, type);
+  const attributes = computeAttributes(
+    href,
+    type,
+    isExternal,
+    isActive,
+    isExactActive,
+    props.activeClass
+  );
+  const eventTypes = getEventTypeList(props.event || "click");
+  const getEventHandlers = createEventHandlersGenerator(navigate, eventTypes);
+  return {
+    route,
+    type,
+    isActive,
+    isExactActive,
+    isExternal,
+    tag: props.tag || "a",
+    attributes,
+    navigate,
+    getEventHandlers
+  };
+}

package/dist/router-push.test.d.ts

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

package/dist/router-push.test.mjs

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { Router } from "./router.mjs";
+import { RouteType, RouterMode } from "./types.mjs";
+describe("Router Push Tests", () => {
+  let router;
+  beforeEach(async () => {
+    router = new Router({
+      mode: RouterMode.memory,
+      base: new URL("http://localhost:3000/"),
+      routes: [
+        { path: "/", component: () => "Home" },
+        { path: "/user/:id", component: () => "User" },
+        { path: "/about", component: () => "About" },
+        {
+          path: "/async",
+          asyncComponent: () => new Promise(
+            (resolve) => setTimeout(() => resolve("AsyncComponent"), 10)
+          )
+        }
+      ]
+    });
+    await router.replace("/");
+  });
+  afterEach(() => {
+    router.destroy();
+  });
+  describe("Basic push navigation", () => {
+    test("should successfully push to new route", async () => {
+      const route = await router.push("/user/123");
+      expect(route.path).toBe("/user/123");
+      expect(route.params.id).toBe("123");
+      expect(route.type).toBe(RouteType.push);
+      expect(route.handle).not.toBe(null);
+      expect(router.route.path).toBe("/user/123");
+    });
+    test("should handle query parameters in push", async () => {
+      const route = await router.push(
+        "/user/123?tab=profile&active=true"
+      );
+      expect(route.params.id).toBe("123");
+      expect(route.query.tab).toBe("profile");
+      expect(route.query.active).toBe("true");
+    });
+    test("should handle async component loading", async () => {
+      const route = await router.push("/async");
+      expect(route.path).toBe("/async");
+      expect(route.handle).not.toBe(null);
+    });
+  });
+  describe("Error handling", () => {
+    test("should throw error for async component loading failure", async () => {
+      const errorRouter = new Router({
+        mode: RouterMode.memory,
+        base: new URL("http://localhost:3000/"),
+        routes: [
+          { path: "/", component: () => "Home" },
+          {
+            path: "/error",
+            asyncComponent: () => Promise.reject(new Error("Loading failed"))
+          }
+        ]
+      });
+      await errorRouter.replace("/");
+      await expect(errorRouter.push("/error")).rejects.toThrow();
+      errorRouter.destroy();
+    });
+    test("should throw error when guard prevents navigation", async () => {
+      const guardRouter = new Router({
+        mode: RouterMode.memory,
+        base: new URL("http://localhost:3000/"),
+        routes: [
+          { path: "/", component: () => "Home" },
+          {
+            path: "/protected",
+            component: () => "Protected",
+            beforeEnter: () => false
+          }
+        ]
+      });
+      await guardRouter.replace("/");
+      await expect(guardRouter.push("/protected")).rejects.toThrow();
+      guardRouter.destroy();
+    });
+  });
+  describe("Concurrent navigation", () => {
+    test("should handle concurrent push operations", async () => {
+      const promises = [
+        router.push("/user/1").catch((err) => err),
+        router.push("/user/2").catch((err) => err)
+      ];
+      const [result1, result2] = await Promise.all(promises);
+      const successResults = [result1, result2].filter(
+        (r) => !(r instanceof Error)
+      );
+      const errorResults = [result1, result2].filter(
+        (r) => r instanceof Error
+      );
+      expect(successResults).toHaveLength(1);
+      expect(errorResults).toHaveLength(1);
+    });
+  });
+  describe("Edge cases", () => {
+    test("should handle push to current route", async () => {
+      await router.push("/about");
+      const route = await router.push("/about");
+      expect(route.path).toBe("/about");
+      expect(route.handle).not.toBe(null);
+    });
+    test("should handle empty parameter", async () => {
+      const route = await router.push("");
+      expect(route).toBeDefined();
+      expect(typeof route.path).toBe("string");
+    });
+  });
+});

package/dist/router-replace.test.d.ts

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