@intelligentgraphics/ig.gfx.packager 3.1.3 → 3.2.0

package/lib/lib.js

@@ -0,0 +1,1595 @@
+import { C as writePackageCreatorIndex, D as isErrorEPERM, E as isErrorENOENT, S as readPackageNpmManifest, T as isErrorEACCES, _ as getPackageReleasesDirectory, a as getPackageTypescriptFiles, b as readPackageCreatorIndex, c as readStringFromFileOrUndefined, d as readWorkspaceNpmManifest, f as readPublishedPackageCreatorIndex, g as PACKAGE_FILE, h as INDEX_FILE, i as assetService_exports, l as determineWorkspaceIGLibraries, m as readPublishedPackageNpmManifest, n as readScriptPackageTSConfig, o as consoleReporter, p as readPublishedPackageCreatorManifest, r as resolveScriptPackageEntryModule, s as createPackageScopedReporter, t as isScriptPackageModules, u as getWorkspaceOutputPath, v as parseCreatorPackageName, w as writePackageCreatorManifest, x as readPackageCreatorManifest, y as readPackageAnimationList } from "./scripts-B1CadgeN.js";
+import * as path from "node:path";
+import * as fs from "fs/promises";
+import * as terser from "terser";
+import { EOL } from "node:os";
+import ts from "typescript";
+import * as fs$1 from "node:fs";
+import { createReadStream, createWriteStream } from "node:fs";
+import EventEmitter from "events";
+import { SourceMapConsumer, SourceMapGenerator } from "source-map-js";
+import Ajv from "ajv";
+import { pipeline } from "node:stream/promises";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import simpleGit from "simple-git";
+import JSZip from "jszip";
+import "@inquirer/prompts";
+import { buffer } from "node:stream/consumers";
+import { findNamespaceByMemberSourceFile, resolveNamespaceFullName, resolveNamespaces } from "@intelligentgraphics/declarationbundler";
+//#region src/commands/build/tsc.ts
+const tryReadTsConfig = (location) => {
+	const { config } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path) => {
+		try {
+			return fs$1.readFileSync(path, "utf8");
+		} catch {
+			return;
+		}
+	});
+	return config;
+};
+const createTSCBuildParticipant = (location, outputDir, skipDeclarations) => (env) => {
+	const files = getPackageTypescriptFiles(location);
+	try {
+		env.onBuildStart();
+		env.log("Compiling typescript files");
+		const compilerOptions = getCompilerOptions(location, outputDir, skipDeclarations);
+		const host = ts.createCompilerHost(compilerOptions);
+		host.getCurrentDirectory = () => location.scriptsDir;
+		let js;
+		let definitions;
+		let sourceMap;
+		host.writeFile = (fileName, data, writeByteOrderMark) => {
+			if (fileName.endsWith(".js")) js = data;
+			else if (fileName.endsWith(".d.ts")) definitions = data;
+			else if (fileName.endsWith(".js.map")) sourceMap = data;
+		};
+		const programOptions = {
+			rootNames: files,
+			options: compilerOptions,
+			host
+		};
+		const program = ts.createProgram(programOptions);
+		const emitResult = program.emit();
+		const allDiagnostics = ts.getPreEmitDiagnostics(program);
+		if (!emitResult.emitSkipped) {
+			if (allDiagnostics.length > 0) console.log(ts.formatDiagnostics(allDiagnostics, host));
+			if (js === void 0 || definitions === void 0) throw new Error(`Unexpected: no js or definitions were created`);
+			env.onBuildEnd({
+				type: "success",
+				artefacts: {
+					js: js.replace(`//# sourceMappingURL=out.js.map`, ""),
+					declarations: getDeclarationFileReferences(location, program, outputDir) + definitions,
+					sourceMap
+				}
+			});
+		} else {
+			const error = ts.formatDiagnostics(allDiagnostics, host);
+			throw new Error(error);
+		}
+	} catch (err) {
+		env.onBuildEnd({
+			type: "error",
+			error: err instanceof Error ? err : new Error(String(err))
+		});
+	}
+	return { destroy: () => {} };
+};
+const createTSCWatchBuildParticipant = (location, outputDir, skipDeclarations) => {
+	return ({ onBuildStart, onBuildEnd }) => {
+		let state = {
+			diagnostics: [],
+			js: void 0,
+			definitions: void 0,
+			sourceMap: void 0
+		};
+		const customSys = {
+			...ts.sys,
+			writeFile: (fileName, data, writeByteOrderMark) => {
+				if (fileName.endsWith(".js")) state.js = data;
+				else if (fileName.endsWith(".d.ts")) state.definitions = data;
+				else if (fileName.endsWith(".js.map")) state.sourceMap = data;
+			}
+		};
+		const registerDiagnostic = (diagnostic) => {
+			switch (diagnostic.code) {
+				case 6053: return;
+				case 18003: return;
+			}
+			state.diagnostics.push(diagnostic);
+		};
+		let currentProgram;
+		const reportWatchStatusChanged = (diagnostic) => {
+			switch (diagnostic.code) {
+				case 6031:
+				case 6032:
+					onBuildStart();
+					break;
+				case 6193:
+				case 6194:
+					const emitState = state;
+					state = {
+						diagnostics: [],
+						js: void 0,
+						definitions: void 0,
+						sourceMap: void 0
+					};
+					if (emitState.diagnostics.length > 0) {
+						const message = ts.formatDiagnostics(emitState.diagnostics, formattingHost);
+						onBuildEnd({
+							type: "error",
+							error: new Error(message)
+						});
+						return;
+					}
+					if (emitState.js === void 0) {
+						onBuildEnd({
+							type: "success",
+							artefacts: { js: "" }
+						});
+						return;
+					}
+					if (!currentProgram) throw new Error(`Expected a program to exist`);
+					onBuildEnd({
+						type: "success",
+						artefacts: {
+							js: emitState.js.replace(`//# sourceMappingURL=out.js.map`, ""),
+							declarations: emitState.definitions ? getDeclarationFileReferences(location, currentProgram, outputDir) + emitState.definitions : void 0,
+							sourceMap: emitState.sourceMap
+						}
+					});
+					break;
+			}
+		};
+		const host = ts.createWatchCompilerHost(path.join(location.scriptsDir, "tsconfig.json"), getCompilerOptions(location, outputDir, skipDeclarations), customSys, ts.createSemanticDiagnosticsBuilderProgram, registerDiagnostic, reportWatchStatusChanged);
+		const originalAfterProgramCreate = host.afterProgramCreate;
+		host.afterProgramCreate = (program) => {
+			currentProgram = program;
+			originalAfterProgramCreate?.(program);
+		};
+		const formattingHost = {
+			getCanonicalFileName: (path) => path,
+			getCurrentDirectory: host.getCurrentDirectory,
+			getNewLine: () => ts.sys.newLine
+		};
+		const watchProgram = ts.createWatchProgram(host);
+		return { destroy: () => {
+			watchProgram.close();
+		} };
+	};
+};
+const getCompilerOptions = (location, outputDir, skipDeclarations) => {
+	const config = tryReadTsConfig(location);
+	config.compilerOptions.lib = ["es2018", "dom"];
+	return {
+		...ts.convertCompilerOptionsFromJson(config.compilerOptions, location.scriptsDir).options,
+		removeComments: false,
+		declaration: !skipDeclarations,
+		sourceMap: true,
+		inlineSources: false,
+		outFile: path.join(outputDir, "out.js"),
+		target: ts.ScriptTarget.ES5,
+		noEmitOnError: true
+	};
+};
+function getDeclarationFileReferences(location, program, outputDir) {
+	const references = /* @__PURE__ */ new Set();
+	for (const file of program.getSourceFiles()) for (const reference of file.referencedFiles) {
+		if (reference.preserve) continue;
+		const dir = path.dirname(file.fileName);
+		const absolute = path.resolve(dir, reference.fileName);
+		if (!absolute.startsWith(location.scriptsDir)) references.add(absolute);
+	}
+	let referenceString = Array.from(references, (reference) => {
+		return `/// <reference path="${path.relative(outputDir, reference).replaceAll(path.sep, "/")}" />`;
+	}).join(EOL);
+	if (referenceString) referenceString += EOL;
+	return referenceString;
+}
+//#endregion
+//#region src/lib/toposort.ts
+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];
+		if (packages[queueEntry].some((dependency) => queue.includes(dependency))) {
+			index++;
+			continue;
+		}
+		queue.splice(index, 1);
+		index = 0;
+		result.push(queueEntry);
+	}
+	return result;
+};
+//#endregion
+//#region src/commands/build/manager.ts
+var BuildManager = class extends EventEmitter {
+	participants = /* @__PURE__ */ new Map();
+	states = /* @__PURE__ */ new Map();
+	participantInstances = [];
+	constructor(manifest, writer, reporter) {
+		super();
+		this.manifest = manifest;
+		this.writer = writer;
+		this.reporter = reporter;
+	}
+	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) {
+			const instance = participant({
+				onBuildStart: () => {
+					let alreadyBusy = false;
+					for (const [name, state] of this.states) if (state.type === "busy") {
+						alreadyBusy = true;
+						continue;
+					}
+					this.states.set(name, { type: "busy" });
+					if (!alreadyBusy) this.emit("start");
+				},
+				onBuildEnd: (result) => {
+					this.states.set(name, result);
+					this.maybeEmit();
+				},
+				log: (message) => this.reporter.log(message)
+			});
+			this.participantInstances.push(instance);
+		}
+	}
+	destroy() {
+		for (const instance of this.participantInstances) instance.destroy();
+	}
+	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.length === 1 ? errors[0] : new AggregateError(errors));
+			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 = /* @__PURE__ */ new Set();
+					sourceMap.eachMapping((mapping) => {
+						sourceMapGenerator.addMapping({
+							generated: {
+								line: lines + mapping.generatedLine,
+								column: mapping.generatedColumn
+							},
+							original: mapping.originalLine !== null && mapping.originalColumn !== null ? {
+								line: mapping.originalLine,
+								column: mapping.originalColumn
+							} : void 0,
+							source: mapping.source,
+							name: mapping.name
+						});
+						if (mapping.source !== null) sources.add(mapping.source);
+					});
+					for (const source of sources) {
+						const content = sourceMap.sourceContentFor(source);
+						if (content !== null) sourceMapGenerator.setSourceContent(source, content);
+					}
+				}
+				completeResult.js += result.artefacts.js;
+			}
+			if (result.artefacts.declarations) {
+				if (completeResult.declarations) completeResult.declarations += "\n";
+				else completeResult.declarations = "";
+				completeResult.declarations += result.artefacts.declarations;
+			}
+		}
+		completeResult.sourceMap = sourceMapGenerator.toString();
+		this.writer(completeResult).then(() => {
+			this.emit("build");
+		});
+	}
+};
+//#endregion
+//#region src/commands/build/animation.schema.ts
+var animation_schema_default = {
+	$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"
+				}
+			}
+		}
+	}
+};
+//#endregion
+//#region src/commands/build/animations.ts
+const createAnimationBuildParticipant = (location, manifest) => {
+	return (env) => {
+		env.onBuildStart();
+		bundleAnimations(location, manifest, env.log).then((result) => {
+			env.onBuildEnd({
+				type: "success",
+				artefacts: { js: 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?.js ?? "" }
+		});
+	}).catch((err) => {
+		env.onBuildEnd({
+			type: "error",
+			error: err.message
+		});
+	});
+	(async () => {
+		for await (const event of fs.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?.js ?? "" }
+				});
+			} catch (err) {
+				env.onBuildEnd({
+					type: "error",
+					error: err instanceof Error ? err : new Error(String(err))
+				});
+			}
+		}
+	})();
+	return { destroy: () => {} };
+};
+const bundleAnimations = async (location, manifest, logStep) => {
+	const animations = /* @__PURE__ */ new Map();
+	for (const scriptFilePath of readPackageAnimationList(location)) {
+		const content = await fs.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;
+		let js = createNamespace(scope.split("."));
+		for (const [name, content] of animations) {
+			js += `${scope}["${name}"] = ` + content + ";";
+			logStep(`Adding animation ${scope}.${name}`);
+		}
+		return { js };
+	}
+};
+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 === void 0) validateAnimationJson = new Ajv({
+		coerceTypes: true,
+		allErrors: true,
+		removeAdditional: true,
+		useDefaults: "empty",
+		validateSchema: "log"
+	}).compile(animation_schema_default);
+	return validateAnimationJson;
+};
+//#endregion
+//#region src/lib/packageVersion.ts
+var PackageVersion = class PackageVersion {
+	static fullTextMatcher = /(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?/;
+	static lineMatcher = /^(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?$/;
+	static extractFromText(input, description) {
+		if (input === void 0) 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 === void 0) 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 === void 0 || b.preRelease === void 0) 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 = void 0;
+		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 * 1e3 + version.minor) * 1e3 + version.patch) * 1e3 + 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 !== void 0;
+	}
+	clone() {
+		return new PackageVersion(this.major, this.minor, this.patch, this.preRelease ? { ...this.preRelease } : void 0, this.buildNumber);
+	}
+	incrementMajor() {
+		this.preRelease = void 0;
+		this.patch = 0;
+		this.minor = 0;
+		this.major++;
+	}
+	incrementMinor() {
+		this.preRelease = void 0;
+		this.patch = 0;
+		this.minor++;
+	}
+	incrementPatch() {
+		this.preRelease = void 0;
+		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 = void 0;
+		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);
+};
+//#endregion
+//#region src/commands/build/index.ts
+async function buildFolders(options) {
+	if (options.outDir !== void 0 && options.clean) await fs.rm(options.outDir, { recursive: true });
+	const baseReporter = options.reporter ?? consoleReporter;
+	const workspace = options.workspace;
+	const folders = options.packages;
+	let sortedPackages = sortPackagesByBuildOrder(folders);
+	let index = 1;
+	const manifests = new Map(sortedPackages.map((location) => [location, readPackageCreatorManifest(location)]));
+	const maxNameLength = Array.from(manifests.values(), (manifest) => manifest.Package.length).reduce((acc, length) => Math.max(acc, length), 0);
+	const managers = [];
+	for (const location of sortedPackages) {
+		const tsConfig = await ensureTsConfig(location);
+		const data = manifests.get(location);
+		const reporter = options.preparedReporter ?? createPackageScopedReporter(baseReporter, data.Package, index, folders.length, maxNameLength);
+		const outputDirectory = options.outDir || location.scriptsDir;
+		await fs.mkdir(outputDirectory, { recursive: true });
+		const manager = new BuildManager(data, (result) => writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, reporter), reporter);
+		if (options.banner) manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
+		const typescriptFiles = getPackageTypescriptFiles(location);
+		if (!typescriptFiles.some((file) => path.basename(file).toLowerCase() === "version.ts")) manager.addParticipant("version", createVersionLogBuildParticipant(data));
+		if (typescriptFiles.length > 0) if (isScriptPackageModules(tsConfig.options)) {
+			const { createRollupBuildParticipant } = await import("./rollup-DZ2wdbmd.js");
+			manager.addParticipant("rollup", createRollupBuildParticipant(location, data, outputDirectory, !tsConfig.options.declaration));
+		} else manager.addParticipant("tsc", createTSCBuildParticipant(location, outputDirectory, tsConfig.options.declaration === false));
+		manager.addParticipant("animation", createAnimationBuildParticipant(location, data));
+		await new Promise((resolve, reject) => {
+			manager.addListener("start", () => {
+				reporter.log(`Build started`);
+			});
+			manager.addListener("error", (error) => {
+				reject(error);
+			});
+			manager.addListener("build", () => {
+				reporter.log(`Build complete`);
+				resolve();
+			});
+			manager.run();
+		});
+		managers.push(manager);
+		if (options.docs) {
+			if (!options.docsHandler) throw new Error("Handler for typescript docs not available");
+			reporter.log("Generating typedoc documentation");
+			await options.docsHandler(location, path.join(outputDirectory, `${data.Package}.d.ts`), path.join(workspace.path, "docs", data.Package), data.Package);
+		}
+		index++;
+	}
+}
+async function buildFoldersWatch(options) {
+	if (options.outDir !== void 0 && options.clean) await fs.rm(options.outDir, { recursive: true });
+	const workspace = options.workspace;
+	const folders = options.packages;
+	options.reporter;
+	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);
+	const managers = [];
+	for (const location of sortedPackages) {
+		const tsConfig = await ensureTsConfig(location);
+		const baseReporter = options.reporter ?? consoleReporter;
+		const data = manifests.get(location);
+		const reporter = options.preparedReporter ?? createPackageScopedReporter(baseReporter, data.Package, index, folders.length, maxNameLength);
+		const outputDirectory = options.outDir || location.scriptsDir;
+		await fs.mkdir(outputDirectory, { recursive: true });
+		const manager = new BuildManager(data, (result) => writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, reporter), reporter);
+		if (options.banner) manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
+		const typescriptFiles = getPackageTypescriptFiles(location);
+		if (!typescriptFiles.some((file) => path.basename(file).toLowerCase() === "version.ts")) manager.addParticipant("version", createVersionLogBuildParticipant(data));
+		if (typescriptFiles.length > 0) if (isScriptPackageModules(tsConfig.options)) {
+			const { createRollupWatchBuildParticipant } = await import("./rollup-DZ2wdbmd.js");
+			manager.addParticipant("rollup", createRollupWatchBuildParticipant(location, data, outputDirectory, !tsConfig.options.declaration));
+		} else manager.addParticipant("tsc", createTSCWatchBuildParticipant(location, outputDirectory, tsConfig.options.declaration === false));
+		manager.addParticipant("animation", createAnimationWatchBuildParticipant(location, data));
+		await new Promise((resolve, reject) => {
+			manager.addListener("start", () => {
+				reporter.log(`Build started`);
+			});
+			manager.addListener("error", (error) => {
+				reporter.log(`Build failed: ${EOL}${error}`);
+				resolve();
+			});
+			manager.addListener("build", () => {
+				reporter.log(`Build complete`);
+				resolve();
+			});
+			manager.run();
+		});
+		managers.push(manager);
+		index++;
+	}
+	return { destroy: () => {
+		for (const manager of managers) manager.destroy();
+	} };
+}
+async function writeBuildResult(buildResult, manifest, location, workspace, outputDirectory, minimize, reporter) {
+	let js = buildResult.js;
+	if (buildResult.sourceMap) js += `\n//# sourceMappingURL=${manifest.Package}.js.map`;
+	await fs.writeFile(path.join(outputDirectory, `${manifest.Package}.js`), js, { encoding: "utf8" });
+	if (buildResult.declarations !== void 0) await fs.writeFile(path.join(outputDirectory, `${manifest.Package}.d.ts`), buildResult.declarations, { encoding: "utf8" });
+	if (buildResult.sourceMap !== void 0) await fs.writeFile(path.join(outputDirectory, `${manifest.Package}.js.map`), buildResult.sourceMap, { encoding: "utf8" });
+	if (minimize) {
+		reporter.log("Minifying the output");
+		const minifyResult = await terser.minify(js, {
+			ecma: 5,
+			sourceMap: {
+				content: buildResult.sourceMap,
+				includeSources: false
+			}
+		});
+		const minifiedPath = path.join(outputDirectory, `${manifest.Package}.min.js`);
+		let code = minifyResult.code;
+		if (minifyResult.map) code += `\n//# sourceMappingURL=${manifest.Package}.min.js.map`;
+		await fs.writeFile(minifiedPath, code, { encoding: "utf8" });
+		if (minifyResult.map !== void 0) await fs.writeFile(minifiedPath + ".map", typeof minifyResult.map === "string" ? minifyResult.map : JSON.stringify(minifyResult.map), { encoding: "utf8" });
+	}
+	if (location.path.includes("Basics") && buildResult.declarations !== void 0) {
+		await fs.mkdir(path.join(workspace.path, "lib"), { recursive: true });
+		reporter.log("Copying basics definition file to the lib folder");
+		await fs.writeFile(path.join(workspace.path, "lib", `${manifest.Package}.d.ts`), buildResult.declarations, { encoding: "utf8" });
+	}
+}
+function createVersionLogBuildParticipant(manifest) {
+	return (env) => {
+		env.onBuildStart();
+		const parsedVersion = manifest.Version !== void 0 ? PackageVersion.extractFromLine(manifest.Version) : void 0;
+		let logText;
+		if (parsedVersion !== void 0) logText = parsedVersion.toDescriptionString(manifest.Package);
+		else logText = manifest.Package;
+		logText += ".";
+		if (manifest.Copyright !== void 0) logText += " " + manifest.Copyright;
+		env.onBuildEnd({
+			type: "success",
+			artefacts: { js: `console.log(${JSON.stringify(logText)})` }
+		});
+		return { destroy: () => {} };
+	};
+}
+function createBannerCommentBuildParticipant(options) {
+	return (env) => {
+		env.onBuildStart();
+		const banner = createBannerComment(options);
+		env.onBuildEnd({
+			type: "success",
+			artefacts: {
+				js: banner ?? "",
+				declarations: banner ?? ""
+			}
+		});
+		return { destroy: () => {} };
+	};
+}
+async function ensureTsConfig(location) {
+	const tsconfigPath = path.join(location.scriptsDir, "tsconfig.json");
+	try {
+		const content = JSON.parse(await fs.readFile(tsconfigPath, "utf8"));
+		if (applyTsConfigOptions(content)) await fs.writeFile(tsconfigPath, JSON.stringify(content, void 0, "	"), "utf8");
+		return ts.parseJsonConfigFileContent(content, ts.sys, location.scriptsDir);
+	} catch (err) {
+		if (!isErrorENOENT(err)) throw err;
+		const content = {};
+		applyTsConfigOptions(content);
+		await fs.writeFile(tsconfigPath, JSON.stringify(content, void 0, "	"), "utf8");
+		return ts.parseJsonConfigFileContent(content, ts.sys, location.scriptsDir);
+	}
+}
+function applyTsConfigOptions(data) {
+	let expectedValues;
+	if (data.compilerOptions?.module?.toLowerCase().startsWith("es")) expectedValues = {
+		target: "esnext",
+		lib: ["es2024", "dom"],
+		module: "es2015",
+		moduleResolution: "node"
+	};
+	else expectedValues = {
+		target: "es5",
+		lib: ["es2018", "dom"]
+	};
+	data.compilerOptions = data.compilerOptions ?? {};
+	data.compilerOptions.strict ??= false;
+	const writeToOptions = data.compilerOptions;
+	let changed = false;
+	for (const [key, value] of Object.entries(expectedValues)) {
+		const currentValue = writeToOptions[key];
+		switch (typeof value) {
+			case "string":
+			case "number":
+			case "boolean":
+				if (value !== currentValue) {
+					changed = true;
+					writeToOptions[key] = value;
+				}
+				break;
+			case "object":
+				if (Array.isArray(value) && (!Array.isArray(currentValue) || value.length !== currentValue.length || value.some((item, index) => item !== currentValue[index]))) {
+					changed = true;
+					writeToOptions[key] = value;
+				}
+				break;
+		}
+	}
+	return changed;
+}
+function sortPackagesByBuildOrder(folders) {
+	const packages = Array.from(folders).reduce((acc, location) => {
+		const data = readPackageNpmManifest(location);
+		if (data !== void 0) acc[data.name] = {
+			data,
+			location
+		};
+		else acc[location.path] = {
+			data: void 0,
+			location
+		};
+		return acc;
+	}, {});
+	const sortedPackages = toposort(Object.getOwnPropertyNames(packages).reduce((acc, packageName) => {
+		const packageData = packages[packageName];
+		if (packageData.data === void 0) acc[packageName] = [];
+		else acc[packageName] = Object.getOwnPropertyNames({
+			...packageData.data.devDependencies,
+			...packageData.data.dependencies,
+			...packageData.data.peerDependencies
+		}).filter((packageName) => packages[packageName] !== void 0);
+		return acc;
+	}, {}));
+	const result = [];
+	for (const packageName of sortedPackages) {
+		const location = packages[packageName].location;
+		if (readPackageCreatorManifest(location).Package.endsWith(".Basics")) result.unshift(location);
+		else result.push(location);
+	}
+	return result;
+}
+function createBannerComment(banner) {
+	const bannerParts = [];
+	if (banner.text) bannerParts.push(" * " + banner.text);
+	{
+		const details = [];
+		if (banner.version) details.push(`Version: ${banner.version}`);
+		if (banner.commit) if (banner.commitDirty) details.push(`Commit: ${banner.commit} (dirty)`);
+		else details.push(`Commit: ${banner.commit}`);
+		if (banner.date) details.push(`Date: ${banner.date.toISOString()}`);
+		const detailsText = details.map((line) => ` * ${line}`).join("\n");
+		if (detailsText) bannerParts.push(detailsText);
+	}
+	const bannerText = bannerParts.join("\n\n");
+	if (bannerText) return `/*
+${bannerText}
+*
+* @preserve			
+*/`;
+}
+//#endregion
+//#region src/lib/git.ts
+const getVersionInformationFromGit = async (workspaceLocation, packageLocation) => {
+	try {
+		const git = simpleGit({ baseDir: workspaceLocation.path });
+		const dirty = (await git.diffSummary()).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);
+			return !path.relative(packageLocation.path, fullPath).startsWith("..");
+		});
+		const log = await git.log({ maxCount: 1 });
+		return {
+			commit: !log.latest?.hash ? void 0 : log.latest.hash.substring(0, 7),
+			dirty,
+			commitDate: log.latest?.date
+		};
+	} catch (err) {
+		return {};
+	}
+};
+//#endregion
+//#region src/lib/banner.ts
+const getWorkspaceBannerText = (manifest) => {
+	let bannerText = manifest?.packager?.banner;
+	if (bannerText) {
+		const match = bannerText.match(/Copyright \(C\) (\d+)( ?- ?(\d+))?/);
+		if (match !== null) {
+			const startYear = parseInt(match[1]);
+			const endYear = (/* @__PURE__ */ 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;
+};
+//#endregion
+//#region src/lib/parseVersion.ts
+const parseVersionFromString = (input) => {
+	if (input === void 0) throw new Error(`Can not parse version from undefined`);
+	let match;
+	let major;
+	let minor;
+	let patch;
+	let build;
+	let preReleaseType;
+	let preReleaseNumber;
+	if ((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 = void 0;
+	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);
+};
+const parseVersionFromNumericVersion = (version) => {
+	return new PackageVersion(Math.floor(version / 1e9), Math.floor(version % 1e9 / 1e6), Math.floor(version % 1e6 / 1e3), void 0, version % 1e3);
+};
+//#endregion
+//#region src/lib/versionFile.ts
+const logRegex = /console\.log\(\s*"([\w\s\.\(\)]+)\ *Copyright[\w\s\(\)\.]+(\d{4}|\d{4} - \d{4})([\w\s\(\)\.]+)?",?\s*\)/i;
+const currentYear = new Date(Date.now()).getFullYear();
+function getVersionFileHandler(location) {
+	const filePath = path.join(location.scriptsDir, "Version.ts");
+	function invalidVersionFile(versionFile, exists) {
+		return {
+			exists,
+			write: (name, newVersion) => {
+				if (fs$1.readdirSync(location.scriptsDir).filter((file) => file.endsWith(".ts")).length > 0) return createVersionFileWriter([currentYear], "")(name, newVersion);
+			},
+			reset: () => {
+				if (versionFile !== void 0) fs$1.writeFileSync(filePath, versionFile, { encoding: "utf8" });
+				else try {
+					fs$1.rmSync(filePath);
+				} catch (err) {
+					if (!isErrorENOENT(err)) throw err;
+				}
+			}
+		};
+	}
+	function createVersionFileWriter(copyright = [currentYear], copyrightStuff = "") {
+		return (name, newVersion) => {
+			const result = `console.log("${newVersion.toDescriptionString(name)}. Copyright (C) ${createYearString(copyright)}${copyrightStuff}");`;
+			fs$1.writeFileSync(filePath, result, { encoding: "utf-8" });
+		};
+	}
+	let rawVersionFile = readStringFromFileOrUndefined(filePath);
+	if (rawVersionFile === void 0) return invalidVersionFile(rawVersionFile, false);
+	const versionFile = rawVersionFile.replace(/\n/g, "");
+	const match = versionFile.match(logRegex);
+	if (!match) return invalidVersionFile(versionFile, true);
+	const [_full, _description, copyright, copyrightStuff] = match;
+	const copyrightYears = copyright.match(/^(\d+)( ?- ?(\d+))?$/);
+	let years;
+	if (copyrightYears === null) years = [currentYear];
+	else years = [Number(copyrightYears[1]), currentYear];
+	return {
+		exists: true,
+		write: createVersionFileWriter(years, copyrightStuff),
+		reset: () => {
+			fs$1.writeFileSync(filePath, versionFile, { encoding: "utf8" });
+		}
+	};
+}
+const createYearString = (years) => {
+	if (years[1] === void 0 || years[0] === years[1]) return years[0].toString();
+	return `${years[0]} - ${years[1]}`;
+};
+//#endregion
+//#region src/commands/publish/zip.ts
+const buildArchiveFromPublishedPackage = (location, manifest, creatorPackage) => {
+	const archive = new JSZip();
+	archive.file(PACKAGE_FILE, JSON.stringify(creatorPackage, null, 2));
+	const index = readPublishedPackageCreatorIndex(location);
+	if (index !== void 0) archive.file(INDEX_FILE, JSON.stringify(index, null, 2));
+	archive.file(manifest.main, fs$1.createReadStream(path.join(location.path, manifest.main)));
+	if (creatorPackage.Package === "IG.GFX.Standard") {
+		const source = path.join(location.path, "Images");
+		if (fs$1.existsSync(source)) {
+			const images = fs$1.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$1.createReadStream(path.join(source, file)));
+			}
+		}
+	}
+	return archive;
+};
+const runtimeScripts = [
+	"Interactor",
+	"Core",
+	"Mixed"
+];
+const notRuntimeScripts = ["Context", "Evaluator"];
+const buildArchiveFromPackage = async (reporter, packageLocation, data, binDir, minified = true) => {
+	const { domain } = parseCreatorPackageName(data);
+	const scriptDirectories = [packageLocation.path, packageLocation.scriptsDir];
+	if (data.Package === "IG.GFX.Standard") {
+		reporter.log(`Including Images folder`);
+		scriptDirectories.push(path.join(packageLocation.path, "Images"));
+	}
+	const manifest = readPackageCreatorManifest(packageLocation);
+	if (manifest !== void 0) {
+		if (manifest.RunTime && notRuntimeScripts.includes(manifest.Type)) {
+			reporter.log("Setting script RunTime to false because of script type");
+			writePackageCreatorManifest(packageLocation, {
+				...manifest,
+				RunTime: false
+			});
+		} else if (!manifest.RunTime && runtimeScripts.includes(manifest.Type)) {
+			reporter.log("Setting script RunTime to true because of script type");
+			writePackageCreatorManifest(packageLocation, {
+				...manifest,
+				RunTime: true
+			});
+		}
+	}
+	let libFile;
+	try {
+		const libFilePath = minified ? path.join(binDir, `${data.Package}.min.js`) : path.join(binDir, `${data.Package}.js`);
+		libFile = fs$1.readFileSync(libFilePath, { encoding: "utf8" });
+	} catch (err) {
+		if (!isErrorENOENT(err)) throw err;
+	}
+	const archive = new JSZip();
+	let library = "";
+	if (libFile) library = libFile;
+	if (!library) library = `/* This file is part of the ${domain} Data Packages.
+		* Copyright (C) ${new Date(Date.now()).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 !== void 0) archive.file(INDEX_FILE, JSON.stringify(creatorIndex, null, 2));
+	for (const directory of scriptDirectories) try {
+		for (const file of fs$1.readdirSync(directory)) {
+			const { ext } = path.parse(file);
+			switch (ext) {
+				case ".png":
+				case ".jpeg":
+				case ".jpg": break;
+				default: continue;
+			}
+			archive.file(file, fs$1.createReadStream(path.join(directory, file)));
+		}
+	} catch (err) {
+		reporter.error(`Script directory "${directory}" does not exist`);
+	}
+	return archive;
+};
+//#endregion
+//#region src/lib/assetServiceSessionManager.ts
+const createAssetServiceSessionManager = async (params) => {
+	const targetSession = await assetService_exports.startSession(params);
+	let basicsSession;
+	return {
+		getBasicsSession: async () => {
+			if (targetSession.subDomain === "Basics") return targetSession;
+			if (basicsSession === void 0) basicsSession = await assetService_exports.startSession({
+				...params,
+				subDomain: "Basics"
+			});
+			return basicsSession;
+		},
+		getTargetSession: () => targetSession,
+		destroy: async () => {
+			await assetService_exports.closeSession(targetSession);
+			if (basicsSession !== void 0) await assetService_exports.closeSession(basicsSession);
+		}
+	};
+};
+//#endregion
+//#region src/lib/dependencySync.ts
+const synchronizeDependencies = async (workspaceLocation, creatorPackage, sessionManager, prompter, reporter, logUpToDate = false) => {
+	const libraries = determineWorkspaceIGLibraries(workspaceLocation);
+	if (libraries.length === 0) return true;
+	const targetSession = sessionManager.getTargetSession();
+	const uploadedPackages = (await assetService_exports.getExistingPackages(targetSession)).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 === void 0 || libraryManifest.main === void 0 || libraryCreatorPackage.Package === creatorPackage?.Package) continue;
+		const libraryVersion = PackageVersion.extractFromLine(libraryManifest.version);
+		if (libraryVersion.preRelease) {
+			libraryVersion.buildNumber = libraryVersion.preRelease.version;
+			libraryVersion.preRelease = void 0;
+		} 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 !== void 0 && !uploadedPackageInBasics.version.isLesserThan(libraryVersion);
+		const validInTarget = uploadedPackageInTarget !== void 0 && !uploadedPackageInTarget.version.isLesserThan(libraryVersion);
+		if (validInBasics || validInTarget) {
+			if (targetSession.subDomain !== "Basics" && uploadedPackageInBasics !== void 0 && uploadedPackageInTarget !== void 0) reporter.log(`Package ${libraryCreatorPackage.Package} is uploaded both for Basics and ${targetSession.subDomain}. The package within ${targetSession.subDomain} will be used.`);
+			if (logUpToDate) reporter.log(`Package ${libraryCreatorPackage.Package} is already uploaded with the required version ${libraryVersion.toVersionString({})}`);
+			continue;
+		}
+		const possibleTargets = [];
+		if (uploadedPackageInBasics) {
+			const version = uploadedPackageInBasics.version.toVersionString({ buildNumber: true });
+			possibleTargets.push({
+				value: "Basics",
+				name: `Basics (Current: ${version})`
+			});
+		} else possibleTargets.push({
+			value: "Basics",
+			name: "Basics (Current: None)"
+		});
+		if (targetSession.subDomain !== "Basics") if (uploadedPackageInTarget) {
+			const version = uploadedPackageInTarget.version.toVersionString({ buildNumber: true });
+			possibleTargets.push({
+				value: targetSession.subDomain,
+				name: `${targetSession.subDomain} (Current: ${version})`
+			});
+		} else possibleTargets.push({
+			value: targetSession.subDomain,
+			name: `${targetSession.subDomain} (Current: None)`
+		});
+		const libraryVersionString = libraryVersion.toVersionString({ buildNumber: true });
+		const uploadTargetScope = await prompter.ask({
+			message: `Version ${libraryVersionString} of dependency ${libraryCreatorPackage.Package} is required but not available. Please select a subdomain to upload the required dependency version to`,
+			options: [...possibleTargets, {
+				name: "Skip upload",
+				value: "Skip"
+			}],
+			default: possibleTargets[0].value
+		});
+		if (uploadTargetScope === "Skip") continue;
+		const archive = buildArchiveFromPublishedPackage(libraryLocation, libraryManifest, libraryCreatorPackage);
+		const newVersionString = libraryVersion.toVersionString({ buildNumber: true });
+		const session = uploadTargetScope === "Basics" ? await sessionManager.getBasicsSession() : targetSession;
+		reporter.log(`Uploading package ${libraryCreatorPackage.Package} with version ${newVersionString} to ${session.domain}.${session.subDomain}`);
+		await assetService_exports.uploadPackageFromBuffer(session, {
+			name: libraryCreatorPackage.Package,
+			version: newVersionString
+		}, await archive.generateAsync({ type: "nodebuffer" }));
+	}
+};
+//#endregion
+//#region src/commands/publish/index.ts
+const execAsync = promisify(exec);
+const releaseFolder = async (options) => {
+	const workspace = options.workspace;
+	const location = options.directory;
+	const versionFile = getVersionFileHandler(location);
+	const packageDescription = readPackageCreatorManifest(location);
+	const fullPackageName = packageDescription.Package;
+	const reporter = options.reporter ?? createPackageScopedReporter(consoleReporter, packageDescription.Package);
+	const { domain, subdomain } = parseCreatorPackageName(packageDescription);
+	const publishDomain = options.domain ?? domain;
+	const publishSubdomain = options.subdomain ?? subdomain;
+	const sharedPackageJson = readWorkspaceNpmManifest(workspace);
+	let newVersion;
+	try {
+		newVersion = parseVersionFromString(options.newVersion);
+	} catch (err) {
+		throw new Error(`Please enter a version in this format 1.0.0.100`);
+	}
+	packageDescription.Version = newVersion.toVersionString({ buildNumber: true });
+	writePackageCreatorManifest(location, packageDescription);
+	if (newVersion.buildNumber < 100) newVersion.preRelease = {
+		type: "beta",
+		version: newVersion.buildNumber
+	};
+	else if (newVersion.buildNumber > 100) newVersion.preRelease = {
+		type: "patch",
+		version: newVersion.buildNumber - 100
+	};
+	const binDir = options.outDir ?? getWorkspaceOutputPath(workspace);
+	await fs.mkdir(binDir, { recursive: true });
+	let assetServerPackageDetails;
+	let packageNameWithVersion;
+	{
+		const versionWithoutPrelease = newVersion.clone();
+		versionWithoutPrelease.preRelease = void 0;
+		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) {
+			if (await fs.stat(zipFilePath).catch((err) => {
+				if (isErrorENOENT(err)) return false;
+				return Promise.reject(err);
+			})) throw new Error(`Expected a zip file to exist at path ${zipFilePath} since pushOnly is specified`);
+		} else {
+			const gitVersionInformation = await getVersionInformationFromGit(workspace, location);
+			if (versionFile.exists) versionFile.write(fullPackageName, newVersion);
+			const bannerText = sharedPackageJson !== void 0 ? getWorkspaceBannerText(sharedPackageJson) : void 0;
+			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())
+				} : void 0,
+				preparedReporter: reporter
+			});
+			newVersion.preRelease = void 0;
+			try {
+				await fs.rm(zipFilePath);
+			} catch (err) {
+				if (!isErrorENOENT(err)) throw err;
+			}
+			if (readPackageAnimationList(location).length > 0) {
+				if (!readWorkspaceNpmManifest(workspace).dependencies?.["@intelligentgraphics/3d.ig.gfx.standard"]) {
+					if (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?`)) {
+						await execAsync(`npm install @intelligentgraphics/3d.ig.gfx.standard`, {
+							encoding: "utf-8",
+							cwd: workspace.path
+						});
+						await execAsync(`npm run postinstall`, { cwd: workspace.path });
+					}
+				}
+			}
+			reporter.log(`Creating zip file`);
+			const archive = await buildArchiveFromPackage(reporter, location, packageDescription, binDir, options.minimize);
+			try {
+				const zipOutputStream = createWriteStream(zipFilePath);
+				await pipeline(archive.generateNodeStream(), zipOutputStream);
+			} catch (err) {
+				if (isErrorEACCES(err) || isErrorEPERM(err)) {
+					reporter.log(`Could not create zip file in the bin directory because of a permissions error. Only using it in-memory`);
+					uploadable = { getStream: () => archive.generateNodeStream() };
+				} else throw err;
+			}
+		}
+		if (!options.noUpload) {
+			if (!options.authentication) throw new Error(`Expected authentication to be available`);
+			reporter.log(`Opening connection to IG.Asset.Server`);
+			const sessionManager = await createAssetServiceSessionManager({
+				url: options.service,
+				address: options.address,
+				domain: publishDomain,
+				subDomain: publishSubdomain,
+				authentication: options.authentication
+			});
+			try {
+				if (!options.skipDependencies) try {
+					await synchronizeDependencies(workspace, packageDescription, sessionManager, options.prompter, reporter);
+				} catch (err) {
+					reporter.error(`Failed to synchronize dependencies for ${packageDescription.Package}`, err instanceof Error ? err : new Error(String(err)));
+				}
+				reporter.log(`Uploading package to ${publishDomain}.${publishSubdomain}`);
+				await assetService_exports.uploadPackageFromBuffer(sessionManager.getTargetSession(), assetServerPackageDetails, await buffer(uploadable.getStream()));
+			} finally {
+				await sessionManager.destroy().catch((err) => {
+					reporter.error(`Failed to close IG.Asset.Server session(s)`, err);
+				});
+			}
+		}
+	} catch (err) {
+		versionFile.reset();
+		throw err;
+	}
+	if (newVersion.buildNumber >= 100 && !options.pushOnly) {
+		reporter.error("Copying zip to releases folder");
+		const zipFileName = `${packageNameWithVersion}.zip`;
+		const releasesPath = getPackageReleasesDirectory(location);
+		await fs.mkdir(releasesPath, { recursive: true });
+		await pipeline(uploadable.getStream(), createWriteStream(path.join(releasesPath, zipFileName)));
+	}
+};
+//#endregion
+//#region src/commands/generateIndex.ts
+/**
+* Extracts and returns script array for _Index.json from a src folder
+*
+* @param folderPath path to a src folder
+*/
+function generateIndex({ location, ignore = [], strictOptional }) {
+	const arr = [];
+	const existingIndex = readPackageCreatorIndex(location) ?? [];
+	const manifest = readPackageCreatorManifest(location);
+	const compilerOptions = readScriptPackageTSConfig(location).options;
+	const isModule = compilerOptions.module === ts.ModuleKind.ES2015 || compilerOptions.module === ts.ModuleKind.ESNext;
+	if (strictOptional === void 0) strictOptional = compilerOptions.strict === true || compilerOptions.strictNullChecks === true;
+	const files = getPackageTypescriptFiles(location).filter((path) => !ignore.some((suffix) => path.endsWith(suffix)));
+	let program;
+	let rootNamespace;
+	if (isModule) {
+		const entryFilePath = resolveScriptPackageEntryModule(location, manifest);
+		if (entryFilePath === void 0) throw new Error(`Could not resolve entry module`);
+		const host = ts.createCompilerHost({}, true);
+		program = ts.createProgram([entryFilePath], {
+			allowJs: true,
+			...compilerOptions
+		}, host);
+		const entryFile = program.getSourceFile(entryFilePath);
+		if (entryFile === void 0) throw new Error(`Failed to find entry module`);
+		rootNamespace = resolveNamespaces(entryFile, program, host, program.getTypeChecker(), manifest.Scope ?? manifest.Package);
+	} else program = ts.createProgram(files, { allowJs: true });
+	const typeChecker = program.getTypeChecker();
+	files.forEach((file) => {
+		const sourceFile = program.getSourceFile(file);
+		if (sourceFile === void 0) return;
+		const namespace = rootNamespace === void 0 ? void 0 : findNamespaceByMemberSourceFile(rootNamespace, sourceFile);
+		for (const scriptingClass of findScriptingClasses(sourceFile)) {
+			if (scriptingClass.node.name === void 0) throw new Error(`Expected ${scriptingClass.type} class to have a name`);
+			let name;
+			if (isModule && namespace !== void 0) name = `${resolveNamespaceFullName(namespace)}.${scriptingClass.node.name.text}`;
+			else name = typeChecker.getFullyQualifiedName(typeChecker.getSymbolAtLocation(scriptingClass.node.name));
+			const parameterDeclaration = getScriptingClassParameterdeclaration(scriptingClass);
+			const parametersType = parameterDeclaration === void 0 ? void 0 : typeChecker.getTypeAtLocation(parameterDeclaration);
+			if (parametersType === void 0) 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?.Description ?? name,
+				Type: scriptingClass.type === "evaluator" ? "Evaluator" : "Interactor",
+				Parameters: []
+			};
+			const dict = getTagDict(ts.getJSDocTags(scriptingClass.node));
+			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 !== void 0) {
+				obj.Parameters = parseParametersList(typeChecker.getPropertiesOfType(parametersType), strictOptional);
+				if (obj.Parameters.length === 0 && parametersType.getStringIndexType() !== void 0) obj.Parameters = existingIndexEntry?.Parameters ?? [];
+			} else if (existingIndexEntry !== void 0) obj.Parameters = existingIndexEntry.Parameters;
+			arr.push(obj);
+		}
+	});
+	arr.sort((a, b) => a.Name.localeCompare(b.Name));
+	writePackageCreatorIndex(location, arr);
+}
+function capitalizeFirstLetter(string) {
+	return string?.charAt(0).toUpperCase() + 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";
+		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) => {
+		const parameter = {
+			Name: symbol.name,
+			Description: void 0,
+			Type: "String",
+			Default: void 0,
+			DisplayIndex: i + 1
+		};
+		if (parameter.Name.length > 45) throw new Error(`Parameter name length >45 '${parameter.Name}'`);
+		let declaration = symbol.getDeclarations()?.[0];
+		let documentationComment = symbol.getDocumentationComment(void 0);
+		let checkLinksSymbol = symbol;
+		while (checkLinksSymbol !== void 0 && declaration === void 0) {
+			const links = checkLinksSymbol.links;
+			if (links?.syntheticOrigin) {
+				declaration = links.syntheticOrigin.getDeclarations()?.[0];
+				if (documentationComment.length === 0) documentationComment = links.syntheticOrigin.getDocumentationComment(void 0);
+				checkLinksSymbol = links.syntheticOrigin;
+			}
+		}
+		if (declaration !== void 0) {
+			const dict = getTagDict(ts.getJSDocTags(declaration));
+			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 !== void 0) {
+					const parsedType = parseTypeFromName(propertySignature.type.getText());
+					if (parsedType !== void 0) parameter.Type = parsedType;
+				}
+			}
+			if (dict.default) parameter.Default = parseDefault(dict.default, parameter.Type);
+			if (strictOptional && declaration.kind === ts.SyntaxKind.PropertySignature) {
+				if (declaration.questionToken === void 0) 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") return memberNode?.name?.getText() == "Create" && parameterIndex === 2;
+	if (scriptingClass.type === "interactor") return memberNode.kind === ts.SyntaxKind.Constructor && parameterIndex === 0;
+	return false;
+};
+/**
+* Finds interactors and evaluators within a script file
+*
+* @param {ts.Node} node
+* @return {*}
+*/
+function* findScriptingClasses(node) {
+	for (const child of node.getChildren()) {
+		if (!ts.isClassDeclaration(child)) {
+			yield* findScriptingClasses(child);
+			continue;
+		}
+		const scriptingClass = detectScriptingClass(child);
+		if (scriptingClass !== void 0) yield scriptingClass;
+	}
+}
+const detectScriptingClass = (node) => {
+	if (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"));
+	})) return {
+		node,
+		type: "evaluator"
+	};
+	if (node.heritageClauses?.some((clause) => {
+		if (clause.token !== ts.SyntaxKind.ExtendsKeyword) return false;
+		return clause.types.some((type) => type.getText().includes("Interactor"));
+	})) return {
+		node,
+		type: "interactor"
+	};
+};
+//#endregion
+export { buildFolders, buildFoldersWatch, createAssetServiceSessionManager, generateIndex, isScriptPackageModules, readScriptPackageTSConfig, releaseFolder, resolveScriptPackageEntryModule, synchronizeDependencies };
+
+//# sourceMappingURL=lib.js.map