@atlaspack/utils 2.19.2 → 2.19.4-dev-ts-project-refs-d30e9754f.0

package/dist/prettyDiagnostic.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = prettyDiagnostic;
+const codeframe_1 = __importDefault(require("@atlaspack/codeframe"));
+const markdown_ansi_1 = __importDefault(require("@atlaspack/markdown-ansi"));
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const terminal_link_1 = __importDefault(require("terminal-link"));
+/* eslint-disable import/no-extraneous-dependencies */
+const snarkdown_1 = __importDefault(require("snarkdown"));
+async function prettyDiagnostic(diagnostic, options, terminalWidth, format = 'ansi') {
+    let { origin, message, stack, codeFrames, hints, skipFormatting, documentationURL, } = diagnostic;
+    const md = format === 'ansi' ? markdown_ansi_1.default : snarkdown_1.default;
+    const terminalLink = format === 'ansi'
+        ? terminal_link_1.default
+        : // eslint-disable-next-line no-unused-vars
+            (text, url, _) => `<a href="${url}">${text}</a>`;
+    const chalk = format === 'ansi'
+        ? chalk_1.default
+        : {
+            gray: {
+                underline: (v) => `<span style="color: grey; text-decoration: underline;">${v}</span>`,
+            },
+        };
+    let result = {
+        message: md(`**${origin ?? 'unknown'}**: `) +
+            (skipFormatting ? message : md(message)),
+        stack: '',
+        codeframe: '',
+        frames: [],
+        hints: [],
+        documentation: '',
+    };
+    if (codeFrames != null) {
+        for (let codeFrame of codeFrames) {
+            let filePath = codeFrame.filePath;
+            if (filePath != null && options && !path_1.default.isAbsolute(filePath)) {
+                filePath = path_1.default.join(options.projectRoot, filePath);
+            }
+            let highlights = codeFrame.codeHighlights;
+            let code = codeFrame.code;
+            if (code == null && options && filePath != null) {
+                code = await options.inputFS.readFile(filePath, 'utf8');
+            }
+            let formattedCodeFrame = '';
+            if (code != null) {
+                formattedCodeFrame = (0, codeframe_1.default)(code, highlights, {
+                    useColor: true,
+                    syntaxHighlighting: true,
+                    language: codeFrame.language ||
+                        (filePath != null ? path_1.default.extname(filePath).substr(1) : undefined),
+                    terminalWidth,
+                });
+            }
+            let location;
+            if (typeof filePath !== 'string') {
+                location = '';
+            }
+            else if (highlights.length === 0) {
+                location = filePath;
+            }
+            else {
+                location = `${filePath}:${highlights[0].start.line}:${highlights[0].start.column}`;
+            }
+            result.codeframe += location ? chalk.gray.underline(location) + '\n' : '';
+            result.codeframe += formattedCodeFrame;
+            if (codeFrame !== codeFrames[codeFrames.length - 1]) {
+                result.codeframe += '\n\n';
+            }
+            result.frames.push({
+                location,
+                code: formattedCodeFrame,
+            });
+        }
+    }
+    if (stack != null) {
+        result.stack = stack;
+    }
+    if (Array.isArray(hints) && hints.length) {
+        result.hints = hints.map((h) => {
+            return md(h);
+        });
+    }
+    if (documentationURL != null) {
+        result.documentation = terminalLink('Learn more', documentationURL, {
+            fallback: (text, url) => `${text}: ${url}`,
+        });
+    }
+    return result;
+}

package/dist/progress-message.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProgressMessage = getProgressMessage;
+exports.getPackageProgressMessage = getPackageProgressMessage;
+const path_1 = __importDefault(require("path"));
+function getProgressMessage(event) {
+    switch (event.phase) {
+        case 'transforming':
+            return `Building ${path_1.default.basename(event.filePath)}...`;
+        case 'bundling':
+            return 'Bundling...';
+        case 'packaging':
+            return `Packaging ${event.bundle.displayName}...`;
+        case 'optimizing':
+            return `Optimizing ${event.bundle.displayName}...`;
+        case 'packagingAndOptimizing': {
+            return getPackageProgressMessage(event.completeBundles, event.totalBundles);
+        }
+    }
+    return null;
+}
+function getPackageProgressMessage(completeBundles, totalBundles) {
+    let percent = Math.floor((completeBundles / totalBundles) * 100);
+    let completeStr = completeBundles.toString();
+    let totalStr = totalBundles.toString();
+    let displayBundles = completeStr.padStart(totalStr.length, ' ');
+    return `Packaging bundles ${displayBundles}/${totalBundles} (${percent}%)`;
+}

package/dist/relativeBundlePath.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeBundlePath = relativeBundlePath;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("./path");
+function relativeBundlePath(from, to, opts = { leadingDotSlash: true }) {
+    let fromPath = path_1.default.join(from.target.distDir, from.name);
+    let toPath = path_1.default.join(to.target.distDir, to.name);
+    return (0, path_2.relativePath)(path_1.default.dirname(fromPath), toPath, opts.leadingDotSlash);
+}

package/dist/relativeUrl.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = relativeUrl;
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+function relativeUrl(from, to) {
+    return url_1.default.format(url_1.default.parse(path_1.default.relative(from, to)));
+}

package/dist/replaceBundleReferences.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceURLReferences = replaceURLReferences;
+exports.replaceInlineReferences = replaceInlineReferences;
+exports.getURLReplacement = getURLReplacement;
+const rust_1 = require("@atlaspack/rust");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const stream_1 = require("stream");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const assert_1 = __importDefault(require("assert"));
+const url_1 = __importDefault(require("url"));
+const _1 = require("./");
+/*
+ * Replaces references to dependency ids for URL dependencies with:
+ *   - in the case of an unresolvable url dependency, the original specifier.
+ *     These are external requests that Parcel did not bundle.
+ *   - in the case of a reference to another bundle, the relative url to that
+ *     bundle from the current bundle.
+ */
+function replaceURLReferences({ bundle, bundleGraph, contents, map, getReplacement = (s) => s, relative = true, }) {
+    let replacements = new Map();
+    let urlDependencies = [];
+    bundle.traverse((node) => {
+        if (node.type === 'dependency' && node.value.specifierType === 'url') {
+            urlDependencies.push(node.value);
+        }
+    });
+    for (let dependency of urlDependencies) {
+        if (dependency.specifierType !== 'url') {
+            continue;
+        }
+        let placeholder = dependency.meta?.placeholder ?? dependency.id;
+        (0, assert_1.default)(typeof placeholder === 'string');
+        let resolved = bundleGraph.getReferencedBundle(dependency, bundle);
+        if (resolved == null) {
+            replacements.set(placeholder, {
+                from: placeholder,
+                to: getReplacement(dependency.specifier),
+            });
+            continue;
+        }
+        if (resolved.bundleBehavior === 'inline' ||
+            resolved.bundleBehavior === 'inlineIsolated') {
+            // If a bundle is inline, it should be replaced with inline contents,
+            // not a URL.
+            continue;
+        }
+        replacements.set(placeholder, getURLReplacement({
+            dependency,
+            fromBundle: bundle,
+            toBundle: resolved,
+            relative,
+            getReplacement,
+        }));
+    }
+    return performReplacement(replacements, contents, map);
+}
+/*
+ * Replaces references to dependency ids for inline bundles with the packaged
+ * contents of that bundle.
+ */
+async function replaceInlineReferences({ bundle, bundleGraph, contents, map, getInlineReplacement, getInlineBundleContents, }) {
+    let replacements = new Map();
+    let dependencies = [];
+    bundle.traverse((node) => {
+        if (node.type === 'dependency') {
+            dependencies.push(node.value);
+        }
+    });
+    for (let dependency of dependencies) {
+        let entryBundle = bundleGraph.getReferencedBundle(dependency, bundle);
+        if (entryBundle?.bundleBehavior !== 'inline' &&
+            entryBundle?.bundleBehavior !== 'inlineIsolated') {
+            continue;
+        }
+        let packagedBundle = await getInlineBundleContents(entryBundle, bundleGraph);
+        let packagedContents = (packagedBundle.contents instanceof stream_1.Readable
+            ? await (0, _1.bufferStream)(packagedBundle.contents)
+            : packagedBundle.contents).toString();
+        let inlineType = (0, nullthrows_1.default)(entryBundle.getMainEntry()).meta.inlineType;
+        if (inlineType == null || inlineType === 'string') {
+            let placeholder = dependency.meta?.placeholder ?? dependency.id;
+            (0, assert_1.default)(typeof placeholder === 'string');
+            replacements.set(placeholder, getInlineReplacement(dependency, inlineType, packagedContents));
+        }
+    }
+    return performReplacement(replacements, contents, map);
+}
+function getURLReplacement({ dependency, fromBundle, toBundle, relative, getReplacement, }) {
+    let to;
+    let orig = url_1.default.parse(dependency.specifier);
+    if (relative) {
+        to = url_1.default.format({
+            pathname: (0, _1.relativeBundlePath)(fromBundle, toBundle, {
+                leadingDotSlash: false,
+            }),
+            hash: orig.hash,
+        });
+        // If the resulting path includes a colon character and doesn't start with a ./ or ../
+        // we need to add one so that the first part before the colon isn't parsed as a URL protocol.
+        if (to.includes(':') && !to.startsWith('./') && !to.startsWith('../')) {
+            to = './' + to;
+        }
+    }
+    else {
+        to = (0, _1.urlJoin)(toBundle.target.publicUrl, url_1.default.format({
+            pathname: (0, nullthrows_1.default)(toBundle.name),
+            hash: orig.hash,
+        }));
+    }
+    let placeholder = dependency.meta?.placeholder ?? dependency.id;
+    (0, assert_1.default)(typeof placeholder === 'string');
+    return {
+        from: placeholder,
+        to: getReplacement ? getReplacement(to) : to,
+    };
+}
+function performReplacement(replacements, contents, map) {
+    let finalContents = contents;
+    if ((0, feature_flags_1.getFeatureFlag)('inlineStringReplacementPerf')) {
+        let replacementList = Array.from(replacements.values());
+        if (replacementList.length > 0) {
+            finalContents = (0, rust_1.performStringReplacements)(contents, replacementList);
+        }
+    }
+    else {
+        for (let { from, to } of replacements.values()) {
+            // Perform replacement
+            finalContents = finalContents.split(from).join(to);
+        }
+    }
+    return {
+        contents: finalContents,
+        // TODO: Update sourcemap with adjusted contents
+        map,
+    };
+}

package/dist/schema.js

@@ -0,0 +1,389 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fuzzySearch = fuzzySearch;
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const levenshtein = __importStar(require("fastest-levenshtein"));
+function validateSchema(schema, data) {
+    function walk(
+    // @ts-expect-error TS7006
+    schemaAncestors, dataNode, dataPath) {
+        let [schemaNode] = schemaAncestors;
+        if (schemaNode.type) {
+            let type = Array.isArray(dataNode) ? 'array' : typeof dataNode;
+            if (schemaNode.type !== type) {
+                return {
+                    type: 'type',
+                    dataType: 'value',
+                    dataPath,
+                    expectedTypes: [schemaNode.type],
+                    ancestors: schemaAncestors,
+                    prettyType: schemaNode.__type,
+                };
+            }
+            else {
+                switch (schemaNode.type) {
+                    case 'array': {
+                        if (schemaNode.items) {
+                            let results = [];
+                            // @ts-expect-error TS18046
+                            for (let i = 0; i < dataNode.length; i++) {
+                                let result = walk([schemaNode.items].concat(schemaAncestors), 
+                                // @ts-expect-error TS18046
+                                dataNode[i], dataPath + '/' + i);
+                                if (result)
+                                    results.push(result);
+                            }
+                            if (results.length)
+                                return results.reduce((acc, v) => acc.concat(v), []);
+                        }
+                        break;
+                    }
+                    case 'string': {
+                        // @ts-expect-error TS2322
+                        let value = dataNode;
+                        if (schemaNode.enum) {
+                            if (!schemaNode.enum.includes(value)) {
+                                return {
+                                    type: 'enum',
+                                    dataType: 'value',
+                                    dataPath,
+                                    expectedValues: schemaNode.enum,
+                                    actualValue: value,
+                                    ancestors: schemaAncestors,
+                                };
+                            }
+                        }
+                        else if (schemaNode.__validate) {
+                            let validationError = schemaNode.__validate(value);
+                            if (typeof validationError == 'string') {
+                                return {
+                                    type: 'other',
+                                    dataType: 'value',
+                                    dataPath,
+                                    message: validationError,
+                                    actualValue: value,
+                                    ancestors: schemaAncestors,
+                                };
+                            }
+                        }
+                        break;
+                    }
+                    case 'number': {
+                        // @ts-expect-error TS2322
+                        let value = dataNode;
+                        if (schemaNode.enum) {
+                            if (!schemaNode.enum.includes(value)) {
+                                return {
+                                    type: 'enum',
+                                    dataType: 'value',
+                                    dataPath,
+                                    expectedValues: schemaNode.enum,
+                                    actualValue: value,
+                                    ancestors: schemaAncestors,
+                                };
+                            }
+                        }
+                        break;
+                    }
+                    case 'object': {
+                        let results = [];
+                        let invalidProps;
+                        if (schemaNode.__forbiddenProperties) {
+                            // @ts-expect-error TS2769
+                            let keys = Object.keys(dataNode);
+                            // @ts-expect-error TS7006
+                            invalidProps = schemaNode.__forbiddenProperties.filter((val) => keys.includes(val));
+                            results.push(...invalidProps.map(
+                            // @ts-expect-error TS7006
+                            (k) => ({
+                                type: 'forbidden-prop',
+                                dataPath: dataPath + '/' + (0, diagnostic_1.encodeJSONKeyComponent)(k),
+                                dataType: 'key',
+                                prop: k,
+                                expectedProps: Object.keys(schemaNode.properties),
+                                actualProps: keys,
+                                ancestors: schemaAncestors,
+                            })));
+                        }
+                        if (schemaNode.required) {
+                            // @ts-expect-error TS2769
+                            let keys = Object.keys(dataNode);
+                            let missingKeys = schemaNode.required.filter(
+                            // @ts-expect-error TS7006
+                            (val) => !keys.includes(val));
+                            results.push(...missingKeys.map(
+                            // @ts-expect-error TS7006
+                            (k) => ({
+                                type: 'missing-prop',
+                                dataPath,
+                                dataType: 'value',
+                                prop: k,
+                                expectedProps: schemaNode.required,
+                                actualProps: keys,
+                                ancestors: schemaAncestors,
+                            })));
+                        }
+                        if (schemaNode.properties) {
+                            let { additionalProperties = true } = schemaNode;
+                            // @ts-expect-error TS2407
+                            for (let k in dataNode) {
+                                if (invalidProps && invalidProps.includes(k)) {
+                                    // Don't check type on forbidden props
+                                    continue;
+                                }
+                                else if (k in schemaNode.properties) {
+                                    let result = walk([schemaNode.properties[k]].concat(schemaAncestors), 
+                                    // @ts-expect-error TS18046
+                                    dataNode[k], dataPath + '/' + (0, diagnostic_1.encodeJSONKeyComponent)(k));
+                                    if (result)
+                                        results.push(result);
+                                }
+                                else {
+                                    if (typeof additionalProperties === 'boolean') {
+                                        if (!additionalProperties) {
+                                            results.push({
+                                                type: 'enum',
+                                                dataType: 'key',
+                                                dataPath: dataPath + '/' + (0, diagnostic_1.encodeJSONKeyComponent)(k),
+                                                expectedValues: Object.keys(schemaNode.properties).filter((p) => !(p in dataNode)),
+                                                actualValue: k,
+                                                ancestors: schemaAncestors,
+                                                prettyType: schemaNode.__type,
+                                            });
+                                        }
+                                    }
+                                    else {
+                                        let result = walk([additionalProperties].concat(schemaAncestors), 
+                                        // @ts-expect-error TS18046
+                                        dataNode[k], dataPath + '/' + (0, diagnostic_1.encodeJSONKeyComponent)(k));
+                                        if (result)
+                                            results.push(result);
+                                    }
+                                }
+                            }
+                        }
+                        if (results.length)
+                            return results.reduce((acc, v) => acc.concat(v), []);
+                        break;
+                    }
+                    case 'boolean':
+                        // NOOP, type was checked already
+                        break;
+                    default:
+                        throw new Error(`Unimplemented schema type ${type}?`);
+                }
+            }
+        }
+        else {
+            if (schemaNode.enum && !schemaNode.enum.includes(dataNode)) {
+                return {
+                    type: 'enum',
+                    dataType: 'value',
+                    dataPath: dataPath,
+                    expectedValues: schemaNode.enum,
+                    actualValue: schemaNode,
+                    ancestors: schemaAncestors,
+                };
+            }
+            if (schemaNode.oneOf || schemaNode.allOf) {
+                let list = schemaNode.oneOf || schemaNode.allOf;
+                let results = [];
+                for (let f of list) {
+                    let result = walk([f].concat(schemaAncestors), dataNode, dataPath);
+                    if (result)
+                        results.push(result);
+                }
+                if (schemaNode.oneOf
+                    ? results.length == schemaNode.oneOf.length
+                    : results.length > 0) {
+                    // return the result with more values / longer key
+                    results.sort((a, b) => Array.isArray(a) || Array.isArray(b)
+                        ? Array.isArray(a) && !Array.isArray(b)
+                            ? -1
+                            : !Array.isArray(a) && Array.isArray(b)
+                                ? 1
+                                : Array.isArray(a) && Array.isArray(b)
+                                    ? b.length - a.length
+                                    : 0
+                        : b.dataPath.length - a.dataPath.length);
+                    return results[0];
+                }
+            }
+            else if (schemaNode.not) {
+                let result = walk([schemaNode.not].concat(schemaAncestors), dataNode, dataPath);
+                // @ts-expect-error TS2339
+                if (!result || result.length == 0) {
+                    return {
+                        type: 'other',
+                        dataPath,
+                        dataType: null,
+                        message: schemaNode.__message,
+                        actualValue: dataNode,
+                        ancestors: schemaAncestors,
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+    let result = walk([schema], data, '');
+    return Array.isArray(result) ? result : result ? [result] : [];
+}
+exports.default = validateSchema;
+function fuzzySearch(expectedValues, actualValue) {
+    let result = expectedValues
+        .map((exp) => [exp, levenshtein.distance(exp, actualValue)])
+        .filter(
+    // Remove if more than half of the string would need to be changed
+    // @ts-expect-error TS2769
+    ([, d]) => d * 2 < actualValue.length);
+    // @ts-expect-error TS2345
+    result.sort(([, a], [, b]) => a - b);
+    // @ts-expect-error TS2345
+    return result.map(([v]) => v);
+}
+validateSchema.diagnostic = function (schema, data, origin, message) {
+    if ('source' in data &&
+        'data' in data &&
+        typeof data.source !== 'string' &&
+        !data) {
+        throw new Error('At least one of data.source and data.data must be defined!');
+    }
+    // @ts-expect-error TS2339
+    let object = data.map
+        ? // @ts-expect-error TS2339
+            data.map.data
+        : // @ts-expect-error TS2339
+            (data.data ?? JSON.parse(data.source));
+    let errors = validateSchema(schema, object);
+    if (errors.length) {
+        let keys = errors.map((e) => {
+            let message;
+            if (e.type === 'enum') {
+                let { actualValue } = e;
+                let expectedValues = e.expectedValues.map(String);
+                let likely = actualValue != null
+                    ? fuzzySearch(expectedValues, String(actualValue))
+                    : [];
+                if (likely.length > 0) {
+                    message = `Did you mean ${likely
+                        .map((v) => JSON.stringify(v))
+                        .join(', ')}?`;
+                }
+                else if (expectedValues.length > 0) {
+                    message = `Possible values: ${expectedValues
+                        .map((v) => JSON.stringify(v))
+                        .join(', ')}`;
+                }
+                else {
+                    message = 'Unexpected value';
+                }
+            }
+            else if (e.type === 'forbidden-prop') {
+                let { prop, expectedProps, actualProps } = e;
+                let likely = fuzzySearch(expectedProps, prop).filter((v) => !actualProps.includes(v));
+                if (likely.length > 0) {
+                    message = `Did you mean ${likely
+                        .map((v) => JSON.stringify(v))
+                        .join(', ')}?`;
+                }
+                else {
+                    message = 'Unexpected property';
+                }
+            }
+            else if (e.type === 'missing-prop') {
+                let { prop, actualProps } = e;
+                let likely = fuzzySearch(actualProps, prop);
+                if (likely.length > 0) {
+                    message = `Did you mean ${JSON.stringify(prop)}?`;
+                    e.dataPath += '/' + likely[0];
+                    e.dataType = 'key';
+                }
+                else {
+                    message = `Missing property ${prop}`;
+                }
+            }
+            else if (e.type === 'type') {
+                if (e.prettyType != null) {
+                    message = `Expected ${e.prettyType}`;
+                }
+                else {
+                    message = `Expected type ${e.expectedTypes.join(', ')}`;
+                }
+            }
+            else {
+                message = e.message;
+            }
+            return { key: e.dataPath, type: e.dataType, message };
+        });
+        let map, code;
+        // @ts-expect-error TS2339
+        if (data.map) {
+            // @ts-expect-error TS2339
+            map = data.map;
+            code = data.source;
+        }
+        else {
+            // @ts-expect-error TS2339
+            map = data.source ?? JSON.stringify((0, nullthrows_1.default)(data.data), 0, '\t');
+            code = map;
+        }
+        let codeFrames = [
+            {
+                filePath: data.filePath ?? undefined,
+                language: 'json',
+                code,
+                codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(map, keys.map(({ key, type, message }) => ({
+                    key: (data.prependKey ?? '') + key,
+                    type: type,
+                    message: message != null ? (0, diagnostic_1.escapeMarkdown)(message) : message,
+                }))),
+            },
+        ];
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: message,
+                origin,
+                // @ts-expect-error TS2322
+                codeFrames,
+            },
+        });
+    }
+};