nx 20.8.4 → 22.7.7

package/dist/src/utils/task-history.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHistory = void 0;
+exports.getTaskHistory = getTaskHistory;
+const client_1 = require("../daemon/client/client");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const native_1 = require("../native");
+const db_connection_1 = require("./db-connection");
+class TaskHistory {
+    constructor() {
+        this.taskHistory = new native_1.NxTaskHistory((0, db_connection_1.getDbConnection)());
+    }
+    /**
+     * This function returns estimated timings per task
+     * @param targets
+     * @returns a map where key is task id (project:target:configuration), value is average time of historical runs
+     */
+    async getEstimatedTaskTimings(targets) {
+        if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+            return this.taskHistory.getEstimatedTaskTimings(targets);
+        }
+        return await client_1.daemonClient.getEstimatedTaskTimings(targets);
+    }
+    async getFlakyTasks(hashes) {
+        if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+            return this.taskHistory.getFlakyTasks(hashes);
+        }
+        return await client_1.daemonClient.getFlakyTasks(hashes);
+    }
+    async recordTaskRuns(taskRuns) {
+        if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+            return this.taskHistory.recordTaskRuns(taskRuns);
+        }
+        return client_1.daemonClient.recordTaskRuns(taskRuns);
+    }
+}
+exports.TaskHistory = TaskHistory;
+let taskHistory;
+/**
+ * This function returns the singleton instance of TaskHistory
+ * @returns singleton instance of TaskHistory, null if database is disabled or WASM is enabled
+ */
+function getTaskHistory() {
+    if (native_1.IS_WASM) {
+        return null;
+    }
+    if (!taskHistory) {
+        taskHistory = new TaskHistory();
+    }
+    return taskHistory;
+}

package/dist/src/utils/update-nxw.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNxw = updateNxw;
+const add_nx_scripts_1 = require("../command-line/init/implementation/dot-nx/add-nx-scripts");
+const path_1 = require("../utils/path");
+const fs_1 = require("fs");
+function updateNxw(tree) {
+    const wrapperPath = (0, path_1.normalizePath)((0, add_nx_scripts_1.nxWrapperPath)());
+    if (tree.exists(wrapperPath)) {
+        tree.write(wrapperPath, (0, add_nx_scripts_1.getNxWrapperContents)());
+    }
+    const bashScriptPath = 'nx';
+    if (tree.exists(bashScriptPath) && tree.isFile(bashScriptPath)) {
+        tree.write(bashScriptPath, (0, add_nx_scripts_1.getShellScriptContents)(), {
+            mode: fs_1.constants.S_IXUSR | fs_1.constants.S_IRUSR | fs_1.constants.S_IWUSR,
+        });
+    }
+    const batchScriptPath = 'nx.bat';
+    if (tree.exists(batchScriptPath) && tree.isFile(batchScriptPath)) {
+        tree.write(batchScriptPath, (0, add_nx_scripts_1.getBatchScriptContents)());
+    }
+}

package/dist/src/utils/versions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxVersion = void 0;
+exports.nxVersion = require('nx/package.json').version;

package/dist/src/utils/wait-for-socket-connection.d.ts

@@ -0,0 +1,15 @@
+import { Socket } from 'net';
+/**
+ * Polls an IPC socket path until a connection succeeds or the attempt
+ * limit / abort signal is reached.
+ *
+ * @param socketPath - A fixed path string, or a function that resolves
+ *   the path on each attempt (useful when the server hasn't written its
+ *   socket file yet).
+ * @returns The connected socket, or `null` if polling was exhausted or aborted.
+ */
+export declare function waitForSocketConnection(socketPath: string | (() => string | null), options?: {
+    signal?: AbortSignal;
+    maxAttempts?: number;
+    delayMs?: number;
+}): Promise<Socket | null>;

package/dist/src/utils/wait-for-socket-connection.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForSocketConnection = waitForSocketConnection;
+const net_1 = require("net");
+const DEFAULT_DELAY_MS = 10;
+const DEFAULT_MAX_ATTEMPTS = 10_000;
+/**
+ * Polls an IPC socket path until a connection succeeds or the attempt
+ * limit / abort signal is reached.
+ *
+ * @param socketPath - A fixed path string, or a function that resolves
+ *   the path on each attempt (useful when the server hasn't written its
+ *   socket file yet).
+ * @returns The connected socket, or `null` if polling was exhausted or aborted.
+ */
+async function waitForSocketConnection(socketPath, options) {
+    const maxAttempts = options?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    const delayMs = options?.delayMs ?? DEFAULT_DELAY_MS;
+    const signal = options?.signal;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        if (signal?.aborted)
+            return null;
+        await new Promise((r) => setTimeout(r, delayMs));
+        if (signal?.aborted)
+            return null;
+        const path = typeof socketPath === 'function' ? socketPath() : socketPath;
+        if (path) {
+            const socket = await tryConnect(path);
+            if (socket) {
+                return socket;
+            }
+        }
+        attempts++;
+    }
+    return null;
+}
+function tryConnect(socketPath) {
+    return new Promise((resolve) => {
+        try {
+            const socket = (0, net_1.connect)(socketPath, () => {
+                resolve(socket);
+            });
+            socket.once('error', () => {
+                socket.destroy();
+                resolve(null);
+            });
+        }
+        catch {
+            resolve(null);
+        }
+    });
+}

package/dist/src/utils/workspace-context.d.ts

@@ -0,0 +1,21 @@
+import type { NxWorkspaceFilesExternals } from '../native';
+export declare function setupWorkspaceContext(workspaceRoot: string): void;
+export declare function getNxWorkspaceFilesFromContext(workspaceRoot: string, projectRootMap: Record<string, string>, useDaemonProcess?: boolean): Promise<import("../native").NxWorkspaceFiles>;
+/**
+ * Sync method to get files matching globs from workspace context.
+ * NOTE: This method will create the workspace context if it doesn't exist.
+ * It should only be used within Nx internal in code paths that **must** be sync.
+ * If used in an isolated plugin thread this will cause the workspace context
+ * to be recreated which is slow.
+ */
+export declare function globWithWorkspaceContextSync(workspaceRoot: string, globs: string[], exclude?: string[]): string[];
+export declare function globWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string[]>;
+export declare function multiGlobWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string[][]>;
+export declare function hashWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string>;
+export declare function hashMultiGlobWithWorkspaceContext(workspaceRoot: string, globGroups: string[][]): Promise<string[]>;
+export declare function updateContextWithChangedFiles(workspaceRoot: string, createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
+export declare function updateFilesInContext(workspaceRoot: string, updatedFiles: string[], deletedFiles: string[]): Record<string, string>;
+export declare function getAllFileDataInContext(workspaceRoot: string): Promise<import("../native").FileData[]>;
+export declare function getFilesInDirectoryUsingContext(workspaceRoot: string, dir: string): Promise<string[]>;
+export declare function updateProjectFiles(projectRootMappings: Record<string, string>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): import("../native").UpdatedWorkspaceFiles;
+export declare function resetWorkspaceContext(): void;

package/dist/src/utils/workspace-context.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWorkspaceContext = setupWorkspaceContext;
+exports.getNxWorkspaceFilesFromContext = getNxWorkspaceFilesFromContext;
+exports.globWithWorkspaceContextSync = globWithWorkspaceContextSync;
+exports.globWithWorkspaceContext = globWithWorkspaceContext;
+exports.multiGlobWithWorkspaceContext = multiGlobWithWorkspaceContext;
+exports.hashWithWorkspaceContext = hashWithWorkspaceContext;
+exports.hashMultiGlobWithWorkspaceContext = hashMultiGlobWithWorkspaceContext;
+exports.updateContextWithChangedFiles = updateContextWithChangedFiles;
+exports.updateFilesInContext = updateFilesInContext;
+exports.getAllFileDataInContext = getAllFileDataInContext;
+exports.getFilesInDirectoryUsingContext = getFilesInDirectoryUsingContext;
+exports.updateProjectFiles = updateProjectFiles;
+exports.resetWorkspaceContext = resetWorkspaceContext;
+const perf_hooks_1 = require("perf_hooks");
+const cache_directory_1 = require("./cache-directory");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const client_1 = require("../daemon/client/client");
+const handle_import_1 = require("./handle-import");
+let workspaceContext;
+function setupWorkspaceContext(workspaceRoot) {
+    const { WorkspaceContext } = require('../native');
+    perf_hooks_1.performance.mark('workspace-context');
+    workspaceContext = new WorkspaceContext(workspaceRoot, (0, cache_directory_1.workspaceDataDirectoryForWorkspace)(workspaceRoot));
+    perf_hooks_1.performance.mark('workspace-context:end');
+    perf_hooks_1.performance.measure('workspace context init', 'workspace-context', 'workspace-context:end');
+}
+async function getNxWorkspaceFilesFromContext(workspaceRoot, projectRootMap, useDaemonProcess = true) {
+    if (!useDaemonProcess || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.getWorkspaceFiles(projectRootMap);
+    }
+    return client_1.daemonClient.getWorkspaceFiles(projectRootMap);
+}
+/**
+ * Sync method to get files matching globs from workspace context.
+ * NOTE: This method will create the workspace context if it doesn't exist.
+ * It should only be used within Nx internal in code paths that **must** be sync.
+ * If used in an isolated plugin thread this will cause the workspace context
+ * to be recreated which is slow.
+ */
+function globWithWorkspaceContextSync(workspaceRoot, globs, exclude) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext.glob(globs, exclude);
+}
+async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
+    if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.glob(globs, exclude);
+    }
+    else {
+        return client_1.daemonClient.glob(globs, exclude);
+    }
+}
+async function multiGlobWithWorkspaceContext(workspaceRoot, globs, exclude) {
+    if (workspaceRoot === '/virtual' || (0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.multiGlob(globs, exclude);
+    }
+    return client_1.daemonClient.multiGlob(globs, exclude);
+}
+async function hashWithWorkspaceContext(workspaceRoot, globs, exclude) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.hashFilesMatchingGlob(globs, exclude);
+    }
+    return client_1.daemonClient.hashGlob(globs, exclude);
+}
+async function hashMultiGlobWithWorkspaceContext(workspaceRoot, globGroups) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.hashFilesMatchingGlobs(globGroups);
+    }
+    return client_1.daemonClient.hashMultiGlob(globGroups);
+}
+async function updateContextWithChangedFiles(workspaceRoot, createdFiles, updatedFiles, deletedFiles) {
+    if (!client_1.daemonClient.enabled()) {
+        updateFilesInContext(workspaceRoot, [...createdFiles, ...updatedFiles], deletedFiles);
+    }
+    else if ((0, is_on_daemon_1.isOnDaemon)()) {
+        // make sure to only import this when running on the daemon
+        const { addUpdatedAndDeletedFiles } = await (0, handle_import_1.handleImport)('../daemon/server/project-graph-incremental-recomputation.js', __dirname);
+        // update files for the incremental graph recomputation on the daemon
+        addUpdatedAndDeletedFiles(createdFiles, updatedFiles, deletedFiles);
+    }
+    else {
+        // daemon is enabled but we are not running on it, ask the daemon to update the context
+        await client_1.daemonClient.updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles);
+    }
+}
+function updateFilesInContext(workspaceRoot, updatedFiles, deletedFiles) {
+    ensureContextAvailable(workspaceRoot);
+    return workspaceContext?.incrementalUpdate(updatedFiles, deletedFiles);
+}
+async function getAllFileDataInContext(workspaceRoot) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.allFileData();
+    }
+    return client_1.daemonClient.getWorkspaceContextFileData();
+}
+async function getFilesInDirectoryUsingContext(workspaceRoot, dir) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.getFilesInDirectory(dir);
+    }
+    return client_1.daemonClient.getFilesInDirectory(dir);
+}
+function updateProjectFiles(projectRootMappings, rustReferences, updatedFiles, deletedFiles) {
+    return workspaceContext?.updateProjectFiles(projectRootMappings, rustReferences.projectFiles, rustReferences.globalFiles, updatedFiles, deletedFiles);
+}
+function ensureContextAvailable(workspaceRoot) {
+    if (!workspaceContext || workspaceContext?.workspaceRoot !== workspaceRoot) {
+        setupWorkspaceContext(workspaceRoot);
+    }
+}
+function resetWorkspaceContext() {
+    workspaceContext = undefined;
+}

package/dist/src/utils/workspace-root.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceRoot = void 0;
+exports.setWorkspaceRoot = setWorkspaceRoot;
+exports.workspaceRootInner = workspaceRootInner;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fileutils_1 = require("./fileutils");
+/**
+ * The root of the workspace
+ */
+exports.workspaceRoot = workspaceRootInner(process.cwd(), process.cwd());
+// Required for integration tests in projects which depend on Nx at runtime, such as lerna and angular-eslint
+function setWorkspaceRoot(root) {
+    exports.workspaceRoot = root;
+}
+function workspaceRootInner(dir, candidateRoot) {
+    if (process.env.NX_WORKSPACE_ROOT_PATH)
+        return process.env.NX_WORKSPACE_ROOT_PATH;
+    if (path.dirname(dir) === dir)
+        return candidateRoot;
+    const matches = [
+        path.join(dir, 'nx.json'),
+        path.join(dir, 'nx'),
+        path.join(dir, 'nx.bat'),
+    ];
+    if (matches.some((x) => (0, fileutils_1.fileExists)(x))) {
+        return dir;
+        // This handles the case where we have a workspace which uses npm / yarn / pnpm
+        // workspaces, and has a project which contains Nx in its dependency tree.
+        // e.g. packages/my-lib/package.json contains @nx/devkit, which references Nx and is
+        // thus located in //packages/my-lib/node_modules/nx/package.json
+    }
+    else if ((0, fileutils_1.fileExists)(path.join(dir, 'node_modules', 'nx', 'package.json'))) {
+        return workspaceRootInner(path.dirname(dir), dir);
+    }
+    else {
+        return workspaceRootInner(path.dirname(dir), candidateRoot);
+    }
+}

package/dist/src/utils/write-formatted-json-file.d.ts

@@ -0,0 +1,6 @@
+import { type JsonWriteOptions } from './fileutils';
+/**
+ * Writes a JSON file, formatting with Prettier if available, otherwise
+ * falling back to standard JSON serialization.
+ */
+export declare function writeFormattedJsonFile<T extends object = object>(filePath: string, content: T, options?: JsonWriteOptions): Promise<void>;

package/dist/src/utils/write-formatted-json-file.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFormattedJsonFile = writeFormattedJsonFile;
+const node_fs_1 = require("node:fs");
+const format_changed_files_with_prettier_if_available_1 = require("../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const json_1 = require("./json");
+const fileutils_1 = require("./fileutils");
+const workspace_root_1 = require("./workspace-root");
+/**
+ * Writes a JSON file, formatting with Prettier if available, otherwise
+ * falling back to standard JSON serialization.
+ */
+async function writeFormattedJsonFile(filePath, content, options) {
+    const formattedContent = await (0, format_changed_files_with_prettier_if_available_1.formatFilesWithPrettierIfAvailable)([{ path: filePath, content: (0, json_1.serializeJson)(content) }], workspace_root_1.workspaceRoot, { silent: true });
+    if (formattedContent.has(filePath)) {
+        (0, node_fs_1.writeFileSync)(filePath, formattedContent.get(filePath), {
+            encoding: 'utf-8',
+        });
+    }
+    else {
+        (0, fileutils_1.writeJsonFile)(filePath, content, options);
+    }
+}

package/dist/src/utils/yarn-syml/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Inlined from @yarnpkg/parsers v3.0.2 to eliminate transitive dependency
+ * conflicts (js-yaml -> argparse@1.x) for supply chain hardening.
+ *
+ * Source: https://github.com/yarnpkg/berry/blob/master/packages/yarnpkg-parsers/sources/syml.ts
+ * Grammar: https://github.com/yarnpkg/berry/blob/master/packages/yarnpkg-parsers/sources/grammars/syml.pegjs
+ *
+ * Changes from upstream:
+ * - Replaced js-yaml with @zkochan/js-yaml (already an nx dependency)
+ * - Converted to TypeScript
+ *
+ * To update: compare against the upstream source files linked above and apply
+ * any changes. The syml-grammar.js file is PEG.js-generated from syml.pegjs
+ * and can be copied from the published @yarnpkg/parsers package directly.
+ */
+export declare class PreserveOrdering {
+    readonly data: any;
+    constructor(data: any);
+}
+export declare function stringifySyml(value: any): string;
+export declare function parseSyml(source: string): {
+    [key: string]: any;
+};

package/dist/src/utils/yarn-syml/index.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Inlined from @yarnpkg/parsers v3.0.2 to eliminate transitive dependency
+ * conflicts (js-yaml -> argparse@1.x) for supply chain hardening.
+ *
+ * Source: https://github.com/yarnpkg/berry/blob/master/packages/yarnpkg-parsers/sources/syml.ts
+ * Grammar: https://github.com/yarnpkg/berry/blob/master/packages/yarnpkg-parsers/sources/grammars/syml.pegjs
+ *
+ * Changes from upstream:
+ * - Replaced js-yaml with @zkochan/js-yaml (already an nx dependency)
+ * - Converted to TypeScript
+ *
+ * To update: compare against the upstream source files linked above and apply
+ * any changes. The syml-grammar.js file is PEG.js-generated from syml.pegjs
+ * and can be copied from the published @yarnpkg/parsers package directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreserveOrdering = void 0;
+exports.stringifySyml = stringifySyml;
+exports.parseSyml = parseSyml;
+const { load, FAILSAFE_SCHEMA } = require('@zkochan/js-yaml');
+const { parse: parsePeg } = require('./syml-grammar');
+const simpleStringPattern = /^(?![-?:,\][{}#&*!|>'"%@` \t\r\n]).([ \t]*(?![,\][{}:# \t\r\n]).)*$/;
+const specialObjectKeys = [
+    `__metadata`,
+    `version`,
+    `resolution`,
+    `dependencies`,
+    `peerDependencies`,
+    `dependenciesMeta`,
+    `peerDependenciesMeta`,
+    `binaries`,
+];
+class PreserveOrdering {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.PreserveOrdering = PreserveOrdering;
+function stringifyString(value) {
+    if (value.match(simpleStringPattern)) {
+        return value;
+    }
+    else {
+        return JSON.stringify(value);
+    }
+}
+function isRemovableField(value) {
+    if (typeof value === `undefined`)
+        return true;
+    if (typeof value === `object` && value !== null && !Array.isArray(value))
+        return Object.keys(value).every((key) => isRemovableField(value[key]));
+    return false;
+}
+function stringifyValue(value, indentLevel, newLineIfObject) {
+    if (value === null)
+        return `null\n`;
+    if (typeof value === `number` || typeof value === `boolean`)
+        return `${value.toString()}\n`;
+    if (typeof value === `string`)
+        return `${stringifyString(value)}\n`;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return `[]\n`;
+        const indent = `  `.repeat(indentLevel);
+        const serialized = value
+            .map((sub) => {
+            return `${indent}- ${stringifyValue(sub, indentLevel + 1, false)}`;
+        })
+            .join(``);
+        return `\n${serialized}`;
+    }
+    if (typeof value === `object` && value) {
+        const [data, sort] = value instanceof PreserveOrdering ? [value.data, false] : [value, true];
+        const indent = `  `.repeat(indentLevel);
+        const keys = Object.keys(data);
+        if (sort) {
+            keys.sort((a, b) => {
+                const aIndex = specialObjectKeys.indexOf(a);
+                const bIndex = specialObjectKeys.indexOf(b);
+                if (aIndex === -1 && bIndex === -1)
+                    return a < b ? -1 : a > b ? +1 : 0;
+                if (aIndex !== -1 && bIndex === -1)
+                    return -1;
+                if (aIndex === -1 && bIndex !== -1)
+                    return +1;
+                return aIndex - bIndex;
+            });
+        }
+        const fields = keys
+            .filter((key) => {
+            return !isRemovableField(data[key]);
+        })
+            .map((key, index) => {
+            const value = data[key];
+            const stringifiedKey = stringifyString(key);
+            const stringifiedValue = stringifyValue(value, indentLevel + 1, true);
+            const recordIndentation = index > 0 || newLineIfObject ? indent : ``;
+            const keyPart = stringifiedKey.length > 1024
+                ? `? ${stringifiedKey}\n${recordIndentation}:`
+                : `${stringifiedKey}:`;
+            const valuePart = stringifiedValue.startsWith(`\n`)
+                ? stringifiedValue
+                : ` ${stringifiedValue}`;
+            return `${recordIndentation}${keyPart}${valuePart}`;
+        })
+            .join(indentLevel === 0 ? `\n` : ``) || `\n`;
+        if (!newLineIfObject) {
+            return `${fields}`;
+        }
+        else {
+            return `\n${fields}`;
+        }
+    }
+    throw new Error(`Unsupported value type (${value})`);
+}
+function stringifySyml(value) {
+    try {
+        const stringified = stringifyValue(value, 0, false);
+        return stringified !== `\n` ? stringified : ``;
+    }
+    catch (error) {
+        if (error.location)
+            error.message = error.message.replace(/(\.)?$/, ` (line ${error.location.start.line}, column ${error.location.start.column})$1`);
+        throw error;
+    }
+}
+function parseViaPeg(source) {
+    if (!source.endsWith(`\n`))
+        source += `\n`;
+    return parsePeg(source);
+}
+const LEGACY_REGEXP = /^(#.*(\r?\n))*?#\s+yarn\s+lockfile\s+v1\r?\n/i;
+function parseViaJsYaml(source) {
+    if (LEGACY_REGEXP.test(source))
+        return parseViaPeg(source);
+    const value = load(source, {
+        schema: FAILSAFE_SCHEMA,
+        json: true,
+    });
+    if (value === undefined || value === null)
+        return {};
+    if (typeof value !== `object`)
+        throw new Error(`Expected an indexed object, got a ${typeof value} instead. Does your file follow Yaml's rules?`);
+    if (Array.isArray(value))
+        throw new Error(`Expected an indexed object, got an array instead. Does your file follow Yaml's rules?`);
+    return value;
+}
+function parseSyml(source) {
+    return parseViaJsYaml(source);
+}