rwsdk 1.0.0-alpha.1-test.20250911154541 → 1.0.0-alpha.11

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -4,7 +4,7 @@ import { writeFileSync, mkdirSync, mkdtempSync } from "node:fs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { VENDOR_CLIENT_BARREL_PATH, VENDOR_SERVER_BARREL_PATH, VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
-const generateVendorBarrelContent = (files, projectRootDir) => {
+export const generateVendorBarrelContent = (files, projectRootDir) => {
     const imports = [...files]
         .filter((file) => file.includes("node_modules"))
         .map((file, i) => `import * as M${i} from '${normalizeModulePath(file, projectRootDir, {
@@ -19,7 +19,7 @@ const generateVendorBarrelContent = (files, projectRootDir) => {
         "\n};";
     return `${imports}\n\n${exports}`;
 };
-const generateAppBarrelContent = (files, projectRootDir, barrelFilePath) => {
+export const generateAppBarrelContent = (files, projectRootDir) => {
     return [...files]
         .filter((file) => !file.includes("node_modules"))
         .map((file) => {
@@ -30,7 +30,7 @@ const generateAppBarrelContent = (files, projectRootDir, barrelFilePath) => {
     })
         .join("\n");
 };
-export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) => {
     const { promise: scanPromise, resolve: resolveScanPromise } = Promise.withResolvers();
     const tempDir = mkdtempSync(path.join(os.tmpdir(), "rwsdk-"));
     const APP_CLIENT_BARREL_PATH = path.join(tempDir, "app-client-barrel.js");
@@ -47,6 +47,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 environments: server.environments,
                 clientFiles,
                 serverFiles,
+                entries: [workerEntryPathname],
             }).then(() => {
                 // context(justinvdm, 11 Sep 2025): For vendor barrels, we write the
                 // files directly to disk after the scan. For app barrels, we use a
@@ -129,7 +130,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                         build.onLoad({ filter: /.*/, namespace: "rwsdk-app-barrel-ns" }, (args) => {
                             const isServerBarrel = args.path.includes("app-server-barrel");
                             const files = isServerBarrel ? serverFiles : clientFiles;
-                            const content = generateAppBarrelContent(files, projectRootDir, args.path);
+                            const content = generateAppBarrelContent(files, projectRootDir);
                             return {
                                 contents: content,
                                 loader: "js",

package/dist/vite/directiveModulesDevPlugin.test.d.mts

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

package/dist/vite/directiveModulesDevPlugin.test.mjs

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { generateVendorBarrelContent, generateAppBarrelContent, } from "./directiveModulesDevPlugin.mjs";
+describe("directiveModulesDevPlugin helpers", () => {
+    const projectRootDir = "/Users/test/project";
+    describe("generateVendorBarrelContent", () => {
+        it("should generate correct content for vendor files", () => {
+            const files = new Set([
+                "node_modules/lib-a/index.js",
+                "src/app.js",
+                "node_modules/lib-b/component.tsx",
+            ]);
+            const content = generateVendorBarrelContent(files, projectRootDir);
+            const expected = `import * as M0 from '${projectRootDir}/node_modules/lib-a/index.js';
+import * as M1 from '${projectRootDir}/node_modules/lib-b/component.tsx';
+
+export default {
+  '/node_modules/lib-a/index.js': M0,
+  '/node_modules/lib-b/component.tsx': M1,
+};`;
+            expect(content).toEqual(expected);
+        });
+        it("should return empty content if no vendor files", () => {
+            const files = new Set(["src/app.js", "src/component.tsx"]);
+            const content = generateVendorBarrelContent(files, projectRootDir);
+            expect(content).toEqual("\n\nexport default {\n\n};");
+        });
+        it("should handle an empty file set", () => {
+            const files = new Set();
+            const content = generateVendorBarrelContent(files, projectRootDir);
+            expect(content).toEqual("\n\nexport default {\n\n};");
+        });
+    });
+    describe("generateAppBarrelContent", () => {
+        it("should generate correct content for app files", () => {
+            const files = new Set([
+                "src/app.js",
+                "node_modules/lib-a/index.js",
+                "src/component.tsx",
+            ]);
+            const content = generateAppBarrelContent(files, projectRootDir);
+            const expected = `import "${projectRootDir}/src/app.js";
+import "${projectRootDir}/src/component.tsx";`;
+            expect(content).toEqual(expected);
+        });
+        it("should return empty content if no app files", () => {
+            const files = new Set([
+                "node_modules/lib-a/index.js",
+                "node_modules/lib-b/component.tsx",
+            ]);
+            const content = generateAppBarrelContent(files, projectRootDir);
+            expect(content).toEqual("");
+        });
+        it("should handle an empty file set", () => {
+            const files = new Set();
+            const content = generateAppBarrelContent(files, projectRootDir);
+            expect(content).toEqual("");
+        });
+    });
+});

package/dist/vite/directivesPlugin.d.mts

@@ -1,4 +1,5 @@
 import { Plugin } from "vite";
+export declare const getLoader: (filePath: string) => "jsx" | "js" | "ts" | "tsx";
 export declare const directivesPlugin: ({ projectRootDir, clientFiles, serverFiles, }: {
     projectRootDir: string;
     clientFiles: Set<string>;

package/dist/vite/directivesPlugin.mjs

@@ -5,7 +5,7 @@ import { transformClientComponents } from "./transformClientComponents.mjs";
 import { transformServerFunctions } from "./transformServerFunctions.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:rsc-directives-plugin");
-const getLoader = (filePath) => {
+export const getLoader = (filePath) => {
     const ext = path.extname(filePath).slice(1);
     switch (ext) {
         case "mjs":

package/dist/vite/directivesPlugin.test.d.mts

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

package/dist/vite/directivesPlugin.test.mjs

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { getLoader } from "./directivesPlugin.mjs";
+describe("getLoader", () => {
+    const testCases = [
+        { path: "file.js", expected: "js" },
+        { path: "file.mjs", expected: "js" },
+        { path: "file.cjs", expected: "js" },
+        { path: "file.ts", expected: "ts" },
+        { path: "file.mts", expected: "ts" },
+        { path: "file.cts", expected: "ts" },
+        { path: "file.jsx", expected: "jsx" },
+        { path: "file.tsx", expected: "tsx" },
+        { path: "/path/to/component.ts", expected: "ts" },
+        { path: "../relative/path.jsx", expected: "jsx" },
+        { path: "file.css", expected: "js" }, // default case
+        { path: "file.json", expected: "js" }, // default case
+        { path: "file", expected: "js" }, // no extension
+    ];
+    testCases.forEach(({ path, expected }) => {
+        it(`should return "${expected}" for "${path}"`, () => {
+            expect(getLoader(path)).toBe(expected);
+        });
+    });
+});

package/dist/vite/ensureAliasArray.test.d.mts

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

package/dist/vite/ensureAliasArray.test.mjs

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { ensureAliasArray } from "./ensureAliasArray.mjs";
+describe("ensureAliasArray", () => {
+    it("should create resolve and alias array if resolve is undefined", () => {
+        const config = {};
+        const result = ensureAliasArray(config);
+        expect(result).toEqual([]);
+        expect(config.resolve?.alias).toEqual([]);
+        expect(result).toBe(config.resolve?.alias);
+    });
+    it("should create alias array if alias is undefined", () => {
+        const config = { resolve: {} };
+        const result = ensureAliasArray(config);
+        expect(result).toEqual([]);
+        expect(config.resolve?.alias).toEqual([]);
+        expect(result).toBe(config.resolve?.alias);
+    });
+    it("should convert an alias object to an array", () => {
+        const config = {
+            resolve: {
+                alias: {
+                    find: "/replacement",
+                    another: "/another-replacement",
+                },
+            },
+        };
+        const result = ensureAliasArray(config);
+        const expected = [
+            { find: "find", replacement: "/replacement" },
+            { find: "another", replacement: "/another-replacement" },
+        ];
+        expect(result).toEqual(expected);
+        expect(config.resolve?.alias).toEqual(expected);
+        expect(result).toBe(config.resolve?.alias);
+    });
+    it("should return a clone of an existing alias array", () => {
+        const originalAlias = [{ find: "find", replacement: "/replacement" }];
+        const config = {
+            resolve: {
+                alias: originalAlias,
+            },
+        };
+        const result = ensureAliasArray(config);
+        expect(result).toEqual(originalAlias);
+        expect(result).not.toBe(originalAlias);
+        expect(config.resolve?.alias).toEqual(originalAlias);
+        expect(config.resolve?.alias).not.toBe(originalAlias);
+    });
+    it("should handle an empty alias object", () => {
+        const config = {
+            resolve: {
+                alias: {},
+            },
+        };
+        const result = ensureAliasArray(config);
+        expect(result).toEqual([]);
+        expect(config.resolve?.alias).toEqual([]);
+    });
+    it("should handle an empty alias array", () => {
+        const config = {
+            resolve: {
+                alias: [],
+            },
+        };
+        const originalAlias = config.resolve?.alias;
+        const result = ensureAliasArray(config);
+        expect(result).toEqual([]);
+        expect(config.resolve?.alias).toEqual([]);
+        expect(result).not.toBe(originalAlias);
+    });
+});

package/dist/vite/findSpecifiers.mjs

@@ -178,7 +178,8 @@ export function findExports(id, code, log) {
                         });
                         logger("Found default export: %s", name);
                     }
-                    else if (matchText.includes("export {")) {
+                    else if (matchText.includes("export {") &&
+                        !match.getMatch("MODULE")) {
                         // Local export declaration
                         const exportListMatch = matchText.match(/export\s*\{\s*([^}]+)\s*\}/);
                         if (exportListMatch) {

package/dist/vite/findSpecifiers.test.d.mts

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

package/dist/vite/findSpecifiers.test.mjs

@@ -0,0 +1,202 @@
+import { describe, it, expect } from "vitest";
+import { findImportSpecifiers, findExports } from "./findSpecifiers.mjs";
+function dedupeImports(imports) {
+    const seen = new Set();
+    return imports.filter((imp) => {
+        const key = `${imp.s}:${imp.e}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+describe("findSpecifiers", () => {
+    describe("findImportSpecifiers", () => {
+        it("should find various import types", () => {
+            const code = `
+        import { a } from "module-a";
+        import b from 'module-b';
+        import * as c from "module-c";
+        import "module-d";
+        const e = import('module-e');
+        const f = require("module-f");
+      `;
+            const results = findImportSpecifiers("test.ts", code, []);
+            const specifiers = dedupeImports(results).map((r) => r.raw);
+            expect(specifiers).toEqual([
+                "module-a",
+                "module-c",
+                "module-b",
+                "module-d",
+                "module-e",
+                "module-f",
+            ]);
+        });
+        it("should find re-exports", () => {
+            const code = `
+        export { a } from "module-a";
+        export * from 'module-b';
+      `;
+            const results = findImportSpecifiers("test.ts", code, []);
+            const specifiers = dedupeImports(results).map((r) => r.raw);
+            expect(specifiers).toEqual(["module-a", "module-b"]);
+        });
+        it("should ignore specified patterns", () => {
+            const code = `
+        import { a } from "module-a";
+        import b from 'module-b';
+        import c from "ignored-module";
+      `;
+            const results = findImportSpecifiers("test.ts", code, [/ignored/]);
+            const specifiers = dedupeImports(results).map((r) => r.raw);
+            expect(specifiers).toEqual(["module-a", "module-b"]);
+        });
+        it("should ignore virtual modules", () => {
+            const code = `import a from "virtual:my-virtual-module";`;
+            const results = findImportSpecifiers("test.ts", code, []);
+            expect(results).toHaveLength(0);
+        });
+        it("should ignore __rwsdknossr modules", () => {
+            const code = `import a from "some-module?__rwsdknossr";`;
+            const results = findImportSpecifiers("test.ts", code, []);
+            expect(results).toHaveLength(0);
+        });
+        it("should handle tsx files", () => {
+            const code = `
+        import React from 'react';
+        const App = () => <div>Hello</div>;
+        export default App;
+      `;
+            const results = findImportSpecifiers("test.tsx", code, []);
+            const specifiers = dedupeImports(results).map((r) => r.raw);
+            expect(specifiers).toEqual(["react"]);
+        });
+        it("should return correct positions", () => {
+            const code = `import { a } from "module-a";`;
+            const results = findImportSpecifiers("test.ts", code, []);
+            const deduped = dedupeImports(results);
+            expect(deduped).toHaveLength(1);
+            expect(deduped[0].s).toBe(19);
+            expect(deduped[0].e).toBe(27);
+            expect(code.substring(deduped[0].s, deduped[0].e)).toBe("module-a");
+        });
+    });
+    describe("findExports", () => {
+        it("should find named exports (const, let, function)", () => {
+            const code = `
+        export const a = 1;
+        export let b = 2;
+        export function c() {}
+        export async function d() {}
+      `;
+            const results = findExports("test.ts", code);
+            expect(results).toEqual([
+                { name: "a", isDefault: false },
+                { name: "b", isDefault: false },
+                { name: "c", isDefault: false },
+                { name: "d", isDefault: false },
+            ]);
+        });
+        it("should find default exports", () => {
+            const code = `
+        export default function myFunc() {}
+        const b = 1;
+        export default b;
+      `;
+            const results = findExports("test.ts", code);
+            expect(results).toEqual([
+                { name: "myFunc", isDefault: true },
+                { name: "default", isDefault: true },
+            ]);
+        });
+        it("should find export declarations", () => {
+            const code = `
+        const a = 1;
+        const b = 2;
+        export { a, b as c };
+      `;
+            const results = findExports("test.ts", code);
+            expect(results).toEqual([
+                {
+                    name: "a",
+                    isDefault: false,
+                    alias: undefined,
+                    originalName: "a",
+                },
+                {
+                    name: "c",
+                    isDefault: false,
+                    alias: "c",
+                    originalName: "b",
+                },
+            ]);
+        });
+        it("should find re-exports", () => {
+            const code = `
+        export { a, b as c } from 'module-a';
+        export { default as d } from 'module-b';
+      `;
+            const results = findExports("test.ts", code);
+            expect(results).toEqual([
+                {
+                    name: "a",
+                    isDefault: false,
+                    alias: undefined,
+                    originalName: "a",
+                    isReExport: true,
+                    moduleSpecifier: "module-a",
+                },
+                {
+                    name: "c",
+                    isDefault: false,
+                    alias: "c",
+                    originalName: "b",
+                    isReExport: true,
+                    moduleSpecifier: "module-a",
+                },
+                {
+                    name: "d",
+                    isDefault: true,
+                    alias: "d",
+                    originalName: "default",
+                    isReExport: true,
+                    moduleSpecifier: "module-b",
+                },
+                {
+                    alias: undefined,
+                    isDefault: false,
+                    name: "a",
+                    originalName: "a",
+                },
+                {
+                    alias: "c",
+                    isDefault: false,
+                    name: "c",
+                    originalName: "b",
+                },
+                {
+                    alias: "d",
+                    isDefault: true,
+                    name: "d",
+                    originalName: "default",
+                },
+            ]);
+        });
+        it("should handle mixed exports", () => {
+            const code = `
+        export const a = 1;
+        export default function b() {}
+        const c = 3;
+        export { c };
+      `;
+            const results = findExports("test.tsx", code);
+            expect(results).toEqual([
+                { name: "a", isDefault: false },
+                { name: "b", isDefault: true },
+                { isDefault: true, name: "default" },
+                { name: "c", isDefault: false, originalName: "c", alias: undefined },
+            ]);
+        });
+    });
+});

package/dist/vite/findSsrSpecifiers.test.d.mts

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

package/dist/vite/findSsrSpecifiers.test.mjs

@@ -0,0 +1,99 @@
+import { describe, it, expect } from "vitest";
+import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
+describe("findSsrImportCallSites", () => {
+    it("should find __vite_ssr_import__ with double quotes", () => {
+        const code = `const a = __vite_ssr_import__("module-a");`;
+        const results = findSsrImportCallSites("test.ts", code);
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({
+            start: 10,
+            end: 41,
+            specifier: "module-a",
+            kind: "import",
+        });
+    });
+    it("should find __vite_ssr_import__ with single quotes", () => {
+        const code = `const a = __vite_ssr_import__('module-a');`;
+        const results = findSsrImportCallSites("test.ts", code);
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({
+            start: 10,
+            end: 41,
+            specifier: "module-a",
+            kind: "import",
+        });
+    });
+    it("should find __vite_ssr_dynamic_import__ with double quotes", () => {
+        const code = `const a = __vite_ssr_dynamic_import__("module-a");`;
+        const results = findSsrImportCallSites("test.ts", code);
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({
+            start: 10,
+            end: 49,
+            specifier: "module-a",
+            kind: "dynamic_import",
+        });
+    });
+    it("should find __vite_ssr_dynamic_import__ with single quotes", () => {
+        const code = `const a = __vite_ssr_dynamic_import__('module-a');`;
+        const results = findSsrImportCallSites("test.ts", code);
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({
+            start: 10,
+            end: 49,
+            specifier: "module-a",
+            kind: "dynamic_import",
+        });
+    });
+    it("should find calls with additional arguments", () => {
+        const code = `const a = __vite_ssr_import__('module-a', { ssr: true });`;
+        const results = findSsrImportCallSites("test.ts", code);
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({
+            start: 10,
+            end: 56,
+            specifier: "module-a",
+            kind: "import",
+        });
+    });
+    it("should find a mix of different calls", () => {
+        const code = `
+      const a = __vite_ssr_import__("module-a");
+      const b = __vite_ssr_dynamic_import__('module-b');
+    `;
+        const results = findSsrImportCallSites("test.ts", code);
+        expect(results).toHaveLength(2);
+        expect(results).toEqual(expect.arrayContaining([
+            {
+                start: 17,
+                end: 48,
+                specifier: "module-a",
+                kind: "import",
+            },
+            {
+                start: 66,
+                end: 105,
+                specifier: "module-b",
+                kind: "dynamic_import",
+            },
+        ]));
+    });
+    it("should return correct ranges for replacement", () => {
+        const code = `__vite_ssr_import__("module-a")`;
+        const results = findSsrImportCallSites("test.ts", code);
+        expect(results).toHaveLength(1);
+        const { start, end } = results[0];
+        expect(code.substring(start, end)).toBe('__vite_ssr_import__("module-a")');
+    });
+    it("should return an empty array when no calls are found", () => {
+        const code = `import a from "module-a";`;
+        const results = findSsrImportCallSites("test.ts", code);
+        expect(results).toHaveLength(0);
+    });
+    it("should handle tsx files correctly", () => {
+        const code = `const a = () => <div>{__vite_ssr_import__("module-a")}</div>;`;
+        const results = findSsrImportCallSites("test.tsx", code);
+        expect(results).toHaveLength(1);
+        expect(results[0].specifier).toBe("module-a");
+    });
+});

package/dist/vite/hasDirective.d.mts

@@ -1,7 +1,10 @@
 /**
  * Efficiently checks if a React directive (e.g., "use server", "use client")
- * is present in the code. Optimized for performance with a two-step approach:
- * 1. Quick string search to see if directive exists anywhere
- * 2. Line-by-line check only if the directive might be present
+ * is present in the code.
+ *
+ * This function is optimized for performance by only checking the first few
+ * lines of the code, as directives must appear at the very top of a file.
+ * It handles comments, whitespace, and any valid directive prologue
+ * (e.g., "use strict").
  */
 export declare function hasDirective(code: string, directive: string): boolean;

package/dist/vite/hasDirective.mjs

@@ -1,54 +1,70 @@
 /**
  * Efficiently checks if a React directive (e.g., "use server", "use client")
- * is present in the code. Optimized for performance with a two-step approach:
- * 1. Quick string search to see if directive exists anywhere
- * 2. Line-by-line check only if the directive might be present
+ * is present in the code.
+ *
+ * This function is optimized for performance by only checking the first few
+ * lines of the code, as directives must appear at the very top of a file.
+ * It handles comments, whitespace, and any valid directive prologue
+ * (e.g., "use strict").
  */
 export function hasDirective(code, directive) {
-    // Quick performance check: if directive doesn't exist anywhere, skip line checking
-    const singleQuoteDirective = `'${directive}'`;
-    const doubleQuoteDirective = `"${directive}"`;
-    if (!code.includes(singleQuoteDirective) &&
-        !code.includes(doubleQuoteDirective)) {
-        return false;
-    }
-    // Split into lines and check each one
-    const lines = code.split("\n");
+    const lines = code.slice(0, 512).split("\n"); // Check first ~512 chars
     let inMultiLineComment = false;
+    let foundUseClient = false;
+    let foundTargetDirective = false;
+    const doubleQuoteDirective = `"${directive}"`;
+    const singleQuoteDirective = `'${directive}'`;
+    const doubleQuoteUseClient = `"use client"`;
+    const singleQuoteUseClient = `'use client'`;
     for (const line of lines) {
         const trimmedLine = line.trim();
-        // Skip empty lines
         if (trimmedLine.length === 0) {
             continue;
         }
-        // Handle multi-line comments
-        if (trimmedLine.startsWith("/*")) {
-            inMultiLineComment = true;
-            // Check if the comment ends on the same line
+        if (inMultiLineComment) {
             if (trimmedLine.includes("*/")) {
                 inMultiLineComment = false;
             }
             continue;
         }
-        if (inMultiLineComment) {
-            // Check if this line ends the multi-line comment
-            if (trimmedLine.includes("*/")) {
-                inMultiLineComment = false;
+        if (trimmedLine.startsWith("/*")) {
+            if (!trimmedLine.includes("*/")) {
+                inMultiLineComment = true;
             }
             continue;
         }
-        // Skip single-line comments
         if (trimmedLine.startsWith("//")) {
             continue;
         }
-        // Check if this line starts with the directive
+        const cleanedLine = trimmedLine.endsWith(";")
+            ? trimmedLine.slice(0, -1)
+            : trimmedLine;
+        if (trimmedLine.startsWith(doubleQuoteUseClient) ||
+            trimmedLine.startsWith(singleQuoteUseClient)) {
+            foundUseClient = true;
+            if (directive === "use client") {
+                return true;
+            }
+        }
         if (trimmedLine.startsWith(doubleQuoteDirective) ||
             trimmedLine.startsWith(singleQuoteDirective)) {
-            return true;
+            foundTargetDirective = true;
+            if (directive !== "use server") {
+                return true;
+            }
         }
-        // If we hit a non-empty, non-comment line that's not a directive, we can stop
-        // (directives must be at the top of the file/scope, after comments)
+        // Any other string literal is part of a valid directive prologue.
+        // We can continue searching.
+        if (trimmedLine.startsWith('"') || trimmedLine.startsWith("'")) {
+            continue;
+        }
+        // If we encounter any other non-directive, non-comment, non-string-literal
+        // line of code, the directive prologue is over. Stop.
         break;
     }
-    return false;
+    // If looking for 'use server' and 'use client' was found, return false (client takes priority)
+    if (directive === "use server" && foundUseClient) {
+        return false;
+    }
+    return foundTargetDirective;
 }

package/dist/vite/hasDirective.test.d.mts

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