@intelligentgraphics/ig.gfx.packager 3.1.3 → 3.2.0

package/build/index-Dn5_iPca.mjs

@@ -1,1370 +0,0 @@
-import * as path from 'path';
-import * as fs$1 from 'fs/promises';
-import * as terser from 'terser';
-import { EOL } from 'os';
-import ts from 'typescript';
-import * as fs from 'fs';
-import 'resolve';
-import 'write-package';
-import { e as readPackageAnimationList, r as readPackageCreatorManifest, q as readPackageNpmManifest, i as isErrorENOENT } from './cli-CPzBOjl0.mjs';
-import { g as getPackageTypescriptFiles, i as isScriptPackageModules } from './scripts-B3noxiX3.mjs';
-import 'axios';
-import EventEmitter from 'events';
-import { SourceMapGenerator, SourceMapConsumer } from 'source-map-js';
-import 'glob';
-import Ajv from 'ajv';
-
-const consoleReporter = {
-    log (message) {
-        console.log(message);
-    },
-    error (message, _error) {
-        console.error(message);
-    }
-};
-const createPackageScopedReporter = (reporter, scope, index, total, maxNameLength = 15)=>{
-    const numLength = total === undefined ? undefined : total.toString().length;
-    const indexString = total === undefined || total < 2 ? "" : `${index.toString().padStart(numLength, "0")}/${total} `;
-    const identifierString = `${indexString}${scope.padEnd(maxNameLength)}`;
-    return {
-        log (message) {
-            reporter.log(`${identifierString} >> ${message}`);
-        },
-        error (message, error) {
-            reporter.error(`${identifierString} >> ${message}`, error);
-        }
-    };
-};
-
-const tryReadTsConfig = (location)=>{
-    const { config } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
-        try {
-            return fs.readFileSync(path, "utf8");
-        } catch  {
-            return undefined;
-        }
-    });
-    return config;
-};
-const createTSCBuildParticipant = (location, outputDir, 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 === undefined || definitions === undefined) {
-                    throw new Error(`Unexpected: no js or definitions were created`);
-                }
-                env.onBuildEnd({
-                    type: "success",
-                    artefacts: {
-                        js: js.replace(`//# sourceMappingURL=out.js.map`, ""),
-                        declarations: 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.message
-            });
-        }
-        return {
-            destroy: ()=>{}
-        };
-    };
-const createTSCWatchBuildParticipant = (location, outputDir, skipDeclarations)=>{
-    return ({ onBuildStart, onBuildEnd })=>{
-        let state = {
-            diagnostics: [],
-            js: undefined,
-            definitions: undefined,
-            sourceMap: undefined
-        };
-        const customSys = {
-            ...ts.sys,
-            writeFile: (fileName, data, writeByteOrderMark)=>{
-                if (fileName.endsWith(".js")) {
-                    state.js = data;
-                } else if (fileName.endsWith(".d.ts")) {
-                    state.definitions = data;
-                } else if (fileName.endsWith(".js.map")) {
-                    state.sourceMap = data;
-                }
-            }
-        };
-        const registerDiagnostic = (diagnostic)=>{
-            switch(diagnostic.code){
-                // file not found - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4640
-                // probably deleted -> ignore
-                case 6053:
-                    return;
-                // no inputs were found - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L6838
-                // we don't care about this error. a user might have temporarily deleted the last ts file and will readd one later.
-                case 18003:
-                    return;
-            }
-            state.diagnostics.push(diagnostic);
-        };
-        let currentProgram;
-        const reportWatchStatusChanged = (diagnostic)=>{
-            switch(diagnostic.code){
-                // regular watch mode - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4567
-                case 6031:
-                // incremental watch mode - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4571
-                case 6032:
-                    // build start
-                    onBuildStart();
-                    break;
-                // found one error - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L5119
-                case 6193:
-                // found n or 0 errors - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L5123
-                case 6194:
-                    // build end
-                    const emitState = state;
-                    state = {
-                        diagnostics: [],
-                        js: undefined,
-                        definitions: undefined,
-                        sourceMap: undefined
-                    };
-                    if (emitState.diagnostics.length > 0) {
-                        const message = ts.formatDiagnostics(emitState.diagnostics, formattingHost);
-                        onBuildEnd({
-                            type: "error",
-                            error: new Error(message)
-                        });
-                        return;
-                    }
-                    if (emitState.js === undefined) {
-                        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 : undefined,
-                            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 = [
-        "es5",
-        "dom"
-    ];
-    const result = ts.convertCompilerOptionsFromJson(config.compilerOptions, location.scriptsDir);
-    const compilerOptions = {
-        ...result.options,
-        removeComments: false,
-        declaration: !skipDeclarations,
-        sourceMap: true,
-        inlineSources: false,
-        // We don't use tsc to actually emit the files, but we still need to set the correct
-        // output directory so the compiler can rewrite the `reference path` directives.
-        outFile: path.join(outputDir, "out.js"),
-        target: ts.ScriptTarget.ES5,
-        noEmitOnError: true
-    };
-    return compilerOptions;
-};
-function getDeclarationFileReferences(location, program, outputDir) {
-    const references = 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)=>`/// <reference path="${path.relative(outputDir, reference)}" />`).join(EOL);
-    if (referenceString) {
-        referenceString += EOL;
-    }
-    return referenceString;
-}
-
-// Stolen from ig.tools.core
-const toposort = (packages)=>{
-    const queue = Object.getOwnPropertyNames(packages);
-    const result = [];
-    let index = 0;
-    while(queue.length > 0){
-        if (index >= queue.length) {
-            throw new Error("Packages can not have cyclic dependencies");
-        }
-        const queueEntry = queue[index];
-        const dependencies = packages[queueEntry];
-        const dependencyQueued = dependencies.some((dependency)=>queue.includes(dependency));
-        if (dependencyQueued) {
-            index++;
-            continue;
-        }
-        queue.splice(index, 1);
-        index = 0;
-        result.push(queueEntry);
-    }
-    return result;
-};
-
-class BuildManager extends EventEmitter {
-    constructor(manifest, writer, reporter){
-        super(), this.manifest = manifest, this.writer = writer, this.reporter = reporter, this.participants = new Map(), this.states = new Map(), this.participantInstances = [];
-    }
-    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 = new Set();
-                    sourceMap.eachMapping((mapping)=>{
-                        sourceMapGenerator.addMapping({
-                            generated: {
-                                line: lines + mapping.generatedLine,
-                                column: mapping.generatedColumn
-                            },
-                            original: mapping.originalLine !== null && mapping.originalColumn !== null ? {
-                                line: mapping.originalLine,
-                                column: mapping.originalColumn
-                            } : undefined,
-                            source: mapping.source,
-                            name: mapping.name
-                        });
-                        if (mapping.source !== null) {
-                            sources.add(mapping.source);
-                        }
-                    });
-                    for (const source of sources){
-                        const content = sourceMap.sourceContentFor(source);
-                        if (content !== null) {
-                            sourceMapGenerator.setSourceContent(source, content);
-                        }
-                    }
-                }
-                completeResult.js += result.artefacts.js;
-            }
-            if (result.artefacts.declarations) {
-                if (completeResult.declarations) {
-                    completeResult.declarations += "\n";
-                } else {
-                    completeResult.declarations = "";
-                }
-                completeResult.declarations += result.artefacts.declarations;
-            }
-        }
-        completeResult.sourceMap = sourceMapGenerator.toString();
-        this.writer(completeResult).then(()=>{
-            this.emit("build");
-        });
-    }
-}
-
-var animationSchema = {
-    $schema: "http://json-schema.org/draft-07/schema",
-    $id: "https://archive.intelligentgraphics.biz/schemas/gfx/animation.json",
-    $comment: "Version 2023-02-17, Source: ig.data.gfx/Specs/animation.json",
-    title: "Animation description format",
-    additionalProperties: false,
-    type: "object",
-    properties: {
-        $schema: {
-            type: "string"
-        },
-        Id: {
-            type: "string",
-            description: "Animation id, to be unique in the project scope. Needs to be a valid JavaScript identifier."
-        },
-        Animations: {
-            type: "array",
-            description: "Declaration of animation states for gfx objects",
-            items: {
-                type: "object",
-                additionalProperties: false,
-                properties: {
-                    _: {
-                        type: "string",
-                        description: "Comment"
-                    },
-                    Path: {
-                        $ref: "#/definitions/igxcPath"
-                    },
-                    States: {
-                        type: "object",
-                        additionalProperties: {
-                            type: "object",
-                            additionalProperties: false,
-                            properties: {
-                                Position: {
-                                    $ref: "#/definitions/vec3"
-                                },
-                                Rotation: {
-                                    $ref: "#/definitions/rotation"
-                                },
-                                Scaling: {
-                                    $ref: "#/definitions/vec3"
-                                },
-                                Visibility: {
-                                    type: "boolean"
-                                },
-                                Deformation: {
-                                    anyOf: [
-                                        {
-                                            type: "number"
-                                        },
-                                        {
-                                            type: "string"
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        },
-        Kinematics: {
-            oneOf: [
-                {
-                    $ref: "#/definitions/kinematicChain"
-                },
-                {
-                    type: "array",
-                    items: {
-                        $ref: "#/definitions/kinematicChain"
-                    }
-                }
-            ]
-        },
-        LinkedPoints: {
-            type: "object",
-            additionalProperties: {
-                type: "array",
-                items: {
-                    type: "string"
-                }
-            }
-        },
-        _: {
-            type: "string",
-            description: "Comment"
-        }
-    },
-    definitions: {
-        vec3: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                X: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                Y: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                Z: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                _: {
-                    type: "string",
-                    description: "Comment"
-                }
-            }
-        },
-        rotation: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                Q: {
-                    description: "If true, the rotation is considered to be a Quaternion. Otherwise, it's interpreted as Euler arcs and W will be ignored.",
-                    type: "boolean"
-                },
-                X: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                Y: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                Z: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                W: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                _: {
-                    type: "string",
-                    description: "Comment"
-                }
-            }
-        },
-        igxcPath: {
-            type: "string",
-            description: "Relative path of the target object",
-            pattern: "^((o|e)\\d+(\\.(o|e)\\d+)*|\\.)$"
-        },
-        param: {
-            type: "string",
-            pattern: "^Param\\d+$"
-        },
-        kinematicChain: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                GeometryBase: {
-                    type: "string"
-                },
-                Joints: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        properties: {
-                            Name: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        type: "string"
-                                    }
-                                ]
-                            },
-                            HeadX: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        $ref: "#/definitions/igxcPath"
-                                    }
-                                ]
-                            },
-                            HeadY: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        $ref: "#/definitions/igxcPath"
-                                    }
-                                ]
-                            },
-                            HeadZ: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        $ref: "#/definitions/igxcPath"
-                                    }
-                                ]
-                            },
-                            Tail: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        $ref: "#/definitions/igxcPath"
-                                    }
-                                ]
-                            },
-                            LimitLeft: {
-                                type: "number"
-                            },
-                            LimitRight: {
-                                type: "number"
-                            },
-                            LimitUp: {
-                                type: "number"
-                            },
-                            LimitDown: {
-                                type: "number"
-                            },
-                            FollowJointNode: {
-                                $ref: "#/definitions/igxcPath"
-                            },
-                            _TargetNodeForFollow: {
-                                type: "string"
-                            }
-                        }
-                    }
-                },
-                Target: {
-                    oneOf: [
-                        {
-                            $ref: "#/definitions/igxcPath"
-                        },
-                        {
-                            $ref: "#/definitions/param"
-                        },
-                        {
-                            type: "string",
-                            enum: [
-                                "subbase"
-                            ]
-                        }
-                    ]
-                },
-                Parent: {
-                    oneOf: [
-                        {
-                            $ref: "#/definitions/igxcPath"
-                        },
-                        {
-                            type: "string",
-                            enum: [
-                                "root"
-                            ]
-                        }
-                    ]
-                },
-                Tolerance: {
-                    type: "number"
-                },
-                MaxIterations: {
-                    type: "integer"
-                },
-                _: {
-                    type: "string",
-                    description: "Comment"
-                },
-                __: {
-                    type: "string",
-                    description: "Super Comment"
-                }
-            }
-        }
-    }
-};
-
-const createAnimationBuildParticipant = (location, manifest)=>{
-    return (env)=>{
-        env.onBuildStart();
-        bundleAnimations(location, manifest, env.log).then((result)=>{
-            env.onBuildEnd({
-                type: "success",
-                artefacts: {
-                    js: result?.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$1.watch(location.scriptsDir)){
-                if (event.filename?.endsWith(".animation.json")) {
-                    env.onBuildStart();
-                    try {
-                        const result = await bundleAnimations(location, manifest, env.log);
-                        env.onBuildEnd({
-                            type: "success",
-                            artefacts: {
-                                js: result?.js ?? ""
-                            }
-                        });
-                    } catch (err) {
-                        env.onBuildEnd({
-                            type: "error",
-                            error: err.message
-                        });
-                    }
-                }
-            }
-        })();
-        return {
-            destroy: ()=>{}
-        };
-    };
-const bundleAnimations = async (location, manifest, logStep)=>{
-    const animations = new Map();
-    for (const scriptFilePath of readPackageAnimationList(location)){
-        const content = await fs$1.readFile(scriptFilePath, {
-            encoding: "utf8"
-        });
-        let data;
-        try {
-            data = JSON.parse(content);
-        } catch (err) {
-            const relativePath = path.relative(location.path, scriptFilePath);
-            if (err instanceof SyntaxError) {
-                throw new Error(`Encountered invalid syntax in file "${relativePath}": ${String(err)}`);
-            }
-            throw new Error(`Encountered an unexpected error while parsing animation json file at path "${relativePath}"`, {
-                cause: err
-            });
-        }
-        if (!data.Id) {
-            const fileName = path.basename(scriptFilePath, ".animation.json");
-            data.Id = fileName;
-        }
-        (await getAnimationJsonValidation())(data);
-        delete data.$schema;
-        animations.set(data.Id, JSON.stringify(data));
-    }
-    if (animations.size > 0) {
-        const scope = manifest.Scope ?? manifest.Package;
-        const scopeParts = scope.split(".");
-        let js = createNamespace(scopeParts);
-        for (const [name, content] of animations){
-            js += `${scope}["${name}"] = ` + content + ";";
-            logStep(`Adding animation ${scope}.${name}`);
-        }
-        return {
-            js
-        };
-    }
-    return undefined;
-};
-const createNamespace = (parts)=>{
-    let code = `var ${parts[0]};`;
-    for(let index = 0; index < parts.length; index++){
-        const path = parts.slice(0, index + 1).join(".");
-        code += `\n(${path} = ${path} || {});`;
-    }
-    return code;
-};
-let validateAnimationJson;
-const getAnimationJsonValidation = async ()=>{
-    if (validateAnimationJson === undefined) {
-        validateAnimationJson = new Ajv({
-            coerceTypes: true,
-            allErrors: true,
-            removeAdditional: true,
-            useDefaults: "empty",
-            validateSchema: "log"
-        }).compile(animationSchema);
-    }
-    return validateAnimationJson;
-};
-
-// Stolen from ig.tools.core
-class PackageVersion {
-    static{
-        // https://regex101.com/r/90PEY9/1
-        this.fullTextMatcher = /(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?/;
-    }
-    static{
-        this.lineMatcher = /^(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?$/;
-    }
-    static extractFromText(input, description) {
-        if (input === undefined) {
-            throw new Error(`Can not parse version from undefined`);
-        }
-        const match = input.match(PackageVersion.fullTextMatcher);
-        if (!match) {
-            throw new Error(`Could not extract a version from input: ${input}`);
-        }
-        return PackageVersion.fromMatch(match, description);
-    }
-    static extractFromLine(input, description) {
-        if (input === undefined) {
-            throw new Error(`Can not parse version from undefined`);
-        }
-        const match = input.match(PackageVersion.lineMatcher);
-        if (!match) {
-            throw new Error(`Could not parse version from input: ${input}`);
-        }
-        return PackageVersion.fromMatch(match, description);
-    }
-    static equals(a, b, checkPrerelease = false) {
-        if (a.major !== b.major || a.minor !== b.minor || a.patch !== b.patch) {
-            return false;
-        }
-        if (checkPrerelease === false) {
-            return true;
-        }
-        if (a.preRelease === b.preRelease) {
-            return true;
-        }
-        if (a.preRelease === undefined || b.preRelease === undefined) {
-            return false;
-        }
-        return a.preRelease.type === b.preRelease.type && a.preRelease.version === b.preRelease.version;
-    }
-    static fromMatch([, major, , minor = "0", , patch = "0", , build, , preReleaseType, preReleaseNumber], description) {
-        let preRelease = undefined;
-        let buildNumber = 100;
-        if (preReleaseType && preReleaseNumber) {
-            preRelease = {
-                type: preReleaseType,
-                version: parseInt(preReleaseNumber)
-            };
-        }
-        if (build) {
-            buildNumber = Number(build);
-        } else if (description) {
-            const descriptionMatch = description.match(/(\d+)\)$/);
-            if (descriptionMatch) {
-                buildNumber = parseInt(descriptionMatch[1]);
-            }
-        }
-        return new PackageVersion(parseInt(major), parseInt(minor), parseInt(patch), preRelease, buildNumber);
-    }
-    static sort(a, b, ascending = true) {
-        const createSortResult = (a, b)=>ascending ? a - b : b - a;
-        if (a.major !== b.major) {
-            return createSortResult(a.major, b.major);
-        }
-        if (a.minor !== b.minor) {
-            return createSortResult(a.minor, b.minor);
-        }
-        if (a.patch !== b.patch) {
-            return createSortResult(a.patch, b.patch);
-        }
-        return createSortResult(a.preRelease ? a.preRelease.version : 0, b.preRelease ? b.preRelease.version : 0);
-    }
-    static toNumber(version) {
-        return ((version.major * 1000 + version.minor) * 1000 + version.patch) * 1000 + version.buildNumber;
-    }
-    constructor(major, minor, patch, preRelease, buildNumber){
-        this.major = major;
-        this.minor = minor;
-        this.patch = patch;
-        this.preRelease = preRelease;
-        this.buildNumber = buildNumber;
-    }
-    isPreRelease() {
-        return this.preRelease !== undefined;
-    }
-    clone() {
-        return new PackageVersion(this.major, this.minor, this.patch, this.preRelease ? {
-            ...this.preRelease
-        } : undefined, this.buildNumber);
-    }
-    incrementMajor() {
-        this.preRelease = undefined;
-        this.patch = 0;
-        this.minor = 0;
-        this.major++;
-    }
-    incrementMinor() {
-        this.preRelease = undefined;
-        this.patch = 0;
-        this.minor++;
-    }
-    incrementPatch() {
-        this.preRelease = undefined;
-        this.patch++;
-    }
-    createPreRelease(type) {
-        if (!this.preRelease) {
-            this.buildNumber = 1;
-        } else {
-            this.buildNumber++;
-        }
-        if (this.preRelease && type === this.preRelease.type) {
-            this.preRelease.version++;
-            return;
-        }
-        this.preRelease = {
-            version: 0,
-            type
-        };
-    }
-    createRelease() {
-        this.preRelease = undefined;
-        this.buildNumber = 100;
-    }
-    toVersionString({ buildNumber } = {}) {
-        let version = [
-            this.major,
-            this.minor,
-            this.patch
-        ].join(".");
-        if (buildNumber) {
-            version += "." + this.buildNumber;
-        }
-        if (this.preRelease) {
-            version += `-${this.preRelease.type}.${this.preRelease.version}`;
-        }
-        return version;
-    }
-    toDescriptionString(packageName) {
-        const base = [
-            this.major,
-            this.minor,
-            this.patch
-        ].join(".");
-        const parts = [
-            packageName,
-            base
-        ];
-        if (this.preRelease) {
-            parts.push(upperCaseFirst(this.preRelease.type));
-            parts.push(this.preRelease.version);
-        }
-        parts.push(`(${base}.${this.buildNumber})`);
-        return parts.join(" ");
-    }
-    /**
-	 * Determines wether the version is lesser than the input version
-	 *
-	 * @param {PackageVersion} version
-	 * @returns
-	 */ isLesserThan(version) {
-        return PackageVersion.toNumber(this) < PackageVersion.toNumber(version);
-    }
-    /**
-	 * Determines wether the version is greater than the input version
-	 *
-	 * @param {PackageVersion} version
-	 * @returns
-	 */ isGreaterThan(version) {
-        return PackageVersion.toNumber(this) > PackageVersion.toNumber(version);
-    }
-}
-const upperCaseFirst = (input)=>{
-    return input.slice(0, 1).toUpperCase() + input.slice(1);
-};
-
-async function buildFolders(options) {
-    if (options.outDir !== undefined && options.clean) {
-        await fs$1.rm(options.outDir, {
-            recursive: true
-        });
-    }
-    const baseReporter = options.reporter ?? consoleReporter;
-    const workspace = options.workspace;
-    const folders = options.packages;
-    let sortedPackages = sortPackagesByBuildOrder(folders);
-    let index = 1;
-    const manifests = new Map(sortedPackages.map((location)=>[
-            location,
-            readPackageCreatorManifest(location)
-        ]));
-    const maxNameLength = Array.from(manifests.values(), (manifest)=>manifest.Package.length).reduce((acc, length)=>Math.max(acc, length), 0);
-    for (const location of sortedPackages){
-        const tsConfig = await ensureTsConfig(location);
-        const data = manifests.get(location);
-        const reporter = options.preparedReporter ?? createPackageScopedReporter(baseReporter, data.Package, index, folders.length, maxNameLength);
-        const outputDirectory = options.outDir || location.scriptsDir;
-        await fs$1.mkdir(outputDirectory, {
-            recursive: true
-        });
-        const manager = new BuildManager(data, (result)=>writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, reporter), reporter);
-        if (options.banner) {
-            manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
-        }
-        const typescriptFiles = getPackageTypescriptFiles(location);
-        if (!typescriptFiles.some((file)=>path.basename(file).toLowerCase() === "version.ts")) {
-            manager.addParticipant("version", createVersionLogBuildParticipant(data));
-        }
-        if (typescriptFiles.length > 0) {
-            if (isScriptPackageModules(tsConfig.options)) {
-                const { createRollupBuildParticipant } = await import('./rollup-BeQ0dM8U.mjs');
-                manager.addParticipant("rollup", createRollupBuildParticipant(location, data, outputDirectory, !tsConfig.options.declaration));
-            } else {
-                manager.addParticipant("tsc", createTSCBuildParticipant(location, outputDirectory, // in the past we always created declaration files,
-                // so we'll use it as the default for legacy modules
-                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();
-        });
-        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 !== undefined && options.clean) {
-        await fs$1.rm(options.outDir, {
-            recursive: true
-        });
-    }
-    const workspace = options.workspace;
-    const folders = options.packages;
-    options.reporter ?? consoleReporter;
-    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$1.mkdir(outputDirectory, {
-            recursive: true
-        });
-        const manager = new BuildManager(data, (result)=>writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, reporter), reporter);
-        if (options.banner) {
-            manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
-        }
-        const typescriptFiles = getPackageTypescriptFiles(location);
-        if (!typescriptFiles.some((file)=>path.basename(file).toLowerCase() === "version.ts")) {
-            manager.addParticipant("version", createVersionLogBuildParticipant(data));
-        }
-        if (typescriptFiles.length > 0) {
-            if (isScriptPackageModules(tsConfig.options)) {
-                const { createRollupWatchBuildParticipant } = await import('./rollup-BeQ0dM8U.mjs');
-                manager.addParticipant("rollup", createRollupWatchBuildParticipant(location, data, outputDirectory, !tsConfig.options.declaration));
-            } else {
-                manager.addParticipant("tsc", createTSCWatchBuildParticipant(location, outputDirectory, // in the past we always created declaration files,
-                // so we'll use it as the default for legacy modules
-                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$1.writeFile(path.join(outputDirectory, `${manifest.Package}.js`), js, {
-        encoding: "utf8"
-    });
-    if (buildResult.declarations !== undefined) {
-        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.d.ts`), buildResult.declarations, {
-            encoding: "utf8"
-        });
-    }
-    if (buildResult.sourceMap !== undefined) {
-        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.js.map`), buildResult.sourceMap, {
-            encoding: "utf8"
-        });
-    }
-    if (minimize) {
-        reporter.log("Minifying the output");
-        const minifyResult = await terser.minify(js, {
-            ecma: 5,
-            sourceMap: {
-                content: buildResult.sourceMap,
-                includeSources: false
-            }
-        });
-        const minifiedPath = path.join(outputDirectory, `${manifest.Package}.min.js`);
-        let code = minifyResult.code;
-        if (minifyResult.map) {
-            code += `\n//# sourceMappingURL=${manifest.Package}.min.js.map`;
-        }
-        await fs$1.writeFile(minifiedPath, code, {
-            encoding: "utf8"
-        });
-        if (minifyResult.map !== undefined) {
-            await fs$1.writeFile(minifiedPath + ".map", typeof minifyResult.map === "string" ? minifyResult.map : JSON.stringify(minifyResult.map), {
-                encoding: "utf8"
-            });
-        }
-    }
-    if (location.path.includes("Basics") && buildResult.declarations !== undefined) {
-        await fs$1.mkdir(path.join(workspace.path, "lib"), {
-            recursive: true
-        });
-        reporter.log("Copying basics definition file to the lib folder");
-        await fs$1.writeFile(path.join(workspace.path, "lib", `${manifest.Package}.d.ts`), buildResult.declarations, {
-            encoding: "utf8"
-        });
-    }
-}
-function createVersionLogBuildParticipant(manifest) {
-    return (env)=>{
-        env.onBuildStart();
-        const parsedVersion = manifest.Version !== undefined ? PackageVersion.extractFromLine(manifest.Version) : undefined;
-        let logText;
-        if (parsedVersion !== undefined) {
-            logText = parsedVersion.toDescriptionString(manifest.Package);
-        } else {
-            logText = manifest.Package;
-        }
-        logText += ".";
-        if (manifest.Copyright !== undefined) {
-            logText += " " + manifest.Copyright;
-        }
-        env.onBuildEnd({
-            type: "success",
-            artefacts: {
-                js: `console.log(${JSON.stringify(logText)})`
-            }
-        });
-        return {
-            destroy: ()=>{}
-        };
-    };
-}
-function createBannerCommentBuildParticipant(options) {
-    return (env)=>{
-        env.onBuildStart();
-        const banner = createBannerComment(options);
-        env.onBuildEnd({
-            type: "success",
-            artefacts: {
-                js: banner ?? "",
-                declarations: banner ?? ""
-            }
-        });
-        return {
-            destroy: ()=>{}
-        };
-    };
-}
-async function ensureTsConfig(location) {
-    const tsconfigPath = path.join(location.scriptsDir, "tsconfig.json");
-    try {
-        const content = JSON.parse(await fs$1.readFile(tsconfigPath, "utf8"));
-        applyTsConfigOptions(content);
-        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
-        return ts.parseJsonConfigFileContent(content, ts.sys, location.scriptsDir);
-    } catch (err) {
-        if (!isErrorENOENT(err)) {
-            throw err;
-        }
-        const content = {};
-        applyTsConfigOptions(content);
-        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
-        return ts.parseJsonConfigFileContent(content, ts.sys, location.scriptsDir);
-    }
-}
-function applyTsConfigOptions(data) {
-    if (data.compilerOptions?.module?.toLowerCase().startsWith("es")) {
-        data.compilerOptions = data.compilerOptions ?? {};
-        data.compilerOptions.target = "esnext";
-        data.compilerOptions.lib = [
-            "es2024",
-            "dom"
-        ];
-        data.compilerOptions.module = "es2015";
-        data.compilerOptions.moduleResolution = "node";
-    } else {
-        data.compilerOptions = data.compilerOptions ?? {};
-        data.compilerOptions.target = "es5";
-        data.compilerOptions.lib = [
-            "es5",
-            "dom"
-        ];
-    }
-}
-function sortPackagesByBuildOrder(folders) {
-    const packages = Array.from(folders).reduce((acc, location)=>{
-        const data = readPackageNpmManifest(location);
-        if (data !== undefined) {
-            acc[data.name] = {
-                data,
-                location
-            };
-        } else {
-            acc[location.path] = {
-                data: undefined,
-                location
-            };
-        }
-        return acc;
-    }, {});
-    const packageDependencies = Object.getOwnPropertyNames(packages).reduce((acc, packageName)=>{
-        const packageData = packages[packageName];
-        if (packageData.data === undefined) {
-            acc[packageName] = [];
-        } else {
-            acc[packageName] = Object.getOwnPropertyNames({
-                ...packageData.data.devDependencies,
-                ...packageData.data.dependencies,
-                ...packageData.data.peerDependencies
-            }).filter((packageName)=>packages[packageName] !== undefined);
-        }
-        return acc;
-    }, {});
-    const sortedPackages = toposort(packageDependencies);
-    const result = [];
-    for (const packageName of sortedPackages){
-        const location = packages[packageName].location;
-        if (readPackageCreatorManifest(location).Package.endsWith(".Basics")) {
-            result.unshift(location);
-        } else {
-            result.push(location);
-        }
-    }
-    return result;
-}
-function createBannerComment(banner) {
-    const bannerParts = [];
-    if (banner.text) {
-        bannerParts.push(" * " + banner.text);
-    }
-    {
-        const details = [];
-        if (banner.version) {
-            details.push(`Version: ${banner.version}`);
-        }
-        if (banner.commit) {
-            if (banner.commitDirty) {
-                details.push(`Commit: ${banner.commit} (dirty)`);
-            } else {
-                details.push(`Commit: ${banner.commit}`);
-            }
-        }
-        if (banner.date) {
-            details.push(`Date: ${banner.date.toISOString()}`);
-        }
-        const detailsText = details.map((line)=>` * ${line}`).join("\n");
-        if (detailsText) {
-            bannerParts.push(detailsText);
-        }
-    }
-    const bannerText = bannerParts.join("\n\n");
-    if (bannerText) {
-        return `/*
-${bannerText}
-*
-* @preserve			
-*/`;
-    }
-    return undefined;
-}
-
-var index = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    buildFolders: buildFolders,
-    buildFoldersWatch: buildFoldersWatch
-});
-
-export { PackageVersion as P, consoleReporter as a, buildFolders as b, createPackageScopedReporter as c, index as i };
-//# sourceMappingURL=index-Dn5_iPca.mjs.map