@platforma-sdk/tengo-builder 2.4.25 → 2.4.26

package/dist/compiler/main.cjs

@@ -1,386 +1,310 @@
-'use strict';
-
-var path = require('node:path');
-var fs = require('node:fs');
-var util = require('./util.cjs');
-var compiler = require('./compiler.cjs');
-var source = require('./source.cjs');
-var _package = require('./package.cjs');
-var template = require('./template.cjs');
-var resolveHelper = require('@milaboratories/resolve-helper');
-var plModelBackend = require('@milaboratories/pl-model-backend');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_util = require('./util.cjs');
+const require_package = require('./package.cjs');
+const require_template = require('./template.cjs');
+const require_compiler = require('./compiler.cjs');
+const require_source = require('./source.cjs');
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs);
+let _milaboratories_pl_model_backend = require("@milaboratories/pl-model-backend");
+let _milaboratories_resolve_helper = require("@milaboratories/resolve-helper");
 
+//#region src/compiler/main.ts
 const compiledTplSuffix = ".plj.gz";
 const compiledLibSuffix = ".lib.tengo";
 const compiledSoftwareSuffix = ".sw.json";
 const compiledAssetSuffix = ".as.json";
-// We need to keep track of dependencies for correct tgo-test CLI utility configuraiton.
-// It is much simpler to do this here, than duplicate all tle logic regarding dependencies
-// in go code.
 const srcTestSuffix = ".test.tengo";
 const srcTplSuffix = ".tpl.tengo";
 const srcLibSuffix = ".lib.tengo";
 const srcSoftwareSuffix = ".sw.json";
 const srcAssetSuffix = ".as.json";
-const compilableSuffixes = [srcLibSuffix, srcTplSuffix, srcSoftwareSuffix, srcAssetSuffix];
+const compilableSuffixes = [
+	srcLibSuffix,
+	srcTplSuffix,
+	srcSoftwareSuffix,
+	srcAssetSuffix
+];
 /**
- * Resolves path to package.json file of the given dependency package.
- */
+* Resolves path to package.json file of the given dependency package.
+*/
 function resolvePackageJsonPackage(root, depPackageName) {
-    if (!path__namespace.isAbsolute(root)) {
-        throw new Error(`Root path must be absolute: ${root}`);
-    }
-    // First approach: resolving package's main entry point and try to find package.json
-    // in dir tree upwards.
-    let resolved = resolveHelper.tryResolve(root, depPackageName);
-    if (resolved) {
-        let depth = 0;
-        do {
-            const p = path__namespace.join(resolved, "package.json");
-            if (util.pathType(p) === "file")
-                return p;
-            depth++;
-            resolved = path__namespace.dirname(resolved);
-        } while (depth < 7 && path__namespace.basename(resolved) !== "node_modules");
-    }
-    // Second approach: trying to find package.json in the package dir.
-    const resolved2 = resolveHelper.tryResolveOrError(root, `${depPackageName}/package.json`);
-    if (resolved2.result === undefined) {
-        if (resolved2.err === "ERR_PACKAGE_PATH_NOT_EXPORTED")
-            // tolerating not-exported package.json for dev dependencies
-            return undefined;
-        throw new Error(`Can't resolve package.json for package ${depPackageName ?? "."} relative to ${root}`);
-    }
-    return resolved2.result;
+	if (!node_path.isAbsolute(root)) throw new Error(`Root path must be absolute: ${root}`);
+	let resolved = (0, _milaboratories_resolve_helper.tryResolve)(root, depPackageName);
+	if (resolved) {
+		let depth = 0;
+		do {
+			const p = node_path.join(resolved, "package.json");
+			if (require_util.pathType(p) === "file") return p;
+			depth++;
+			resolved = node_path.dirname(resolved);
+		} while (depth < 7 && node_path.basename(resolved) !== "node_modules");
+	}
+	const resolved2 = (0, _milaboratories_resolve_helper.tryResolveOrError)(root, `${depPackageName}/package.json`);
+	if (resolved2.result === void 0) {
+		if (resolved2.err === "ERR_PACKAGE_PATH_NOT_EXPORTED") return void 0;
+		throw new Error(`Can't resolve package.json for package ${depPackageName ?? "."} relative to ${root}`);
+	}
+	return resolved2.result;
 }
 function resolvePackageJsonRoot(root) {
-    if (!path__namespace.isAbsolute(root)) {
-        throw new Error(`Root path must be absolute: ${root}`);
-    }
-    const p = path__namespace.join(root, "package.json");
-    if (util.pathType(p) === "file")
-        return p;
-    throw new Error(`Can't resolve package.json in ${root}`);
+	if (!node_path.isAbsolute(root)) throw new Error(`Root path must be absolute: ${root}`);
+	const p = node_path.join(root, "package.json");
+	if (require_util.pathType(p) === "file") return p;
+	throw new Error(`Can't resolve package.json in ${root}`);
 }
 /**
- * Get package info from package.json and all dependencies.
- */
+* Get package info from package.json and all dependencies.
+*/
 function getPackageInfo(root, logger, context = "root") {
-    const packageJsonPath = resolvePackageJsonRoot(root);
-    const packageJson = JSON.parse(fs__namespace.readFileSync(packageJsonPath).toString());
-    // resolving dependencies
-    const depInfos = [];
-    if (packageJson.dependencies && context !== "devDependency") {
-        for (const dep of Object.keys(packageJson.dependencies)) {
-            const depPackageJson = resolvePackageJsonPackage(root, dep);
-            if (depPackageJson === undefined)
-                throw new Error(`Can't resolve package.json for dependency ${dep} of ${root}`);
-            const depRoot = path__namespace.dirname(depPackageJson);
-            depInfos.push(getPackageInfo(depRoot, logger, "dependency"));
-        }
-    }
-    if (packageJson.devDependencies && context === "root") {
-        for (const dep of Object.keys(packageJson.devDependencies)) {
-            const depPackageJson = resolvePackageJsonPackage(root, dep);
-            if (depPackageJson === undefined) {
-                logger.warn(`Can't resolve package.json for dev dependency ${dep} of ${root}`);
-                // tolerating not-exported package.json for dev dependencies
-                continue;
-            }
-            const depRoot = path__namespace.dirname(depPackageJson);
-            depInfos.push(getPackageInfo(depRoot, logger, "devDependency"));
-        }
-    }
-    return {
-        name: packageJson.name,
-        version: packageJson.version,
-        type: packageJson.type,
-        dependencies: depInfos,
-        root,
-        context,
-    };
+	const packageJsonPath = resolvePackageJsonRoot(root);
+	const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath).toString());
+	const depInfos = [];
+	if (packageJson.dependencies && context !== "devDependency") for (const dep of Object.keys(packageJson.dependencies)) {
+		const depPackageJson = resolvePackageJsonPackage(root, dep);
+		if (depPackageJson === void 0) throw new Error(`Can't resolve package.json for dependency ${dep} of ${root}`);
+		const depRoot = node_path.dirname(depPackageJson);
+		depInfos.push(getPackageInfo(depRoot, logger, "dependency"));
+	}
+	if (packageJson.devDependencies && context === "root") for (const dep of Object.keys(packageJson.devDependencies)) {
+		const depPackageJson = resolvePackageJsonPackage(root, dep);
+		if (depPackageJson === void 0) {
+			logger.warn(`Can't resolve package.json for dev dependency ${dep} of ${root}`);
+			continue;
+		}
+		const depRoot = node_path.dirname(depPackageJson);
+		depInfos.push(getPackageInfo(depRoot, logger, "devDependency"));
+	}
+	return {
+		name: packageJson.name,
+		version: packageJson.version,
+		type: packageJson.type,
+		dependencies: depInfos,
+		root,
+		context
+	};
 }
 function resolveLibsDst(mode, root) {
-    return path__namespace.resolve(root, mode, "tengo", "lib");
+	return node_path.resolve(root, mode, "tengo", "lib");
 }
 function resolveTemplatesDst(mode, root) {
-    return path__namespace.resolve(root, mode, "tengo", "tpl");
+	return node_path.resolve(root, mode, "tengo", "tpl");
 }
 function resolveSoftwareDst(mode, root) {
-    return path__namespace.resolve(root, mode, "tengo", "software");
+	return node_path.resolve(root, mode, "tengo", "software");
 }
 function resolveAssetsDst(mode, root) {
-    return path__namespace.resolve(root, mode, "tengo", "asset");
+	return node_path.resolve(root, mode, "tengo", "asset");
 }
 function loadDependencies(logger, compiler, packageInfo) {
-    for (const dep of packageInfo.dependencies)
-        loadDependencies(logger, compiler, dep);
-    if (packageInfo.context === "root")
-        // we are not reading compiled files for root package
-        return;
-    // we are in package folder
-    const libDistFolder = resolveLibsDst("dist", packageInfo.root);
-    const tplDistFolder = resolveTemplatesDst("dist", packageInfo.root);
-    const softwareDistFolder = resolveSoftwareDst("dist", packageInfo.root);
-    const assetDistFolder = resolveAssetsDst("dist", packageInfo.root);
-    const libDistExists = util.pathType(libDistFolder) === "dir";
-    const tplDistExists = util.pathType(tplDistFolder) === "dir";
-    const softwareDistExists = util.pathType(softwareDistFolder) === "dir";
-    const assetDistExists = util.pathType(assetDistFolder) === "dir";
-    if (!libDistExists && !tplDistExists && !softwareDistExists && !assetDistExists)
-        // if neither of tengo-specific folders detected, skipping package
-        return;
-    const packageId = { name: packageInfo.name, version: packageInfo.version };
-    if (libDistExists) {
-        loadLibsFromDir(logger, packageId, "dist", libDistFolder, compiler);
-    }
-    if (tplDistExists) {
-        loadTemplatesFromDir(logger, packageId, "dist", tplDistFolder, compiler);
-    }
-    if (softwareDistExists) {
-        loadSoftwareFromDir(logger, packageId, "dist", softwareDistFolder, compiler);
-    }
-    if (assetDistExists) {
-        loadAssetsFromDir(logger, packageId, "dist", assetDistFolder, compiler);
-    }
+	for (const dep of packageInfo.dependencies) loadDependencies(logger, compiler, dep);
+	if (packageInfo.context === "root") return;
+	const libDistFolder = resolveLibsDst("dist", packageInfo.root);
+	const tplDistFolder = resolveTemplatesDst("dist", packageInfo.root);
+	const softwareDistFolder = resolveSoftwareDst("dist", packageInfo.root);
+	const assetDistFolder = resolveAssetsDst("dist", packageInfo.root);
+	const libDistExists = require_util.pathType(libDistFolder) === "dir";
+	const tplDistExists = require_util.pathType(tplDistFolder) === "dir";
+	const softwareDistExists = require_util.pathType(softwareDistFolder) === "dir";
+	const assetDistExists = require_util.pathType(assetDistFolder) === "dir";
+	if (!libDistExists && !tplDistExists && !softwareDistExists && !assetDistExists) return;
+	const packageId = {
+		name: packageInfo.name,
+		version: packageInfo.version
+	};
+	if (libDistExists) loadLibsFromDir(logger, packageId, "dist", libDistFolder, compiler);
+	if (tplDistExists) loadTemplatesFromDir(logger, packageId, "dist", tplDistFolder, compiler);
+	if (softwareDistExists) loadSoftwareFromDir(logger, packageId, "dist", softwareDistFolder, compiler);
+	if (assetDistExists) loadAssetsFromDir(logger, packageId, "dist", assetDistFolder, compiler);
 }
 function loadLibsFromDir(logger, packageId, mode, folder, compiler) {
-    for (const f of fs__namespace.readdirSync(folder)) {
-        const file = path__namespace.resolve(folder, f);
-        if (!f.endsWith(compiledLibSuffix))
-            throw new Error(`unexpected file in 'lib' folder: ${file}`);
-        const fullName = {
-            type: "library",
-            pkg: packageId.name,
-            id: f.slice(0, f.length - compiledLibSuffix.length),
-            version: packageId.version,
-        };
-        const src = source.parseSourceFile(logger, mode, file, fullName, true);
-        compiler.addLib(src);
-        logger.debug(`Adding dependency ${_package.fullNameToString(fullName)} from ${file}`);
-        if (src.dependencies.length > 0) {
-            logger.debug("Dependencies:");
-            for (const dep of src.dependencies)
-                logger.debug(`  - ${_package.typedArtifactNameToString(dep)}`);
-        }
-    }
+	for (const f of node_fs.readdirSync(folder)) {
+		const file = node_path.resolve(folder, f);
+		if (!f.endsWith(compiledLibSuffix)) throw new Error(`unexpected file in 'lib' folder: ${file}`);
+		const fullName = {
+			type: "library",
+			pkg: packageId.name,
+			id: f.slice(0, f.length - 10),
+			version: packageId.version
+		};
+		const src = require_source.parseSourceFile(logger, mode, file, fullName, true);
+		compiler.addLib(src);
+		logger.debug(`Adding dependency ${require_package.fullNameToString(fullName)} from ${file}`);
+		if (src.dependencies.length > 0) {
+			logger.debug("Dependencies:");
+			for (const dep of src.dependencies) logger.debug(`  - ${require_package.typedArtifactNameToString(dep)}`);
+		}
+	}
 }
 function loadTemplatesFromDir(logger, packageId, mode, folder, compiler) {
-    // adding templates
-    for (const f of fs__namespace.readdirSync(folder)) {
-        const file = path__namespace.resolve(folder, f);
-        if (!f.endsWith(compiledTplSuffix))
-            throw new Error(`unexpected file in 'tpl' folder: ${file}`);
-        const fullName = {
-            type: "template",
-            pkg: packageId.name,
-            id: f.slice(0, f.length - compiledTplSuffix.length),
-            version: packageId.version,
-        };
-        const tpl = template.newTemplateFromContent(mode, fullName, fs__namespace.readFileSync(file));
-        compiler.addTemplate(template.templateToSource(tpl));
-        logger.debug(`Adding dependency ${_package.fullNameToString(fullName)} from ${file}`);
-    }
+	for (const f of node_fs.readdirSync(folder)) {
+		const file = node_path.resolve(folder, f);
+		if (!f.endsWith(compiledTplSuffix)) throw new Error(`unexpected file in 'tpl' folder: ${file}`);
+		const fullName = {
+			type: "template",
+			pkg: packageId.name,
+			id: f.slice(0, f.length - 7),
+			version: packageId.version
+		};
+		const tpl = require_template.newTemplateFromContent(mode, fullName, node_fs.readFileSync(file));
+		compiler.addTemplate(require_template.templateToSource(tpl));
+		logger.debug(`Adding dependency ${require_package.fullNameToString(fullName)} from ${file}`);
+	}
 }
 function loadSoftwareFromDir(logger, packageId, mode, folder, compiler) {
-    for (const f of fs__namespace.readdirSync(folder)) {
-        const file = path__namespace.resolve(folder, f);
-        if (!f.endsWith(compiledSoftwareSuffix))
-            throw new Error(`unexpected file in 'software' folder: ${file}`);
-        const fullName = {
-            type: "software",
-            pkg: packageId.name,
-            id: f.slice(0, f.length - compiledSoftwareSuffix.length),
-            version: packageId.version,
-        };
-        const source$1 = fs__namespace.readFileSync(file).toString();
-        const software = new source.ArtifactSource(mode, fullName, source.getSha256(source$1), source$1, file, [], []);
-        logger.debug(`Adding dependency ${_package.fullNameToString(fullName)} from ${file}`);
-        compiler.addSoftware(software);
-    }
+	for (const f of node_fs.readdirSync(folder)) {
+		const file = node_path.resolve(folder, f);
+		if (!f.endsWith(compiledSoftwareSuffix)) throw new Error(`unexpected file in 'software' folder: ${file}`);
+		const fullName = {
+			type: "software",
+			pkg: packageId.name,
+			id: f.slice(0, f.length - 8),
+			version: packageId.version
+		};
+		const source = node_fs.readFileSync(file).toString();
+		const software = new require_source.ArtifactSource(mode, fullName, require_source.getSha256(source), source, file, [], []);
+		logger.debug(`Adding dependency ${require_package.fullNameToString(fullName)} from ${file}`);
+		compiler.addSoftware(software);
+	}
 }
 function loadAssetsFromDir(logger, packageId, mode, folder, compiler) {
-    for (const f of fs__namespace.readdirSync(folder)) {
-        const file = path__namespace.resolve(folder, f);
-        if (!f.endsWith(compiledAssetSuffix))
-            throw new Error(`unexpected file in 'asset' folder: ${file}`);
-        const fullName = {
-            type: "asset",
-            pkg: packageId.name,
-            id: f.slice(0, f.length - compiledAssetSuffix.length),
-            version: packageId.version,
-        };
-        const source$1 = fs__namespace.readFileSync(file).toString();
-        const asset = new source.ArtifactSource(mode, fullName, source.getSha256(source$1), source$1, file, [], []);
-        logger.debug(`Adding dependency ${_package.fullNameToString(fullName)} from ${file}`);
-        compiler.addAsset(asset);
-    }
+	for (const f of node_fs.readdirSync(folder)) {
+		const file = node_path.resolve(folder, f);
+		if (!f.endsWith(compiledAssetSuffix)) throw new Error(`unexpected file in 'asset' folder: ${file}`);
+		const fullName = {
+			type: "asset",
+			pkg: packageId.name,
+			id: f.slice(0, f.length - 8),
+			version: packageId.version
+		};
+		const source = node_fs.readFileSync(file).toString();
+		const asset = new require_source.ArtifactSource(mode, fullName, require_source.getSha256(source), source, file, [], []);
+		logger.debug(`Adding dependency ${require_package.fullNameToString(fullName)} from ${file}`);
+		compiler.addAsset(asset);
+	}
 }
 function parseSources(logger, packageId, mode, root, subdir) {
-    const sources = [];
-    for (const f of fs__namespace.readdirSync(path__namespace.join(root, subdir))) {
-        const inRootPath = path__namespace.join(subdir, f); // path to item inside given <root>
-        const fullPath = path__namespace.join(root, inRootPath); // full path to item from CWD (or abs path, if <root> is abs path)
-        if (util.pathType(fullPath) === "dir") {
-            const nested = parseSources(logger, packageId, mode, root, inRootPath);
-            sources.push(...nested);
-            continue;
-        }
-        // Handling index.lib.tengo files: rename them to <package-name>.lib.tengo
-        const artifactName = f === "index.lib.tengo" ? `${path__namespace.dirname(inRootPath)}.lib.tengo` : inRootPath;
-        const fullName = fullNameFromFileName(packageId, artifactName.replaceAll(path__namespace.sep, "."));
-        if (!fullName) {
-            logger.info(`Skipping unknown file type: ${artifactName}`);
-            continue; // skip unknown file types
-        }
-        // if (subdir != '') {
-        //   throw new Error(`Templates and libraries should reside only inside '${root}' dir.
-        //    You are free to have any file and dirs structure inside '${root}' keeping other files where you want,
-        //    but regarding ${compilableSuffixes.join(', ')}, the flat file structure is mandatory.`);
-        // }
-        const file = path__namespace.resolve(root, inRootPath);
-        logger.debug(`Parsing ${_package.fullNameToString(fullName)} from ${file}`);
-        const newSrc = source.parseSourceFile(logger, mode, file, fullName, true);
-        if (newSrc.dependencies.length > 0) {
-            logger.debug("Detected dependencies:");
-            for (const dep of newSrc.dependencies)
-                logger.debug(`  - ${_package.typedArtifactNameToString(dep)}`);
-        }
-        sources.push(newSrc);
-    }
-    return sources;
+	const sources = [];
+	for (const f of node_fs.readdirSync(node_path.join(root, subdir))) {
+		const inRootPath = node_path.join(subdir, f);
+		if (require_util.pathType(node_path.join(root, inRootPath)) === "dir") {
+			const nested = parseSources(logger, packageId, mode, root, inRootPath);
+			sources.push(...nested);
+			continue;
+		}
+		const artifactName = f === "index.lib.tengo" ? `${node_path.dirname(inRootPath)}.lib.tengo` : inRootPath;
+		const fullName = fullNameFromFileName(packageId, artifactName.replaceAll(node_path.sep, "."));
+		if (!fullName) {
+			logger.info(`Skipping unknown file type: ${artifactName}`);
+			continue;
+		}
+		const file = node_path.resolve(root, inRootPath);
+		logger.debug(`Parsing ${require_package.fullNameToString(fullName)} from ${file}`);
+		const newSrc = require_source.parseSourceFile(logger, mode, file, fullName, true);
+		if (newSrc.dependencies.length > 0) {
+			logger.debug("Detected dependencies:");
+			for (const dep of newSrc.dependencies) logger.debug(`  - ${require_package.typedArtifactNameToString(dep)}`);
+		}
+		sources.push(newSrc);
+	}
+	return sources;
 }
 function newCompiler(logger, packageInfo, mode) {
-    const compiler$1 = new compiler.TengoTemplateCompiler(mode);
-    // collect all data (templates, libs and software) from dependency tree
-    loadDependencies(logger, compiler$1, packageInfo);
-    return compiler$1;
+	const compiler = new require_compiler.TengoTemplateCompiler(mode);
+	loadDependencies(logger, compiler, packageInfo);
+	return compiler;
 }
 function fullNameFromFileName(packageId, artifactName) {
-    const pkgAndVersion = { pkg: packageId.name, version: packageId.version };
-    if (artifactName.endsWith(srcLibSuffix)) {
-        return {
-            ...pkgAndVersion,
-            id: artifactName.substring(0, artifactName.length - srcLibSuffix.length),
-            type: "library",
-        };
-    }
-    if (artifactName.endsWith(srcTplSuffix)) {
-        return {
-            ...pkgAndVersion,
-            id: artifactName.substring(0, artifactName.length - srcTplSuffix.length),
-            type: "template",
-        };
-    }
-    if (artifactName.endsWith(srcSoftwareSuffix)) {
-        return {
-            ...pkgAndVersion,
-            id: artifactName.substring(0, artifactName.length - srcSoftwareSuffix.length),
-            type: "software",
-        };
-    }
-    if (artifactName.endsWith(srcAssetSuffix)) {
-        return {
-            ...pkgAndVersion,
-            id: artifactName.substring(0, artifactName.length - srcAssetSuffix.length),
-            type: "asset",
-        };
-    }
-    if (artifactName.endsWith(srcTestSuffix)) {
-        return {
-            ...pkgAndVersion,
-            id: artifactName.substring(0, artifactName.length - srcTestSuffix.length),
-            type: "test",
-        };
-    }
-    return null;
+	const pkgAndVersion = {
+		pkg: packageId.name,
+		version: packageId.version
+	};
+	if (artifactName.endsWith(srcLibSuffix)) return {
+		...pkgAndVersion,
+		id: artifactName.substring(0, artifactName.length - 10),
+		type: "library"
+	};
+	if (artifactName.endsWith(srcTplSuffix)) return {
+		...pkgAndVersion,
+		id: artifactName.substring(0, artifactName.length - 10),
+		type: "template"
+	};
+	if (artifactName.endsWith(srcSoftwareSuffix)) return {
+		...pkgAndVersion,
+		id: artifactName.substring(0, artifactName.length - 8),
+		type: "software"
+	};
+	if (artifactName.endsWith(srcAssetSuffix)) return {
+		...pkgAndVersion,
+		id: artifactName.substring(0, artifactName.length - 8),
+		type: "asset"
+	};
+	if (artifactName.endsWith(srcTestSuffix)) return {
+		...pkgAndVersion,
+		id: artifactName.substring(0, artifactName.length - 11),
+		type: "test"
+	};
+	return null;
 }
 function compile(logger, packageInfo, mode) {
-    const compiler = newCompiler(logger, packageInfo, mode);
-    const sources = parseSources(logger, packageInfo, mode, "src", "");
-    // checking that we have something to do
-    if (sources.length === 0) {
-        const lookFor = [];
-        for (const suffix of compilableSuffixes) {
-            lookFor.push(`*${suffix}`);
-        }
-        logger.error(`Nothing to compile. Looked for ${lookFor.join(", ")}`);
-        process.exit(1);
-    }
-    // compilation
-    logger.info(`Compiling '${mode}'...`);
-    const compiled = compiler.compileAndAdd(sources);
-    logger.debug(`Done.`);
-    return compiled;
+	const compiler = newCompiler(logger, packageInfo, mode);
+	const sources = parseSources(logger, packageInfo, mode, "src", "");
+	if (sources.length === 0) {
+		const lookFor = [];
+		for (const suffix of compilableSuffixes) lookFor.push(`*${suffix}`);
+		logger.error(`Nothing to compile. Looked for ${lookFor.join(", ")}`);
+		process.exit(1);
+	}
+	logger.info(`Compiling '${mode}'...`);
+	const compiled = compiler.compileAndAdd(sources);
+	logger.debug(`Done.`);
+	return compiled;
 }
 function savePacks(logger, compiled, mode) {
-    // writing libs
-    if (compiled.libs.length > 0) {
-        const libOutput = resolveLibsDst(mode, ".");
-        fs__namespace.mkdirSync(libOutput, { recursive: true });
-        for (const lib of compiled.libs) {
-            const file = path__namespace.resolve(libOutput, lib.fullName.id + compiledLibSuffix);
-            logger.info(`  - writing ${file}`);
-            fs__namespace.writeFileSync(file, lib.src);
-        }
-    }
-    // writing templates
-    if (compiled.templates.length > 0) {
-        const tplOutput = resolveTemplatesDst(mode, ".");
-        fs__namespace.mkdirSync(tplOutput, { recursive: true });
-        for (const tpl of compiled.templates) {
-            const file = path__namespace.resolve(tplOutput, tpl.fullName.id + compiledTplSuffix);
-            logger.info(`  - writing ${file}`);
-            fs__namespace.writeFileSync(file, plModelBackend.serializeTemplate(tpl.data));
-        }
-    }
-    // writing software
-    if (compiled.software.length > 0) {
-        const swOutput = resolveSoftwareDst(mode, ".");
-        fs__namespace.mkdirSync(swOutput, { recursive: true });
-        for (const sw of compiled.software) {
-            const file = path__namespace.resolve(swOutput, sw.fullName.id + compiledSoftwareSuffix);
-            logger.info(`  - writing ${file}`);
-            fs__namespace.writeFileSync(file, sw.src);
-        }
-    }
-    // writing assets
-    if (compiled.assets.length > 0) {
-        const swOutput = resolveAssetsDst(mode, ".");
-        fs__namespace.mkdirSync(swOutput, { recursive: true });
-        for (const sw of compiled.software) {
-            const file = path__namespace.resolve(swOutput, sw.fullName.id + compiledAssetSuffix);
-            logger.info(`  - writing ${file}`);
-            fs__namespace.writeFileSync(file, sw.src);
-        }
-    }
+	if (compiled.libs.length > 0) {
+		const libOutput = resolveLibsDst(mode, ".");
+		node_fs.mkdirSync(libOutput, { recursive: true });
+		for (const lib of compiled.libs) {
+			const file = node_path.resolve(libOutput, lib.fullName.id + compiledLibSuffix);
+			logger.info(`  - writing ${file}`);
+			node_fs.writeFileSync(file, lib.src);
+		}
+	}
+	if (compiled.templates.length > 0) {
+		const tplOutput = resolveTemplatesDst(mode, ".");
+		node_fs.mkdirSync(tplOutput, { recursive: true });
+		for (const tpl of compiled.templates) {
+			const file = node_path.resolve(tplOutput, tpl.fullName.id + compiledTplSuffix);
+			logger.info(`  - writing ${file}`);
+			node_fs.writeFileSync(file, (0, _milaboratories_pl_model_backend.serializeTemplate)(tpl.data));
+		}
+	}
+	if (compiled.software.length > 0) {
+		const swOutput = resolveSoftwareDst(mode, ".");
+		node_fs.mkdirSync(swOutput, { recursive: true });
+		for (const sw of compiled.software) {
+			const file = node_path.resolve(swOutput, sw.fullName.id + compiledSoftwareSuffix);
+			logger.info(`  - writing ${file}`);
+			node_fs.writeFileSync(file, sw.src);
+		}
+	}
+	if (compiled.assets.length > 0) {
+		const swOutput = resolveAssetsDst(mode, ".");
+		node_fs.mkdirSync(swOutput, { recursive: true });
+		for (const sw of compiled.software) {
+			const file = node_path.resolve(swOutput, sw.fullName.id + compiledAssetSuffix);
+			logger.info(`  - writing ${file}`);
+			node_fs.writeFileSync(file, sw.src);
+		}
+	}
 }
 
+//#endregion
 exports.compile = compile;
-exports.fullNameFromFileName = fullNameFromFileName;
 exports.getPackageInfo = getPackageInfo;
 exports.newCompiler = newCompiler;
 exports.parseSources = parseSources;
-exports.resolvePackageJsonRoot = resolvePackageJsonRoot;
 exports.savePacks = savePacks;
-//# sourceMappingURL=main.cjs.map
+//# sourceMappingURL=main.cjs.map