@intelligentgraphics/ig.gfx.packager 3.1.0-alpha.1 → 3.1.0-alpha.2

package/lib/lib.mjs

@@ -1,21 +1,2652 @@
-export { b as buildFolders, a as buildFoldersWatch, c as generateIndex, r as releaseFolder } from './lib-5a3a2112.mjs';
-import 'path';
-import 'fs/promises';
-import 'terser';
-import 'fs';
-import 'resolve';
+import * as path from 'path';
+import * as fs$1 from 'fs/promises';
+import * as terser from 'terser';
+import { EOL } from 'os';
+import ts from 'typescript';
+import * as fs from 'fs';
+import { createWriteStream, createReadStream } from 'fs';
+import resolve from 'resolve';
 import 'write-pkg';
-import 'glob';
+import glob from 'glob';
 import 'write-json-file';
-import 'axios';
-import 'typescript';
-import 'typedoc';
-import 'events';
-import 'source-map-js';
-import 'ajv';
-import 'stream/promises';
-import 'child_process';
-import 'util';
-import 'simple-git';
-import 'jszip';
+import axios, { AxiosError } from 'axios';
+import typedoc from 'typedoc';
+import EventEmitter from 'events';
+import { SourceMapGenerator, SourceMapConsumer } from 'source-map-js';
+import Ajv from 'ajv';
+import { pipeline } from 'stream/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import simpleGit from 'simple-git';
+import JSZip from 'jszip';
+import { buffer } from 'node:stream/consumers';
+import { resolveNamespaces, resolveNamespaceFullName } from '@intelligentgraphics/declarationbundler';
+
+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;
+    }
+};
+/**
+ * Permission denied: An attempt was made to access a file in a way forbidden by its file access permissions.
+ *
+ * @param {unknown} error
+ */ const isErrorEACCES = (error)=>getNodeErrorCode(error) === "EACCES";
+/**
+ * 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";
+const isErrorEPERM = (error)=>getNodeErrorCode(error) === "EPERM";
+
+// Functionality related to working with a single package.
+const PACKAGE_FILE = "_Package.json";
+const INDEX_FILE = "_Index.json";
+const ANIMATION_FILE_SUFFIX = ".animation.json";
+function parseCreatorPackageName(manifest) {
+    const [domain, subdomain] = manifest.Package.split(".");
+    if (subdomain === undefined) {
+        throw new Error(`Expected "Package" field of the _Package.json file to contain a value in the form of Domain.SubDomain`);
+    }
+    return {
+        domain,
+        subdomain
+    };
+}
+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 consoleReporter = {
+    log (message) {
+        console.log(message);
+    },
+    error (message, _error) {
+        console.error(message);
+    }
+};
+const createPackageScopedReporter = (reporter, scope, index, total, maxNameLength = 15)=>{
+    const numLength = total === undefined ? undefined : total.toString().length;
+    const indexString = total === undefined || total < 2 ? "" : `${index.toString().padStart(numLength, "0")}/${total} `;
+    const identifierString = `${indexString}${scope.padEnd(maxNameLength)}`;
+    return {
+        log (message) {
+            reporter.log(`${identifierString} >> ${message}`);
+        },
+        error (message, error) {
+            reporter.error(`${identifierString} >> ${message}`, error);
+        }
+    };
+};
+
+const getPackageTypescriptFiles = (location)=>glob.sync("**/*.ts", {
+        absolute: true,
+        cwd: location.scriptsDir,
+        ignore: "node_modules/**/*"
+    });
+
+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 uploadPackageFromBuffer = async (session, { name, version }, buffer)=>{
+    try {
+        await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}`, buffer);
+    } catch (err) {
+        if (err instanceof AxiosError) {
+            var _err_response;
+            if (((_err_response = err.response) == null ? void 0 : _err_response.status) === 404) {
+                await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}/`, buffer);
+                return;
+            }
+            throw new Error(`Failed to upload package: ${err.message}`);
+        }
+        throw err;
+    }
+};
+const uploadPackageToUrl = async (url, path, buffer)=>{
+    const { data, status } = await axios.post(path, buffer, {
+        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;
+};
+
+function resolveScriptPackageEntryModule(location, manifest) {
+    let candidates = [
+        "index.ts"
+    ];
+    if (manifest.Type === "Context") {
+        candidates.push("Context.ts");
+    }
+    for (const candidate of candidates){
+        const candidatePath = path.join(location.scriptsDir, candidate);
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
+    }
+}
+function readScriptPackageTSConfig(location) {
+    const { config } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
+        try {
+            return fs.readFileSync(path, "utf8");
+        } catch  {
+            return undefined;
+        }
+    });
+    const parsedTsConfig = ts.parseJsonConfigFileContent(config, ts.sys, location.scriptsDir);
+    return parsedTsConfig;
+}
+function isScriptPackageModules(options) {
+    return options.module === ts.ModuleKind.ES2015;
+}
+
+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 createTSCBuildParticipant = (location, outputDir)=>(env)=>{
+        const files = getPackageTypescriptFiles(location);
+        try {
+            env.onBuildStart();
+            env.log("Compiling typescript files");
+            const compilerOptions = getCompilerOptions(location, outputDir);
+            const host = ts.createCompilerHost(compilerOptions);
+            host.getCurrentDirectory = ()=>location.scriptsDir;
+            let js;
+            let definitions;
+            let sourceMap;
+            host.writeFile = (fileName, data, writeByteOrderMark)=>{
+                if (fileName.endsWith(".js")) {
+                    js = data;
+                } else if (fileName.endsWith(".d.ts")) {
+                    definitions = data;
+                } else if (fileName.endsWith(".js.map")) {
+                    sourceMap = data;
+                }
+            };
+            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(ts.formatDiagnostics(allDiagnostics, host));
+                }
+                if (js === undefined || definitions === undefined) {
+                    throw new Error(`Unexpected: no js or definitions were created`);
+                }
+                env.onBuildEnd({
+                    type: "success",
+                    artefacts: {
+                        js: js.replace(`//# sourceMappingURL=out.js.map`, ""),
+                        declarations: definitions,
+                        sourceMap
+                    }
+                });
+            } else {
+                const error = ts.formatDiagnostics(allDiagnostics, host);
+                throw new Error(error);
+            }
+        } catch (err) {
+            env.onBuildEnd({
+                type: "error",
+                error: err.message
+            });
+        }
+        return {
+            destroy: ()=>{}
+        };
+    };
+const createTSCWatchBuildParticipant = (location, outputDir)=>{
+    return ({ onBuildStart, onBuildEnd })=>{
+        let state = {
+            diagnostics: [],
+            js: undefined,
+            definitions: undefined,
+            sourceMap: undefined
+        };
+        const customSys = {
+            ...ts.sys,
+            writeFile: (fileName, data, writeByteOrderMark)=>{
+                if (fileName.endsWith(".js")) {
+                    state.js = data;
+                } else if (fileName.endsWith(".d.ts")) {
+                    state.definitions = data;
+                } else if (fileName.endsWith(".js.map")) {
+                    state.sourceMap = data;
+                }
+            }
+        };
+        const registerDiagnostic = (diagnostic)=>{
+            switch(diagnostic.code){
+                // file not found - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4640
+                // probably deleted -> ignore
+                case 6053:
+                    return;
+                // no inputs were found - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L6838
+                // we don't care about this error. a user might have temporarily deleted the last ts file and will readd one later.
+                case 18003:
+                    return;
+            }
+            state.diagnostics.push(diagnostic);
+        };
+        const reportWatchStatusChanged = (diagnostic)=>{
+            switch(diagnostic.code){
+                // regular watch mode - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4567
+                case 6031:
+                // incremental watch mode - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4571
+                case 6032:
+                    // build start
+                    onBuildStart();
+                    break;
+                // found one error - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L5119
+                case 6193:
+                // found n or 0 errors - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L5123
+                case 6194:
+                    // build end
+                    const emitState = state;
+                    state = {
+                        diagnostics: [],
+                        js: undefined,
+                        definitions: undefined,
+                        sourceMap: undefined
+                    };
+                    if (emitState.diagnostics.length > 0) {
+                        const message = ts.formatDiagnostics(emitState.diagnostics, formattingHost);
+                        onBuildEnd({
+                            type: "error",
+                            error: message
+                        });
+                        return;
+                    }
+                    if (emitState.js === undefined || emitState.definitions === undefined) {
+                        onBuildEnd({
+                            type: "success",
+                            artefacts: {
+                                js: ""
+                            }
+                        });
+                        return;
+                    }
+                    onBuildEnd({
+                        type: "success",
+                        artefacts: {
+                            js: emitState.js.replace(`//# sourceMappingURL=out.js.map`, ""),
+                            declarations: emitState.definitions,
+                            sourceMap: emitState.sourceMap
+                        }
+                    });
+                    break;
+            }
+        };
+        const host = ts.createWatchCompilerHost(path.join(location.scriptsDir, "tsconfig.json"), getCompilerOptions(location, outputDir), customSys, ts.createSemanticDiagnosticsBuilderProgram, registerDiagnostic, reportWatchStatusChanged);
+        const formattingHost = {
+            getCanonicalFileName: (path)=>path,
+            getCurrentDirectory: host.getCurrentDirectory,
+            getNewLine: ()=>ts.sys.newLine
+        };
+        const watchProgram = ts.createWatchProgram(host);
+        return {
+            destroy: ()=>{
+                watchProgram.close();
+            }
+        };
+    };
+};
+const getCompilerOptions = (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: true,
+        inlineSources: 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
+    };
+    return compilerOptions;
+};
+
+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;
+};
+
+class BuildManager extends EventEmitter {
+    constructor(manifest, writer, reporter){
+        super(), this.manifest = manifest, this.writer = writer, this.reporter = reporter, this.participants = new Map(), this.states = new Map();
+    }
+    addParticipant(name, participant) {
+        this.participants.set(name, participant);
+    }
+    run() {
+        for (const [name] of this.participants){
+            this.states.set(name, {
+                type: "busy"
+            });
+        }
+        this.emit("start");
+        for (const [name, participant] of this.participants){
+            participant({
+                onBuildStart: ()=>{
+                    let alreadyBusy = false;
+                    for (const [name, state] of this.states){
+                        if (state.type === "busy") {
+                            alreadyBusy = true;
+                            continue;
+                        }
+                    }
+                    this.states.set(name, {
+                        type: "busy"
+                    });
+                    if (!alreadyBusy) {
+                        this.emit("start");
+                    }
+                },
+                onBuildEnd: (result)=>{
+                    this.states.set(name, result);
+                    this.maybeEmit();
+                },
+                log: (message)=>this.reporter.log(message)
+            });
+        }
+    }
+    maybeEmit() {
+        const errors = [];
+        const results = [];
+        for (const [_, state] of this.states){
+            if (state.type === "busy") {
+                return;
+            }
+            if (state.type === "success") {
+                results.push(state);
+            } else if (state.type === "error") {
+                errors.push(state.error);
+            }
+        }
+        if (errors.length > 0) {
+            this.emit("error", errors.join("\n"));
+            return;
+        }
+        const completeResult = {
+            js: ""
+        };
+        const sourceMapGenerator = new SourceMapGenerator();
+        for (const result of results){
+            if (result.artefacts.js) {
+                if (completeResult.js) {
+                    completeResult.js += "\n";
+                }
+                if (result.artefacts.sourceMap) {
+                    const lines = completeResult.js.split("\n").length - 1;
+                    const sourceMap = new SourceMapConsumer(JSON.parse(result.artefacts.sourceMap));
+                    const sources = new Set();
+                    sourceMap.eachMapping((mapping)=>{
+                        sourceMapGenerator.addMapping({
+                            generated: {
+                                line: lines + mapping.generatedLine,
+                                column: mapping.generatedColumn
+                            },
+                            original: mapping.originalLine !== null && mapping.originalColumn !== null ? {
+                                line: mapping.originalLine,
+                                column: mapping.originalColumn
+                            } : undefined,
+                            source: mapping.source,
+                            name: mapping.name
+                        });
+                        if (mapping.source !== null) {
+                            sources.add(mapping.source);
+                        }
+                    });
+                    for (const source of sources){
+                        const content = sourceMap.sourceContentFor(source);
+                        if (content !== null) {
+                            sourceMapGenerator.setSourceContent(source, content);
+                        }
+                    }
+                }
+                completeResult.js += result.artefacts.js;
+            }
+            if (result.artefacts.declarations) {
+                if (completeResult.declarations) {
+                    completeResult.declarations += "\n";
+                } else {
+                    completeResult.declarations = "";
+                }
+                completeResult.declarations += result.artefacts.declarations;
+            }
+        }
+        completeResult.sourceMap = sourceMapGenerator.toString();
+        this.writer(completeResult).then(()=>{
+            this.emit("build");
+        });
+    }
+}
+
+var animationSchema = {
+    $schema: "http://json-schema.org/draft-07/schema",
+    $id: "https://archive.intelligentgraphics.biz/schemas/gfx/animation.json",
+    $comment: "Version 2023-02-17, Source: ig.data.gfx/Specs/animation.json",
+    title: "Animation description format",
+    additionalProperties: false,
+    type: "object",
+    properties: {
+        $schema: {
+            type: "string"
+        },
+        Id: {
+            type: "string",
+            description: "Animation id, to be unique in the project scope. Needs to be a valid JavaScript identifier."
+        },
+        Animations: {
+            type: "array",
+            description: "Declaration of animation states for gfx objects",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    _: {
+                        type: "string",
+                        description: "Comment"
+                    },
+                    Path: {
+                        $ref: "#/definitions/igxcPath"
+                    },
+                    States: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            additionalProperties: false,
+                            properties: {
+                                Position: {
+                                    $ref: "#/definitions/vec3"
+                                },
+                                Rotation: {
+                                    $ref: "#/definitions/rotation"
+                                },
+                                Scaling: {
+                                    $ref: "#/definitions/vec3"
+                                },
+                                Visibility: {
+                                    type: "boolean"
+                                },
+                                Deformation: {
+                                    anyOf: [
+                                        {
+                                            type: "number"
+                                        },
+                                        {
+                                            type: "string"
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        Kinematics: {
+            oneOf: [
+                {
+                    $ref: "#/definitions/kinematicChain"
+                },
+                {
+                    type: "array",
+                    items: {
+                        $ref: "#/definitions/kinematicChain"
+                    }
+                }
+            ]
+        },
+        LinkedPoints: {
+            type: "object",
+            additionalProperties: {
+                type: "array",
+                items: {
+                    type: "string"
+                }
+            }
+        },
+        _: {
+            type: "string",
+            description: "Comment"
+        }
+    },
+    definitions: {
+        vec3: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                X: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Y: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Z: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                }
+            }
+        },
+        rotation: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                Q: {
+                    description: "If true, the rotation is considered to be a Quaternion. Otherwise, it's interpreted as Euler arcs and W will be ignored.",
+                    type: "boolean"
+                },
+                X: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Y: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Z: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                W: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                }
+            }
+        },
+        igxcPath: {
+            type: "string",
+            description: "Relative path of the target object",
+            pattern: "^((o|e)\\d+(\\.(o|e)\\d+)*|\\.)$"
+        },
+        param: {
+            type: "string",
+            pattern: "^Param\\d+$"
+        },
+        kinematicChain: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                GeometryBase: {
+                    type: "string"
+                },
+                Joints: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            Name: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        type: "string"
+                                    }
+                                ]
+                            },
+                            HeadX: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            HeadY: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            HeadZ: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            Tail: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            LimitLeft: {
+                                type: "number"
+                            },
+                            LimitRight: {
+                                type: "number"
+                            },
+                            LimitUp: {
+                                type: "number"
+                            },
+                            LimitDown: {
+                                type: "number"
+                            },
+                            FollowJointNode: {
+                                $ref: "#/definitions/igxcPath"
+                            },
+                            _TargetNodeForFollow: {
+                                type: "string"
+                            }
+                        }
+                    }
+                },
+                Target: {
+                    oneOf: [
+                        {
+                            $ref: "#/definitions/igxcPath"
+                        },
+                        {
+                            $ref: "#/definitions/param"
+                        },
+                        {
+                            type: "string",
+                            enum: [
+                                "subbase"
+                            ]
+                        }
+                    ]
+                },
+                Parent: {
+                    oneOf: [
+                        {
+                            $ref: "#/definitions/igxcPath"
+                        },
+                        {
+                            type: "string",
+                            enum: [
+                                "root"
+                            ]
+                        }
+                    ]
+                },
+                Tolerance: {
+                    type: "number"
+                },
+                MaxIterations: {
+                    type: "integer"
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                },
+                __: {
+                    type: "string",
+                    description: "Super Comment"
+                }
+            }
+        }
+    }
+};
+
+const createAnimationBuildParticipant = (location, manifest)=>{
+    return (env)=>{
+        env.onBuildStart();
+        bundleAnimations(location, manifest, env.log).then((result)=>{
+            env.onBuildEnd({
+                type: "success",
+                artefacts: {
+                    js: (result == null ? void 0 : result.js) ?? ""
+                }
+            });
+        }).catch((err)=>{
+            env.onBuildEnd({
+                type: "error",
+                error: err.message
+            });
+        });
+        return {
+            destroy: ()=>{}
+        };
+    };
+};
+const createAnimationWatchBuildParticipant = (location, manifest)=>(env)=>{
+        env.onBuildStart();
+        bundleAnimations(location, manifest, env.log).then((result)=>{
+            env.onBuildEnd({
+                type: "success",
+                artefacts: {
+                    js: (result == null ? void 0 : result.js) ?? ""
+                }
+            });
+        }).catch((err)=>{
+            env.onBuildEnd({
+                type: "error",
+                error: err.message
+            });
+        });
+        (async ()=>{
+            for await (const event of fs$1.watch(location.scriptsDir)){
+                var _event_filename;
+                if ((_event_filename = event.filename) == null ? void 0 : _event_filename.endsWith(".animation.json")) {
+                    env.onBuildStart();
+                    try {
+                        const result = await bundleAnimations(location, manifest, env.log);
+                        env.onBuildEnd({
+                            type: "success",
+                            artefacts: {
+                                js: (result == null ? void 0 : result.js) ?? ""
+                            }
+                        });
+                    } catch (err) {
+                        env.onBuildEnd({
+                            type: "error",
+                            error: err.message
+                        });
+                    }
+                }
+            }
+        })();
+        return {
+            destroy: ()=>{}
+        };
+    };
+const bundleAnimations = async (location, manifest, logStep)=>{
+    const animations = new Map();
+    for (const scriptFilePath of readPackageAnimationList(location)){
+        const content = await fs$1.readFile(scriptFilePath, {
+            encoding: "utf8"
+        });
+        let data;
+        try {
+            data = JSON.parse(content);
+        } catch (err) {
+            const relativePath = path.relative(location.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
+            });
+        }
+        if (!data.Id) {
+            const fileName = path.basename(scriptFilePath, ".animation.json");
+            data.Id = fileName;
+        }
+        (await getAnimationJsonValidation())(data);
+        delete data.$schema;
+        animations.set(data.Id, JSON.stringify(data));
+    }
+    if (animations.size > 0) {
+        const scope = manifest.Scope ?? manifest.Package;
+        const scopeParts = scope.split(".");
+        let js = createNamespace(scopeParts);
+        for (const [name, content] of animations){
+            js += `${scope}["${name}"] = ` + content + ";";
+            logStep(`Adding animation ${scope}.${name}`);
+        }
+        return {
+            js
+        };
+    }
+    return undefined;
+};
+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;
+};
+let validateAnimationJson;
+const getAnimationJsonValidation = async ()=>{
+    if (validateAnimationJson === undefined) {
+        validateAnimationJson = new Ajv({
+            coerceTypes: true,
+            allErrors: true,
+            removeAdditional: true,
+            useDefaults: "empty",
+            validateSchema: "log"
+        }).compile(animationSchema);
+    }
+    return validateAnimationJson;
+};
+
+// Stolen from ig.tools.core
+class PackageVersion {
+    static #_ = // https://regex101.com/r/90PEY9/1
+    this.fullTextMatcher = /(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?/;
+    static #_2 = 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);
+};
+
+async function buildFolders(options) {
+    if (options.outDir !== undefined && options.clean) {
+        await fs$1.rm(options.outDir, {
+            recursive: true
+        });
+    }
+    const baseReporter = options.reporter ?? consoleReporter;
+    const workspace = options.workspace;
+    const folders = options.packages;
+    let sortedPackages = sortPackagesByBuildOrder(folders);
+    let index = 1;
+    const manifests = new Map(sortedPackages.map((location)=>[
+            location,
+            readPackageCreatorManifest(location)
+        ]));
+    const maxNameLength = Array.from(manifests.values(), (manifest)=>manifest.Package.length).reduce((acc, length)=>Math.max(acc, length), 0);
+    for (const location of sortedPackages){
+        const tsConfig = await ensureTsConfig(location);
+        const data = manifests.get(location);
+        const reporter = options.preparedReporter ?? createPackageScopedReporter(baseReporter, data.Package, index, folders.length, maxNameLength);
+        const outputDirectory = options.outDir || location.scriptsDir;
+        await fs$1.mkdir(outputDirectory, {
+            recursive: true
+        });
+        const manager = new BuildManager(data, (result)=>writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, reporter), reporter);
+        if (options.banner) {
+            manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
+        }
+        const typescriptFiles = getPackageTypescriptFiles(location);
+        if (!typescriptFiles.some((file)=>path.basename(file).toLowerCase() === "version.ts")) {
+            manager.addParticipant("version", createVersionLogBuildParticipant(data));
+        }
+        if (typescriptFiles.length > 0) {
+            if (isScriptPackageModules(tsConfig.options)) {
+                const { createRollupBuildParticipant } = await import('./rollup-BITLKeAN.mjs');
+                manager.addParticipant("rollup", createRollupBuildParticipant(location, data, outputDirectory));
+            } else {
+                manager.addParticipant("tsc", createTSCBuildParticipant(location, outputDirectory));
+            }
+        }
+        manager.addParticipant("animation", createAnimationBuildParticipant(location, data));
+        await new Promise((resolve, reject)=>{
+            manager.addListener("start", ()=>{
+                reporter.log(`Build started`);
+            });
+            manager.addListener("error", (error)=>{
+                reject(new Error(error));
+            });
+            manager.addListener("build", ()=>{
+                reporter.log(`Build complete`);
+                resolve();
+            });
+            manager.run();
+        });
+        if (options.docs) {
+            reporter.log("Generating typedoc documentation");
+            await generateDocs(location, path.join(outputDirectory, `${data.Package}.d.ts`), path.join(workspace.path, "docs", data.Package), data.Package);
+        }
+        index++;
+    }
+}
+async function buildFoldersWatch(options) {
+    if (options.outDir !== undefined && options.clean) {
+        await fs$1.rm(options.outDir, {
+            recursive: true
+        });
+    }
+    const workspace = options.workspace;
+    const folders = options.packages;
+    let sortedPackages = sortPackagesByBuildOrder(folders);
+    let index = 1;
+    const manifests = new Map(sortedPackages.map((location)=>[
+            location,
+            readPackageCreatorManifest(location)
+        ]));
+    const maxNameLength = Array.from(manifests.values(), (manifest)=>manifest.Package.length).reduce((acc, length)=>Math.max(acc, length), 0);
+    for (const location of sortedPackages){
+        const tsConfig = await ensureTsConfig(location);
+        const baseReporter = options.reporter ?? consoleReporter;
+        const data = manifests.get(location);
+        const reporter = createPackageScopedReporter(baseReporter, data.Package, index, folders.length, maxNameLength);
+        const outputDirectory = options.outDir || location.scriptsDir;
+        await fs$1.mkdir(outputDirectory, {
+            recursive: true
+        });
+        const manager = new BuildManager(data, (result)=>writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, reporter), reporter);
+        if (options.banner) {
+            manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
+        }
+        const typescriptFiles = getPackageTypescriptFiles(location);
+        if (!typescriptFiles.some((file)=>path.basename(file).toLowerCase() === "version.ts")) {
+            manager.addParticipant("version", createVersionLogBuildParticipant(data));
+        }
+        if (typescriptFiles.length > 0) {
+            if (isScriptPackageModules(tsConfig.options)) {
+                const { createRollupWatchBuildParticipant } = await import('./rollup-BITLKeAN.mjs');
+                manager.addParticipant("rollup", createRollupWatchBuildParticipant(location, data, outputDirectory));
+            } else {
+                manager.addParticipant("tsc", createTSCWatchBuildParticipant(location, outputDirectory));
+            }
+        }
+        manager.addParticipant("animation", createAnimationWatchBuildParticipant(location, data));
+        await new Promise((resolve, reject)=>{
+            manager.addListener("start", ()=>{
+                reporter.log(`Build started`);
+            });
+            manager.addListener("error", (error)=>{
+                reporter.log(`Build failed: ${EOL}${error}`);
+                resolve();
+            });
+            manager.addListener("build", ()=>{
+                reporter.log(`Build complete`);
+                resolve();
+            });
+            manager.run();
+        });
+        index++;
+    }
+    await new Promise(()=>{});
+}
+async function writeBuildResult(buildResult, manifest, location, workspace, outputDirectory, minimize, reporter) {
+    let js = buildResult.js;
+    if (buildResult.sourceMap) {
+        js += `\n//# sourceMappingURL=${manifest.Package}.js.map`;
+    }
+    await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.js`), js, {
+        encoding: "utf8"
+    });
+    if (buildResult.declarations !== undefined) {
+        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.d.ts`), buildResult.declarations, {
+            encoding: "utf8"
+        });
+    }
+    if (buildResult.sourceMap !== undefined) {
+        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.js.map`), buildResult.sourceMap, {
+            encoding: "utf8"
+        });
+    }
+    if (minimize) {
+        reporter.log("Minifying the output");
+        const minifyResult = await terser.minify(js, {
+            ecma: 5,
+            sourceMap: {
+                content: buildResult.sourceMap,
+                includeSources: false
+            }
+        });
+        const minifiedPath = path.join(outputDirectory, `${manifest.Package}.min.js`);
+        await fs$1.writeFile(minifiedPath, minifyResult.code, {
+            encoding: "utf8"
+        });
+        if (minifyResult.map !== undefined) {
+            await fs$1.writeFile(minifiedPath + ".map", typeof minifyResult.map === "string" ? minifyResult.map : JSON.stringify(minifyResult.map), {
+                encoding: "utf8"
+            });
+        }
+    }
+    if (location.path.includes("Basics") && buildResult.declarations !== undefined) {
+        await fs$1.mkdir(path.join(workspace.path, "lib"), {
+            recursive: true
+        });
+        reporter.log("Copying basics definition file to the lib folder");
+        await fs$1.writeFile(path.join(workspace.path, "lib", `${manifest.Package}.d.ts`), buildResult.declarations, {
+            encoding: "utf8"
+        });
+    }
+}
+function createVersionLogBuildParticipant(manifest) {
+    return (env)=>{
+        env.onBuildStart();
+        const parsedVersion = manifest.Version !== undefined ? PackageVersion.extractFromLine(manifest.Version) : undefined;
+        let logText;
+        if (parsedVersion !== undefined) {
+            logText = parsedVersion.toDescriptionString(manifest.Package);
+        } else {
+            logText = manifest.Package;
+        }
+        logText += ".";
+        if (manifest.Copyright !== undefined) {
+            logText += " " + manifest.Copyright;
+        }
+        env.onBuildEnd({
+            type: "success",
+            artefacts: {
+                js: `console.log(${JSON.stringify(logText)})`
+            }
+        });
+        return {
+            destroy: ()=>{}
+        };
+    };
+}
+function createBannerCommentBuildParticipant(options) {
+    return (env)=>{
+        env.onBuildStart();
+        const banner = createBannerComment(options);
+        env.onBuildEnd({
+            type: "success",
+            artefacts: {
+                js: banner ?? "",
+                declarations: banner ?? ""
+            }
+        });
+        return {
+            destroy: ()=>{}
+        };
+    };
+}
+async function ensureTsConfig(location) {
+    const tsconfigPath = path.join(location.scriptsDir, "tsconfig.json");
+    try {
+        const content = JSON.parse(await fs$1.readFile(tsconfigPath, "utf8"));
+        applyTsConfigOptions(content);
+        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+        return ts.parseJsonConfigFileContent(content, ts.sys, location.scriptsDir);
+    } catch (err) {
+        if (!isErrorENOENT(err)) {
+            throw err;
+        }
+        const content = {};
+        applyTsConfigOptions(content);
+        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+        return ts.parseJsonConfigFileContent(content, ts.sys, location.scriptsDir);
+    }
+}
+function applyTsConfigOptions(data) {
+    var _data_compilerOptions_module, _data_compilerOptions;
+    if ((_data_compilerOptions = data.compilerOptions) == null ? void 0 : (_data_compilerOptions_module = _data_compilerOptions.module) == null ? void 0 : _data_compilerOptions_module.toLowerCase().startsWith("es")) {
+        data.compilerOptions = data.compilerOptions ?? {};
+        data.compilerOptions.target = "esnext";
+        data.compilerOptions.lib = [
+            "esnext",
+            "dom"
+        ];
+        data.compilerOptions.module = "es2015";
+        data.compilerOptions.moduleResolution = "node";
+    } else {
+        data.compilerOptions = data.compilerOptions ?? {};
+        data.compilerOptions.target = "es5";
+        data.compilerOptions.lib = [
+            "es5",
+            "dom"
+        ];
+    }
+}
+function 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;
+}
+function 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;
+};
+
+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();
+function getVersionFileHandler(location) {
+    const filePath = path.join(location.scriptsDir, "Version.ts");
+    function invalidVersionFile(versionFile, exists) {
+        return {
+            exists,
+            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;
+                        }
+                    }
+                }
+            }
+        };
+    }
+    function createVersionFileWriter(copyright = [
+        currentYear
+    ], copyrightStuff = "") {
+        return (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, false);
+    }
+    const versionFile = rawVersionFile.replace(/\n/g, "");
+    const match = versionFile.match(logRegex);
+    if (!match) {
+        return invalidVersionFile(versionFile, true);
+    }
+    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 {
+        exists: true,
+        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)));
+    if (creatorPackage.Package === "IG.GFX.Standard") {
+        const source = path.join(location.path, "Images");
+        if (fs.existsSync(source)) {
+            const images = fs.readdirSync(source);
+            for (const file of images){
+                const { ext } = path.parse(file);
+                switch(ext){
+                    case ".png":
+                    case ".jpeg":
+                    case ".jpg":
+                        break;
+                    default:
+                        continue;
+                }
+                archive.file(file, fs.createReadStream(path.join(source, file)));
+            }
+        }
+    }
+    return archive;
+};
+const runtimeScripts = [
+    "Interactor",
+    "Core",
+    "Mixed"
+];
+const notRuntimeScripts = [
+    "Context",
+    "Evaluator"
+];
+const buildArchiveFromPackage = async (reporter, packageLocation, data, binDir, minified = true)=>{
+    const { domain } = parseCreatorPackageName(data);
+    const scriptDirectories = [
+        packageLocation.path,
+        packageLocation.scriptsDir
+    ];
+    if (data.Package === "IG.GFX.Standard") {
+        reporter.log(`Including Images folder`);
+        scriptDirectories.push(path.join(packageLocation.path, "Images"));
+    }
+    const manifest = readPackageCreatorManifest(packageLocation);
+    if (manifest !== undefined) {
+        if (manifest.RunTime && notRuntimeScripts.includes(manifest.Type)) {
+            reporter.log("Setting script RunTime to false because of script type");
+            writePackageCreatorManifest(packageLocation, {
+                ...manifest,
+                RunTime: false
+            });
+        } else if (!manifest.RunTime && runtimeScripts.includes(manifest.Type)) {
+            reporter.log("Setting script RunTime to true because of script type");
+            writePackageCreatorManifest(packageLocation, {
+                ...manifest,
+                RunTime: true
+            });
+        }
+    }
+    let libFile;
+    try {
+        const libFilePath = minified ? path.join(binDir, `${data.Package}.min.js`) : path.join(binDir, `${data.Package}.js`);
+        libFile = fs.readFileSync(libFilePath, {
+            encoding: "utf8"
+        });
+    } catch (err) {
+        if (!isErrorENOENT(err)) {
+            throw err;
+        }
+    }
+    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. */`;
+    }
+    archive.file(`${data.Package}.js`, library);
+    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) {
+            reporter.error(`Script directory "${directory}" does not exist`);
+        }
+    }
+    return archive;
+};
+
+const createAssetServiceSessionManager = 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);
+            }
+        }
+    };
+};
+
+const synchronizeDependencies = async (workspaceLocation, creatorPackage, sessionManager, prompter, reporter, logUpToDate = false)=>{
+    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 == null ? void 0 : 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) {
+                reporter.log(`Package ${libraryCreatorPackage.Package} is uploaded both for Basics and ${targetSession.subDomain}. The package within ${targetSession.subDomain} will be used.`);
+            }
+            if (logUpToDate) {
+                reporter.log(`Package ${libraryCreatorPackage.Package} is already uploaded with the required version ${libraryVersion.toVersionString({})}`);
+            }
+            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 session = uploadTargetScope === "Basics" ? await sessionManager.getBasicsSession() : targetSession;
+        reporter.log(`Uploading package ${libraryCreatorPackage.Package} with version ${newVersionString} to ${session.domain}.${session.subDomain}`);
+        await uploadPackageFromBuffer(session, {
+            name: libraryCreatorPackage.Package,
+            version: newVersionString
+        }, await archive.generateAsync({
+            type: "nodebuffer"
+        }));
+    }
+};
+
+const execAsync = promisify(exec);
+const releaseFolder = async (options)=>{
+    const workspace = options.workspace;
+    const location = options.directory;
+    const versionFile = getVersionFileHandler(location);
+    const packageDescription = readPackageCreatorManifest(location);
+    const fullPackageName = packageDescription.Package;
+    const reporter = options.reporter ?? createPackageScopedReporter(consoleReporter, 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) {
+    // 	reporter.log(
+    // 		`Running npm install to make sure all dependencies are up to date`,
+    // 	);
+    // 	await execAsync(`npm install`, {
+    // 		encoding: "utf-8",
+    // 		cwd: workspace.path,
+    // 	});
+    // }
+    const binDir = options.outDir ?? getWorkspaceOutputPath(workspace);
+    await fs$1.mkdir(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
+        };
+    }
+    let zipFilePath = path.join(binDir, packageNameWithVersion + ".zip");
+    let uploadable = {
+        getStream: ()=>createReadStream(zipFilePath)
+    };
+    try {
+        if (options.pushOnly) {
+            const zipFileExists = await fs$1.stat(zipFilePath).catch((err)=>{
+                if (isErrorENOENT(err)) {
+                    return false;
+                }
+                return Promise.reject(err);
+            });
+            if (zipFileExists) {
+                throw new Error(`Expected a zip file to exist at path ${zipFilePath} since pushOnly is specified`);
+            }
+        } else {
+            const gitVersionInformation = await getVersionInformationFromGit(workspace, location);
+            if (versionFile.exists) {
+                versionFile.write(fullPackageName, newVersion);
+            }
+            const bannerText = sharedPackageJson !== undefined ? getWorkspaceBannerText(sharedPackageJson) : undefined;
+            await buildFolders({
+                ...options,
+                packages: [
+                    location
+                ],
+                banner: options.banner ? {
+                    text: bannerText,
+                    commit: gitVersionInformation.commit,
+                    commitDirty: gitVersionInformation.dirty,
+                    version: newVersion.toVersionString({
+                        buildNumber: true
+                    }),
+                    date: new Date(Date.now())
+                } : undefined,
+                preparedReporter: reporter
+            });
+            newVersion.preRelease = undefined;
+            try {
+                await fs$1.rm(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(`The IG.GFX.Standard package should be added as a dependency to provide the 'AnimationInteractor' used to display animations. Do you wish to add it now?`);
+                    if (install) {
+                        await execAsync(`npm install @intelligentgraphics/3d.ig.gfx.standard`, {
+                            encoding: "utf-8",
+                            cwd: workspace.path
+                        });
+                        await execAsync(`npm run postinstall`, {
+                            cwd: workspace.path
+                        });
+                    }
+                }
+            }
+            reporter.log(`Creating zip file`);
+            const archive = await buildArchiveFromPackage(reporter, location, packageDescription, binDir, options.minimize);
+            try {
+                const zipOutputStream = createWriteStream(zipFilePath);
+                await pipeline(archive.generateNodeStream(), zipOutputStream);
+            } catch (err) {
+                if (isErrorEACCES(err) || isErrorEPERM(err)) {
+                    reporter.log(`Could not create zip file in the bin directory because of a permissions error. Only using it in-memory`);
+                    uploadable = {
+                        getStream: ()=>archive.generateNodeStream()
+                    };
+                } else {
+                    throw err;
+                }
+            }
+        }
+        if (!options.noUpload) {
+            if (!options.authentication) {
+                throw new Error(`Expected authentication to be available`);
+            }
+            reporter.log(`Opening connection to IG.Asset.Server`);
+            const sessionManager = await createAssetServiceSessionManager({
+                url: options.service,
+                address: options.address,
+                domain: publishDomain,
+                subDomain: publishSubdomain,
+                authentication: options.authentication
+            });
+            try {
+                if (!options.skipDependencies) {
+                    try {
+                        await synchronizeDependencies(workspace, packageDescription, sessionManager, options.prompter, reporter);
+                    } catch (err) {
+                        reporter.error(`Failed to synchronize dependencies for ${packageDescription.Package}`, err);
+                    }
+                }
+                reporter.log(`Uploading package to ${publishDomain}.${publishSubdomain}`);
+                await uploadPackageFromBuffer(sessionManager.getTargetSession(), assetServerPackageDetails, await buffer(uploadable.getStream()));
+            } finally{
+                await sessionManager.destroy().catch((err)=>{
+                    reporter.error(`Failed to close IG.Asset.Server session(s)`, err);
+                });
+            }
+        }
+    } catch (err) {
+        versionFile.reset();
+        throw err;
+    }
+    if (newVersion.buildNumber >= 100 && !options.pushOnly) {
+        reporter.error("Copying zip to releases folder");
+        const zipFileName = `${packageNameWithVersion}.zip`;
+        const releasesPath = getPackageReleasesDirectory(location);
+        await fs$1.mkdir(releasesPath, {
+            recursive: true
+        });
+        await pipeline(uploadable.getStream(), createWriteStream(path.join(releasesPath, zipFileName)));
+    }
+};
+
+/**
+ * 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 arr = [];
+    const existingIndex = readPackageCreatorIndex(location) ?? [];
+    const manifest = readPackageCreatorManifest(location);
+    const compilerOptions = readScriptPackageTSConfig(location).options;
+    const isModule = compilerOptions.module === ts.ModuleKind.ES2015 || compilerOptions.module === ts.ModuleKind.ESNext;
+    const files = getPackageTypescriptFiles(location).filter((path)=>!ignore.some((suffix)=>path.endsWith(suffix)));
+    let program;
+    let namespaces;
+    if (isModule) {
+        const entryFilePath = resolveScriptPackageEntryModule(location, manifest);
+        if (entryFilePath === undefined) {
+            throw new Error(`Could not resolve entry module`);
+        }
+        const host = ts.createCompilerHost({}, true);
+        program = ts.createProgram([
+            entryFilePath
+        ], {
+            allowJs: true,
+            ...compilerOptions
+        }, host);
+        const entryFile = program.getSourceFile(entryFilePath);
+        if (entryFile === undefined) {
+            throw new Error(`Failed to find entry module`);
+        }
+        namespaces = resolveNamespaces(entryFile, program, host, manifest.Scope ?? manifest.Package);
+    } else {
+        program = ts.createProgram(files, {
+            allowJs: true
+        });
+        namespaces = [];
+    }
+    const typeChecker = program.getTypeChecker();
+    files.forEach((file)=>{
+        // Create a Program to represent the project, then pull out the
+        // source file to parse its AST.
+        const sourceFile = program.getSourceFile(file);
+        const namespace = namespaces.find((namespace)=>namespace.files.includes(sourceFile));
+        // Loop through the root AST nodes of the file
+        for (const scriptingClass of findScriptingClasses(sourceFile)){
+            if (scriptingClass.node.name === undefined) {
+                throw new Error(`Expected ${scriptingClass.type} class to have a name`);
+            }
+            let name;
+            if (isModule && namespace !== undefined) {
+                const moduleNamespace = resolveNamespaceFullName(namespace);
+                name = `${moduleNamespace}.${scriptingClass.node.name.text}`;
+            } else {
+                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 {*}
+ */ function* findScriptingClasses(node) {
+    for (const child of node.getChildren()){
+        if (!ts.isClassDeclaration(child)) {
+            yield* findScriptingClasses(child);
+            continue;
+        }
+        const scriptingClass = detectScriptingClass(child);
+        if (scriptingClass !== undefined) {
+            yield scriptingClass;
+        }
+    }
+}
+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, buildFoldersWatch, createAssetServiceSessionManager, generateIndex, isScriptPackageModules, readScriptPackageTSConfig, releaseFolder, resolveScriptPackageEntryModule, synchronizeDependencies };
 //# sourceMappingURL=lib.mjs.map