@keymanapp/common-types 18.0.41-alpha → 18.0.46-alpha

package/build/src/util/compiler-interfaces.js

@@ -1,382 +1,382 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d8f40277-52ef-5022-98a6-7d35fef5d901")}catch(e){}}();
-;
-export var CompilerErrorSeverity;
-(function (CompilerErrorSeverity) {
-    CompilerErrorSeverity[CompilerErrorSeverity["Info"] = 0] = "Info";
-    CompilerErrorSeverity[CompilerErrorSeverity["Hint"] = 1048576] = "Hint";
-    CompilerErrorSeverity[CompilerErrorSeverity["Warn"] = 2097152] = "Warn";
-    CompilerErrorSeverity[CompilerErrorSeverity["Error"] = 3145728] = "Error";
-    CompilerErrorSeverity[CompilerErrorSeverity["Fatal"] = 4194304] = "Fatal";
-})(CompilerErrorSeverity || (CompilerErrorSeverity = {}));
-;
-export const CompilerErrorSeverityValues = [
-    CompilerErrorSeverity.Info,
-    CompilerErrorSeverity.Hint,
-    CompilerErrorSeverity.Warn,
-    CompilerErrorSeverity.Error,
-    CompilerErrorSeverity.Fatal,
-];
-/**
- * Mask values for mapping compiler errors
- */
-export var CompilerErrorMask;
-(function (CompilerErrorMask) {
-    CompilerErrorMask[CompilerErrorMask["Severity"] = 15728640] = "Severity";
-    CompilerErrorMask[CompilerErrorMask["Error"] = 1048575] = "Error";
-    CompilerErrorMask[CompilerErrorMask["Namespace"] = 1044480] = "Namespace";
-    CompilerErrorMask[CompilerErrorMask["BaseError"] = 4095] = "BaseError";
-    CompilerErrorMask[CompilerErrorMask["Reserved"] = 4278190080] = "Reserved";
-})(CompilerErrorMask || (CompilerErrorMask = {}));
-;
-const errorSeverityName = {
-    [CompilerErrorSeverity.Info]: 'info',
-    [CompilerErrorSeverity.Hint]: 'hint',
-    [CompilerErrorSeverity.Warn]: 'warn',
-    [CompilerErrorSeverity.Error]: 'error',
-    [CompilerErrorSeverity.Fatal]: 'fatal',
-};
-export class CompilerError {
-    static severity(code) {
-        return code & CompilerErrorMask.Severity;
-    }
-    static error(code) {
-        return code & CompilerErrorMask.Error;
-    }
-    static baseError(code) {
-        return code & CompilerErrorMask.BaseError;
-    }
-    static namespace(code) {
-        return code & CompilerErrorMask.Namespace;
-    }
-    static formatSeverity(code) {
-        return errorSeverityName[CompilerError.severity(code)] ?? 'UNKNOWN';
-    }
-    /** true if events has at least one message of the atLeast severity */
-    static hasSeverity(events, atLeast) {
-        for (const { code } of events) {
-            if (CompilerError.severity(code) >= atLeast) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /** true if events has at least one Error or worse */
-    static hasError(events) {
-        return CompilerError.hasSeverity(events, CompilerErrorSeverity.Error);
-    }
-    /**
-     * Format an error code number. The error code number does not include
-     * the severity mask, as this is reported in text form separately; see
-     * `severityName`.
-     * @example
-     *
-     * The following call returns `KM03004`
-     * ```
-     *   formatCode(CompilerMessage.ERROR_InvalidDisplayMapFile)
-     * ```
-     */
-    static formatCode(code) {
-        return Number.isInteger(code) ? 'KM' + CompilerError.error(code).toString(16).toUpperCase().padStart(5, '0') : 'KM?????';
-    }
-    /**
-     * Formats an event filename for an error report,
-     * stripping off path component
-     * @param filename
-     * @returns
-     */
-    static formatFilename(filename, options) {
-        if (!filename) {
-            return '';
-        }
-        if (options?.fullPath) {
-            return options?.forwardSlashes ?
-                filename.replaceAll(/\\/g, '/') :
-                filename.replaceAll(/\//g, '\\');
-        }
-        let x = filename.lastIndexOf('/');
-        if (x < 0) {
-            x = filename.lastIndexOf('\\');
-        }
-        return x >= 0 ? filename.substring(x + 1) : filename;
-    }
-    /**
-     * Formats an event line for an error report
-     * @param line
-     * @returns
-     */
-    static formatLine(line) {
-        return line ? line.toString() : '';
-    }
-    /**
-     * Formats an event message for an error report
-     * @param message
-     * @returns
-     */
-    static formatMessage(message) {
-        return message ?? '';
-    }
-    /**
-     * Formats a compiler message, without coloring; an ANSI color version is
-     * implemented in NodeCompilerCallbacks.
-     * @param event event or array of events
-     */
-    static formatEvent(event) {
-        if (!event) {
-            return "";
-        }
-        if (Array.isArray(event)) {
-            return event.map(item => CompilerError.formatEvent(item)).join('\n') + '\n';
-        }
-        return (event.filename
-            ? CompilerError.formatFilename(event.filename) +
-                (event.line ? ':' + CompilerError.formatLine(event.line) : '') + ' - '
-            : '') +
-            CompilerError.formatSeverity(event.code) + ' ' +
-            CompilerError.formatCode(event.code) + ': ' +
-            CompilerError.formatMessage(event.message);
-    }
-    /**
-     * @param e Error-like
-     */
-    static exceptionToString(e) {
-        return `${(e ?? 'unknown error').toString()}\n\nCall stack:\n${(e instanceof Error ? e.stack : (new Error()).stack)}`;
-    }
-    /**
-     * Returns the corresponding error severity value from a partial name match,
-     * e.g. 'inf' returns CompilerErrorSeverity.Info, or returns null if not found
-     * @param name
-     * @returns
-     */
-    static severityNameToValue(name) {
-        name = name.toLowerCase();
-        for (let level of CompilerErrorSeverityValues) {
-            if (errorSeverityName[level].startsWith(name)) {
-                return level;
-            }
-        }
-        return null;
-    }
-}
-;
-/** @deprecated use `CompilerError.severity` instead */
-export function compilerErrorSeverity(code) {
-    return CompilerError.severity(code);
-}
-/** @deprecated use `CompilerError.formatSeverity` instead */
-export function compilerErrorSeverityName(code) {
-    return CompilerError.formatSeverity(code);
-}
-/** @deprecated use `CompilerError.formatCode` instead */
-export function compilerErrorFormatCode(code) {
-    return CompilerError.formatCode(code);
-}
-/** @deprecated use `CompilerError.formatEvent` instead */
-export function compilerEventFormat(e) {
-    return CompilerError.formatEvent(e);
-}
-/**
- * Defines the error code ranges for various compilers. Once defined, these
- * ranges must not be changed as external modules may depend on specific error
- * codes. Individual errors are defined at a compiler level, for example,
- * kmc-ldml/src/compiler/messages.ts.
- *
- * kmc defines a mapping between each namespace and the corresponding compiler's
- * error reporting class in kmc/src/messages/messageNamespaces.ts
- */
-export var CompilerErrorNamespace;
-(function (CompilerErrorNamespace) {
-    /**
-     * kmc-ldml errors between 0x0000…0x0FFF
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["LdmlKeyboardCompiler"] = 0] = "LdmlKeyboardCompiler";
-    /**
-     * common/web/types errors between 0x1000…0x1FFF
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["CommonTypes"] = 4096] = "CommonTypes";
-    /**
-     * kmc-kmn errors between 0x2000…0x2FFF; these map to
-     * the base codes found in kmn_compiler_errors.h, exclusive severity flags
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["KmnCompiler"] = 8192] = "KmnCompiler";
-    /**
-     * kmc-model errors between 0x3000…0x3FFF
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["ModelCompiler"] = 12288] = "ModelCompiler";
-    /**
-     * kmc-package errors between 0x4000…0x4FFF
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["PackageCompiler"] = 16384] = "PackageCompiler";
-    /**
-     * kmc and related infrastructure errors between 0x5000…0x5FFF
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["Infrastructure"] = 20480] = "Infrastructure";
-    /**
-     * kmc-analyze 0x6000…0x6FFF
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["Analyzer"] = 24576] = "Analyzer";
-    /**
-     * kmc-kmn/kmw-compiler errors between 0x7000…0x7FFF; note that some errors
-     * generated by kmc-kmn/kmw-compiler are from kmc-kmn namespace for legacy
-     * reasons
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["KmwCompiler"] = 28672] = "KmwCompiler";
-    /**
-     * kmc-model-info 0x8000…0x8FFF
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["ModelInfoCompiler"] = 32768] = "ModelInfoCompiler";
-    /**
-     * kmc-keyboard-info 0x9000…0x9FFF
-     */
-    CompilerErrorNamespace[CompilerErrorNamespace["KeyboardInfoCompiler"] = 36864] = "KeyboardInfoCompiler";
-})(CompilerErrorNamespace || (CompilerErrorNamespace = {}));
-;
-;
-;
-;
-;
-;
-;
-;
-;
-/**
- * Wrapper class for CompilerCallbacks for a given input file
- */
-export class CompilerFileCallbacks {
-    filename;
-    options;
-    parent;
-    messages = [];
-    constructor(filename, options, parent) {
-        this.filename = filename;
-        this.options = options;
-        this.parent = parent;
-    }
-    /**
-     * Returns `true` if any message in the `messages` array is a Fatal or Error
-     * message, and if `compilerWarningsAsErrors` is `true`, then also returns
-     * `true` if any message is a Warning.
-     */
-    static hasFailureMessage(messages, compilerWarningsAsErrors) {
-        const failureCodes = [
-            CompilerErrorSeverity.Fatal, CompilerErrorSeverity.Error
-        ].concat(compilerWarningsAsErrors ? [CompilerErrorSeverity.Warn] : []);
-        return messages.find(m => failureCodes.includes(CompilerError.severity(m.code))) != undefined;
-    }
-    /**
-     *
-     * @param event
-     * @param overrides
-     * @returns true if event has been suppressed
-     */
-    static applyMessageOverridesToEvent(event, overrides) {
-        // Override event severity from user preference -- this will not override
-        // fatal or error events
-        const severity = overrides?.[CompilerError.error(event.code)] ??
-            CompilerError.severity(event.code);
-        if (severity == 'disable') {
-            return true;
-        }
-        // Override the default event severity with the command line option
-        event.code = severity | (event.code & ~CompilerErrorMask.Severity);
-        return false;
-    }
-    /**
-     * Returns `true` if any message in the `messages` array is a Fatal or Error
-     * message, and if `compilerWarningsAsErrors` is `true`, then also returns
-     * `true` if any message is a Warning.
-     *
-     * If passed a defined `compilerWarningsAsErrors` value, then uses that,
-     * otherwise uses `options.compilerWarningsAsErrors`, or `false` if that is
-     * also `undefined`.
-     */
-    hasFailureMessage(compilerWarningsAsErrors) {
-        return CompilerFileCallbacks.hasFailureMessage(this.messages, compilerWarningsAsErrors ?? this.options.compilerWarningsAsErrors ?? false);
-    }
-    clear() {
-        this.messages = [];
-    }
-    loadFile(filename) {
-        return this.parent.loadFile(filename);
-    }
-    fileSize(filename) {
-        return this.parent.fileSize(filename);
-    }
-    get path() {
-        return this.parent.path;
-    }
-    get fs() {
-        return this.parent.fs;
-    }
-    resolveFilename(baseFilename, filename) {
-        return this.parent.resolveFilename(baseFilename, filename);
-    }
-    reportMessage(event) {
-        const disable = CompilerFileCallbacks.applyMessageOverridesToEvent(event, this.options.messageOverrides);
-        this.messages.push(event);
-        if (!disable) {
-            this.parent.reportMessage({ filename: this.filename, ...event });
-        }
-    }
-    debug(msg) {
-        return this.parent.debug(msg);
-    }
-}
-;
-export const defaultCompilerOptions = {
-    logLevel: 'info',
-    logFormat: 'formatted',
-    // outFile: (undefined)
-    saveDebug: false,
-    shouldAddCompilerVersion: true,
-    compilerWarningsAsErrors: false,
-    warnDeprecatedCode: true,
-    checkFilenameConventions: false,
-};
-/**
- * Convenience function for constructing CompilerEvents
- * @param code     Unique numeric value of the event
- * @param message  A short description of the error presented to the user
- * @param detail   Detailed Markdown-formatted description of the error
- *                 including references to documentation, remediation options.
- * @returns
- */
-export const CompilerMessageSpec = (code, message, detail) => ({
-    code,
-    message,
-    detail,
-});
-export const CompilerMessageDef = (param) => String(param ?? `<param>`);
-export const CompilerMessageSpecWithException = (code, message, exceptionVar, detail) => ({
-    code,
-    message: exceptionVar
-        ? (message ?? `Unexpected exception`) + `: ${exceptionVar.toString()}\n\nCall stack:\n${(exceptionVar instanceof Error ? exceptionVar.stack : (new Error()).stack)}` :
-        message,
-    detail,
-    exceptionVar,
-});
-/**
- * Compiler logging level and correspondence to severity
- */
-export const ALL_COMPILER_LOG_LEVELS = [
-    'silent',
-    'error',
-    'warn',
-    'hint',
-    'info',
-    'debug' /// All messages: errors + warnings + hints + info, plus debug logs
-];
-export const compilerLogLevelToSeverity = {
-    'silent': CompilerErrorMask.Severity,
-    'error': CompilerErrorSeverity.Error,
-    'warn': CompilerErrorSeverity.Warn,
-    'hint': CompilerErrorSeverity.Hint,
-    'info': CompilerErrorSeverity.Info,
-    'debug': CompilerErrorSeverity.Info
-};
-export const ALL_COMPILER_LOG_FORMATS = [
-    'tsv',
-    'formatted'
-];
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="700d18cd-bca6-5162-a68e-85e89dc556ea")}catch(e){}}();
+;
+export var CompilerErrorSeverity;
+(function (CompilerErrorSeverity) {
+    CompilerErrorSeverity[CompilerErrorSeverity["Info"] = 0] = "Info";
+    CompilerErrorSeverity[CompilerErrorSeverity["Hint"] = 1048576] = "Hint";
+    CompilerErrorSeverity[CompilerErrorSeverity["Warn"] = 2097152] = "Warn";
+    CompilerErrorSeverity[CompilerErrorSeverity["Error"] = 3145728] = "Error";
+    CompilerErrorSeverity[CompilerErrorSeverity["Fatal"] = 4194304] = "Fatal";
+})(CompilerErrorSeverity || (CompilerErrorSeverity = {}));
+;
+export const CompilerErrorSeverityValues = [
+    CompilerErrorSeverity.Info,
+    CompilerErrorSeverity.Hint,
+    CompilerErrorSeverity.Warn,
+    CompilerErrorSeverity.Error,
+    CompilerErrorSeverity.Fatal,
+];
+/**
+ * Mask values for mapping compiler errors
+ */
+export var CompilerErrorMask;
+(function (CompilerErrorMask) {
+    CompilerErrorMask[CompilerErrorMask["Severity"] = 15728640] = "Severity";
+    CompilerErrorMask[CompilerErrorMask["Error"] = 1048575] = "Error";
+    CompilerErrorMask[CompilerErrorMask["Namespace"] = 1044480] = "Namespace";
+    CompilerErrorMask[CompilerErrorMask["BaseError"] = 4095] = "BaseError";
+    CompilerErrorMask[CompilerErrorMask["Reserved"] = 4278190080] = "Reserved";
+})(CompilerErrorMask || (CompilerErrorMask = {}));
+;
+const errorSeverityName = {
+    [CompilerErrorSeverity.Info]: 'info',
+    [CompilerErrorSeverity.Hint]: 'hint',
+    [CompilerErrorSeverity.Warn]: 'warn',
+    [CompilerErrorSeverity.Error]: 'error',
+    [CompilerErrorSeverity.Fatal]: 'fatal',
+};
+export class CompilerError {
+    static severity(code) {
+        return code & CompilerErrorMask.Severity;
+    }
+    static error(code) {
+        return code & CompilerErrorMask.Error;
+    }
+    static baseError(code) {
+        return code & CompilerErrorMask.BaseError;
+    }
+    static namespace(code) {
+        return code & CompilerErrorMask.Namespace;
+    }
+    static formatSeverity(code) {
+        return errorSeverityName[CompilerError.severity(code)] ?? 'UNKNOWN';
+    }
+    /** true if events has at least one message of the atLeast severity */
+    static hasSeverity(events, atLeast) {
+        for (const { code } of events) {
+            if (CompilerError.severity(code) >= atLeast) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** true if events has at least one Error or worse */
+    static hasError(events) {
+        return CompilerError.hasSeverity(events, CompilerErrorSeverity.Error);
+    }
+    /**
+     * Format an error code number. The error code number does not include
+     * the severity mask, as this is reported in text form separately; see
+     * `severityName`.
+     * @example
+     *
+     * The following call returns `KM03004`
+     * ```
+     *   formatCode(CompilerMessage.ERROR_InvalidDisplayMapFile)
+     * ```
+     */
+    static formatCode(code) {
+        return Number.isInteger(code) ? 'KM' + CompilerError.error(code).toString(16).toUpperCase().padStart(5, '0') : 'KM?????';
+    }
+    /**
+     * Formats an event filename for an error report,
+     * stripping off path component
+     * @param filename
+     * @returns
+     */
+    static formatFilename(filename, options) {
+        if (!filename) {
+            return '';
+        }
+        if (options?.fullPath) {
+            return options?.forwardSlashes ?
+                filename.replaceAll(/\\/g, '/') :
+                filename.replaceAll(/\//g, '\\');
+        }
+        let x = filename.lastIndexOf('/');
+        if (x < 0) {
+            x = filename.lastIndexOf('\\');
+        }
+        return x >= 0 ? filename.substring(x + 1) : filename;
+    }
+    /**
+     * Formats an event line for an error report
+     * @param line
+     * @returns
+     */
+    static formatLine(line) {
+        return line ? line.toString() : '';
+    }
+    /**
+     * Formats an event message for an error report
+     * @param message
+     * @returns
+     */
+    static formatMessage(message) {
+        return message ?? '';
+    }
+    /**
+     * Formats a compiler message, without coloring; an ANSI color version is
+     * implemented in NodeCompilerCallbacks.
+     * @param event event or array of events
+     */
+    static formatEvent(event) {
+        if (!event) {
+            return "";
+        }
+        if (Array.isArray(event)) {
+            return event.map(item => CompilerError.formatEvent(item)).join('\n') + '\n';
+        }
+        return (event.filename
+            ? CompilerError.formatFilename(event.filename) +
+                (event.line ? ':' + CompilerError.formatLine(event.line) : '') + ' - '
+            : '') +
+            CompilerError.formatSeverity(event.code) + ' ' +
+            CompilerError.formatCode(event.code) + ': ' +
+            CompilerError.formatMessage(event.message);
+    }
+    /**
+     * @param e Error-like
+     */
+    static exceptionToString(e) {
+        return `${(e ?? 'unknown error').toString()}\n\nCall stack:\n${(e instanceof Error ? e.stack : (new Error()).stack)}`;
+    }
+    /**
+     * Returns the corresponding error severity value from a partial name match,
+     * e.g. 'inf' returns CompilerErrorSeverity.Info, or returns null if not found
+     * @param name
+     * @returns
+     */
+    static severityNameToValue(name) {
+        name = name.toLowerCase();
+        for (let level of CompilerErrorSeverityValues) {
+            if (errorSeverityName[level].startsWith(name)) {
+                return level;
+            }
+        }
+        return null;
+    }
+}
+;
+/** @deprecated use `CompilerError.severity` instead */
+export function compilerErrorSeverity(code) {
+    return CompilerError.severity(code);
+}
+/** @deprecated use `CompilerError.formatSeverity` instead */
+export function compilerErrorSeverityName(code) {
+    return CompilerError.formatSeverity(code);
+}
+/** @deprecated use `CompilerError.formatCode` instead */
+export function compilerErrorFormatCode(code) {
+    return CompilerError.formatCode(code);
+}
+/** @deprecated use `CompilerError.formatEvent` instead */
+export function compilerEventFormat(e) {
+    return CompilerError.formatEvent(e);
+}
+/**
+ * Defines the error code ranges for various compilers. Once defined, these
+ * ranges must not be changed as external modules may depend on specific error
+ * codes. Individual errors are defined at a compiler level, for example,
+ * kmc-ldml/src/compiler/messages.ts.
+ *
+ * kmc defines a mapping between each namespace and the corresponding compiler's
+ * error reporting class in kmc/src/messages/messageNamespaces.ts
+ */
+export var CompilerErrorNamespace;
+(function (CompilerErrorNamespace) {
+    /**
+     * kmc-ldml errors between 0x0000…0x0FFF
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["LdmlKeyboardCompiler"] = 0] = "LdmlKeyboardCompiler";
+    /**
+     * common/web/types errors between 0x1000…0x1FFF
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["CommonTypes"] = 4096] = "CommonTypes";
+    /**
+     * kmc-kmn errors between 0x2000…0x2FFF; these map to
+     * the base codes found in kmn_compiler_errors.h, exclusive severity flags
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["KmnCompiler"] = 8192] = "KmnCompiler";
+    /**
+     * kmc-model errors between 0x3000…0x3FFF
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["ModelCompiler"] = 12288] = "ModelCompiler";
+    /**
+     * kmc-package errors between 0x4000…0x4FFF
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["PackageCompiler"] = 16384] = "PackageCompiler";
+    /**
+     * kmc and related infrastructure errors between 0x5000…0x5FFF
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["Infrastructure"] = 20480] = "Infrastructure";
+    /**
+     * kmc-analyze 0x6000…0x6FFF
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["Analyzer"] = 24576] = "Analyzer";
+    /**
+     * kmc-kmn/kmw-compiler errors between 0x7000…0x7FFF; note that some errors
+     * generated by kmc-kmn/kmw-compiler are from kmc-kmn namespace for legacy
+     * reasons
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["KmwCompiler"] = 28672] = "KmwCompiler";
+    /**
+     * kmc-model-info 0x8000…0x8FFF
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["ModelInfoCompiler"] = 32768] = "ModelInfoCompiler";
+    /**
+     * kmc-keyboard-info 0x9000…0x9FFF
+     */
+    CompilerErrorNamespace[CompilerErrorNamespace["KeyboardInfoCompiler"] = 36864] = "KeyboardInfoCompiler";
+})(CompilerErrorNamespace || (CompilerErrorNamespace = {}));
+;
+;
+;
+;
+;
+;
+;
+;
+;
+/**
+ * Wrapper class for CompilerCallbacks for a given input file
+ */
+export class CompilerFileCallbacks {
+    filename;
+    options;
+    parent;
+    messages = [];
+    constructor(filename, options, parent) {
+        this.filename = filename;
+        this.options = options;
+        this.parent = parent;
+    }
+    /**
+     * Returns `true` if any message in the `messages` array is a Fatal or Error
+     * message, and if `compilerWarningsAsErrors` is `true`, then also returns
+     * `true` if any message is a Warning.
+     */
+    static hasFailureMessage(messages, compilerWarningsAsErrors) {
+        const failureCodes = [
+            CompilerErrorSeverity.Fatal, CompilerErrorSeverity.Error
+        ].concat(compilerWarningsAsErrors ? [CompilerErrorSeverity.Warn] : []);
+        return messages.find(m => failureCodes.includes(CompilerError.severity(m.code))) != undefined;
+    }
+    /**
+     *
+     * @param event
+     * @param overrides
+     * @returns true if event has been suppressed
+     */
+    static applyMessageOverridesToEvent(event, overrides) {
+        // Override event severity from user preference -- this will not override
+        // fatal or error events
+        const severity = overrides?.[CompilerError.error(event.code)] ??
+            CompilerError.severity(event.code);
+        if (severity == 'disable') {
+            return true;
+        }
+        // Override the default event severity with the command line option
+        event.code = severity | (event.code & ~CompilerErrorMask.Severity);
+        return false;
+    }
+    /**
+     * Returns `true` if any message in the `messages` array is a Fatal or Error
+     * message, and if `compilerWarningsAsErrors` is `true`, then also returns
+     * `true` if any message is a Warning.
+     *
+     * If passed a defined `compilerWarningsAsErrors` value, then uses that,
+     * otherwise uses `options.compilerWarningsAsErrors`, or `false` if that is
+     * also `undefined`.
+     */
+    hasFailureMessage(compilerWarningsAsErrors) {
+        return CompilerFileCallbacks.hasFailureMessage(this.messages, compilerWarningsAsErrors ?? this.options.compilerWarningsAsErrors ?? false);
+    }
+    clear() {
+        this.messages = [];
+    }
+    loadFile(filename) {
+        return this.parent.loadFile(filename);
+    }
+    fileSize(filename) {
+        return this.parent.fileSize(filename);
+    }
+    get path() {
+        return this.parent.path;
+    }
+    get fs() {
+        return this.parent.fs;
+    }
+    resolveFilename(baseFilename, filename) {
+        return this.parent.resolveFilename(baseFilename, filename);
+    }
+    reportMessage(event) {
+        const disable = CompilerFileCallbacks.applyMessageOverridesToEvent(event, this.options.messageOverrides);
+        this.messages.push(event);
+        if (!disable) {
+            this.parent.reportMessage({ filename: this.filename, ...event });
+        }
+    }
+    debug(msg) {
+        return this.parent.debug(msg);
+    }
+}
+;
+export const defaultCompilerOptions = {
+    logLevel: 'info',
+    logFormat: 'formatted',
+    // outFile: (undefined)
+    saveDebug: false,
+    shouldAddCompilerVersion: true,
+    compilerWarningsAsErrors: false,
+    warnDeprecatedCode: true,
+    checkFilenameConventions: false,
+};
+/**
+ * Convenience function for constructing CompilerEvents
+ * @param code     Unique numeric value of the event
+ * @param message  A short description of the error presented to the user
+ * @param detail   Detailed Markdown-formatted description of the error
+ *                 including references to documentation, remediation options.
+ * @returns
+ */
+export const CompilerMessageSpec = (code, message, detail) => ({
+    code,
+    message,
+    detail,
+});
+export const CompilerMessageDef = (param) => String(param ?? `<param>`);
+export const CompilerMessageSpecWithException = (code, message, exceptionVar, detail) => ({
+    code,
+    message: exceptionVar
+        ? (message ?? `Unexpected exception`) + `: ${exceptionVar.toString()}\n\nCall stack:\n${(exceptionVar instanceof Error ? exceptionVar.stack : (new Error()).stack)}` :
+        message,
+    detail,
+    exceptionVar,
+});
+/**
+ * Compiler logging level and correspondence to severity
+ */
+export const ALL_COMPILER_LOG_LEVELS = [
+    'silent', /// Nothing is emitted to stdout, not even errors (fatal exceptions may still emit to stdout)
+    'error', /// Only errors emitted
+    'warn', /// Errors + warnings
+    'hint', /// Errors + warnings + hints
+    'info', /// All messages: errors + warnings + hints + info
+    'debug' /// All messages: errors + warnings + hints + info, plus debug logs
+];
+export const compilerLogLevelToSeverity = {
+    'silent': CompilerErrorMask.Severity, // effectively excludes all reporting
+    'error': CompilerErrorSeverity.Error,
+    'warn': CompilerErrorSeverity.Warn,
+    'hint': CompilerErrorSeverity.Hint,
+    'info': CompilerErrorSeverity.Info,
+    'debug': CompilerErrorSeverity.Info
+};
+export const ALL_COMPILER_LOG_FORMATS = [
+    'tsv',
+    'formatted'
+];
 //# sourceMappingURL=compiler-interfaces.js.map
-//# debugId=d8f40277-52ef-5022-98a6-7d35fef5d901
+//# debugId=700d18cd-bca6-5162-a68e-85e89dc556ea