@notask/unity-cli-tools 1.2.0-rc.1 → 2.0.0

package/dist/cjs/errors/Result.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ok = ok;
+exports.err = err;
+exports.isOk = isOk;
+exports.isErr = isErr;
+exports.unwrap = unwrap;
+exports.unwrapOr = unwrapOr;
+exports.map = map;
+exports.mapErr = mapErr;
+exports.andThen = andThen;
+exports.firstOk = firstOk;
+exports.combine = combine;
+function ok(value) {
+    return { success: true, value };
+}
+function err(error) {
+    return { success: false, error };
+}
+function isOk(result) {
+    return result.success === true;
+}
+function isErr(result) {
+    return result.success === false;
+}
+function unwrap(result) {
+    if (isOk(result)) {
+        return result.value;
+    }
+    throw result.error;
+}
+function unwrapOr(result, defaultValue) {
+    if (isOk(result)) {
+        return result.value;
+    }
+    return defaultValue;
+}
+function map(result, fn) {
+    if (isOk(result)) {
+        return ok(fn(result.value));
+    }
+    return result;
+}
+function mapErr(result, fn) {
+    if (isErr(result)) {
+        return err(fn(result.error));
+    }
+    return result;
+}
+function andThen(result, fn) {
+    if (isOk(result)) {
+        return fn(result.value);
+    }
+    return result;
+}
+function firstOk(results) {
+    if (results.length === 0) {
+        throw new Error("Cannot call firstOk on empty array");
+    }
+    for (const result of results) {
+        if (isOk(result)) {
+            return result;
+        }
+    }
+    return results[results.length - 1];
+}
+function combine(results) {
+    const values = [];
+    for (const result of results) {
+        if (isErr(result)) {
+            return result;
+        }
+        values.push(result.value);
+    }
+    return ok(values);
+}

package/dist/cjs/errors/UnityError.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidArgumentError = exports.UnityTestError = exports.UnityPackageError = exports.UnityLicenseError = exports.UnityProjectError = exports.UnityInstallationError = exports.UnityCommandError = exports.UnityEditorNotFoundError = exports.UnityHubNotFoundError = exports.UnityError = void 0;
+class UnityError extends Error {
+    code;
+    context;
+    constructor(message, code, context) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.context = context;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.UnityError = UnityError;
+class UnityHubNotFoundError extends UnityError {
+    constructor(message = "Unity Hub is not available", context) {
+        super(message, "UNITY_HUB_NOT_FOUND", context);
+    }
+}
+exports.UnityHubNotFoundError = UnityHubNotFoundError;
+class UnityEditorNotFoundError extends UnityError {
+    constructor(version, path) {
+        super(`Unity Editor version ${version} not found${path ? ` at path: ${path}` : ""}`, "UNITY_EDITOR_NOT_FOUND", { version, path });
+    }
+}
+exports.UnityEditorNotFoundError = UnityEditorNotFoundError;
+class UnityCommandError extends UnityError {
+    stdout;
+    stderr;
+    exitCode;
+    constructor(message, stdout = "", stderr = "", exitCode, context) {
+        super(message, "UNITY_COMMAND_ERROR", context);
+        this.stdout = stdout;
+        this.stderr = stderr;
+        this.exitCode = exitCode;
+    }
+}
+exports.UnityCommandError = UnityCommandError;
+class UnityInstallationError extends UnityError {
+    constructor(message, context) {
+        super(message, "UNITY_INSTALLATION_ERROR", context);
+    }
+}
+exports.UnityInstallationError = UnityInstallationError;
+class UnityProjectError extends UnityError {
+    constructor(message, context) {
+        super(message, "UNITY_PROJECT_ERROR", context);
+    }
+}
+exports.UnityProjectError = UnityProjectError;
+class UnityLicenseError extends UnityError {
+    constructor(message, context) {
+        super(message, "UNITY_LICENSE_ERROR", context);
+    }
+}
+exports.UnityLicenseError = UnityLicenseError;
+class UnityPackageError extends UnityError {
+    constructor(message, context) {
+        super(message, "UNITY_PACKAGE_ERROR", context);
+    }
+}
+exports.UnityPackageError = UnityPackageError;
+class UnityTestError extends UnityError {
+    testOutput;
+    constructor(message, testOutput = "", context) {
+        super(message, "UNITY_TEST_ERROR", context);
+        this.testOutput = testOutput;
+    }
+}
+exports.UnityTestError = UnityTestError;
+class InvalidArgumentError extends UnityError {
+    constructor(message, context) {
+        super(message, "INVALID_ARGUMENT", context);
+    }
+}
+exports.InvalidArgumentError = InvalidArgumentError;

package/dist/cjs/errors/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Result.js"), exports);
+__exportStar(require("./UnityError.js"), exports);

package/dist/cjs/events/hubEventEmitter.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnityHubInstallerEvent = void 0;
 const events_1 = require("events");
-const unity_ts_1 = require("../types/unity.js");
-const hubEventParser_ts_1 = require("./hubEventParser.js");
+const unity_js_1 = require("../types/unity.js");
+const hubEventParser_js_1 = require("./hubEventParser.js");
 class UnityHubInstallerEvent extends events_1.EventEmitter {
     #moduleTracker = new Map();
     constructor() {
@@ -24,37 +24,37 @@ class UnityHubInstallerEvent extends events_1.EventEmitter {
                 reject(new Error("Cancelled"));
             };
             const cleanup = () => {
-                this.off(unity_ts_1.InstallerEventType.Completed, onComplete);
-                this.off(unity_ts_1.InstallerEventType.Error, onError);
-                this.off(unity_ts_1.InstallerEventType.Cancelled, onCancel);
+                this.off(unity_js_1.InstallerEventType.Completed, onComplete);
+                this.off(unity_js_1.InstallerEventType.Error, onError);
+                this.off(unity_js_1.InstallerEventType.Cancelled, onCancel);
             };
-            this.on(unity_ts_1.InstallerEventType.Completed, onComplete);
-            this.on(unity_ts_1.InstallerEventType.Error, onError);
-            this.on(unity_ts_1.InstallerEventType.Cancelled, onCancel);
+            this.on(unity_js_1.InstallerEventType.Completed, onComplete);
+            this.on(unity_js_1.InstallerEventType.Error, onError);
+            this.on(unity_js_1.InstallerEventType.Cancelled, onCancel);
         });
     }
     Progress(raw) {
-        const events = hubEventParser_ts_1.UnityHubEventParser.parseUnityHubEvent(raw);
+        const events = hubEventParser_js_1.UnityHubEventParser.parseUnityHubEvent(raw);
         if (events.length === 0)
             return;
         this.#Error(events);
-        const progressEvents = events.filter((e) => e.status !== unity_ts_1.InstallerStatus.Error);
+        const progressEvents = events.filter((e) => e.status !== unity_js_1.InstallerStatus.Error);
         if (progressEvents.length === 0)
             return;
-        this.emit(unity_ts_1.InstallerEventType.Progress, progressEvents);
+        this.emit(unity_js_1.InstallerEventType.Progress, progressEvents);
         this.#updateModuleTracker(events);
         this.#Complete(progressEvents);
     }
     #Error(events) {
-        const errorEvents = events.filter((e) => e.status === unity_ts_1.InstallerStatus.Error);
+        const errorEvents = events.filter((e) => e.status === unity_js_1.InstallerStatus.Error);
         if (errorEvents.length === 0)
             return;
-        this.emit(unity_ts_1.InstallerEventType.Error, errorEvents);
+        this.emit(unity_js_1.InstallerEventType.Error, errorEvents);
     }
     #Complete(events) {
-        const installed = events.filter((e) => e.status === unity_ts_1.InstallerStatus.Installed);
+        const installed = events.filter((e) => e.status === unity_js_1.InstallerStatus.Installed);
         if (installed.length > 0 && installed.length === events.length) {
-            this.emit(unity_ts_1.InstallerEventType.Completed, installed);
+            this.emit(unity_js_1.InstallerEventType.Completed, installed);
         }
     }
     Cancel() {
@@ -62,7 +62,7 @@ class UnityHubInstallerEvent extends events_1.EventEmitter {
         this.#Cancelled([]);
     }
     #Cancelled(event) {
-        this.emit(unity_ts_1.InstallerEventType.Cancelled, event);
+        this.emit(unity_js_1.InstallerEventType.Cancelled, event);
     }
     #updateModuleTracker(events) {
         for (const event of events) {

package/dist/cjs/events/hubEventParser.js

@@ -1,44 +1,114 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnityHubEventParser = void 0;
-const unity_ts_1 = require("../types/unity.js");
+const index_js_1 = require("./patterns/index.js");
 class UnityHubEventParser {
-    static errorPatterns = [/Error:.*/];
+    static patternRegistry;
+    static statusNormalizer;
+    static config = {
+        locale: "en",
+        logUnknownStatuses: true,
+        minConfidence: 30,
+        useFallbackPatterns: true,
+    };
+    static initialize() {
+        if (this.patternRegistry) {
+            return;
+        }
+        this.statusNormalizer = new index_js_1.StatusNormalizer();
+        this.patternRegistry = new index_js_1.PatternRegistry();
+        this.patternRegistry.register(new index_js_1.ErrorPattern(this.config.locale));
+        this.patternRegistry.register(new index_js_1.BracketModulePattern(this.statusNormalizer, this.config.locale));
+        if (this.config.useFallbackPatterns) {
+            this.patternRegistry.register(new index_js_1.FallbackPattern(this.statusNormalizer, this.config.locale));
+        }
+    }
     static parseUnityHubEvent(event) {
+        this.initialize();
+        const result = this.parseWithDetails(event);
+        return result.events;
+    }
+    static parseWithDetails(event) {
+        this.initialize();
         const events = [];
-        const lines = event.split("\n");
+        const unparsedLines = [];
+        const lines = event.split(/\r?\n/);
         for (const line of lines) {
-            const errorLine = this.checkForErrors(line);
-            if (errorLine) {
-                events.push(errorLine);
+            const trimmedLine = line.trim();
+            if (!trimmedLine) {
                 continue;
             }
-        }
-        const pattern = /^\[(?<module>[^\]]+)\]\s+(?<status>.+?)(?:(?:\s+(?<progress>\d+(?:\.\d+)?))%)?\.*$/;
-        for (const line of lines) {
-            const match = line.match(pattern);
-            if (match?.groups) {
-                const { module, status, progress } = match.groups;
+            const match = this.patternRegistry.match(trimmedLine, this.config.locale, this.config.minConfidence);
+            if (match) {
                 events.push({
-                    module: module.trim(),
-                    status: status.replace(/\.\.\.$/, "").trim(),
-                    progress: progress ? parseFloat(progress) : status !== unity_ts_1.InstallerStatus.Downloading ? null : 0,
+                    module: match.module,
+                    status: match.status,
+                    progress: match.progress,
+                    error: match.error,
                 });
             }
-        }
-        return events;
-    }
-    static checkForErrors(line) {
-        for (const pattern of this.errorPatterns) {
-            if (pattern.test(line)) {
-                return {
-                    module: "UnityHub",
-                    status: unity_ts_1.InstallerStatus.Error,
-                    error: line.trim(),
-                };
+            else {
+                unparsedLines.push(trimmedLine);
+                if (this.config.logUnknownStatuses) {
+                    console.debug(`UnityHubEventParser: Could not parse line: "${trimmedLine}"`);
+                }
             }
         }
-        return null;
+        return {
+            events,
+            unknownStatuses: this.statusNormalizer.getUnknownStatuses(),
+            unparsedLines,
+        };
+    }
+    static setLocale(locale) {
+        this.config.locale = locale;
+        if (this.patternRegistry) {
+            this.patternRegistry.clear();
+            this.initialize();
+        }
+    }
+    static getLocale() {
+        return this.config.locale;
+    }
+    static registerCustomPattern(pattern) {
+        this.initialize();
+        this.patternRegistry.register(pattern);
+    }
+    static addStatusNormalization(statusText, status, locale) {
+        this.initialize();
+        this.statusNormalizer.addNormalization({ text: statusText, status, locale });
+    }
+    static getUnknownStatuses() {
+        this.initialize();
+        return this.statusNormalizer.getUnknownStatuses();
+    }
+    static clearUnknownStatuses() {
+        this.initialize();
+        this.statusNormalizer.clearUnknownStatuses();
+    }
+    static configure(config) {
+        this.config = { ...this.config, ...config };
+        if (config.locale && this.patternRegistry) {
+            this.patternRegistry.clear();
+            this.initialize();
+        }
+    }
+    static getConfig() {
+        return { ...this.config };
+    }
+    static reset() {
+        this.patternRegistry = undefined;
+        this.statusNormalizer = undefined;
+        this.config = {
+            locale: "en",
+            logUnknownStatuses: true,
+            minConfidence: 30,
+            useFallbackPatterns: true,
+        };
+    }
+    static getPatternNames() {
+        this.initialize();
+        return this.patternRegistry.getPatternNames();
     }
 }
 exports.UnityHubEventParser = UnityHubEventParser;

package/dist/cjs/events/patterns/implementations/bracketModulePattern.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BracketModulePattern = void 0;
+const unity_js_1 = require("../../../types/unity.js");
+class BracketModulePattern {
+    name = "BracketModulePattern";
+    priority = 80;
+    locale;
+    statusNormalizer;
+    pattern = /^\s*[\[\(]([^\]\)]+)[\]\)]\s+(.+?)(?:\s+(\d+(?:\.\d+)?)\s*%)?\.{0,3}\s*$/;
+    constructor(statusNormalizer, locale) {
+        this.statusNormalizer = statusNormalizer;
+        this.locale = locale;
+    }
+    match(line, locale) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) {
+            return null;
+        }
+        const match = trimmedLine.match(this.pattern);
+        if (!match) {
+            return null;
+        }
+        const [, moduleName, statusText, progressStr] = match;
+        if (!moduleName || !statusText) {
+            return null;
+        }
+        const effectiveLocale = locale || this.locale;
+        const normalizedStatus = this.statusNormalizer.normalize(statusText, effectiveLocale);
+        if (!normalizedStatus) {
+            return {
+                module: moduleName.trim(),
+                status: statusText.trim(),
+                progress: progressStr ? parseFloat(progressStr) : null,
+                confidence: 40,
+            };
+        }
+        let progress = null;
+        if (progressStr) {
+            const parsed = parseFloat(progressStr);
+            if (!isNaN(parsed) && parsed >= 0 && parsed <= 100) {
+                progress = parsed;
+            }
+        }
+        else if (normalizedStatus === unity_js_1.InstallerStatus.Downloading ||
+            normalizedStatus === unity_js_1.InstallerStatus.Installing) {
+            progress = 0;
+        }
+        return {
+            module: moduleName.trim(),
+            status: normalizedStatus,
+            progress,
+            confidence: 85,
+        };
+    }
+}
+exports.BracketModulePattern = BracketModulePattern;

package/dist/cjs/events/patterns/implementations/errorPattern.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorPattern = void 0;
+const unity_js_1 = require("../../../types/unity.js");
+var ErrorSeverity;
+(function (ErrorSeverity) {
+    ErrorSeverity["Critical"] = "critical";
+    ErrorSeverity["Error"] = "error";
+    ErrorSeverity["Warning"] = "warning";
+})(ErrorSeverity || (ErrorSeverity = {}));
+class ErrorPattern {
+    name = "ErrorPattern";
+    priority = 90;
+    locale;
+    criticalPatterns = [
+        /\b(?:fatal|critical|emergency)\b/i,
+        /\bexception\b/i,
+        /\bstack\s*trace\b/i,
+        /\bcrash(?:ed)?\b/i,
+    ];
+    errorPatterns = [
+        /\berror\s*:/i,
+        /\berror\b/i,
+        /\bfailed\b/i,
+        /\bcannot\b/i,
+        /\bunable\s+to\b/i,
+        /\bcould\s+not\b/i,
+        /\bfailure\b/i,
+    ];
+    warningPatterns = [/\bwarning\s*:/i, /\bwarning\b/i, /\bcaution\b/i];
+    localizedErrorPatterns = new Map([
+        ["ja", [/エラー/, /失敗/, /例外/, /できません/]],
+        ["de", [/fehler/i, /fehlgeschlagen/i, /ausnahme/i, /kann\s+nicht/i]],
+        ["fr", [/erreur/i, /échec/i, /échoué/i, /exception/i, /impossible/i]],
+        ["es", [/error/i, /fallo/i, /fallido/i, /excepción/i, /no\s+se\s+puede/i]],
+        ["zh-Hans", [/错误/, /失败/, /异常/, /无法/]],
+        ["zh-Hant", [/錯誤/, /失敗/, /異常/, /無法/]],
+        ["ko", [/오류/, /실패/, /예외/, /할\s*수\s*없습니다/]],
+    ]);
+    constructor(locale) {
+        this.locale = locale;
+    }
+    match(line, locale) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) {
+            return null;
+        }
+        const effectiveLocale = locale || this.locale;
+        if (this.matchesAnyPattern(trimmedLine, this.criticalPatterns)) {
+            return this.createErrorMatch(trimmedLine, ErrorSeverity.Critical, 95);
+        }
+        if (this.matchesAnyPattern(trimmedLine, this.errorPatterns)) {
+            return this.createErrorMatch(trimmedLine, ErrorSeverity.Error, 90);
+        }
+        if (effectiveLocale && this.localizedErrorPatterns.has(effectiveLocale)) {
+            const patterns = this.localizedErrorPatterns.get(effectiveLocale);
+            if (this.matchesAnyPattern(trimmedLine, patterns)) {
+                return this.createErrorMatch(trimmedLine, ErrorSeverity.Error, 88);
+            }
+        }
+        if (this.matchesAnyPattern(trimmedLine, this.warningPatterns)) {
+            return this.createErrorMatch(trimmedLine, ErrorSeverity.Warning, 70);
+        }
+        return null;
+    }
+    matchesAnyPattern(line, patterns) {
+        return patterns.some((pattern) => pattern.test(line));
+    }
+    createErrorMatch(line, severity, confidence) {
+        const bracketMatch = line.match(/^\s*[\[\(]([^\]\)]+)[\]\)]/);
+        const module = bracketMatch ? bracketMatch[1].trim() : "UnityHub";
+        return {
+            module,
+            status: unity_js_1.InstallerStatus.Error,
+            error: line.trim(),
+            confidence,
+        };
+    }
+    addErrorPattern(pattern, severity = ErrorSeverity.Error) {
+        switch (severity) {
+            case ErrorSeverity.Critical:
+                this.criticalPatterns.push(pattern);
+                break;
+            case ErrorSeverity.Error:
+                this.errorPatterns.push(pattern);
+                break;
+            case ErrorSeverity.Warning:
+                this.warningPatterns.push(pattern);
+                break;
+        }
+    }
+    addLocalizedPatterns(locale, patterns) {
+        if (!this.localizedErrorPatterns.has(locale)) {
+            this.localizedErrorPatterns.set(locale, []);
+        }
+        this.localizedErrorPatterns.get(locale).push(...patterns);
+    }
+}
+exports.ErrorPattern = ErrorPattern;

package/dist/cjs/events/patterns/implementations/fallbackPattern.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackPattern = void 0;
+class FallbackPattern {
+    name = "FallbackPattern";
+    priority = 20;
+    locale;
+    statusNormalizer;
+    constructor(statusNormalizer, locale) {
+        this.statusNormalizer = statusNormalizer;
+        this.locale = locale;
+    }
+    match(line, locale) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) {
+            return null;
+        }
+        const effectiveLocale = locale || this.locale;
+        const progressMatch = trimmedLine.match(/(\d+(?:\.\d+)?)\s*%/);
+        const progress = progressMatch ? parseFloat(progressMatch[1]) : null;
+        const statusMatch = this.findStatusInLine(trimmedLine, effectiveLocale);
+        if (!statusMatch) {
+            return null;
+        }
+        const moduleName = this.extractModuleName(trimmedLine, statusMatch.statusText);
+        return {
+            module: moduleName || "Unknown",
+            status: statusMatch.status,
+            progress,
+            confidence: 30,
+        };
+    }
+    findStatusInLine(line, locale) {
+        const normalizations = this.statusNormalizer.getNormalizationsForLocale(locale);
+        const sortedNormalizations = Array.from(normalizations.entries()).sort((a, b) => b[0].length - a[0].length);
+        for (const [statusText, status] of sortedNormalizations) {
+            const pattern = new RegExp(`\\b${this.escapeRegex(statusText)}\\b`, "i");
+            if (pattern.test(line)) {
+                return { status, statusText };
+            }
+        }
+        return null;
+    }
+    extractModuleName(line, statusText) {
+        let cleanLine = line.replace(new RegExp(`\\b${this.escapeRegex(statusText)}\\b`, "gi"), "");
+        cleanLine = cleanLine.replace(/\d+(?:\.\d+)?\s*%/, "");
+        cleanLine = cleanLine.replace(/[:\-\[\]\(\)]/g, " ");
+        cleanLine = cleanLine.trim();
+        const words = cleanLine.split(/\s+/).filter((w) => w.length > 0);
+        if (words.length === 0) {
+            return null;
+        }
+        const capitalizedWords = words.filter((w) => /^[A-Z]/.test(w));
+        if (capitalizedWords.length > 0) {
+            return capitalizedWords.join(" ");
+        }
+        return words.join(" ");
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+}
+exports.FallbackPattern = FallbackPattern;

package/dist/cjs/events/patterns/implementations/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackPattern = exports.ErrorPattern = exports.BracketModulePattern = void 0;
+var bracketModulePattern_js_1 = require("./bracketModulePattern.js");
+Object.defineProperty(exports, "BracketModulePattern", { enumerable: true, get: function () { return bracketModulePattern_js_1.BracketModulePattern; } });
+var errorPattern_js_1 = require("./errorPattern.js");
+Object.defineProperty(exports, "ErrorPattern", { enumerable: true, get: function () { return errorPattern_js_1.ErrorPattern; } });
+var fallbackPattern_js_1 = require("./fallbackPattern.js");
+Object.defineProperty(exports, "FallbackPattern", { enumerable: true, get: function () { return fallbackPattern_js_1.FallbackPattern; } });

package/dist/cjs/events/patterns/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternRegistry = exports.StatusNormalizer = void 0;
+__exportStar(require("./types.js"), exports);
+var statusNormalizer_js_1 = require("./statusNormalizer.js");
+Object.defineProperty(exports, "StatusNormalizer", { enumerable: true, get: function () { return statusNormalizer_js_1.StatusNormalizer; } });
+var patternRegistry_js_1 = require("./patternRegistry.js");
+Object.defineProperty(exports, "PatternRegistry", { enumerable: true, get: function () { return patternRegistry_js_1.PatternRegistry; } });
+__exportStar(require("./implementations/index.js"), exports);