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

package/lib/lib.mjs

@@ -1,2517 +1,21 @@
-import * as path from 'path';
-import * as fs$1 from 'fs/promises';
-import * as terser from 'terser';
-import * as fs from 'fs';
-import { createWriteStream, createReadStream } from 'fs';
-import resolve from 'resolve';
+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 'write-pkg';
-import glob from 'glob';
+import 'glob';
 import 'write-json-file';
-import axios from 'axios';
-import ts from 'typescript';
-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';
-
-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";
-const parseCreatorPackageName = (manifest)=>{
-    const [domain, subdomain] = manifest.Package.split(".");
-    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, "	") + "\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, "	") + "\n");
-};
-const readPackageNpmManifest = (location)=>{
-    try {
-        return readNpmManifest(location.manifestDir);
-    } catch (err) {
-        if (isErrorENOENT(err)) {
-            return undefined;
-        }
-        throw err;
-    }
-};
-const readPackageAnimationList = (location)=>{
-    const directoryContent = fs.readdirSync(location.manifestDir);
-    const animationPathList = [];
-    for (const entry of directoryContent){
-        if (entry.endsWith(ANIMATION_FILE_SUFFIX)) {
-            const animationPath = path.join(location.manifestDir, entry);
-            animationPathList.push(animationPath);
-        }
-    }
-    return animationPathList;
-};
-const getPackageReleasesDirectory = (location)=>path.join(location.path, "Releases");
-
-/**
- * Detects a published package from a path.
- *
- * Can return undefined if the package is not installed.
- *
- * @param {string} resolveBasePath
- * @param {string} name
- * @return {*}  {(PublishedPackageLocation | undefined)}
- */ const detectPublishedPackageFromPath = (resolveBasePath, name)=>{
-    try {
-        const manifestPath = resolve.sync(name + "/package.json", {
-            basedir: resolveBasePath
-        });
-        const dir = path.dirname(manifestPath);
-        return {
-            _kind: "PublishedPackageLocation",
-            path: dir
-        };
-    } catch (err) {
-        return undefined;
-    }
-};
-const readPublishedPackageNpmManifest = (location)=>{
-    return readNpmManifest(location.path);
-};
-const readPublishedPackageCreatorManifest = (location)=>{
-    try {
-        const packageJsonPath = path.join(location.path, PACKAGE_FILE);
-        const packageJson = stripUtf8Bom(fs.readFileSync(packageJsonPath, {
-            encoding: "utf8"
-        }));
-        return JSON.parse(packageJson);
-    } catch (err) {
-        if (isErrorENOENT(err)) {
-            return undefined;
-        }
-        throw err;
-    }
-};
-const readPublishedPackageCreatorIndex = (location)=>{
-    try {
-        const packageJsonPath = path.join(location.path, INDEX_FILE);
-        const packageJson = stripUtf8Bom(fs.readFileSync(packageJsonPath, {
-            encoding: "utf8"
-        }));
-        const result = JSON.parse(packageJson);
-        return result;
-    } catch (err) {
-        if (isErrorENOENT(err)) {
-            return undefined;
-        }
-        throw err;
-    }
-};
-
-const readWorkspaceNpmManifest = (workspace)=>{
-    try {
-        return readNpmManifest(workspace.path);
-    } catch (err) {
-        if (isErrorENOENT(err)) {
-            throw new Error(`Expected a package.json file to exist in ${workspace.path}. See packager readme for instructions on how to create the package.json.`);
-        }
-        throw err;
-    }
-};
-const getWorkspaceOutputPath = (workspace)=>path.join(workspace.path, "bin");
-
-// /**
-//  * Determines the implicit dependencies of a an actual data workspace package.
-//  *
-//  * An implicit dependency is a dependency that is installed for the workspace and has the same runtime environment (evaluator, interactor) as the package.
-//  *
-//  * @param {WorkspaceLocation} workspace
-//  * @param {CreatorPackage} creatorPackage
-//  * @returns {PublishedPackageLocation[]}
-//  */
-// export const determinePackageImplicitDependencies = (
-// 	workspace: WorkspaceLocation,
-// 	creatorPackage: CreatorPackage,
-// ): PublishedPackageLocation[] => {
-// 	const libraries = determineWorkspaceIGLibraries(workspace);
-// 	const results: PublishedPackageLocation[] = [];
-// 	for (const librarylocation of libraries) {
-// 		const libraryManifest =
-// 			readPublishedPackageCreatorManifest(librarylocation);
-// 		if (
-// 			libraryManifest !== undefined &&
-// 			(libraryManifest.Type === "Mixed" ||
-// 				libraryManifest.RunTime === creatorPackage.RunTime)
-// 		) {
-// 			results.push(librarylocation);
-// 		}
-// 	}
-// 	return results;
-// };
-/**
- * Recursively determines all installed ig libraries for a workspace.
- *
- * @param {WorkspaceLocation} workspace
- * @returns {PublishedPackageLocation[]}
- */ const determineWorkspaceIGLibraries = (workspace)=>{
-    const manifest = readWorkspaceNpmManifest(workspace);
-    const libraries = collectIGLibraries(workspace, manifest);
-    const results = new Map();
-    for (const location of libraries){
-        const manifest = readPublishedPackageNpmManifest(location);
-        if (!results.has(manifest.name)) {
-            results.set(manifest.name, location);
-        }
-    }
-    return Array.from(results.values());
-};
-const collectIGLibraries = (workspace, manifest)=>{
-    if (!manifest.dependencies) {
-        return [];
-    }
-    const runtimeDependencies = Object.getOwnPropertyNames(manifest.dependencies);
-    const result = [];
-    for (const runtimeDependency of runtimeDependencies){
-        var _runtimeManifest_ig;
-        const location = detectPublishedPackageFromPath(workspace.path, runtimeDependency);
-        if (location === undefined) {
-            continue;
-        }
-        const runtimeManifest = readPublishedPackageNpmManifest(location);
-        // packages need to explicitly be marked as ig scriptingLibraries
-        if ((_runtimeManifest_ig = runtimeManifest.ig) == null ? void 0 : _runtimeManifest_ig.scriptingLibrary) {
-            result.push(location);
-            result.push(...collectIGLibraries(workspace, runtimeManifest));
-        }
-    }
-    return result;
-};
-
-const readStringFromFile = (filePath)=>fs.readFileSync(filePath, {
-        encoding: "utf8"
-    });
-const readStringFromFileOrUndefined = (filePath)=>{
-    try {
-        return readStringFromFile(filePath);
-    } catch (err) {
-        if (!isErrorENOENT(err)) {
-            throw err;
-        }
-        return undefined;
-    }
-};
-
-const logPackageMessage = (name, step, index, total, 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}${name.padEnd(maxNameLength)}`;
-    console.log(`${identifierString} >> ${step}`);
-};
-
-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 uploadPackageFromStream = async (session, { name, version }, stream)=>{
-    await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}/`, stream);
-};
-const uploadPackageToUrl = async (url, path, stream)=>{
-    const { data, status } = await axios.post(path, stream, {
-        baseURL: url
-    });
-    let objectBody;
-    if (typeof data === "string") {
-        try {
-            objectBody = JSON.parse(data);
-        } catch (err) {}
-    } else if (typeof data === "object") {
-        objectBody = data;
-    }
-    if (objectBody !== undefined) {
-        if ("state" in objectBody && objectBody.state !== "SUCCESS") {
-            throw new Error(objectBody.response ?? objectBody.state);
-        }
-    }
-    if (status >= 400) {
-        if (objectBody !== undefined) {
-            let text_1 = "";
-            for(const key in objectBody){
-                text_1 += key + ": \n";
-                if (typeof objectBody[key] === "object") {
-                    text_1 += JSON.stringify(objectBody[key], undefined, 2);
-                } else {
-                    text_1 += objectBody[key];
-                }
-                text_1 += "\n\n";
-            }
-            throw new Error(text_1);
-        }
-        throw new Error(data);
-    }
-    return data;
-};
-const getExistingPackages = async (session)=>{
-    const { data } = await axios.get(`Script/GetInformation/${session.sessionId}`, {
-        baseURL: session.url,
-        validateStatus: (status)=>status === 404 || status === 200
-    }).catch((err)=>{
-        throw new Error(`Failed to get existing packages: ${err.message}`);
-    });
-    return data;
-};
-
-const tryReadTsConfig = (location)=>{
-    const { config } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
-        try {
-            return fs.readFileSync(path, "utf8");
-        } catch  {
-            return undefined;
-        }
-    });
-    return config;
-};
-const createTSCBuildParticipant = (location, outputDir)=>(env)=>{
-        const files = getPackageTypescriptFiles(location);
-        if (files.length === 0) {
-            env.onBuildStart();
-            env.onBuildEnd({
-                type: "success",
-                artefacts: {
-                    js: "",
-                    definitions: ""
-                }
-            });
-            return {
-                destroy: ()=>{}
-            };
-        }
-        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(allDiagnostics.map(createErrorMessage).join("\n"));
-                }
-                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`, ""),
-                        definitions,
-                        sourceMap
-                    }
-                });
-            } else {
-                const error = allDiagnostics.map(createErrorMessage).join("\n");
-                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 reportDiagnostic = (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 = emitState.diagnostics.map(createErrorMessage).join("\n");
-                        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`, ""),
-                            definitions: emitState.definitions,
-                            sourceMap: emitState.sourceMap
-                        }
-                    });
-                    break;
-            }
-        };
-        const host = ts.createWatchCompilerHost(path.join(location.scriptsDir, "tsconfig.json"), getCompilerOptions(location, outputDir), customSys, ts.createSemanticDiagnosticsBuilderProgram, reportDiagnostic, reportWatchStatusChanged);
-        const watchProgram = ts.createWatchProgram(host);
-        const files = getPackageTypescriptFiles(location);
-        if (files.length === 0) {
-            onBuildStart();
-            onBuildEnd({
-                type: "success",
-                artefacts: {
-                    js: "",
-                    definitions: ""
-                }
-            });
-        }
-        return {
-            destroy: ()=>{
-                watchProgram.close();
-            }
-        };
-    };
-};
-const createErrorMessage = (diagnostic)=>{
-    if (!diagnostic.file) {
-        return `${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
-    }
-    const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-    return `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`;
-};
-const 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, logStep){
-        super();
-        this.manifest = manifest;
-        this.writer = writer;
-        this.logStep = logStep;
-        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: this.logStep
-            });
-        }
-    }
-    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: {
-                                line: mapping.originalLine,
-                                column: mapping.originalColumn
-                            },
-                            source: mapping.source,
-                            name: mapping.name
-                        });
-                        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.definitions) {
-                if (completeResult.definitions) {
-                    completeResult.definitions += "\n";
-                } else {
-                    completeResult.definitions = "";
-                }
-                completeResult.definitions += result.artefacts.definitions;
-            }
-        }
-        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)){
-                if (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;
-};
-
-const buildFolders = async (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){
-        await ensureTsConfig(location);
-        const data = manifests.get(location);
-        const logStep = (step)=>logPackageMessage(data.Package, step, 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, logStep), logStep);
-        if (options.banner) {
-            manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
-        }
-        manager.addParticipant("tsc", createTSCBuildParticipant(location, outputDirectory));
-        manager.addParticipant("animation", createAnimationBuildParticipant(location, data));
-        await new Promise((resolve, reject)=>{
-            manager.addListener("start", ()=>{
-                logStep(`Build started`);
-            });
-            manager.addListener("error", (error)=>{
-                reject(new Error(error));
-            });
-            manager.addListener("build", ()=>{
-                logStep(`Build complete`);
-                resolve();
-            });
-            manager.run();
-        });
-        if (options.docs) {
-            logStep("Generating typedoc documentation");
-            await generateDocs(location, path.join(outputDirectory, `${data.Package}.d.ts`), path.join(workspace.path, "docs", data.Package), data.Package);
-        }
-        index++;
-    }
-};
-const buildFoldersWatch = async (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){
-        await ensureTsConfig(location);
-        const data = manifests.get(location);
-        const currentIndex = index;
-        const logStep = (step)=>logPackageMessage(data.Package, step, currentIndex, 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, logStep), logStep);
-        if (options.banner) {
-            manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
-        }
-        manager.addParticipant("tsc", createTSCWatchBuildParticipant(location, outputDirectory));
-        manager.addParticipant("animation", createAnimationWatchBuildParticipant(location, data));
-        await new Promise((resolve, reject)=>{
-            manager.addListener("start", ()=>{
-                logStep(`Build started`);
-            });
-            manager.addListener("error", (error)=>{
-                logStep(`Build failed: ${error}`);
-                resolve();
-            });
-            manager.addListener("build", ()=>{
-                logStep(`Build complete`);
-                resolve();
-            });
-            manager.run();
-        });
-        index++;
-    }
-    await new Promise(()=>{});
-};
-const writeBuildResult = async (buildResult, manifest, location, workspace, outputDirectory, minimize, logStep)=>{
-    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.definitions !== undefined) {
-        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.d.ts`), buildResult.definitions, {
-            encoding: "utf8"
-        });
-    }
-    if (buildResult.sourceMap !== undefined) {
-        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.js.map`), buildResult.sourceMap, {
-            encoding: "utf8"
-        });
-    }
-    if (minimize) {
-        logStep("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.definitions !== undefined) {
-        await fs$1.mkdir(path.join(workspace.path, "lib"), {
-            recursive: true
-        });
-        logStep("Copying basics definition file to the lib folder");
-        await fs$1.writeFile(path.join(workspace.path, "lib", `${manifest.Package}.d.ts`), buildResult.definitions, {
-            encoding: "utf8"
-        });
-    }
-};
-const createBannerCommentBuildParticipant = (options)=>(env)=>{
-        env.onBuildStart();
-        const banner = createBannerComment(options);
-        env.onBuildEnd({
-            type: "success",
-            artefacts: {
-                js: banner ?? "",
-                definitions: banner ?? ""
-            }
-        });
-        return {
-            destroy: ()=>{}
-        };
-    };
-const ensureTsConfig = async (location)=>{
-    const tsconfigPath = path.join(location.scriptsDir, "tsconfig.json");
-    try {
-        const content = JSON.parse(await fs$1.readFile(tsconfigPath, "utf8"));
-        applyTsConfigOption(content);
-        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "	"), "utf8");
-    } catch (err) {
-        if (!isErrorENOENT(err)) {
-            throw err;
-        }
-        const content = {};
-        applyTsConfigOption(content);
-        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "	"), "utf8");
-    }
-};
-const applyTsConfigOption = (data)=>{
-    data.compilerOptions = data.compilerOptions ?? {};
-    data.compilerOptions.target = "es5";
-    data.compilerOptions.lib = [
-        "es5",
-        "dom"
-    ];
-};
-const sortPackagesByBuildOrder = (folders)=>{
-    const packages = Array.from(folders).reduce((acc, location)=>{
-        const data = readPackageNpmManifest(location);
-        if (data !== undefined) {
-            acc[data.name] = {
-                data,
-                location
-            };
-        } else {
-            acc[location.path] = {
-                data: undefined,
-                location
-            };
-        }
-        return acc;
-    }, {});
-    const packageDependencies = Object.getOwnPropertyNames(packages).reduce((acc, packageName)=>{
-        const packageData = packages[packageName];
-        if (packageData.data === undefined) {
-            acc[packageName] = [];
-        } else {
-            acc[packageName] = Object.getOwnPropertyNames({
-                ...packageData.data.devDependencies,
-                ...packageData.data.dependencies,
-                ...packageData.data.peerDependencies
-            }).filter((packageName)=>packages[packageName] !== undefined);
-        }
-        return acc;
-    }, {});
-    const sortedPackages = toposort(packageDependencies);
-    const result = [];
-    for (const packageName of sortedPackages){
-        const location = packages[packageName].location;
-        if (readPackageCreatorManifest(location).Package.endsWith(".Basics")) {
-            result.unshift(location);
-        } else {
-            result.push(location);
-        }
-    }
-    return result;
-};
-const createBannerComment = (banner)=>{
-    const bannerParts = [];
-    if (banner.text) {
-        bannerParts.push(" * " + banner.text);
-    }
-    {
-        const details = [];
-        if (banner.version) {
-            details.push(`Version: ${banner.version}`);
-        }
-        if (banner.commit) {
-            if (banner.commitDirty) {
-                details.push(`Commit: ${banner.commit} (dirty)`);
-            } else {
-                details.push(`Commit: ${banner.commit}`);
-            }
-        }
-        if (banner.date) {
-            details.push(`Date: ${banner.date.toISOString()}`);
-        }
-        const detailsText = details.map((line)=>` * ${line}`).join("\n");
-        if (detailsText) {
-            bannerParts.push(detailsText);
-        }
-    }
-    const bannerText = bannerParts.join("\n\n");
-    if (bannerText) {
-        return `/*
-${bannerText}
-*
-* @preserve			
-*/`;
-    }
-    return undefined;
-};
-
-const getVersionInformationFromGit = async (workspaceLocation, packageLocation)=>{
-    try {
-        var _log_latest, _log_latest1;
-        const git = simpleGit({
-            baseDir: workspaceLocation.path
-        });
-        // check wether the files for a folder are changed
-        // if so, mark as dirty
-        const diff = await git.diffSummary();
-        const dirty = diff.files.some((file)=>{
-            if (file.file.toLowerCase().includes("releases") || file.file.toLowerCase().endsWith("version.ts") || file.file.toLowerCase().endsWith("package.json")) {
-                return false;
-            }
-            const fullPath = path.resolve(workspaceLocation.path, file.file);
-            const relativePath = path.relative(packageLocation.path, fullPath);
-            return !relativePath.startsWith("..");
-        });
-        const log = await git.log({
-            maxCount: 1
-        });
-        const commit = !((_log_latest = log.latest) == null ? void 0 : _log_latest.hash) ? undefined : log.latest.hash.substring(0, 7);
-        return {
-            commit,
-            dirty,
-            commitDate: (_log_latest1 = log.latest) == null ? void 0 : _log_latest1.date
-        };
-    } catch (err) {
-        return {};
-    }
-};
-
-const getWorkspaceBannerText = (manifest)=>{
-    var _manifest_packager;
-    let bannerText = manifest == null ? void 0 : (_manifest_packager = manifest.packager) == null ? void 0 : _manifest_packager.banner;
-    if (bannerText) {
-        const match = bannerText.match(/Copyright \(C\) (\d+)( ?- ?(\d+))?/);
-        if (match !== null) {
-            const startYear = parseInt(match[1]);
-            const endYear = new Date().getFullYear();
-            if (startYear !== endYear) {
-                bannerText = bannerText.replace(match[0], `Copyright (C) ${startYear} - ${endYear}`);
-            } else {
-                bannerText = bannerText.replace(match[0], `Copyright (C) ${startYear}`);
-            }
-        }
-    }
-    return bannerText;
-};
-
-// Stolen from ig.tools.core
-class PackageVersion {
-    static #_ = // https://regex101.com/r/90PEY9/1
-    this.fullTextMatcher = /(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?/;
-    static #_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);
-};
-
-const parseVersionFromString = (input)=>{
-    if (input === undefined) {
-        throw new Error(`Can not parse version from undefined`);
-    }
-    let match;
-    let major;
-    let minor;
-    let patch;
-    let build;
-    let preReleaseType;
-    let preReleaseNumber;
-    if (// first try to find a full match with build number
-    (match = input.match(/(\d+)\.(\d+)\.(\d+)\.(\d+)(-([^\.]+)\.(\d+))?/)) !== null) {
-        [, major, minor, patch, build, preReleaseType, preReleaseNumber] = match;
-    } else if ((match = input.match(/(\d+)\.(\d+)\.(\d+)(-([^\.]+)\.(\d+))?/)) !== null) {
-        [, major, minor, patch, , preReleaseType, preReleaseNumber] = match;
-    }
-    if (match === null) {
-        throw new Error(`Could not parse version from input: ${input}`);
-    }
-    let preRelease = undefined;
-    let buildNumber = 100;
-    if (preReleaseType && preReleaseNumber) {
-        preRelease = {
-            type: preReleaseType,
-            version: parseInt(preReleaseNumber)
-        };
-    }
-    if (build) {
-        buildNumber = Number(build);
-    } else if (input) {
-        const descriptionMatch = input.match(/(\d+)\)$/);
-        if (descriptionMatch) {
-            buildNumber = parseInt(descriptionMatch[1]);
-        }
-    }
-    return new PackageVersion(parseInt(major), parseInt(minor), parseInt(patch), preRelease, buildNumber);
-};
-// 1000001001 -> 1.0.1.1
-// 1002017001 -> 1.2.17.1
-const parseVersionFromNumericVersion = (version)=>{
-    const major = Math.floor(version / 1000000000);
-    const minor = Math.floor(version % 1000000000 / 1000000);
-    const patch = Math.floor(version % 1000000 / 1000);
-    const buildNumber = version % 1000;
-    return new PackageVersion(major, minor, patch, undefined, buildNumber);
-};
-
-// https://regex101.com/r/LtGAu5/1
-const logRegex = /console\.log\(\s*"([\w\s\.\(\)]+)\ *Copyright[\w\s\(\)\.]+(\d{4}|\d{4} - \d{4})([\w\s\(\)\.]+)?",?\s*\)/i;
-const currentYear = new Date(Date.now()).getFullYear();
-const getVersionFileHandler = (location)=>{
-    const filePath = path.join(location.scriptsDir, "Version.ts");
-    const invalidVersionFile = (versionFile)=>({
-            version: undefined,
-            write: (name, newVersion)=>{
-                const scriptsContent = fs.readdirSync(location.scriptsDir);
-                const tsFiles = scriptsContent.filter((file)=>file.endsWith(".ts"));
-                if (tsFiles.length > 0) {
-                    return createVersionFileWriter([
-                        currentYear
-                    ], "")(name, newVersion);
-                }
-            },
-            reset: ()=>{
-                if (versionFile !== undefined) {
-                    fs.writeFileSync(filePath, versionFile, {
-                        encoding: "utf8"
-                    });
-                } else {
-                    try {
-                        fs.rmSync(filePath);
-                    } catch (err) {
-                        if (!isErrorENOENT(err)) {
-                            throw err;
-                        }
-                    }
-                }
-            }
-        });
-    const createVersionFileWriter = (copyright = [
-        currentYear
-    ], copyrightStuff = "")=>(name, newVersion)=>{
-            const descriptionText = newVersion.toDescriptionString(name);
-            const copyrightText = createYearString(copyright);
-            const result = `console.log("${descriptionText}. Copyright (C) ${copyrightText}${copyrightStuff}");`;
-            fs.writeFileSync(filePath, result, {
-                encoding: "utf-8"
-            });
-        };
-    let rawVersionFile = readStringFromFileOrUndefined(filePath);
-    if (rawVersionFile === undefined) {
-        return invalidVersionFile(rawVersionFile);
-    }
-    const versionFile = rawVersionFile.replace(/\n/g, "");
-    const match = versionFile.match(logRegex);
-    if (!match) {
-        return invalidVersionFile(versionFile);
-    }
-    const [_full, _description, copyright, copyrightStuff] = match;
-    const copyrightYears = copyright.match(/^(\d+)( ?- ?(\d+))?$/);
-    let years;
-    if (copyrightYears === null) {
-        years = [
-            currentYear
-        ];
-    } else {
-        years = [
-            Number(copyrightYears[1]),
-            currentYear
-        ];
-    }
-    return {
-        write: createVersionFileWriter(years, copyrightStuff),
-        reset: ()=>{
-            fs.writeFileSync(filePath, versionFile, {
-                encoding: "utf8"
-            });
-        }
-    };
-};
-const createYearString = (years)=>{
-    if (years[1] === undefined || years[0] === years[1]) {
-        return years[0].toString();
-    }
-    return `${years[0]} - ${years[1]}`;
-};
-
-const buildArchiveFromPublishedPackage = (location, manifest, creatorPackage)=>{
-    const archive = new JSZip();
-    archive.file(PACKAGE_FILE, JSON.stringify(creatorPackage, null, 2));
-    const index = readPublishedPackageCreatorIndex(location);
-    if (index !== undefined) {
-        archive.file(INDEX_FILE, JSON.stringify(index, null, 2));
-    }
-    archive.file(manifest.main, fs.createReadStream(path.join(location.path, manifest.main)));
-    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 (packageLocation, data, binDir, minified = true)=>{
-    const { domain } = parseCreatorPackageName(data);
-    const logStep = (step)=>logPackageMessage(data.Package, step);
-    const scriptDirectories = [
-        packageLocation.path,
-        packageLocation.scriptsDir
-    ];
-    if (data.Package === "IG.GFX.Standard") {
-        logStep(`Including Images folder`);
-        scriptDirectories.push(path.join(packageLocation.path, "Images"));
-    }
-    const manifest = readPackageCreatorManifest(packageLocation);
-    if (manifest !== undefined) {
-        if (manifest.RunTime && notRuntimeScripts.includes(manifest.Type)) {
-            logStep("Setting script RunTime to false because of script type");
-            writePackageCreatorManifest(packageLocation, {
-                ...manifest,
-                RunTime: false
-            });
-        } else if (!manifest.RunTime && runtimeScripts.includes(manifest.Type)) {
-            logStep("Setting script RunTime to true because of script type");
-            writePackageCreatorManifest(packageLocation, {
-                ...manifest,
-                RunTime: true
-            });
-        }
-    }
-    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) {
-            console.error(`Script directory "${directory}" does not exist`);
-        }
-    }
-    return archive;
-};
-
-const execAsync = promisify(exec);
-const releaseFolder = async (options)=>{
-    const workspace = options.workspace;
-    const location = options.directory;
-    const { write: writeVersionFile, reset: resetVersionFile } = getVersionFileHandler(location);
-    const packageDescription = readPackageCreatorManifest(location);
-    const fullPackageName = packageDescription.Package;
-    const { domain, subdomain } = parseCreatorPackageName(packageDescription);
-    const publishDomain = options.domain ?? domain;
-    const publishSubdomain = options.subdomain ?? subdomain;
-    const sharedPackageJson = readWorkspaceNpmManifest(workspace);
-    let newVersion;
-    try {
-        newVersion = parseVersionFromString(options.newVersion);
-    } catch (err) {
-        throw new Error(`Please enter a version in this format 1.0.0.100`);
-    }
-    packageDescription.Version = newVersion.toVersionString({
-        buildNumber: true
-    });
-    writePackageCreatorManifest(location, packageDescription);
-    if (newVersion.buildNumber < 100) {
-        newVersion.preRelease = {
-            type: "beta",
-            version: newVersion.buildNumber
-        };
-    } else if (newVersion.buildNumber > 100) {
-        newVersion.preRelease = {
-            type: "patch",
-            version: newVersion.buildNumber - 100
-        };
-    }
-    if (sharedPackageJson !== undefined) {
-        logPackageMessage(packageDescription.Package, `Running npm install to make sure all dependencies are up to date`);
-        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);
-            writeVersionFile(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
-            });
-            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
-                        });
-                    }
-                }
-            }
-            logPackageMessage(packageDescription.Package, `Creating zip file`);
-            const archive = await buildArchiveFromPackage(location, packageDescription, binDir, options.minimize);
-            try {
-                const zipOutputStream = createWriteStream(zipFilePath);
-                await pipeline(archive.generateNodeStream(), zipOutputStream);
-            } catch (err) {
-                if (isErrorEACCES(err) || isErrorEPERM(err)) {
-                    logPackageMessage(packageDescription.Package, `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`);
-            }
-            logPackageMessage(packageDescription.Package, `Opening connection to IG.Asset.Server`);
-            const sessionManager = await createSessionManager({
-                url: options.service,
-                address: options.address,
-                domain: publishDomain,
-                subDomain: publishSubdomain,
-                authentication: options.authentication
-            });
-            try {
-                if (!options.skipDependencies) {
-                    await ensureRequiredVersions(workspace, packageDescription, sessionManager, options.prompter);
-                }
-                logPackageMessage(packageDescription.Package, `Uploading package to ${publishDomain}.${publishSubdomain}`);
-                await uploadPackageFromStream(sessionManager.getTargetSession(), assetServerPackageDetails, uploadable.getStream());
-            } finally{
-                await sessionManager.destroy().catch((err)=>{
-                    logPackageMessage(packageDescription.Package, `Failed to close IG.Asset.Server session(s): ${err}`);
-                });
-            }
-        }
-    } catch (err) {
-        resetVersionFile();
-        throw err;
-    }
-    if (newVersion.buildNumber >= 100 && !options.pushOnly) {
-        logPackageMessage(fullPackageName, "Copying zip to releases folder");
-        const zipFileName = `${packageNameWithVersion}.zip`;
-        const releasesPath = getPackageReleasesDirectory(location);
-        await fs$1.mkdir(releasesPath, {
-            recursive: true
-        });
-        await pipeline(uploadable.getStream(), createWriteStream(path.join(releasesPath, zipFileName)));
-    }
-};
-const ensureRequiredVersions = async (workspaceLocation, creatorPackage, sessionManager, prompter)=>{
-    const libraries = determineWorkspaceIGLibraries(workspaceLocation);
-    // If there are no libraries, we don't need to check for required versions
-    if (libraries.length === 0) {
-        return true;
-    }
-    const targetSession = sessionManager.getTargetSession();
-    const rawUploadedPackages = await getExistingPackages(targetSession);
-    const uploadedPackages = rawUploadedPackages.map((entry)=>{
-        let version;
-        try {
-            version = parseVersionFromNumericVersion(entry.numericVersion);
-        } catch (err) {
-            throw new Error(`Encountered invalid format for version ${entry.numericVersion}`);
-        }
-        if (version.buildNumber < 100) {
-            version.preRelease = {
-                type: "beta",
-                version: version.buildNumber
-            };
-        } else if (version.buildNumber > 100) {
-            version.preRelease = {
-                type: "patch",
-                version: version.buildNumber - 100
-            };
-        }
-        return {
-            ...entry,
-            version
-        };
-    });
-    for (const libraryLocation of libraries){
-        const libraryManifest = readPublishedPackageNpmManifest(libraryLocation);
-        const libraryCreatorPackage = readPublishedPackageCreatorManifest(libraryLocation);
-        if (libraryCreatorPackage === undefined || libraryManifest.main === undefined || libraryCreatorPackage.Package === creatorPackage.Package) {
-            continue;
-        }
-        const libraryVersion = PackageVersion.extractFromLine(libraryManifest.version);
-        if (libraryVersion.preRelease) {
-            libraryVersion.buildNumber = libraryVersion.preRelease.version;
-            libraryVersion.preRelease = undefined;
-        } else {
-            libraryVersion.buildNumber = 100;
-        }
-        let uploadedPackageInBasics;
-        let uploadedPackageInTarget;
-        for (const uploadedPackage of uploadedPackages){
-            if (uploadedPackage.scope === libraryCreatorPackage.Package) {
-                if (uploadedPackage.support) {
-                    uploadedPackageInBasics = uploadedPackage;
-                } else {
-                    uploadedPackageInTarget = uploadedPackage;
-                }
-            }
-        }
-        const validInBasics = uploadedPackageInBasics !== undefined && !uploadedPackageInBasics.version.isLesserThan(libraryVersion);
-        const validInTarget = uploadedPackageInTarget !== undefined && !uploadedPackageInTarget.version.isLesserThan(libraryVersion);
-        if (validInBasics || validInTarget) {
-            if (targetSession.subDomain !== "Basics" && uploadedPackageInBasics !== undefined && uploadedPackageInTarget !== undefined) {
-                logPackageMessage(creatorPackage.Package, `Package ${libraryCreatorPackage.Package} is uploaded both for Basics and ${targetSession.subDomain}. The package within ${targetSession.subDomain} will be used.`);
-            }
-            continue;
-        }
-        const possibleTargets = [];
-        if (uploadedPackageInBasics) {
-            const version = uploadedPackageInBasics.version.toVersionString({
-                buildNumber: true
-            });
-            possibleTargets.push({
-                value: "Basics",
-                name: `Basics (Current: ${version})`
-            });
-        } else {
-            possibleTargets.push({
-                value: "Basics",
-                name: "Basics (Current: None)"
-            });
-        }
-        if (targetSession.subDomain !== "Basics") {
-            if (uploadedPackageInTarget) {
-                const version = uploadedPackageInTarget.version.toVersionString({
-                    buildNumber: true
-                });
-                possibleTargets.push({
-                    value: targetSession.subDomain,
-                    name: `${targetSession.subDomain} (Current: ${version})`
-                });
-            } else {
-                possibleTargets.push({
-                    value: targetSession.subDomain,
-                    name: `${targetSession.subDomain} (Current: None)`
-                });
-            }
-        }
-        const libraryVersionString = libraryVersion.toVersionString({
-            buildNumber: true
-        });
-        const uploadTargetScope = await prompter.ask({
-            message: `Version ${libraryVersionString} of dependency ${libraryCreatorPackage.Package} is required but not available. Please select a subdomain to upload the correct dependency version to`,
-            options: [
-                ...possibleTargets,
-                {
-                    name: "Skip upload",
-                    value: "Skip"
-                }
-            ],
-            default: possibleTargets[0].value
-        });
-        if (uploadTargetScope === "Skip") {
-            continue;
-        }
-        const archive = buildArchiveFromPublishedPackage(libraryLocation, libraryManifest, libraryCreatorPackage);
-        const newVersionString = libraryVersion.toVersionString({
-            buildNumber: true
-        });
-        const session = uploadTargetScope === "Basics" ? await sessionManager.getBasicsSession() : targetSession;
-        logPackageMessage(creatorPackage.Package, `Uploading package ${libraryCreatorPackage.Package} with version ${newVersionString} to ${session.domain}.${session.subDomain}`);
-        await uploadPackageFromStream(session, {
-            name: libraryCreatorPackage.Package,
-            version: newVersionString
-        }, archive.generateNodeStream());
-    }
-};
-const createSessionManager = async (params)=>{
-    const targetSession = await startSession(params);
-    let basicsSession;
-    return {
-        getBasicsSession: async ()=>{
-            if (targetSession.subDomain === "Basics") {
-                return targetSession;
-            }
-            if (basicsSession === undefined) {
-                basicsSession = await startSession({
-                    ...params,
-                    subDomain: "Basics"
-                });
-            }
-            return basicsSession;
-        },
-        getTargetSession: ()=>targetSession,
-        destroy: async ()=>{
-            await closeSession(targetSession);
-            if (basicsSession !== undefined) {
-                await closeSession(basicsSession);
-            }
-        }
-    };
-};
-
-/**
- * Extracts and returns script array for _Index.json from a src folder
- *
- * @param folderPath path to a src folder
- */ function generateIndex({ location, ignore = [], strictOptional = false }) {
-    const files = getPackageTypescriptFiles(location);
-    const filtered = files.filter((path)=>{
-        return !ignore.some((suffix)=>path.endsWith(suffix));
-    });
-    const arr = [];
-    const existingIndex = readPackageCreatorIndex(location) ?? [];
-    const program = ts.createProgram(filtered, {
-        allowJs: true
-    });
-    const typeChecker = program.getTypeChecker();
-    filtered.forEach((file)=>{
-        // Create a Program to represent the project, then pull out the
-        // source file to parse its AST.
-        const sourceFile = program.getSourceFile(file);
-        // Loop through the root AST nodes of the file
-        ts.forEachChild(sourceFile, (node)=>{
-            for (const scriptingClass of findScriptingClasses(node)){
-                if (scriptingClass.node.name === undefined) {
-                    throw new Error(`Expected ${scriptingClass.type} class to have a name`);
-                }
-                const name = typeChecker.getFullyQualifiedName(typeChecker.getSymbolAtLocation(scriptingClass.node.name));
-                if (name.length > 45) {
-                    throw new Error(`Package name length >45 '${name}'`);
-                }
-                const parameterDeclaration = getScriptingClassParameterdeclaration(scriptingClass);
-                const parametersType = parameterDeclaration === undefined ? undefined : typeChecker.getTypeAtLocation(parameterDeclaration);
-                if (parametersType === undefined) {
-                    console.log(`Failed to find parameters type declaration for ${scriptingClass.type} ${name}. Skipping parameter list generation`);
-                }
-                const existingIndexEntry = existingIndex.find((entry)=>entry.Name === name);
-                const obj = {
-                    Name: name,
-                    Description: (existingIndexEntry == null ? void 0 : existingIndexEntry.Description) ?? name,
-                    Type: scriptingClass.type === "evaluator" ? "Evaluator" : "Interactor",
-                    Parameters: []
-                };
-                const rawDocTags = ts.getJSDocTags(scriptingClass.node);
-                const dict = getTagDict(rawDocTags);
-                if (dict.summary) {
-                    obj.Description = dict.summary;
-                } else {
-                    const comment = typeChecker.getTypeAtLocation(scriptingClass.node).symbol.getDocumentationComment(typeChecker).map((comment)=>comment.text).join(" ");
-                    if (comment) {
-                        obj.Description = comment;
-                    }
-                }
-                if (parametersType !== undefined) {
-                    obj.Parameters = parseParametersList(typeChecker.getPropertiesOfType(parametersType), strictOptional);
-                    if (obj.Parameters.length === 0 && parametersType.getStringIndexType() !== undefined) {
-                        obj.Parameters = (existingIndexEntry == null ? void 0 : existingIndexEntry.Parameters) ?? [];
-                    }
-                } else if (existingIndexEntry !== undefined) {
-                    obj.Parameters = existingIndexEntry.Parameters;
-                }
-                arr.push(obj);
-            }
-        });
-    });
-    arr.sort((a, b)=>a.Name.localeCompare(b.Name));
-    writePackageCreatorIndex(location, arr);
-}
-function capitalizeFirstLetter(string) {
-    return (string == null ? void 0 : string.charAt(0).toUpperCase()) + (string == null ? void 0 : string.slice(1));
-}
-const parseDefault = (value, type)=>{
-    const uType = capitalizeFirstLetter(type);
-    if (value === "null") return null;
-    switch(uType){
-        case "LengthM":
-        case "ArcDEG":
-        case "Float":
-            return parseFloat(value);
-        case "Integer":
-        case "Int":
-            return parseInt(value);
-        case "Boolean":
-        case "Bool":
-            return value === "true";
-        case "Material":
-        case "String":
-        case "Geometry":
-        default:
-            return value.replace(/^"/, "").replace(/"$/, "");
-    }
-};
-const parseTypeFromName = (name)=>{
-    const parts = name.split(".");
-    const identifier = parts[parts.length - 1];
-    switch(identifier){
-        case "LengthM":
-        case "ArcDEG":
-        case "Float":
-        case "Integer":
-            return identifier;
-        case "GeometryReference":
-            return "Geometry";
-        case "MaterialReference":
-            return "Material";
-        case "AnimationReference":
-            return "Animation";
-        case "InteractorReference":
-            return "Interactor";
-        case "EvaluatorReference":
-            return "Evaluator";
-        case "String":
-        case "string":
-            return "String";
-        case "number":
-        case "Number":
-            return "Float";
-        case "boolean":
-        case "Boolean":
-            return "Boolean";
-    }
-};
-const parseParametersList = (properties, strictOptional)=>{
-    return properties.map((symbol, i)=>{
-        var _symbol_getDeclarations;
-        const parameter = {
-            Name: symbol.name,
-            Description: undefined,
-            Type: "String",
-            Default: undefined,
-            DisplayIndex: i + 1
-        };
-        if (parameter.Name.length > 45) {
-            throw new Error(`Parameter name length >45 '${parameter.Name}'`);
-        }
-        let declaration = (_symbol_getDeclarations = symbol.getDeclarations()) == null ? void 0 : _symbol_getDeclarations[0];
-        let documentationComment = symbol.getDocumentationComment(undefined);
-        let checkLinksSymbol = symbol;
-        while(checkLinksSymbol !== undefined && declaration === undefined){
-            const links = checkLinksSymbol.links;
-            if (links == null ? void 0 : links.syntheticOrigin) {
-                var _links_syntheticOrigin_getDeclarations;
-                declaration = (_links_syntheticOrigin_getDeclarations = links.syntheticOrigin.getDeclarations()) == null ? void 0 : _links_syntheticOrigin_getDeclarations[0];
-                if (documentationComment.length === 0) {
-                    documentationComment = links.syntheticOrigin.getDocumentationComment(undefined);
-                }
-                checkLinksSymbol = links.syntheticOrigin;
-            }
-        }
-        if (declaration !== undefined) {
-            const rawDocTags = ts.getJSDocTags(declaration);
-            const dict = getTagDict(rawDocTags);
-            if (dict.summary) {
-                parameter.Description = dict.summary;
-            } else {
-                const comment = documentationComment.map((comment)=>comment.text).join(" ");
-                if (comment) {
-                    parameter.Description = comment;
-                }
-            }
-            if (dict.creatorType) {
-                parameter.Type = dict.creatorType;
-            } else {
-                const propertySignature = declaration;
-                if (propertySignature.type !== undefined) {
-                    const parsedType = parseTypeFromName(propertySignature.type.getText());
-                    if (parsedType !== undefined) {
-                        parameter.Type = parsedType;
-                    }
-                }
-            }
-            if (dict.default) {
-                parameter.Default = parseDefault(dict.default, parameter.Type);
-            }
-            if (strictOptional && declaration.kind === ts.SyntaxKind.PropertySignature) {
-                const propertySignature = declaration;
-                if (propertySignature.questionToken === undefined) {
-                    parameter.Required = true;
-                }
-            }
-        }
-        return parameter;
-    });
-};
-function getTagDict(tags) {
-    const dict = {};
-    for (const tag of tags){
-        dict[tag.tagName.text] = tag.comment;
-    }
-    return dict;
-}
-const getScriptingClassParameterdeclaration = (scriptingClass)=>{
-    for (const member of scriptingClass.node.members){
-        if (ts.isMethodDeclaration(member)) {
-            for(let index = 0; index < member.parameters.length; index++){
-                const parameter = member.parameters[index];
-                if (isScriptingClassParameterDeclaration(scriptingClass, member, index)) {
-                    return parameter;
-                }
-            }
-        }
-        if (ts.isConstructorDeclaration(member)) {
-            for(let index = 0; index < member.parameters.length; index++){
-                const parameter = member.parameters[index];
-                if (isScriptingClassParameterDeclaration(scriptingClass, member, index)) {
-                    return parameter;
-                }
-            }
-        }
-    }
-};
-const isScriptingClassParameterDeclaration = (scriptingClass, memberNode, parameterIndex)=>{
-    if (scriptingClass.type === "evaluator") {
-        var _memberNode_name;
-        return (memberNode == null ? void 0 : (_memberNode_name = memberNode.name) == null ? void 0 : _memberNode_name.getText()) == "Create" && parameterIndex === 2;
-    }
-    if (scriptingClass.type === "interactor") {
-        return memberNode.kind === ts.SyntaxKind.Constructor && parameterIndex === 0;
-    }
-    return false;
-};
-/**
- * Finds interactors and evaluators within a script file
- *
- * @param {ts.Node} node
- * @return {*}
- */ const findScriptingClasses = (node)=>{
-    let body;
-    if (ts.isModuleDeclaration(node)) {
-        body = node.body;
-    }
-    if (body !== undefined && ts.isModuleDeclaration(body)) {
-        body = body.body;
-    }
-    const classes = [];
-    if (body !== undefined) {
-        ts.forEachChild(body, (child)=>{
-            if (!ts.isClassDeclaration(child)) {
-                return;
-            }
-            const scriptingClass = detectScriptingClass(child);
-            if (scriptingClass !== undefined) {
-                classes.push(scriptingClass);
-            }
-        });
-    }
-    return classes;
-};
-const detectScriptingClass = (node)=>{
-    var _node_heritageClauses, _node_heritageClauses1;
-    const isEvaluator = (_node_heritageClauses = node.heritageClauses) == null ? void 0 : _node_heritageClauses.some((clause)=>{
-        if (clause.token !== ts.SyntaxKind.ExtendsKeyword && clause.token !== ts.SyntaxKind.ImplementsKeyword) {
-            return false;
-        }
-        return clause.types.some((type)=>type.getText().includes("Evaluator"));
-    });
-    if (isEvaluator) {
-        return {
-            node,
-            type: "evaluator"
-        };
-    }
-    const isInteractor = (_node_heritageClauses1 = node.heritageClauses) == null ? void 0 : _node_heritageClauses1.some((clause)=>{
-        if (clause.token !== ts.SyntaxKind.ExtendsKeyword) {
-            return false;
-        }
-        return clause.types.some((type)=>type.getText().includes("Interactor"));
-    });
-    if (isInteractor) {
-        return {
-            node,
-            type: "interactor"
-        };
-    }
-};
-
-export { buildFolders, buildFoldersWatch, generateIndex, releaseFolder };
+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';
 //# sourceMappingURL=lib.mjs.map