@intelligentgraphics/ig.gfx.packager 3.1.4 → 3.2.1

package/build/build-CMbCj7x-.js

@@ -0,0 +1,945 @@
+import { A as isErrorENOENT, S as readPackageAnimationList, T as readPackageNpmManifest, i as createPackageScopedReporter, n as getPackageTypescriptFiles, r as consoleReporter, w as readPackageCreatorManifest } from "./build-kkMVBBJL.js";
+import "./package-DHx2bvVO.js";
+import "./workspace-D0XY2EMu.js";
+import { t as isScriptPackageModules } from "./scripts-CBblHIL1.js";
+import * as fs$1 from "node:fs";
+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 EventEmitter from "events";
+import { SourceMapConsumer, SourceMapGenerator } from "source-map-js";
+import Ajv from "ajv";
+//#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-Csyght27.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-Csyght27.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
+export { buildFolders, buildFoldersWatch, PackageVersion as t };
+
+//# sourceMappingURL=build-CMbCj7x-.js.map