@navita/core 0.0.0-main-20230917201540

package/createRenderer.d.ts

@@ -0,0 +1,25 @@
+import { Options as Options$1, Engine, UsedIdCache } from '@navita/engine';
+export { Engine, Options as EngineOptions, UsedIdCache } from '@navita/engine';
+import { ImportMap } from '@navita/types';
+export { ImportMap } from '@navita/types';
+
+interface Options {
+    resolver: (filepath: string, request: string) => Promise<string>;
+    readFile: (filepath: string) => Promise<string>;
+    importMap: ImportMap;
+    engineOptions?: Options$1;
+}
+declare function createRenderer({ resolver, readFile, importMap, engineOptions, }: Options): {
+    engine: Engine;
+    transformAndProcess({ content, filePath, }: {
+        content: string;
+        filePath: string;
+    }): Promise<{
+        result: string;
+        dependencies: string[];
+        usedIds: UsedIdCache;
+    }>;
+};
+type Renderer = ReturnType<typeof createRenderer>;
+
+export { Options, Renderer, createRenderer };

package/createRenderer.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var engine = require('@navita/engine');
+var swc = require('@navita/swc');
+var evaluateAndProcess = require('./evaluateAndProcess.js');
+require('node:path');
+require('node:vm');
+require('node:fs');
+require('enhanced-resolve');
+require('@navita/adapter');
+
+function startsWithRSCDirective(content) {
+    return /^(['"])use client\1;?/.test(content);
+}
+
+function createRenderer({ resolver , readFile , importMap =[] , engineOptions  }) {
+    const engine$1 = new engine.Engine(engineOptions);
+    return {
+        engine: engine$1,
+        async transformAndProcess ({ content , filePath  }) {
+            const [newContent, { result , dependencies  }] = await Promise.all([
+                swc.transformer(content, {
+                    filename: filePath,
+                    importMap
+                }),
+                evaluateAndProcess.evaluateAndProcess({
+                    type: 'entryPoint',
+                    source: content,
+                    filePath,
+                    resolver,
+                    readFile,
+                    importMap,
+                    engine: engine$1
+                })
+            ]);
+            const finalContent = [];
+            // Check if content starts with "use client".
+            if (startsWithRSCDirective(content)) {
+                const [directive, ...restContent] = newContent.trim().split('\n');
+                finalContent.push(directive, result, ...restContent);
+            } else {
+                finalContent.push(result, newContent.trim());
+            }
+            return {
+                result: finalContent.join('\n'),
+                dependencies,
+                usedIds: engine$1.getUsedCacheIds([
+                    filePath
+                ])
+            };
+        }
+    };
+}
+
+exports.createRenderer = createRenderer;

package/createRenderer.mjs

@@ -0,0 +1,53 @@
+import { Engine } from '@navita/engine';
+import { transformer } from '@navita/swc';
+import { evaluateAndProcess } from './evaluateAndProcess.mjs';
+import 'node:path';
+import 'node:vm';
+import 'node:fs';
+import 'enhanced-resolve';
+import '@navita/adapter';
+
+function startsWithRSCDirective(content) {
+    return /^(['"])use client\1;?/.test(content);
+}
+
+function createRenderer({ resolver , readFile , importMap =[] , engineOptions  }) {
+    const engine = new Engine(engineOptions);
+    return {
+        engine,
+        async transformAndProcess ({ content , filePath  }) {
+            const [newContent, { result , dependencies  }] = await Promise.all([
+                transformer(content, {
+                    filename: filePath,
+                    importMap
+                }),
+                evaluateAndProcess({
+                    type: 'entryPoint',
+                    source: content,
+                    filePath,
+                    resolver,
+                    readFile,
+                    importMap,
+                    engine
+                })
+            ]);
+            const finalContent = [];
+            // Check if content starts with "use client".
+            if (startsWithRSCDirective(content)) {
+                const [directive, ...restContent] = newContent.trim().split('\n');
+                finalContent.push(directive, result, ...restContent);
+            } else {
+                finalContent.push(result, newContent.trim());
+            }
+            return {
+                result: finalContent.join('\n'),
+                dependencies,
+                usedIds: engine.getUsedCacheIds([
+                    filePath
+                ])
+            };
+        }
+    };
+}
+
+export { createRenderer };

package/evaluateAndProcess.d.ts

@@ -0,0 +1,36 @@
+import { Engine } from '@navita/engine';
+import { ImportMap } from '@navita/types';
+
+type FilePath = string;
+type ResolverCache = Record<FilePath, unknown>;
+type NodeModuleCache = Record<FilePath, unknown>;
+
+type FilePathWithType = string;
+type ModuleCache = Map<FilePathWithType, {
+    source: string;
+    compiledFn: () => Promise<{
+        dependencies: string[];
+        exports: Record<string, unknown>;
+    }>;
+}>;
+interface Caches {
+    nodeModuleCache?: NodeModuleCache;
+    resolverCache?: ResolverCache;
+    moduleCache?: ModuleCache;
+}
+type Types = 'entryPoint' | 'dependency';
+interface Output<Type extends Types> {
+    result: Type extends 'entryPoint' ? string : Record<string, unknown>;
+    dependencies: string[];
+}
+declare function evaluateAndProcess<Type extends 'entryPoint' | 'dependency'>({ type, filePath, source, engine, resolver, readFile, importMap, nodeModuleCache, resolverCache, moduleCache, }: {
+    source: string;
+    filePath: string;
+    type: Type;
+    engine: Engine;
+    resolver: (filePath: string, request: string) => Promise<string>;
+    readFile: (filePath: string) => Promise<string>;
+    importMap: ImportMap;
+} & Caches): Promise<Output<Type>>;
+
+export { Caches, evaluateAndProcess };

package/evaluateAndProcess.js

@@ -0,0 +1,271 @@
+'use strict';
+
+var path = require('node:path');
+var swc = require('@navita/swc');
+var vm = require('node:vm');
+var fs = require('node:fs');
+var enhancedResolve = require('enhanced-resolve');
+var engine = require('@navita/engine');
+var adapter = require('@navita/adapter');
+
+function createMagicProxy() {
+    // Todo: at some point, the magic proxy should notify the user
+    //  that they are using a browser API in a node environment
+    return new Proxy({}, {
+        get: ()=>createMagicProxy()
+    });
+}
+
+const context = vm.createContext({
+    global
+});
+const vmGlobalsRecord = new vm.Script(`
+Object
+  .getOwnPropertyNames(globalThis)
+  .reduce((acc, name) => ({
+    ...acc,
+    [name]: globalThis[name],
+  }), {});
+`).runInContext(context);
+const vmGlobalsNonEnumerableRecord = {};
+Object.getOwnPropertyNames(global).forEach((name)=>{
+    // The second condition here is to prevent jest's Symbol polyfill from being added.
+    // https://github.com/jestjs/jest/blob/25a8785584c9d54a05887001ee7f498d489a5441/packages/jest-util/src/installCommonGlobals.ts#L49
+    if (!vmGlobalsRecord[name] && global[name] !== globalThis.Symbol) {
+        vmGlobalsNonEnumerableRecord[name] = global[name];
+    }
+});
+function createCompiledFunction(source, define) {
+    // This looks a bit weird, but it's much quicker to do it this way than to
+    // run vm.runInContext. There's a bit more information in this issue:
+    // https://github.com/nodejs/node/issues/31658
+    const sandbox = {
+        define,
+        ...vmGlobalsRecord,
+        ...vmGlobalsNonEnumerableRecord,
+        window: createMagicProxy(),
+        document: createMagicProxy(),
+        navigator: createMagicProxy(),
+        console
+    };
+    const params = Object.keys(sandbox);
+    const implementations = Object.values(sandbox);
+    const compiledFunction = vm.compileFunction(source, params, {
+        parsingContext: context
+    });
+    return ()=>compiledFunction(...implementations);
+}
+
+const { ResolverFactory , CachedInputFileSystem  } = enhancedResolve;
+const resolver = ResolverFactory.createResolver({
+    fileSystem: new CachedInputFileSystem(fs, 4000),
+    extensions: [
+        ".js",
+        ".cjs",
+        ".mjs"
+    ],
+    conditionNames: [
+        "import",
+        "require"
+    ]
+});
+const requireResolveLike = (request, paths = [])=>Promise.any(paths.map((path)=>new Promise((resolve, reject)=>{
+            resolver.resolve({}, path, request, {}, (err, result)=>{
+                if (err || !result) {
+                    return reject(err);
+                }
+                resolve(result);
+            });
+        })));
+const importWithRequireResolution = async (request, startPath = __dirname)=>{
+    return import(await requireResolveLike(request, [
+        startPath
+    ]) || request);
+};
+function createDefineFunction({ filePath , resolver , isExternal , resolverCache , nodeModuleCache , setAdapter  }, resolveDependency) {
+    const filepathDirectory = path.dirname(filePath);
+    return async function define(dependencies, factoryFn) {
+        const exports = {};
+        const dependencyMap = {
+            require: importWithRequireResolution,
+            exports
+        };
+        const resolvedDependencies = await Promise.all(dependencies.filter((dependency)=>!(dependency in dependencyMap)).map((dependency)=>{
+            if (!resolverCache[filepathDirectory]) {
+                resolverCache[filepathDirectory] = {};
+            }
+            if (resolverCache[filepathDirectory][dependency]) {
+                return resolverCache[filepathDirectory][dependency];
+            }
+            const resolved = resolver(filePath, dependency).catch(()=>undefined).then((resolvedDependency)=>{
+                if (!resolvedDependency) {
+                    return requireResolveLike(dependency, [
+                        filepathDirectory,
+                        __dirname
+                    ]).catch(()=>{
+                        throw new Error(`Failed to resolve dependency "${dependency}" in ${filePath}`);
+                    });
+                }
+                return resolvedDependency;
+            });
+            resolverCache[filepathDirectory][dependency] = resolved;
+            return resolved;
+        })).catch((error)=>{
+            throw error;
+        });
+        for (const dependency of resolvedDependencies){
+            if (nodeModuleCache[dependency]) {
+                dependencyMap[dependency] = nodeModuleCache[dependency];
+                continue;
+            }
+            /**
+       * Ignore everything that's not:
+       * .js, .ts, .jsx, .tsx, .mts, .mjs, .cjs, .cts
+       */ if (/\.(?![mc]?[tj]sx?$)[^.]+$/.test(dependency)) {
+                dependencyMap[dependency] = {};
+                continue;
+            }
+            if (isExternal(dependency)) {
+                const module = importWithRequireResolution(dependency, filepathDirectory);
+                if (!nodeModuleCache[dependency]) {
+                    nodeModuleCache[dependency] = module;
+                }
+                dependencyMap[dependency] = nodeModuleCache[dependency];
+                continue;
+            }
+            dependencyMap[dependency] = resolveDependency(dependency);
+        }
+        const dependencyValues = await Promise.all(Object.values(dependencyMap));
+        // The adapter needs to be set before factoryFn is called.
+        setAdapter();
+        factoryFn(...dependencyValues);
+        return {
+            dependencies: resolvedDependencies.filter((x)=>!isExternal(x)),
+            exports
+        };
+    };
+}
+
+function formatResults(results = []) {
+    const result = results.map((item)=>{
+        if (item instanceof engine.Static) {
+            return '';
+        }
+        return JSON.stringify(item);
+    });
+    return `const $$evaluatedValues = [${result.join(',')}];`;
+}
+
+function setAdapter({ engine: engine$1 , collectResults ,  }) {
+    adapter.setAdapter({
+        generateIdentifier: (value)=>engine$1.generateIdentifier(value),
+        addStaticCss: (selector, css)=>engine$1.addStatic(selector, css),
+        addCss: (css)=>engine$1.addStyle(css),
+        addKeyframe: (keyframe)=>engine$1.addKeyframes(keyframe),
+        addFontFace: (fontFace)=>{
+            const hasFontFamily = (Array.isArray(fontFace) ? fontFace : [
+                fontFace
+            ]).some((fontFace)=>'fontFamily' in fontFace);
+            if (hasFontFamily) {
+                throw new Error('This function creates and returns a font-family name, so the "fontFamily" property should not be provided.');
+            }
+            return engine$1.addFontFace(fontFace);
+        },
+        collectResult ({ index , filePath , identifier , result: resultFactory , line , column ,  }) {
+            if (index === 0) {
+                if (collectResults) {
+                    collectResults[filePath] = [];
+                }
+                engine$1.clearUsedIds(filePath);
+            }
+            engine$1.setFilePath(filePath);
+            let result = resultFactory();
+            engine$1.setFilePath(undefined);
+            if (result instanceof engine.ClassList) {
+                const extraClass = engine$1.addSourceMapReference({
+                    index,
+                    identifier,
+                    classList: result,
+                    filePath,
+                    line,
+                    column
+                });
+                if (extraClass) {
+                    result = new engine.ClassList([
+                        result.toString(),
+                        extraClass
+                    ].join(' '));
+                }
+            }
+            if (collectResults) {
+                collectResults[filePath][index] = result;
+            }
+            return result;
+        }
+    });
+}
+
+const rootDir = path.resolve(__dirname, "../../");
+const isExternal = (dependency)=>dependency.startsWith(rootDir) || dependency.includes('node_modules');
+const defaultNodeModuleCache = {};
+const defaultResolverCache = {};
+const defaultModuleCache = new Map();
+const collectedResults = {};
+async function evaluateAndProcess({ type , filePath , source , engine , resolver , readFile , importMap , nodeModuleCache =defaultNodeModuleCache , resolverCache =defaultResolverCache , moduleCache =defaultModuleCache  }) {
+    const cacheKey = `${filePath}:${type}`;
+    const compiledFn = await (async ()=>{
+        if (moduleCache.has(cacheKey)) {
+            const cache = moduleCache.get(cacheKey);
+            if (cache.source === source) {
+                return cache.compiledFn;
+            }
+        }
+        const newSource = await swc.extraction(source, {
+            filename: filePath,
+            entryPoint: type === 'entryPoint',
+            importMap
+        });
+        const define = createDefineFunction({
+            filePath,
+            resolver,
+            isExternal,
+            resolverCache,
+            nodeModuleCache,
+            setAdapter: ()=>setAdapter({
+                    engine,
+                    collectResults: collectedResults
+                })
+        }, (dependency)=>readFile(dependency).then((source)=>evaluateAndProcess({
+                    type: 'dependency',
+                    source: source.toString(),
+                    filePath: dependency,
+                    engine,
+                    resolver,
+                    readFile,
+                    importMap,
+                    nodeModuleCache,
+                    resolverCache,
+                    moduleCache
+                })).then(({ result  })=>result));
+        const compiledFn = createCompiledFunction(`return ${newSource}`, define);
+        moduleCache.set(cacheKey, {
+            source,
+            compiledFn
+        });
+        return compiledFn;
+    })();
+    return compiledFn().then(({ dependencies , exports  })=>{
+        if (type === 'entryPoint') {
+            return {
+                result: formatResults(collectedResults[filePath]),
+                dependencies
+            };
+        }
+        return {
+            result: exports,
+            dependencies
+        };
+    });
+}
+
+exports.evaluateAndProcess = evaluateAndProcess;

package/evaluateAndProcess.mjs

@@ -0,0 +1,273 @@
+import { fileURLToPath as fileURLToPath$1 } from 'url';
+const __filename = fileURLToPath$1(import.meta.url);
+import { dirname as dirname$1 } from 'path';
+const __dirname = dirname$1(__filename);
+import path from 'node:path';
+import { extraction } from '@navita/swc';
+import vm from 'node:vm';
+import fs from 'node:fs';
+import enhancedResolve from 'enhanced-resolve';
+import { Static, ClassList } from '@navita/engine';
+import { setAdapter as setAdapter$1 } from '@navita/adapter';
+
+function createMagicProxy() {
+    // Todo: at some point, the magic proxy should notify the user
+    //  that they are using a browser API in a node environment
+    return new Proxy({}, {
+        get: ()=>createMagicProxy()
+    });
+}
+
+const context = vm.createContext({
+    global
+});
+const vmGlobalsRecord = new vm.Script(`
+Object
+  .getOwnPropertyNames(globalThis)
+  .reduce((acc, name) => ({
+    ...acc,
+    [name]: globalThis[name],
+  }), {});
+`).runInContext(context);
+const vmGlobalsNonEnumerableRecord = {};
+Object.getOwnPropertyNames(global).forEach((name)=>{
+    // The second condition here is to prevent jest's Symbol polyfill from being added.
+    // https://github.com/jestjs/jest/blob/25a8785584c9d54a05887001ee7f498d489a5441/packages/jest-util/src/installCommonGlobals.ts#L49
+    if (!vmGlobalsRecord[name] && global[name] !== globalThis.Symbol) {
+        vmGlobalsNonEnumerableRecord[name] = global[name];
+    }
+});
+function createCompiledFunction(source, define) {
+    // This looks a bit weird, but it's much quicker to do it this way than to
+    // run vm.runInContext. There's a bit more information in this issue:
+    // https://github.com/nodejs/node/issues/31658
+    const sandbox = {
+        define,
+        ...vmGlobalsRecord,
+        ...vmGlobalsNonEnumerableRecord,
+        window: createMagicProxy(),
+        document: createMagicProxy(),
+        navigator: createMagicProxy(),
+        console
+    };
+    const params = Object.keys(sandbox);
+    const implementations = Object.values(sandbox);
+    const compiledFunction = vm.compileFunction(source, params, {
+        parsingContext: context
+    });
+    return ()=>compiledFunction(...implementations);
+}
+
+const { ResolverFactory , CachedInputFileSystem  } = enhancedResolve;
+const resolver = ResolverFactory.createResolver({
+    fileSystem: new CachedInputFileSystem(fs, 4000),
+    extensions: [
+        ".js",
+        ".cjs",
+        ".mjs"
+    ],
+    conditionNames: [
+        "import",
+        "require"
+    ]
+});
+const requireResolveLike = (request, paths = [])=>Promise.any(paths.map((path)=>new Promise((resolve, reject)=>{
+            resolver.resolve({}, path, request, {}, (err, result)=>{
+                if (err || !result) {
+                    return reject(err);
+                }
+                resolve(result);
+            });
+        })));
+const importWithRequireResolution = async (request, startPath = __dirname)=>{
+    return import(await requireResolveLike(request, [
+        startPath
+    ]) || request);
+};
+function createDefineFunction({ filePath , resolver , isExternal , resolverCache , nodeModuleCache , setAdapter  }, resolveDependency) {
+    const filepathDirectory = path.dirname(filePath);
+    return async function define(dependencies, factoryFn) {
+        const exports = {};
+        const dependencyMap = {
+            require: importWithRequireResolution,
+            exports
+        };
+        const resolvedDependencies = await Promise.all(dependencies.filter((dependency)=>!(dependency in dependencyMap)).map((dependency)=>{
+            if (!resolverCache[filepathDirectory]) {
+                resolverCache[filepathDirectory] = {};
+            }
+            if (resolverCache[filepathDirectory][dependency]) {
+                return resolverCache[filepathDirectory][dependency];
+            }
+            const resolved = resolver(filePath, dependency).catch(()=>undefined).then((resolvedDependency)=>{
+                if (!resolvedDependency) {
+                    return requireResolveLike(dependency, [
+                        filepathDirectory,
+                        __dirname
+                    ]).catch(()=>{
+                        throw new Error(`Failed to resolve dependency "${dependency}" in ${filePath}`);
+                    });
+                }
+                return resolvedDependency;
+            });
+            resolverCache[filepathDirectory][dependency] = resolved;
+            return resolved;
+        })).catch((error)=>{
+            throw error;
+        });
+        for (const dependency of resolvedDependencies){
+            if (nodeModuleCache[dependency]) {
+                dependencyMap[dependency] = nodeModuleCache[dependency];
+                continue;
+            }
+            /**
+       * Ignore everything that's not:
+       * .js, .ts, .jsx, .tsx, .mts, .mjs, .cjs, .cts
+       */ if (/\.(?![mc]?[tj]sx?$)[^.]+$/.test(dependency)) {
+                dependencyMap[dependency] = {};
+                continue;
+            }
+            if (isExternal(dependency)) {
+                const module = importWithRequireResolution(dependency, filepathDirectory);
+                if (!nodeModuleCache[dependency]) {
+                    nodeModuleCache[dependency] = module;
+                }
+                dependencyMap[dependency] = nodeModuleCache[dependency];
+                continue;
+            }
+            dependencyMap[dependency] = resolveDependency(dependency);
+        }
+        const dependencyValues = await Promise.all(Object.values(dependencyMap));
+        // The adapter needs to be set before factoryFn is called.
+        setAdapter();
+        factoryFn(...dependencyValues);
+        return {
+            dependencies: resolvedDependencies.filter((x)=>!isExternal(x)),
+            exports
+        };
+    };
+}
+
+function formatResults(results = []) {
+    const result = results.map((item)=>{
+        if (item instanceof Static) {
+            return '';
+        }
+        return JSON.stringify(item);
+    });
+    return `const $$evaluatedValues = [${result.join(',')}];`;
+}
+
+function setAdapter({ engine , collectResults ,  }) {
+    setAdapter$1({
+        generateIdentifier: (value)=>engine.generateIdentifier(value),
+        addStaticCss: (selector, css)=>engine.addStatic(selector, css),
+        addCss: (css)=>engine.addStyle(css),
+        addKeyframe: (keyframe)=>engine.addKeyframes(keyframe),
+        addFontFace: (fontFace)=>{
+            const hasFontFamily = (Array.isArray(fontFace) ? fontFace : [
+                fontFace
+            ]).some((fontFace)=>'fontFamily' in fontFace);
+            if (hasFontFamily) {
+                throw new Error('This function creates and returns a font-family name, so the "fontFamily" property should not be provided.');
+            }
+            return engine.addFontFace(fontFace);
+        },
+        collectResult ({ index , filePath , identifier , result: resultFactory , line , column ,  }) {
+            if (index === 0) {
+                if (collectResults) {
+                    collectResults[filePath] = [];
+                }
+                engine.clearUsedIds(filePath);
+            }
+            engine.setFilePath(filePath);
+            let result = resultFactory();
+            engine.setFilePath(undefined);
+            if (result instanceof ClassList) {
+                const extraClass = engine.addSourceMapReference({
+                    index,
+                    identifier,
+                    classList: result,
+                    filePath,
+                    line,
+                    column
+                });
+                if (extraClass) {
+                    result = new ClassList([
+                        result.toString(),
+                        extraClass
+                    ].join(' '));
+                }
+            }
+            if (collectResults) {
+                collectResults[filePath][index] = result;
+            }
+            return result;
+        }
+    });
+}
+
+const rootDir = path.resolve(__dirname, "../../");
+const isExternal = (dependency)=>dependency.startsWith(rootDir) || dependency.includes('node_modules');
+const defaultNodeModuleCache = {};
+const defaultResolverCache = {};
+const defaultModuleCache = new Map();
+const collectedResults = {};
+async function evaluateAndProcess({ type , filePath , source , engine , resolver , readFile , importMap , nodeModuleCache =defaultNodeModuleCache , resolverCache =defaultResolverCache , moduleCache =defaultModuleCache  }) {
+    const cacheKey = `${filePath}:${type}`;
+    const compiledFn = await (async ()=>{
+        if (moduleCache.has(cacheKey)) {
+            const cache = moduleCache.get(cacheKey);
+            if (cache.source === source) {
+                return cache.compiledFn;
+            }
+        }
+        const newSource = await extraction(source, {
+            filename: filePath,
+            entryPoint: type === 'entryPoint',
+            importMap
+        });
+        const define = createDefineFunction({
+            filePath,
+            resolver,
+            isExternal,
+            resolverCache,
+            nodeModuleCache,
+            setAdapter: ()=>setAdapter({
+                    engine,
+                    collectResults: collectedResults
+                })
+        }, (dependency)=>readFile(dependency).then((source)=>evaluateAndProcess({
+                    type: 'dependency',
+                    source: source.toString(),
+                    filePath: dependency,
+                    engine,
+                    resolver,
+                    readFile,
+                    importMap,
+                    nodeModuleCache,
+                    resolverCache,
+                    moduleCache
+                })).then(({ result  })=>result));
+        const compiledFn = createCompiledFunction(`return ${newSource}`, define);
+        moduleCache.set(cacheKey, {
+            source,
+            compiledFn
+        });
+        return compiledFn;
+    })();
+    return compiledFn().then(({ dependencies , exports  })=>{
+        if (type === 'entryPoint') {
+            return {
+                result: formatResults(collectedResults[filePath]),
+                dependencies
+            };
+        }
+        return {
+            result: exports,
+            dependencies
+        };
+    });
+}
+
+export { evaluateAndProcess };

package/index.d.ts

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

package/index.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/index.mjs

@@ -0,0 +1 @@
+

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@navita/core",
+  "version": "0.0.0-main-20230917201540",
+  "license": "MIT",
+  "private": false,
+  "sideEffects": false,
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./createRenderer": {
+      "import": "./createRenderer.mjs",
+      "require": "./createRenderer.js",
+      "types": "./createRenderer.d.ts"
+    },
+    "./evaluateAndProcess": {
+      "import": "./evaluateAndProcess.mjs",
+      "require": "./evaluateAndProcess.js",
+      "types": "./evaluateAndProcess.d.ts"
+    }
+  },
+  "dependencies": {
+    "enhanced-resolve": "^5.15.0",
+    "outdent": "^0.8.0",
+    "@navita/types": "0.0.0-main-20230917201540",
+    "@navita/adapter": "0.0.0-main-20230917201540",
+    "@navita/swc": "0.0.0-main-20230917201540",
+    "@navita/engine": "0.0.0-main-20230917201540"
+  }
+}