@intelligentgraphics/ig.gfx.packager 3.0.10 → 3.0.12

package/lib/lib.mjs

@@ -0,0 +1,1754 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import * as terser from 'terser';
+import resolve from 'resolve';
+import 'write-pkg';
+import glob from 'glob';
+import 'write-json-file';
+import axios from 'axios';
+import ts from 'typescript';
+import typedoc from 'typedoc';
+import { pipeline } from 'stream/promises';
+import { execSync } from 'child_process';
+import simpleGit from 'simple-git';
+import Ajv from 'ajv';
+import JSZip from 'jszip';
+
+const stripUtf8Bom = (text)=>{
+    // Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+    // conversion translates it to FEFF (UTF-16 BOM).
+    if (text.charCodeAt(0) === 0xfeff) {
+        return text.slice(1);
+    }
+    return text;
+};
+
+const readNpmManifest = (directory)=>{
+    const packageJsonPath = path.join(directory, "package.json");
+    const packageJson = stripUtf8Bom(fs.readFileSync(packageJsonPath, {
+        encoding: "utf8"
+    }));
+    return JSON.parse(packageJson);
+};
+
+const getNodeErrorCode = (error)=>{
+    if (error !== null && typeof error === "object" && error.code !== undefined) {
+        return error.code;
+    }
+};
+/**
+ * No such file or directory: Commonly raised by fs operations to indicate that a component of the specified pathname does not exist. No entity (file or directory) could be found by the given path.
+ *
+ * @param {unknown} error
+ */ const isErrorENOENT = (error)=>getNodeErrorCode(error) === "ENOENT";
+
+// Functionality related to working with a single package.
+const PACKAGE_FILE = "_Package.json";
+const INDEX_FILE = "_Index.json";
+const ANIMATION_FILE_SUFFIX = ".animation.json";
+const parseCreatorPackageName = (manifest)=>{
+    const [domain, ...subdomainParts] = manifest.Package.split(".");
+    return {
+        domain,
+        subdomain: subdomainParts.join(".")
+    };
+};
+const readPackageCreatorManifest = (location)=>{
+    const packageJsonPath = path.join(location.manifestDir, PACKAGE_FILE);
+    const packageJson = stripUtf8Bom(fs.readFileSync(packageJsonPath, {
+        encoding: "utf8"
+    }));
+    return JSON.parse(packageJson);
+};
+const writePackageCreatorManifest = (location, creatorPackage)=>{
+    const packageJsonPath = path.join(location.manifestDir, PACKAGE_FILE);
+    fs.writeFileSync(packageJsonPath, JSON.stringify(creatorPackage, null, "\t") + "\n");
+};
+const getPackageCreatorIndexPath = (location)=>path.join(location.manifestDir, INDEX_FILE);
+const readPackageCreatorIndex = (location)=>{
+    try {
+        const indexPath = getPackageCreatorIndexPath(location);
+        const index = stripUtf8Bom(fs.readFileSync(indexPath, {
+            encoding: "utf8"
+        }));
+        return JSON.parse(index);
+    } catch (err) {
+        if (isErrorENOENT(err)) {
+            return undefined;
+        }
+        throw err;
+    }
+};
+const writePackageCreatorIndex = (location, index)=>{
+    const indexPath = getPackageCreatorIndexPath(location);
+    fs.writeFileSync(indexPath, JSON.stringify(index, null, "\t") + "\n");
+};
+const readPackageNpmManifest = (location)=>{
+    try {
+        return readNpmManifest(location.manifestDir);
+    } catch (err) {
+        if (isErrorENOENT(err)) {
+            return undefined;
+        }
+        throw err;
+    }
+};
+const readPackageAnimationList = (location)=>{
+    const directoryContent = fs.readdirSync(location.manifestDir);
+    const animationPathList = [];
+    for (const entry of directoryContent){
+        if (entry.endsWith(ANIMATION_FILE_SUFFIX)) {
+            const animationPath = path.join(location.manifestDir, entry);
+            animationPathList.push(animationPath);
+        }
+    }
+    return animationPathList;
+};
+const getPackageReleasesDirectory = (location)=>path.join(location.path, "Releases");
+
+/**
+ * Detects a published package from a path.
+ *
+ * Can return undefined if the package is not installed.
+ *
+ * @param {string} resolveBasePath
+ * @param {string} name
+ * @return {*}  {(PublishedPackageLocation | undefined)}
+ */ const detectPublishedPackageFromPath = (resolveBasePath, name)=>{
+    try {
+        const manifestPath = resolve.sync(name + "/package.json", {
+            basedir: resolveBasePath
+        });
+        const dir = path.dirname(manifestPath);
+        return {
+            _kind: "PublishedPackageLocation",
+            path: dir
+        };
+    } catch (err) {
+        return undefined;
+    }
+};
+const readPublishedPackageNpmManifest = (location)=>{
+    return readNpmManifest(location.path);
+};
+const readPublishedPackageCreatorManifest = (location)=>{
+    try {
+        const packageJsonPath = path.join(location.path, PACKAGE_FILE);
+        const packageJson = stripUtf8Bom(fs.readFileSync(packageJsonPath, {
+            encoding: "utf8"
+        }));
+        return JSON.parse(packageJson);
+    } catch (err) {
+        if (isErrorENOENT(err)) {
+            return undefined;
+        }
+        throw err;
+    }
+};
+const readPublishedPackageCreatorIndex = (location)=>{
+    try {
+        const packageJsonPath = path.join(location.path, INDEX_FILE);
+        const packageJson = stripUtf8Bom(fs.readFileSync(packageJsonPath, {
+            encoding: "utf8"
+        }));
+        const result = JSON.parse(packageJson);
+        return result;
+    } catch (err) {
+        if (isErrorENOENT(err)) {
+            return undefined;
+        }
+        throw err;
+    }
+};
+
+const readWorkspaceNpmManifest = (workspace)=>{
+    try {
+        return readNpmManifest(workspace.path);
+    } catch (err) {
+        if (isErrorENOENT(err)) {
+            throw new Error(`Expected a package.json file to exist in ${workspace.path}. See packager readme for instructions on how to create the package.json.`);
+        }
+        throw err;
+    }
+};
+const getWorkspaceOutputPath = (workspace)=>path.join(workspace.path, "bin");
+
+// /**
+//  * Determines the implicit dependencies of a an actual data workspace package.
+//  *
+//  * An implicit dependency is a dependency that is installed for the workspace and has the same runtime environment (evaluator, interactor) as the package.
+//  *
+//  * @param {WorkspaceLocation} workspace
+//  * @param {CreatorPackage} creatorPackage
+//  * @returns {PublishedPackageLocation[]}
+//  */
+// export const determinePackageImplicitDependencies = (
+// 	workspace: WorkspaceLocation,
+// 	creatorPackage: CreatorPackage,
+// ): PublishedPackageLocation[] => {
+// 	const libraries = determineWorkspaceIGLibraries(workspace);
+// 	const results: PublishedPackageLocation[] = [];
+// 	for (const librarylocation of libraries) {
+// 		const libraryManifest =
+// 			readPublishedPackageCreatorManifest(librarylocation);
+// 		if (
+// 			libraryManifest !== undefined &&
+// 			(libraryManifest.Type === "Mixed" ||
+// 				libraryManifest.RunTime === creatorPackage.RunTime)
+// 		) {
+// 			results.push(librarylocation);
+// 		}
+// 	}
+// 	return results;
+// };
+/**
+ * Recursively determines all installed ig libraries for a workspace.
+ *
+ * @param {WorkspaceLocation} workspace
+ * @returns {PublishedPackageLocation[]}
+ */ const determineWorkspaceIGLibraries = (workspace)=>{
+    const manifest = readWorkspaceNpmManifest(workspace);
+    const libraries = collectIGLibraries(workspace, manifest);
+    const results = new Map();
+    for (const location of libraries){
+        const manifest = readPublishedPackageNpmManifest(location);
+        if (!results.has(manifest.name)) {
+            results.set(manifest.name, location);
+        }
+    }
+    return Array.from(results.values());
+};
+const collectIGLibraries = (workspace, manifest)=>{
+    if (!manifest.dependencies) {
+        return [];
+    }
+    const runtimeDependencies = Object.getOwnPropertyNames(manifest.dependencies);
+    const result = [];
+    for (const runtimeDependency of runtimeDependencies){
+        var _runtimeManifest_ig;
+        const location = detectPublishedPackageFromPath(workspace.path, runtimeDependency);
+        if (location === undefined) {
+            continue;
+        }
+        const runtimeManifest = readPublishedPackageNpmManifest(location);
+        // packages need to explicitly be marked as ig scriptingLibraries
+        if ((_runtimeManifest_ig = runtimeManifest.ig) == null ? void 0 : _runtimeManifest_ig.scriptingLibrary) {
+            result.push(location);
+            result.push(...collectIGLibraries(workspace, runtimeManifest));
+        }
+    }
+    return result;
+};
+
+const readStringFromFile = (filePath)=>fs.readFileSync(filePath, {
+        encoding: "utf8"
+    });
+const readStringFromFileOrUndefined = (filePath)=>{
+    try {
+        return readStringFromFile(filePath);
+    } catch (err) {
+        if (!isErrorENOENT(err)) {
+            throw err;
+        }
+        return undefined;
+    }
+};
+
+const logPackageMessage = (name, step, index, total)=>{
+    const numLength = total === undefined ? undefined : total.toString().length;
+    const indexString = total === undefined || total < 2 ? "" : `${index.toString().padStart(numLength, "0")}/${total} `;
+    const identifierString = `${indexString}${name.padEnd(15)}`;
+    console.log(`${identifierString} >> ${step}`);
+};
+
+const getPackageTypescriptFiles = (location)=>glob.sync("**/*.ts", {
+        absolute: true,
+        cwd: location.scriptsDir,
+        ignore: "node_modules/**/*"
+    });
+
+var CreatorWorkspaceGeometryFileType;
+(function(CreatorWorkspaceGeometryFileType) {
+    CreatorWorkspaceGeometryFileType["StandardObj"] = "standard.obj";
+    CreatorWorkspaceGeometryFileType["StandardCtm"] = "standard.ctm";
+    CreatorWorkspaceGeometryFileType["StandardNormals"] = "normals_std.png";
+    CreatorWorkspaceGeometryFileType["DeformationGlb"] = "deformation.glb";
+})(CreatorWorkspaceGeometryFileType || (CreatorWorkspaceGeometryFileType = {}));
+
+const PLUGIN_ID = "0feba3a0-b6d1-11e6-9598-0800200c9a66";
+/**
+ * Starts an IG.Asset.Server session and returns the sessionId
+ *
+ * @param {SessionStartParams} params
+ * @returns
+ */ const startSession = async ({ url , authentication , ...params })=>{
+    const payload = {
+        ...params,
+        user: undefined,
+        password: undefined,
+        license: undefined,
+        plugin: PLUGIN_ID
+    };
+    if (authentication.type === "credentials") {
+        payload.user = authentication.username;
+        payload.password = authentication.password;
+    } else if (authentication.type === "license") {
+        payload.license = authentication.license;
+    }
+    const { data: { session: sessionId , state , response  }  } = await axios.post(`Session/Start2`, JSON.stringify(payload), {
+        baseURL: url
+    });
+    if (state !== "SUCCESS") {
+        let message = `Could not start session. IG.Asset.Server responded with ${state}`;
+        if (response) {
+            message += `: ${response}`;
+        }
+        throw new Error(message);
+    }
+    return {
+        _kind: "AssetService",
+        url,
+        sessionId,
+        domain: params.domain,
+        subDomain: params.subDomain
+    };
+};
+const closeSession = async (session)=>{
+    await axios.get(`Session/Close/${session.sessionId}`, {
+        baseURL: session.url
+    });
+};
+const uploadPackage = async (session, { name , version  }, zipFilePath)=>{
+    try {
+        await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}`, zipFilePath);
+    } catch (err) {
+        await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}/`, zipFilePath);
+    }
+};
+const uploadPackageToUrl = async (url, path, zipFilePath)=>{
+    const { data , status  } = await axios.post(path, fs.createReadStream(zipFilePath), {
+        baseURL: url
+    });
+    let objectBody;
+    if (typeof data === "string") {
+        try {
+            objectBody = JSON.parse(data);
+        } catch (err) {}
+    } else if (typeof data === "object") {
+        objectBody = data;
+    }
+    if (objectBody !== undefined) {
+        if ("state" in objectBody && objectBody.state !== "SUCCESS") {
+            throw new Error(objectBody.response ?? objectBody.state);
+        }
+    }
+    if (status >= 400) {
+        if (objectBody !== undefined) {
+            let text_1 = "";
+            for(const key in objectBody){
+                text_1 += key + ": \n";
+                if (typeof objectBody[key] === "object") {
+                    text_1 += JSON.stringify(objectBody[key], undefined, 2);
+                } else {
+                    text_1 += objectBody[key];
+                }
+                text_1 += "\n\n";
+            }
+            throw new Error(text_1);
+        }
+        throw new Error(data);
+    }
+    return data;
+};
+const getExistingPackages = async (session)=>{
+    const { data  } = await axios.get(`Script/GetInformation/${session.sessionId}`, {
+        baseURL: session.url,
+        validateStatus: (status)=>status === 404 || status === 200
+    }).catch((err)=>{
+        throw new Error(`Failed to get existing packages: ${err.message}`);
+    });
+    return data;
+};
+
+const tryReadTsConfig = (location)=>{
+    const { config  } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
+        try {
+            return fs.readFileSync(path, "utf8");
+        } catch  {
+            return undefined;
+        }
+    });
+    return config;
+};
+const build = async (location, outputDir)=>{
+    const config = tryReadTsConfig(location);
+    config.compilerOptions.lib = [
+        "es5",
+        "dom"
+    ];
+    const result = ts.convertCompilerOptionsFromJson(config.compilerOptions, location.scriptsDir);
+    const compilerOptions = {
+        ...result.options,
+        removeComments: false,
+        declaration: true,
+        sourceMap: false,
+        // We don't use tsc to actually emit the files, but we still need to set the correct
+        // output directory so the compiler can rewrite the `reference path` directives.
+        outFile: path.join(outputDir, "out.js"),
+        target: ts.ScriptTarget.ES5,
+        noEmitOnError: true
+    };
+    const host = ts.createCompilerHost(compilerOptions);
+    host.getCurrentDirectory = ()=>location.scriptsDir;
+    let js;
+    let definitions;
+    host.writeFile = (fileName, data, writeByteOrderMark)=>{
+        if (fileName.endsWith(".js")) {
+            js = data;
+        } else if (fileName.endsWith(".d.ts")) {
+            definitions = data;
+        }
+    };
+    const files = getPackageTypescriptFiles(location);
+    if (files.length === 0) {
+        throw new Error(`Expected typescript files to exist when building a package. Packages only consisting of animation jsons do not need to be built.`);
+    }
+    const programOptions = {
+        rootNames: files,
+        options: compilerOptions,
+        host
+    };
+    const program = ts.createProgram(programOptions);
+    const emitResult = program.emit();
+    const allDiagnostics = ts.getPreEmitDiagnostics(program);
+    if (!emitResult.emitSkipped) {
+        if (allDiagnostics.length > 0) {
+            console.log(allDiagnostics.map(createErrorMessage).join("\n"));
+        }
+        if (js === undefined || definitions === undefined) {
+            throw new Error(`Unexpected: no js or definitions were created`);
+        }
+        return {
+            js,
+            definitions
+        };
+    }
+    const error = allDiagnostics.map(createErrorMessage).join("\n");
+    throw new Error(error);
+};
+const createErrorMessage = (diagnostic)=>{
+    if (!diagnostic.file) {
+        return `${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
+    }
+    const { line , character  } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+    return `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`;
+};
+
+const generateDocs = async (location, declarationFile, outFolder, name)=>{
+    const app = new typedoc.Application();
+    const mediaDir = path.join(location.manifestDir, "Media");
+    app.bootstrap({
+        entryPoints: [
+            declarationFile
+        ],
+        media: mediaDir,
+        out: outFolder,
+        tsconfig: path.join(location.scriptsDir, "tsconfig.json"),
+        skipErrorChecking: true
+    });
+    app.options.setCompilerOptions([
+        declarationFile
+    ], {
+        target: ts.ScriptTarget.ES5
+    }, undefined);
+    app.options.setValue("name", name);
+    const [readmePath] = glob.sync("**/readme.md", {
+        absolute: true,
+        cwd: location.manifestDir
+    });
+    if (readmePath) {
+        app.options.setValue("readme", readmePath);
+    }
+    const project = app.convert();
+    if (project) {
+        await app.generateDocs(project, outFolder);
+    }
+};
+
+// Stolen from ig.tools.core
+const toposort = (packages)=>{
+    const queue = Object.getOwnPropertyNames(packages);
+    const result = [];
+    let index = 0;
+    while(queue.length > 0){
+        if (index >= queue.length) {
+            throw new Error("Packages can not have cyclic dependencies");
+        }
+        const queueEntry = queue[index];
+        const dependencies = packages[queueEntry];
+        const dependencyQueued = dependencies.some((dependency)=>queue.includes(dependency));
+        if (dependencyQueued) {
+            index++;
+            continue;
+        }
+        queue.splice(index, 1);
+        index = 0;
+        result.push(queueEntry);
+    }
+    return result;
+};
+
+const buildFolders = async (options)=>{
+    if (options.outDir !== undefined && options.clean) {
+        fs.rmSync(options.outDir, {
+            recursive: true
+        });
+    }
+    const workspace = options.workspace;
+    const folders = options.packages;
+    let sortedPackages = sortPackagesByBuildOrder(folders);
+    if (options.skipPackagesWithoutTsFiles) {
+        sortedPackages = sortedPackages.filter((location)=>getPackageTypescriptFiles(location).length > 0);
+    }
+    let index = 1;
+    for (const location of sortedPackages){
+        ensureTsConfig(location);
+        const data = readPackageCreatorManifest(location);
+        const logStep = (step)=>logPackageMessage(data.Package, step, index, folders.length);
+        logStep("Compiling typescript to javascript");
+        const outputDirectory = options.outDir || location.scriptsDir;
+        fs.mkdirSync(outputDirectory, {
+            recursive: true
+        });
+        const buildResult = await build(location, outputDirectory);
+        const banner = options.banner ? createBannerComment(options.banner) : undefined;
+        if (banner) {
+            buildResult.js = banner + "\n" + buildResult.js;
+            buildResult.definitions = banner + "\n" + buildResult.definitions;
+        }
+        fs.writeFileSync(path.join(outputDirectory, `${data.Package}.js`), buildResult.js, {
+            encoding: "utf8"
+        });
+        fs.writeFileSync(path.join(outputDirectory, `${data.Package}.d.ts`), buildResult.definitions, {
+            encoding: "utf8"
+        });
+        if (options.minimize) {
+            const minifyResult = await terser.minify(buildResult.js, {
+                ecma: 5
+            });
+            const minifiedPath = path.join(outputDirectory, `${data.Package}.min.js`);
+            fs.writeFileSync(minifiedPath, minifyResult.code, {
+                encoding: "utf8"
+            });
+        }
+        if (location.path.includes("Basics")) {
+            fs.mkdirSync(path.join(workspace.path, "lib"), {
+                recursive: true
+            });
+            logStep("Copying basics definition file to the lib folder");
+            fs.writeFileSync(path.join(workspace.path, "lib", `${data.Package}.d.ts`), buildResult.definitions, {
+                encoding: "utf8"
+            });
+        }
+        if (options.docs) {
+            logStep("Generating typedoc documentation");
+            await generateDocs(location, path.join(outputDirectory, `${data.Package}.d.ts`), path.join(workspace.path, "docs", data.Package), data.Package);
+        }
+        index++;
+    }
+};
+const ensureTsConfig = (location)=>{
+    const tsconfigPath = path.join(location.scriptsDir, "tsconfig.json");
+    if (!fs.existsSync(tsconfigPath)) {
+        const content = {};
+        applyTsConfigOption(content);
+        fs.writeFileSync(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+    } else {
+        const content = JSON.parse(fs.readFileSync(tsconfigPath, "utf8"));
+        applyTsConfigOption(content);
+        fs.writeFileSync(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+    }
+};
+const applyTsConfigOption = (data)=>{
+    data.compilerOptions = data.compilerOptions ?? {};
+    data.compilerOptions.target = "es5";
+    data.compilerOptions.lib = [
+        "es5",
+        "dom"
+    ];
+};
+const sortPackagesByBuildOrder = (folders)=>{
+    const packages = Array.from(folders).reduce((acc, location)=>{
+        const data = readPackageNpmManifest(location);
+        if (data !== undefined) {
+            acc[data.name] = {
+                data,
+                location
+            };
+        } else {
+            acc[location.path] = {
+                data: undefined,
+                location
+            };
+        }
+        return acc;
+    }, {});
+    const packageDependencies = Object.getOwnPropertyNames(packages).reduce((acc, packageName)=>{
+        const packageData = packages[packageName];
+        if (packageData.data === undefined) {
+            acc[packageName] = [];
+        } else {
+            acc[packageName] = Object.getOwnPropertyNames({
+                ...packageData.data.devDependencies,
+                ...packageData.data.dependencies,
+                ...packageData.data.peerDependencies
+            }).filter((packageName)=>packages[packageName] !== undefined);
+        }
+        return acc;
+    }, {});
+    const sortedPackages = toposort(packageDependencies);
+    const result = [];
+    for (const packageName of sortedPackages){
+        const location = packages[packageName].location;
+        if (readPackageCreatorManifest(location).Package.endsWith(".Basics")) {
+            result.unshift(location);
+        } else {
+            result.push(location);
+        }
+    }
+    return result;
+};
+const createBannerComment = (banner)=>{
+    const bannerParts = [];
+    if (banner.text) {
+        bannerParts.push(" * " + banner.text);
+    }
+    {
+        const details = [];
+        if (banner.version) {
+            details.push(`Version: ${banner.version}`);
+        }
+        if (banner.commit) {
+            if (banner.commitDirty) {
+                details.push(`Commit: ${banner.commit} (dirty)`);
+            } else {
+                details.push(`Commit: ${banner.commit}`);
+            }
+        }
+        if (banner.date) {
+            details.push(`Date: ${banner.date.toISOString()}`);
+        }
+        const detailsText = details.map((line)=>` * ${line}`).join("\n");
+        if (detailsText) {
+            bannerParts.push(detailsText);
+        }
+    }
+    const bannerText = bannerParts.join("\n\n");
+    if (bannerText) {
+        return `/*
+${bannerText}
+*
+* @preserve			
+*/`;
+    }
+    return undefined;
+};
+
+const getVersionInformationFromGit = async (workspaceLocation, packageLocation)=>{
+    try {
+        var _log_latest, _log_latest1;
+        const git = simpleGit({
+            baseDir: workspaceLocation.path
+        });
+        // check wether the files for a folder are changed
+        // if so, mark as dirty
+        const diff = await git.diffSummary();
+        const dirty = diff.files.some((file)=>{
+            if (file.file.toLowerCase().includes("releases") || file.file.toLowerCase().endsWith("version.ts") || file.file.toLowerCase().endsWith("package.json")) {
+                return false;
+            }
+            const fullPath = path.resolve(workspaceLocation.path, file.file);
+            const relativePath = path.relative(packageLocation.path, fullPath);
+            return !relativePath.startsWith("..");
+        });
+        const log = await git.log({
+            maxCount: 1
+        });
+        const commit = !((_log_latest = log.latest) == null ? void 0 : _log_latest.hash) ? undefined : log.latest.hash.substring(0, 7);
+        return {
+            commit,
+            dirty,
+            commitDate: (_log_latest1 = log.latest) == null ? void 0 : _log_latest1.date
+        };
+    } catch (err) {
+        return {};
+    }
+};
+
+const getWorkspaceBannerText = (manifest)=>{
+    var _manifest_packager;
+    let bannerText = manifest == null ? void 0 : (_manifest_packager = manifest.packager) == null ? void 0 : _manifest_packager.banner;
+    if (bannerText) {
+        const match = bannerText.match(/Copyright \(C\) (\d+)( ?- ?(\d+))?/);
+        if (match !== null) {
+            const startYear = parseInt(match[1]);
+            const endYear = new Date().getFullYear();
+            if (startYear !== endYear) {
+                bannerText = bannerText.replace(match[0], `Copyright (C) ${startYear} - ${endYear}`);
+            } else {
+                bannerText = bannerText.replace(match[0], `Copyright (C) ${startYear}`);
+            }
+        }
+    }
+    return bannerText;
+};
+
+// Stolen from ig.tools.core
+class PackageVersion {
+    static #_ = (()=>{
+        // https://regex101.com/r/90PEY9/1
+        this.fullTextMatcher = /(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?/;
+    })();
+    static #_1 = (()=>{
+        this.lineMatcher = /^(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?$/;
+    })();
+    static extractFromText(input, description) {
+        if (input === undefined) {
+            throw new Error(`Can not parse version from undefined`);
+        }
+        const match = input.match(PackageVersion.fullTextMatcher);
+        if (!match) {
+            throw new Error(`Could not extract a version from input: ${input}`);
+        }
+        return PackageVersion.fromMatch(match, description);
+    }
+    static extractFromLine(input, description) {
+        if (input === undefined) {
+            throw new Error(`Can not parse version from undefined`);
+        }
+        const match = input.match(PackageVersion.lineMatcher);
+        if (!match) {
+            throw new Error(`Could not parse version from input: ${input}`);
+        }
+        return PackageVersion.fromMatch(match, description);
+    }
+    static equals(a, b, checkPrerelease = false) {
+        if (a.major !== b.major || a.minor !== b.minor || a.patch !== b.patch) {
+            return false;
+        }
+        if (checkPrerelease === false) {
+            return true;
+        }
+        if (a.preRelease === b.preRelease) {
+            return true;
+        }
+        if (a.preRelease === undefined || b.preRelease === undefined) {
+            return false;
+        }
+        return a.preRelease.type === b.preRelease.type && a.preRelease.version === b.preRelease.version;
+    }
+    static fromMatch([, major, , minor = "0", , patch = "0", , build, , preReleaseType, preReleaseNumber], description) {
+        let preRelease = undefined;
+        let buildNumber = 100;
+        if (preReleaseType && preReleaseNumber) {
+            preRelease = {
+                type: preReleaseType,
+                version: parseInt(preReleaseNumber)
+            };
+        }
+        if (build) {
+            buildNumber = Number(build);
+        } else if (description) {
+            const descriptionMatch = description.match(/(\d+)\)$/);
+            if (descriptionMatch) {
+                buildNumber = parseInt(descriptionMatch[1]);
+            }
+        }
+        return new PackageVersion(parseInt(major), parseInt(minor), parseInt(patch), preRelease, buildNumber);
+    }
+    static sort(a, b, ascending = true) {
+        const createSortResult = (a, b)=>ascending ? a - b : b - a;
+        if (a.major !== b.major) {
+            return createSortResult(a.major, b.major);
+        }
+        if (a.minor !== b.minor) {
+            return createSortResult(a.minor, b.minor);
+        }
+        if (a.patch !== b.patch) {
+            return createSortResult(a.patch, b.patch);
+        }
+        return createSortResult(a.preRelease ? a.preRelease.version : 0, b.preRelease ? b.preRelease.version : 0);
+    }
+    static toNumber(version) {
+        return ((version.major * 1000 + version.minor) * 1000 + version.patch) * 1000 + version.buildNumber;
+    }
+    constructor(major, minor, patch, preRelease, buildNumber){
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+        this.preRelease = preRelease;
+        this.buildNumber = buildNumber;
+    }
+    isPreRelease() {
+        return this.preRelease !== undefined;
+    }
+    clone() {
+        return new PackageVersion(this.major, this.minor, this.patch, this.preRelease ? {
+            ...this.preRelease
+        } : undefined, this.buildNumber);
+    }
+    incrementMajor() {
+        this.preRelease = undefined;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+    }
+    incrementMinor() {
+        this.preRelease = undefined;
+        this.patch = 0;
+        this.minor++;
+    }
+    incrementPatch() {
+        this.preRelease = undefined;
+        this.patch++;
+    }
+    createPreRelease(type) {
+        if (!this.preRelease) {
+            this.buildNumber = 1;
+        } else {
+            this.buildNumber++;
+        }
+        if (this.preRelease && type === this.preRelease.type) {
+            this.preRelease.version++;
+            return;
+        }
+        this.preRelease = {
+            version: 0,
+            type
+        };
+    }
+    createRelease() {
+        this.preRelease = undefined;
+        this.buildNumber = 100;
+    }
+    toVersionString({ buildNumber  } = {}) {
+        let version = [
+            this.major,
+            this.minor,
+            this.patch
+        ].join(".");
+        if (buildNumber) {
+            version += "." + this.buildNumber;
+        }
+        if (this.preRelease) {
+            version += `-${this.preRelease.type}.${this.preRelease.version}`;
+        }
+        return version;
+    }
+    toDescriptionString(packageName) {
+        const base = [
+            this.major,
+            this.minor,
+            this.patch
+        ].join(".");
+        const parts = [
+            packageName,
+            base
+        ];
+        if (this.preRelease) {
+            parts.push(upperCaseFirst(this.preRelease.type));
+            parts.push(this.preRelease.version);
+        }
+        parts.push(`(${base}.${this.buildNumber})`);
+        return parts.join(" ");
+    }
+    /**
+	 * Determines wether the version is lesser than the input version
+	 *
+	 * @param {PackageVersion} version
+	 * @returns
+	 */ isLesserThan(version) {
+        return PackageVersion.toNumber(this) < PackageVersion.toNumber(version);
+    }
+    /**
+	 * Determines wether the version is greater than the input version
+	 *
+	 * @param {PackageVersion} version
+	 * @returns
+	 */ isGreaterThan(version) {
+        return PackageVersion.toNumber(this) > PackageVersion.toNumber(version);
+    }
+}
+const upperCaseFirst = (input)=>{
+    return input.slice(0, 1).toUpperCase() + input.slice(1);
+};
+
+const parseVersionFromString = (input)=>{
+    if (input === undefined) {
+        throw new Error(`Can not parse version from undefined`);
+    }
+    let match;
+    let major;
+    let minor;
+    let patch;
+    let build;
+    let preReleaseType;
+    let preReleaseNumber;
+    if (// first try to find a full match with build number
+    (match = input.match(/(\d+)\.(\d+)\.(\d+)\.(\d+)(-([^\.]+)\.(\d+))?/)) !== null) {
+        [, major, minor, patch, build, preReleaseType, preReleaseNumber] = match;
+    } else if ((match = input.match(/(\d+)\.(\d+)\.(\d+)(-([^\.]+)\.(\d+))?/)) !== null) {
+        [, major, minor, patch, , preReleaseType, preReleaseNumber] = match;
+    }
+    if (match === null) {
+        throw new Error(`Could not parse version from input: ${input}`);
+    }
+    let preRelease = undefined;
+    let buildNumber = 100;
+    if (preReleaseType && preReleaseNumber) {
+        preRelease = {
+            type: preReleaseType,
+            version: parseInt(preReleaseNumber)
+        };
+    }
+    if (build) {
+        buildNumber = Number(build);
+    } else if (input) {
+        const descriptionMatch = input.match(/(\d+)\)$/);
+        if (descriptionMatch) {
+            buildNumber = parseInt(descriptionMatch[1]);
+        }
+    }
+    return new PackageVersion(parseInt(major), parseInt(minor), parseInt(patch), preRelease, buildNumber);
+};
+// 1000001001 -> 1.0.1.1
+// 1002017001 -> 1.2.17.1
+const parseVersionFromNumericVersion = (version)=>{
+    const major = Math.floor(version / 1000000000);
+    const minor = Math.floor(version % 1000000000 / 1000000);
+    const patch = Math.floor(version % 1000000 / 1000);
+    const buildNumber = version % 1000;
+    return new PackageVersion(major, minor, patch, undefined, buildNumber);
+};
+
+// https://regex101.com/r/LtGAu5/1
+const logRegex = /console\.log\(\s*"([\w\s\.\(\)]+)\ *Copyright[\w\s\(\)\.]+(\d{4}|\d{4} - \d{4})([\w\s\(\)\.]+)?",?\s*\)/i;
+const currentYear = new Date(Date.now()).getFullYear();
+const getVersionFileHandler = (location)=>{
+    const filePath = path.join(location.scriptsDir, "Version.ts");
+    const invalidVersionFile = (versionFile)=>({
+            version: undefined,
+            write: (name, newVersion)=>{
+                const scriptsContent = fs.readdirSync(location.scriptsDir);
+                const tsFiles = scriptsContent.filter((file)=>file.endsWith(".ts"));
+                if (tsFiles.length > 0) {
+                    return createVersionFileWriter([
+                        currentYear
+                    ], "")(name, newVersion);
+                }
+            },
+            reset: ()=>{
+                if (versionFile !== undefined) {
+                    fs.writeFileSync(filePath, versionFile, {
+                        encoding: "utf8"
+                    });
+                } else {
+                    try {
+                        fs.rmSync(filePath);
+                    } catch (err) {
+                        if (!isErrorENOENT(err)) {
+                            throw err;
+                        }
+                    }
+                }
+            }
+        });
+    const createVersionFileWriter = (copyright = [
+        currentYear
+    ], copyrightStuff = "")=>(name, newVersion)=>{
+            const descriptionText = newVersion.toDescriptionString(name);
+            const copyrightText = createYearString(copyright);
+            const result = `console.log("${descriptionText}. Copyright (C) ${copyrightText}${copyrightStuff}");`;
+            fs.writeFileSync(filePath, result, {
+                encoding: "utf-8"
+            });
+        };
+    let rawVersionFile = readStringFromFileOrUndefined(filePath);
+    if (rawVersionFile === undefined) {
+        return invalidVersionFile(rawVersionFile);
+    }
+    const versionFile = rawVersionFile.replace(/\n/g, "");
+    const match = versionFile.match(logRegex);
+    if (!match) {
+        return invalidVersionFile(versionFile);
+    }
+    const [_full, _description, copyright, copyrightStuff] = match;
+    const copyrightYears = copyright.match(/^(\d+)( ?- ?(\d+))?$/);
+    let years;
+    if (copyrightYears === null) {
+        years = [
+            currentYear
+        ];
+    } else {
+        years = [
+            Number(copyrightYears[1]),
+            currentYear
+        ];
+    }
+    return {
+        write: createVersionFileWriter(years, copyrightStuff),
+        reset: ()=>{
+            fs.writeFileSync(filePath, versionFile, {
+                encoding: "utf8"
+            });
+        }
+    };
+};
+const createYearString = (years)=>{
+    if (years[1] === undefined || years[0] === years[1]) {
+        return years[0].toString();
+    }
+    return `${years[0]} - ${years[1]}`;
+};
+
+const buildArchiveFromPublishedPackage = (location, manifest, creatorPackage)=>{
+    const archive = new JSZip();
+    archive.file(PACKAGE_FILE, JSON.stringify(creatorPackage, null, 2));
+    const index = readPublishedPackageCreatorIndex(location);
+    if (index !== undefined) {
+        archive.file(INDEX_FILE, JSON.stringify(index, null, 2));
+    }
+    archive.file(manifest.main, fs.createReadStream(path.join(location.path, manifest.main)));
+    return archive;
+};
+let validateSchema;
+const runtimeScripts = [
+    "Interactor",
+    "Core",
+    "Mixed"
+];
+const notRuntimeScripts = [
+    "Context",
+    "Evaluator"
+];
+const buildArchiveFromPackage = async (workspaceLocation, packageLocation, data)=>{
+    const { domain , subdomain  } = parseCreatorPackageName(data);
+    const logStep = (step)=>logPackageMessage(data.Package, step);
+    if (validateSchema === undefined) {
+        validateSchema = await axios.get("https://archive.intelligentgraphics.biz/schemas/gfx/animation.json").then(({ data  })=>new Ajv({
+                coerceTypes: true,
+                allErrors: true,
+                removeAdditional: true,
+                useDefaults: "empty",
+                validateSchema: "log"
+            }).compile(data));
+    }
+    const libFilePath = path.join(getWorkspaceOutputPath(workspaceLocation), `${data.Package}.min.js`);
+    const scriptDirectories = [
+        packageLocation.path,
+        packageLocation.scriptsDir
+    ];
+    if (subdomain === "GFX.Standard") {
+        logStep(`Including Images folder`);
+        scriptDirectories.push(path.join(packageLocation.path, "Images"));
+    }
+    const manifest = readPackageCreatorManifest(packageLocation);
+    if (manifest !== undefined) {
+        if (manifest.RunTime && notRuntimeScripts.includes(manifest.Type)) {
+            logStep("Setting script RunTime to false because of script type");
+            writePackageCreatorManifest(packageLocation, {
+                ...manifest,
+                RunTime: false
+            });
+        } else if (!manifest.RunTime && runtimeScripts.includes(manifest.Type)) {
+            logStep("Setting script RunTime to true because of script type");
+            writePackageCreatorManifest(packageLocation, {
+                ...manifest,
+                RunTime: true
+            });
+        }
+    }
+    // if (index === undefined) {
+    // 	throw new Error(
+    // 		`Could not find an "${INDEX_FILE}" file in "${primaryScriptDir}"`,
+    // 	);
+    // }
+    const animations = new Map();
+    for (const scriptFilePath of readPackageAnimationList(packageLocation)){
+        const content = fs.readFileSync(scriptFilePath, {
+            encoding: "utf8"
+        });
+        let data;
+        try {
+            data = JSON.parse(content);
+        } catch (err) {
+            const relativePath = path.relative(workspaceLocation.path, scriptFilePath);
+            if (err instanceof SyntaxError) {
+                throw new Error(`Encountered invalid syntax in file "${relativePath}": ${String(err)}`);
+            }
+            throw new Error(`Encountered an unexpected error while parsing animation json file at path "${relativePath}"`, {
+                cause: err
+            });
+        }
+        validateSchema(data);
+        animations.set(data.Id, JSON.stringify(data));
+    }
+    let libFile;
+    try {
+        libFile = fs.readFileSync(libFilePath, {
+            encoding: "utf8"
+        });
+    } catch (err) {
+        if (!isErrorENOENT(err)) {
+            throw err;
+        }
+    }
+    if (libFile === undefined) {
+        if (animations.size === 0) {
+            throw new Error(`Could not find a javascript file at "${libFilePath}".
+Packaging without a javascript file is only allowed when animation json files are available`);
+        }
+    }
+    const archive = new JSZip();
+    let library = "";
+    if (libFile) {
+        library = libFile;
+    }
+    if (!library) {
+        const date = new Date(Date.now());
+        library = `/* This file is part of the ${domain} Data Packages.
+		* Copyright (C) ${date.getFullYear()} intelligentgraphics. All Rights Reserved. */`;
+    }
+    if (animations.size > 0) {
+        const scope = data.Scope ?? data.Package;
+        const scopeParts = scope.split(".");
+        library += createNamespace(scopeParts);
+        for (const [name, data] of animations){
+            library += `${scope}["${name}"] = ` + data + ";";
+            logPackageMessage(manifest.Package, `Added animation ${scope}.${name}`);
+        }
+    }
+    const minifyResult = await terser.minify(library, {
+        ecma: 5
+    });
+    archive.file(`${data.Package}.js`, minifyResult.code);
+    archive.file(PACKAGE_FILE, JSON.stringify(data, null, 2));
+    const creatorIndex = readPackageCreatorIndex(packageLocation);
+    if (creatorIndex !== undefined) {
+        archive.file(INDEX_FILE, JSON.stringify(creatorIndex, null, 2));
+    }
+    for (const directory of scriptDirectories){
+        try {
+            for (const file of fs.readdirSync(directory)){
+                const { ext  } = path.parse(file);
+                switch(ext){
+                    case ".png":
+                    case ".jpeg":
+                    case ".jpg":
+                        break;
+                    default:
+                        continue;
+                }
+                archive.file(file, fs.createReadStream(path.join(directory, file)));
+            }
+        } catch (err) {
+            console.error(`Script directory "${directory}" does not exist`);
+        }
+    }
+    return archive;
+};
+const createNamespace = (parts)=>{
+    let code = `var ${parts[0]};`;
+    for(let index = 0; index < parts.length; index++){
+        const path = parts.slice(0, index + 1).join(".");
+        code += `\n(${path} = ${path} || {});`;
+    }
+    return code;
+};
+
+const releaseFolder = async (options)=>{
+    const workspace = options.workspace;
+    const location = options.directory;
+    const { write: writeVersionFile , reset: resetVersionFile  } = getVersionFileHandler(location);
+    const packageDescription = readPackageCreatorManifest(location);
+    const fullPackageName = packageDescription.Package;
+    const { domain , subdomain  } = parseCreatorPackageName(packageDescription);
+    const publishDomain = options.domain ?? domain;
+    const publishSubdomain = options.subdomain ?? subdomain;
+    const sharedPackageJson = readWorkspaceNpmManifest(workspace);
+    let newVersion;
+    try {
+        newVersion = parseVersionFromString(options.newVersion);
+    } catch (err) {
+        throw new Error(`Please enter a version in this format 1.0.0.100`);
+    }
+    packageDescription.Version = newVersion.toVersionString({
+        buildNumber: true
+    });
+    writePackageCreatorManifest(location, packageDescription);
+    if (newVersion.buildNumber < 100) {
+        newVersion.preRelease = {
+            type: "beta",
+            version: newVersion.buildNumber
+        };
+    } else if (newVersion.buildNumber > 100) {
+        newVersion.preRelease = {
+            type: "patch",
+            version: newVersion.buildNumber - 100
+        };
+    }
+    if (sharedPackageJson !== undefined) {
+        logPackageMessage(packageDescription.Package, `Running npm install to make sure all dependencies are up to date`);
+        execSync(`npm install`, {
+            encoding: "utf-8",
+            cwd: workspace.path
+        });
+    }
+    const binDir = getWorkspaceOutputPath(workspace);
+    fs.mkdirSync(binDir, {
+        recursive: true
+    });
+    let assetServerPackageDetails;
+    let packageNameWithVersion;
+    {
+        const versionWithoutPrelease = newVersion.clone();
+        versionWithoutPrelease.preRelease = undefined;
+        const newVersionString = versionWithoutPrelease.toVersionString({
+            buildNumber: true
+        });
+        packageNameWithVersion = `${packageDescription.Package}_${newVersionString}`;
+        assetServerPackageDetails = {
+            name: packageDescription.Package,
+            version: newVersionString
+        };
+    }
+    const zipFilePath = path.join(binDir, packageNameWithVersion + ".zip");
+    try {
+        if (options.pushOnly) {
+            if (!fs.existsSync(zipFilePath)) {
+                throw new Error(`Expected a zip file to exist at path ${zipFilePath} since pushOnly is specified`);
+            }
+        } else {
+            const gitVersionInformation = await getVersionInformationFromGit(workspace, location);
+            writeVersionFile(fullPackageName, newVersion);
+            const bannerText = sharedPackageJson !== undefined ? getWorkspaceBannerText(sharedPackageJson) : undefined;
+            await buildFolders({
+                ...options,
+                packages: [
+                    location
+                ],
+                skipPackagesWithoutTsFiles: true,
+                banner: options.banner ? {
+                    text: bannerText,
+                    commit: gitVersionInformation.commit,
+                    commitDirty: gitVersionInformation.dirty,
+                    version: newVersion.toVersionString({
+                        buildNumber: true
+                    }),
+                    date: new Date(Date.now())
+                } : undefined
+            });
+            newVersion.preRelease = undefined;
+            try {
+                fs.rmSync(zipFilePath);
+            } catch (err) {
+                if (!isErrorENOENT(err)) {
+                    throw err;
+                }
+            }
+            if (readPackageAnimationList(location).length > 0) {
+                var _workspaceManifest_dependencies;
+                const workspaceManifest = readWorkspaceNpmManifest(workspace);
+                if (!((_workspaceManifest_dependencies = workspaceManifest.dependencies) == null ? void 0 : _workspaceManifest_dependencies["@intelligentgraphics/3d.ig.gfx.standard"])) {
+                    const install = await options.prompter.confirm(`Animation.json files expect the library 'IG.GFX.Standard' to be available, but it is not registered as a dependency. Do you want it to be added now?`);
+                    if (install) {
+                        execSync(`npm install @intelligentgraphics/3d.ig.gfx.standard`, {
+                            encoding: "utf-8",
+                            cwd: workspace.path,
+                            stdio: "inherit"
+                        });
+                        execSync(`npm run postinstall`, {
+                            cwd: workspace.path
+                        });
+                    }
+                }
+            }
+            const archive = await buildArchiveFromPackage(workspace, location, packageDescription);
+            const zipOutputStream = fs.createWriteStream(zipFilePath);
+            await pipeline(archive.generateNodeStream(), zipOutputStream);
+        }
+        if (!options.noUpload) {
+            if (!options.authentication) {
+                throw new Error(`Expected authentication to be available`);
+            }
+            logPackageMessage(packageDescription.Package, `Opening connection to IG.Asset.Server`);
+            const sessionManager = await createSessionManager({
+                url: options.service,
+                address: options.address,
+                domain: publishDomain,
+                subDomain: publishSubdomain,
+                authentication: options.authentication
+            });
+            try {
+                if (!options.skipDependencies) {
+                    await ensureRequiredVersions(workspace, packageDescription, sessionManager, options.prompter);
+                }
+                logPackageMessage(packageDescription.Package, `Uploading package to ${publishDomain}.${publishSubdomain}`);
+                await uploadPackage(sessionManager.getTargetSession(), assetServerPackageDetails, zipFilePath);
+            } finally{
+                await sessionManager.destroy().catch((err)=>{
+                    logPackageMessage(packageDescription.Package, `Failed to close IG.Asset.Server session(s): ${err}`);
+                });
+            }
+        }
+    } catch (err) {
+        resetVersionFile();
+        throw err;
+    }
+    if (newVersion.buildNumber >= 100 && !options.pushOnly) {
+        logPackageMessage(fullPackageName, "Copying zip to releases folder");
+        const zipFileName = `${packageNameWithVersion}.zip`;
+        const releasesPath = getPackageReleasesDirectory(location);
+        fs.mkdirSync(releasesPath, {
+            recursive: true
+        });
+        fs.copyFileSync(zipFilePath, path.join(releasesPath, zipFileName));
+    }
+};
+const ensureRequiredVersions = async (workspaceLocation, creatorPackage, sessionManager, prompter)=>{
+    const libraries = determineWorkspaceIGLibraries(workspaceLocation);
+    // If there are no libraries, we don't need to check for required versions
+    if (libraries.length === 0) {
+        return true;
+    }
+    const targetSession = sessionManager.getTargetSession();
+    const rawUploadedPackages = await getExistingPackages(targetSession);
+    const uploadedPackages = rawUploadedPackages.map((entry)=>{
+        let version;
+        try {
+            version = parseVersionFromNumericVersion(entry.numericVersion);
+        } catch (err) {
+            throw new Error(`Encountered invalid format for version ${entry.numericVersion}`);
+        }
+        if (version.buildNumber < 100) {
+            version.preRelease = {
+                type: "beta",
+                version: version.buildNumber
+            };
+        } else if (version.buildNumber > 100) {
+            version.preRelease = {
+                type: "patch",
+                version: version.buildNumber - 100
+            };
+        }
+        return {
+            ...entry,
+            version
+        };
+    });
+    for (const libraryLocation of libraries){
+        const libraryManifest = readPublishedPackageNpmManifest(libraryLocation);
+        const libraryCreatorPackage = readPublishedPackageCreatorManifest(libraryLocation);
+        if (libraryCreatorPackage === undefined || libraryManifest.main === undefined || libraryCreatorPackage.Package === creatorPackage.Package) {
+            continue;
+        }
+        const libraryVersion = PackageVersion.extractFromLine(libraryManifest.version);
+        if (libraryVersion.preRelease) {
+            libraryVersion.buildNumber = libraryVersion.preRelease.version;
+            libraryVersion.preRelease = undefined;
+        } else {
+            libraryVersion.buildNumber = 100;
+        }
+        let uploadedPackageInBasics;
+        let uploadedPackageInTarget;
+        for (const uploadedPackage of uploadedPackages){
+            if (uploadedPackage.scope === libraryCreatorPackage.Package) {
+                if (uploadedPackage.support) {
+                    uploadedPackageInBasics = uploadedPackage;
+                } else {
+                    uploadedPackageInTarget = uploadedPackage;
+                }
+            }
+        }
+        const validInBasics = uploadedPackageInBasics !== undefined && !uploadedPackageInBasics.version.isLesserThan(libraryVersion);
+        const validInTarget = uploadedPackageInTarget !== undefined && !uploadedPackageInTarget.version.isLesserThan(libraryVersion);
+        if (validInBasics || validInTarget) {
+            if (targetSession.subDomain !== "Basics" && uploadedPackageInBasics !== undefined && uploadedPackageInTarget !== undefined) {
+                logPackageMessage(creatorPackage.Package, `Package ${libraryCreatorPackage.Package} is uploaded both for Basics and ${targetSession.subDomain}. The package within ${targetSession.subDomain} will be used.`);
+            }
+            continue;
+        }
+        const possibleTargets = [];
+        if (uploadedPackageInBasics) {
+            const version = uploadedPackageInBasics.version.toVersionString({
+                buildNumber: true
+            });
+            possibleTargets.push({
+                value: "Basics",
+                name: `Basics (Current: ${version})`
+            });
+        } else {
+            possibleTargets.push({
+                value: "Basics",
+                name: "Basics (Current: None)"
+            });
+        }
+        if (targetSession.subDomain !== "Basics") {
+            if (uploadedPackageInTarget) {
+                const version = uploadedPackageInTarget.version.toVersionString({
+                    buildNumber: true
+                });
+                possibleTargets.push({
+                    value: targetSession.subDomain,
+                    name: `${targetSession.subDomain} (Current: ${version})`
+                });
+            } else {
+                possibleTargets.push({
+                    value: targetSession.subDomain,
+                    name: `${targetSession.subDomain} (Current: None)`
+                });
+            }
+        }
+        const libraryVersionString = libraryVersion.toVersionString({
+            buildNumber: true
+        });
+        const uploadTargetScope = await prompter.ask({
+            message: `Version ${libraryVersionString} of dependency ${libraryCreatorPackage.Package} is required but not available. Please select a subdomain to upload the correct dependency version to`,
+            options: [
+                ...possibleTargets,
+                {
+                    name: "Skip upload",
+                    value: "Skip"
+                }
+            ],
+            default: possibleTargets[0].value
+        });
+        if (uploadTargetScope === "Skip") {
+            continue;
+        }
+        const archive = buildArchiveFromPublishedPackage(libraryLocation, libraryManifest, libraryCreatorPackage);
+        const newVersionString = libraryVersion.toVersionString({
+            buildNumber: true
+        });
+        const packageNameWithVersion = `${libraryCreatorPackage.Package}_${newVersionString}`;
+        const zipFilePath = path.join(getWorkspaceOutputPath(workspaceLocation), `${packageNameWithVersion}.zip`);
+        try {
+            fs.rmSync(zipFilePath);
+        } catch (err) {
+            if (!isErrorENOENT(err)) {
+                throw err;
+            }
+        }
+        const zipOutputStream = fs.createWriteStream(zipFilePath);
+        await pipeline(archive.generateNodeStream(), zipOutputStream);
+        const session = uploadTargetScope === "Basics" ? await sessionManager.getBasicsSession() : targetSession;
+        logPackageMessage(creatorPackage.Package, `Uploading package ${libraryCreatorPackage.Package} with version ${newVersionString} to ${session.domain}.${session.subDomain}`);
+        await uploadPackage(session, {
+            name: libraryCreatorPackage.Package,
+            version: newVersionString
+        }, zipFilePath);
+    }
+};
+const createSessionManager = async (params)=>{
+    const targetSession = await startSession(params);
+    let basicsSession;
+    return {
+        getBasicsSession: async ()=>{
+            if (targetSession.subDomain === "Basics") {
+                return targetSession;
+            }
+            if (basicsSession === undefined) {
+                basicsSession = await startSession({
+                    ...params,
+                    subDomain: "Basics"
+                });
+            }
+            return basicsSession;
+        },
+        getTargetSession: ()=>targetSession,
+        destroy: async ()=>{
+            await closeSession(targetSession);
+            if (basicsSession !== undefined) {
+                await closeSession(basicsSession);
+            }
+        }
+    };
+};
+
+/**
+ * Extracts and returns script array for _Index.json from a src folder
+ *
+ * @param folderPath path to a src folder
+ */ function generateIndex({ location , ignore =[] , strictOptional =false  }) {
+    const files = getPackageTypescriptFiles(location);
+    const filtered = files.filter((path)=>{
+        return !ignore.some((suffix)=>path.endsWith(suffix));
+    });
+    const arr = [];
+    const existingIndex = readPackageCreatorIndex(location) ?? [];
+    const program = ts.createProgram(filtered, {
+        allowJs: true
+    });
+    const typeChecker = program.getTypeChecker();
+    filtered.forEach((file)=>{
+        // Create a Program to represent the project, then pull out the
+        // source file to parse its AST.
+        const sourceFile = program.getSourceFile(file);
+        // Loop through the root AST nodes of the file
+        ts.forEachChild(sourceFile, (node)=>{
+            for (const scriptingClass of findScriptingClasses(node)){
+                if (scriptingClass.node.name === undefined) {
+                    throw new Error(`Expected ${scriptingClass.type} class to have a name`);
+                }
+                const name = typeChecker.getFullyQualifiedName(typeChecker.getSymbolAtLocation(scriptingClass.node.name));
+                if (name.length > 45) {
+                    throw new Error(`Package name length >45 '${name}'`);
+                }
+                const parameterDeclaration = getScriptingClassParameterdeclaration(scriptingClass);
+                const parametersType = parameterDeclaration === undefined ? undefined : typeChecker.getTypeAtLocation(parameterDeclaration);
+                if (parametersType === undefined) {
+                    console.log(`Failed to find parameters type declaration for ${scriptingClass.type} ${name}. Skipping parameter list generation`);
+                }
+                const existingIndexEntry = existingIndex.find((entry)=>entry.Name === name);
+                const obj = {
+                    Name: name,
+                    Description: (existingIndexEntry == null ? void 0 : existingIndexEntry.Description) ?? name,
+                    Type: scriptingClass.type === "evaluator" ? "Evaluator" : "Interactor",
+                    Parameters: []
+                };
+                const rawDocTags = ts.getJSDocTags(scriptingClass.node);
+                const dict = getTagDict(rawDocTags);
+                if (dict.summary) {
+                    obj.Description = dict.summary;
+                } else {
+                    const comment = typeChecker.getTypeAtLocation(scriptingClass.node).symbol.getDocumentationComment(typeChecker).map((comment)=>comment.text).join(" ");
+                    if (comment) {
+                        obj.Description = comment;
+                    }
+                }
+                if (parametersType !== undefined) {
+                    obj.Parameters = parseParametersList(typeChecker.getPropertiesOfType(parametersType), strictOptional);
+                    if (obj.Parameters.length === 0 && parametersType.getStringIndexType() !== undefined) {
+                        obj.Parameters = (existingIndexEntry == null ? void 0 : existingIndexEntry.Parameters) ?? [];
+                    }
+                } else if (existingIndexEntry !== undefined) {
+                    obj.Parameters = existingIndexEntry.Parameters;
+                }
+                arr.push(obj);
+            }
+        });
+    });
+    arr.sort((a, b)=>a.Name.localeCompare(b.Name));
+    writePackageCreatorIndex(location, arr);
+}
+function capitalizeFirstLetter(string) {
+    return (string == null ? void 0 : string.charAt(0).toUpperCase()) + (string == null ? void 0 : string.slice(1));
+}
+const parseDefault = (value, type)=>{
+    const uType = capitalizeFirstLetter(type);
+    if (value === "null") return null;
+    switch(uType){
+        case "LengthM":
+        case "ArcDEG":
+        case "Float":
+            return parseFloat(value);
+        case "Integer":
+        case "Int":
+            return parseInt(value);
+        case "Boolean":
+        case "Bool":
+            return value === "true";
+        case "Material":
+        case "String":
+        case "Geometry":
+        default:
+            return value.replace(/^"/, "").replace(/"$/, "");
+    }
+};
+const parseTypeFromName = (name)=>{
+    const parts = name.split(".");
+    const identifier = parts[parts.length - 1];
+    switch(identifier){
+        case "LengthM":
+        case "ArcDEG":
+        case "Float":
+        case "Integer":
+            return identifier;
+        case "GeometryReference":
+            return "Geometry";
+        case "MaterialReference":
+            return "Material";
+        case "AnimationReference":
+            return "Animation";
+        case "InteractorReference":
+            return "Interactor";
+        case "EvaluatorReference":
+            return "Evaluator";
+        case "String":
+        case "string":
+            return "String";
+        case "number":
+        case "Number":
+            return "Float";
+        case "boolean":
+        case "Boolean":
+            return "Boolean";
+    }
+};
+const parseParametersList = (properties, strictOptional)=>{
+    return properties.map((symbol, i)=>{
+        var _symbol_getDeclarations;
+        const parameter = {
+            Name: symbol.name,
+            Description: undefined,
+            Type: "String",
+            Default: undefined,
+            DisplayIndex: i + 1
+        };
+        if (parameter.Name.length > 45) {
+            throw new Error(`Parameter name length >45 '${parameter.Name}'`);
+        }
+        let declaration = (_symbol_getDeclarations = symbol.getDeclarations()) == null ? void 0 : _symbol_getDeclarations[0];
+        let documentationComment = symbol.getDocumentationComment(undefined);
+        let checkLinksSymbol = symbol;
+        while(checkLinksSymbol !== undefined && declaration === undefined){
+            const links = checkLinksSymbol.links;
+            if (links == null ? void 0 : links.syntheticOrigin) {
+                var _links_syntheticOrigin_getDeclarations;
+                declaration = (_links_syntheticOrigin_getDeclarations = links.syntheticOrigin.getDeclarations()) == null ? void 0 : _links_syntheticOrigin_getDeclarations[0];
+                if (documentationComment.length === 0) {
+                    documentationComment = links.syntheticOrigin.getDocumentationComment(undefined);
+                }
+                checkLinksSymbol = links.syntheticOrigin;
+            }
+        }
+        if (declaration !== undefined) {
+            const rawDocTags = ts.getJSDocTags(declaration);
+            const dict = getTagDict(rawDocTags);
+            if (dict.summary) {
+                parameter.Description = dict.summary;
+            } else {
+                const comment = documentationComment.map((comment)=>comment.text).join(" ");
+                if (comment) {
+                    parameter.Description = comment;
+                }
+            }
+            if (dict.creatorType) {
+                parameter.Type = dict.creatorType;
+            } else {
+                const propertySignature = declaration;
+                if (propertySignature.type !== undefined) {
+                    const parsedType = parseTypeFromName(propertySignature.type.getText());
+                    if (parsedType !== undefined) {
+                        parameter.Type = parsedType;
+                    }
+                }
+            }
+            if (dict.default) {
+                parameter.Default = parseDefault(dict.default, parameter.Type);
+            }
+            if (strictOptional && declaration.kind === ts.SyntaxKind.PropertySignature) {
+                const propertySignature = declaration;
+                if (propertySignature.questionToken === undefined) {
+                    parameter.Required = true;
+                }
+            }
+        }
+        return parameter;
+    });
+};
+function getTagDict(tags) {
+    const dict = {};
+    for (const tag of tags){
+        dict[tag.tagName.text] = tag.comment;
+    }
+    return dict;
+}
+const getScriptingClassParameterdeclaration = (scriptingClass)=>{
+    for (const member of scriptingClass.node.members){
+        if (ts.isMethodDeclaration(member)) {
+            for(let index = 0; index < member.parameters.length; index++){
+                const parameter = member.parameters[index];
+                if (isScriptingClassParameterDeclaration(scriptingClass, member, index)) {
+                    return parameter;
+                }
+            }
+        }
+        if (ts.isConstructorDeclaration(member)) {
+            for(let index = 0; index < member.parameters.length; index++){
+                const parameter = member.parameters[index];
+                if (isScriptingClassParameterDeclaration(scriptingClass, member, index)) {
+                    return parameter;
+                }
+            }
+        }
+    }
+};
+const isScriptingClassParameterDeclaration = (scriptingClass, memberNode, parameterIndex)=>{
+    if (scriptingClass.type === "evaluator") {
+        var _memberNode_name;
+        return (memberNode == null ? void 0 : (_memberNode_name = memberNode.name) == null ? void 0 : _memberNode_name.getText()) == "Create" && parameterIndex === 2;
+    }
+    if (scriptingClass.type === "interactor") {
+        return memberNode.kind === ts.SyntaxKind.Constructor && parameterIndex === 0;
+    }
+    return false;
+};
+/**
+ * Finds interactors and evaluators within a script file
+ *
+ * @param {ts.Node} node
+ * @return {*}
+ */ const findScriptingClasses = (node)=>{
+    let body;
+    if (ts.isModuleDeclaration(node)) {
+        body = node.body;
+    }
+    if (body !== undefined && ts.isModuleDeclaration(body)) {
+        body = body.body;
+    }
+    const classes = [];
+    if (body !== undefined) {
+        ts.forEachChild(body, (child)=>{
+            if (!ts.isClassDeclaration(child)) {
+                return;
+            }
+            const scriptingClass = detectScriptingClass(child);
+            if (scriptingClass !== undefined) {
+                classes.push(scriptingClass);
+            }
+        });
+    }
+    return classes;
+};
+const detectScriptingClass = (node)=>{
+    var _node_heritageClauses, _node_heritageClauses1;
+    const isEvaluator = (_node_heritageClauses = node.heritageClauses) == null ? void 0 : _node_heritageClauses.some((clause)=>{
+        if (clause.token !== ts.SyntaxKind.ExtendsKeyword && clause.token !== ts.SyntaxKind.ImplementsKeyword) {
+            return false;
+        }
+        return clause.types.some((type)=>type.getText().includes("Evaluator"));
+    });
+    if (isEvaluator) {
+        return {
+            node,
+            type: "evaluator"
+        };
+    }
+    const isInteractor = (_node_heritageClauses1 = node.heritageClauses) == null ? void 0 : _node_heritageClauses1.some((clause)=>{
+        if (clause.token !== ts.SyntaxKind.ExtendsKeyword) {
+            return false;
+        }
+        return clause.types.some((type)=>type.getText().includes("Interactor"));
+    });
+    if (isInteractor) {
+        return {
+            node,
+            type: "interactor"
+        };
+    }
+};
+
+export { buildFolders, generateIndex, releaseFolder };
+//# sourceMappingURL=lib.mjs.map