pnpm 12.9.0 → 12.10.0

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/grammars/syml.pegjs

@@ -1,125 +0,0 @@
-{
-  const INDENT_STEP = 2;
-
-  let indentLevel = 0;
-}
-
-Start
-  = PropertyStatements
-
-ItemStatements
-  = statements:ItemStatement* { return [].concat(... statements) }
-
-ItemStatement
-  = Samedent "-" B value:Expression { return value }
-
-PropertyStatements
-  = statements:PropertyStatement* { return Object.assign({}, ... statements) }
-
-PropertyStatement
-  = B? ("#" (!EOL .)+)? EOL_ANY+ { return {} }
-  / Samedent property:Name B? ":" B? value:Expression { return {[property]: value} }
-  // Compatibility with the old lockfile format (key-values without a ":")
-  / Samedent property:LegacyName B? ":" B? value:Expression { return {[property]: value} }
-  // Compatibility with the old lockfile format (key-values without a ":")
-  / Samedent property:LegacyName B value:LegacyLiteral EOL_ANY+ { return {[property]: value} }
-  // Compatibility with the old lockfile format (multiple keys for a same value)
-  / Samedent property:LegacyName others:(B? "," B? other:LegacyName { return other })+ B? ":" B? value:Expression { return Object.assign({}, ... [property].concat(others).map(property => ({[property]: value}))) }
-
-Expression
-  =  &(EOL Extradent "-" B) EOL_ANY Indent statements:ItemStatements Dedent { return statements }
-  / EOL Indent statements:PropertyStatements Dedent { return statements }
-  / expression:Literal EOL_ANY+ { return expression }
-
-Samedent "correct indentation"
-  = spaces:" "* &{ return spaces.length === indentLevel * INDENT_STEP }
-
-Extradent
-  = spaces:" "* &{ return spaces.length === (indentLevel + 1) * INDENT_STEP }
-
-Indent
-  = &{ indentLevel++; return true }
-
-Dedent
-  = &{ indentLevel--; return true }
-
-Name
-  = string
-  / pseudostring
-
-LegacyName
-  = string
-  / pseudostringLegacy+ { return text() }
-
-Literal
-  = null
-  / boolean
-  / string
-  / pseudostring
-
-LegacyLiteral
-  = null
-  / string
-  / pseudostringLegacy
-
-/**
- */
-
-pseudostring "pseudostring"
-  = [^\r\n\t ?:,\][{}#&*!|>'"%@`-] (B? [^\r\n\t ,\][{}:#"'])* { return text().replace(/^ *| *$/g, '') }
-
-pseudostringLegacy
-  = "--"? [a-zA-Z\/0-9] [^\r\n\t :,]* { return text().replace(/^ *| *$/g, '') }
-
-/**
- * String parsing
- */
-
-null
-  = "null" { return null }
-
-boolean
-  = "true" { return true }
-  / "false" { return false }
-
-string "string"
-  = '"' '"' { return "" }
-  / '"' chars:chars '"' { return chars }
-
-chars
-  = chars:char+ { return chars.join(``) }
-
-char
-  = [^"\\\0-\x1F\x7f]
-  / '\\"' { return `"` }
-  / "\\\\" { return `\\` }
-  / "\\/" { return `/`  }
-  / "\\b" { return `\b` }
-  / "\\f" { return `\f` }
-  / "\\n" { return `\n` }
-  / "\\r" { return `\r` }
-  / "\\t" { return `\t` }
-  / "\\u" h1:hexDigit h2:hexDigit h3:hexDigit h4:hexDigit {
-      return String.fromCharCode(parseInt(`0x${h1}${h2}${h3}${h4}`));
-    }
-
-hexDigit
-  = [0-9a-fA-F]
-
-/**
- * Spaces
- */
-
-B "blank space"
-  = [ \t]+
-
-S "white space"
-  = [ \t\n\r]+
-
-EOL_ANY
-  = EOL (B? EOL)*
-
-EOL
-  = "\r\n"
-  / "\n"
-  / "\r"

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/index.d.ts

@@ -1,6 +0,0 @@
-export type { ArgumentSegment, Argument, CommandChain, CommandLine, EnvSegment, ShellLine } from './grammars/shell';
-export type { ArithmeticExpression, ArithmeticPrimary } from './grammars/shell';
-export { parseShell, stringifyShell, stringifyArgument, stringifyArgumentSegment, stringifyArithmeticExpression, stringifyCommand, stringifyCommandChain, stringifyCommandChainThen, stringifyCommandLine, stringifyCommandLineThen, stringifyEnvSegment, stringifyRedirectArgument, stringifyShellLine, stringifyValueArgument, } from './shell';
-export { parseResolution, stringifyResolution } from './resolution';
-export type { Resolution } from './resolution';
-export { parseSyml, stringifySyml } from './syml';

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/index.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifySyml = exports.parseSyml = exports.stringifyResolution = exports.parseResolution = exports.stringifyValueArgument = exports.stringifyShellLine = exports.stringifyRedirectArgument = exports.stringifyEnvSegment = exports.stringifyCommandLineThen = exports.stringifyCommandLine = exports.stringifyCommandChainThen = exports.stringifyCommandChain = exports.stringifyCommand = exports.stringifyArithmeticExpression = exports.stringifyArgumentSegment = exports.stringifyArgument = exports.stringifyShell = exports.parseShell = void 0;
-var shell_1 = require("./shell");
-Object.defineProperty(exports, "parseShell", { enumerable: true, get: function () { return shell_1.parseShell; } });
-Object.defineProperty(exports, "stringifyShell", { enumerable: true, get: function () { return shell_1.stringifyShell; } });
-Object.defineProperty(exports, "stringifyArgument", { enumerable: true, get: function () { return shell_1.stringifyArgument; } });
-Object.defineProperty(exports, "stringifyArgumentSegment", { enumerable: true, get: function () { return shell_1.stringifyArgumentSegment; } });
-Object.defineProperty(exports, "stringifyArithmeticExpression", { enumerable: true, get: function () { return shell_1.stringifyArithmeticExpression; } });
-Object.defineProperty(exports, "stringifyCommand", { enumerable: true, get: function () { return shell_1.stringifyCommand; } });
-Object.defineProperty(exports, "stringifyCommandChain", { enumerable: true, get: function () { return shell_1.stringifyCommandChain; } });
-Object.defineProperty(exports, "stringifyCommandChainThen", { enumerable: true, get: function () { return shell_1.stringifyCommandChainThen; } });
-Object.defineProperty(exports, "stringifyCommandLine", { enumerable: true, get: function () { return shell_1.stringifyCommandLine; } });
-Object.defineProperty(exports, "stringifyCommandLineThen", { enumerable: true, get: function () { return shell_1.stringifyCommandLineThen; } });
-Object.defineProperty(exports, "stringifyEnvSegment", { enumerable: true, get: function () { return shell_1.stringifyEnvSegment; } });
-Object.defineProperty(exports, "stringifyRedirectArgument", { enumerable: true, get: function () { return shell_1.stringifyRedirectArgument; } });
-Object.defineProperty(exports, "stringifyShellLine", { enumerable: true, get: function () { return shell_1.stringifyShellLine; } });
-Object.defineProperty(exports, "stringifyValueArgument", { enumerable: true, get: function () { return shell_1.stringifyValueArgument; } });
-var resolution_1 = require("./resolution");
-Object.defineProperty(exports, "parseResolution", { enumerable: true, get: function () { return resolution_1.parseResolution; } });
-Object.defineProperty(exports, "stringifyResolution", { enumerable: true, get: function () { return resolution_1.stringifyResolution; } });
-var syml_1 = require("./syml");
-Object.defineProperty(exports, "parseSyml", { enumerable: true, get: function () { return syml_1.parseSyml; } });
-Object.defineProperty(exports, "stringifySyml", { enumerable: true, get: function () { return syml_1.stringifySyml; } });

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/resolution.d.ts

@@ -1,12 +0,0 @@
-export type Resolution = {
-    from?: {
-        fullName: string;
-        description?: string;
-    };
-    descriptor: {
-        fullName: string;
-        description?: string;
-    };
-};
-export declare function parseResolution(source: string): Resolution;
-export declare function stringifyResolution(resolution: Resolution): string;

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/resolution.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseResolution = parseResolution;
-exports.stringifyResolution = stringifyResolution;
-const resolution_1 = require("./grammars/resolution");
-function parseResolution(source) {
-    const legacyResolution = source.match(/^\*{1,2}\/(.*)/);
-    if (legacyResolution)
-        throw new Error(`The override for '${source}' includes a glob pattern. Glob patterns have been removed since their behaviours don't match what you'd expect. Set the override to '${legacyResolution[1]}' instead.`);
-    try {
-        return (0, resolution_1.parse)(source);
-    }
-    catch (error) {
-        if (error.location)
-            error.message = error.message.replace(/(\.)?$/, ` (line ${error.location.start.line}, column ${error.location.start.column})$1`);
-        throw error;
-    }
-}
-function stringifyResolution(resolution) {
-    let str = ``;
-    if (resolution.from) {
-        str += resolution.from.fullName;
-        if (resolution.from.description)
-            str += `@${resolution.from.description}`;
-        str += `/`;
-    }
-    str += resolution.descriptor.fullName;
-    if (resolution.descriptor.description)
-        str += `@${resolution.descriptor.description}`;
-    return str;
-}

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/shell.d.ts

@@ -1,19 +0,0 @@
-import { Argument, ArgumentSegment, ArithmeticExpression, Command, CommandChain, CommandChainThen, CommandLine, CommandLineThen, EnvSegment, RedirectArgument, ShellLine, ValueArgument } from './grammars/shell';
-export declare function parseShell(source: string, options?: {
-    isGlobPattern: (arg: string) => boolean;
-}): ShellLine;
-export declare function stringifyShellLine(shellLine: ShellLine, { endSemicolon }?: {
-    endSemicolon?: boolean;
-}): string;
-export declare function stringifyCommandLine(commandLine: CommandLine): string;
-export declare function stringifyCommandLineThen(commandLineThen: CommandLineThen): string;
-export declare function stringifyCommandChain(commandChain: CommandChain): string;
-export declare function stringifyCommandChainThen(commandChainThen: CommandChainThen): string;
-export declare function stringifyCommand(command: Command): string;
-export declare function stringifyEnvSegment(envSegment: EnvSegment): string;
-export declare function stringifyArgument(argument: Argument): string;
-export declare function stringifyRedirectArgument(argument: RedirectArgument): string;
-export declare function stringifyValueArgument(argument: ValueArgument): string;
-export declare function stringifyArgumentSegment(argumentSegment: ArgumentSegment): string;
-export declare function stringifyArithmeticExpression(argument: ArithmeticExpression): string;
-export { stringifyShellLine as stringifyShell };

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/shell.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseShell = parseShell;
-exports.stringifyShellLine = stringifyShellLine;
-exports.stringifyShell = stringifyShellLine;
-exports.stringifyCommandLine = stringifyCommandLine;
-exports.stringifyCommandLineThen = stringifyCommandLineThen;
-exports.stringifyCommandChain = stringifyCommandChain;
-exports.stringifyCommandChainThen = stringifyCommandChainThen;
-exports.stringifyCommand = stringifyCommand;
-exports.stringifyEnvSegment = stringifyEnvSegment;
-exports.stringifyArgument = stringifyArgument;
-exports.stringifyRedirectArgument = stringifyRedirectArgument;
-exports.stringifyValueArgument = stringifyValueArgument;
-exports.stringifyArgumentSegment = stringifyArgumentSegment;
-exports.stringifyArithmeticExpression = stringifyArithmeticExpression;
-const shell_1 = require("./grammars/shell");
-function parseShell(source, options = { isGlobPattern: () => false }) {
-    try {
-        return (0, shell_1.parse)(source, options);
-    }
-    catch (error) {
-        if (error.location)
-            error.message = error.message.replace(/(\.)?$/, ` (line ${error.location.start.line}, column ${error.location.start.column})$1`);
-        throw error;
-    }
-}
-function stringifyShellLine(shellLine, { endSemicolon = false } = {}) {
-    return shellLine
-        .map(({ command, type }, index) => `${stringifyCommandLine(command)}${type === `;`
-        ? (index !== shellLine.length - 1 || endSemicolon ? `;` : ``)
-        : ` &`}`)
-        .join(` `);
-}
-function stringifyCommandLine(commandLine) {
-    return `${stringifyCommandChain(commandLine.chain)}${commandLine.then ? ` ${stringifyCommandLineThen(commandLine.then)}` : ``}`;
-}
-function stringifyCommandLineThen(commandLineThen) {
-    return `${commandLineThen.type} ${stringifyCommandLine(commandLineThen.line)}`;
-}
-function stringifyCommandChain(commandChain) {
-    return `${stringifyCommand(commandChain)}${commandChain.then ? ` ${stringifyCommandChainThen(commandChain.then)}` : ``}`;
-}
-function stringifyCommandChainThen(commandChainThen) {
-    return `${commandChainThen.type} ${stringifyCommandChain(commandChainThen.chain)}`;
-}
-function stringifyCommand(command) {
-    switch (command.type) {
-        case `command`:
-            return `${command.envs.length > 0 ? `${command.envs.map(env => stringifyEnvSegment(env)).join(` `)} ` : ``}${command.args.map(argument => stringifyArgument(argument)).join(` `)}`;
-        case `subshell`:
-            return `(${stringifyShellLine(command.subshell)})${command.args.length > 0 ? ` ${command.args.map(argument => stringifyRedirectArgument(argument)).join(` `)}` : ``}`;
-        case `group`:
-            return `{ ${stringifyShellLine(command.group, { /* Bash compat */ endSemicolon: true })} }${command.args.length > 0 ? ` ${command.args.map(argument => stringifyRedirectArgument(argument)).join(` `)}` : ``}`;
-        case `envs`:
-            return command.envs.map(env => stringifyEnvSegment(env)).join(` `);
-        default:
-            throw new Error(`Unsupported command type:  "${command.type}"`);
-    }
-}
-function stringifyEnvSegment(envSegment) {
-    return `${envSegment.name}=${envSegment.args[0] ? stringifyValueArgument(envSegment.args[0]) : ``}`;
-}
-function stringifyArgument(argument) {
-    switch (argument.type) {
-        case `redirection`:
-            return stringifyRedirectArgument(argument);
-        case `argument`:
-            return stringifyValueArgument(argument);
-        default:
-            throw new Error(`Unsupported argument type: "${argument.type}"`);
-    }
-}
-function stringifyRedirectArgument(argument) {
-    return `${argument.subtype} ${argument.args.map(argument => stringifyValueArgument(argument)).join(` `)}`;
-}
-function stringifyValueArgument(argument) {
-    return argument.segments.map(segment => stringifyArgumentSegment(segment)).join(``);
-}
-const ESCAPED_CONTROL_CHARS = new Map([
-    [`\f`, `\\f`],
-    [`\n`, `\\n`],
-    [`\r`, `\\r`],
-    [`\t`, `\\t`],
-    [`\v`, `\\v`],
-    [`\0`, `\\0`],
-]);
-const ESCAPED_DBL_CHARS = new Map([
-    [`\\`, `\\\\`],
-    [`$`, `\\$`],
-    [`"`, `\\"`],
-    ...Array.from(ESCAPED_CONTROL_CHARS, ([c, replacement]) => {
-        return [c, `"$'${replacement}'"`];
-    }),
-]);
-const getEscapedControlChar = (c) => {
-    return ESCAPED_CONTROL_CHARS.get(c) ?? `\\x${c.charCodeAt(0).toString(16).padStart(2, `0`)}`;
-};
-const getEscapedDblChar = (match) => {
-    return ESCAPED_DBL_CHARS.get(match) ?? `"$'${getEscapedControlChar(match)}'"`;
-};
-function stringifyArgumentSegment(argumentSegment) {
-    const doubleQuoteIfRequested = (string, quote) => quote
-        ? `"${string}"`
-        : string;
-    const quoteIfNeeded = (text) => {
-        if (text === ``)
-            return `''`;
-        if (!text.match(/[()}<>$|&;"'\n\t ]/))
-            return text;
-        if (!text.match(/['\t\p{C}]/u))
-            return `'${text}'`;
-        if (!text.match(/'/)) {
-            return `$'${text.replace(/[\t\p{C}]/u, getEscapedControlChar)}'`;
-        }
-        else {
-            return `"${text.replace(/["$\t\p{C}]/u, getEscapedDblChar)}"`;
-        }
-    };
-    switch (argumentSegment.type) {
-        case `text`:
-            return quoteIfNeeded(argumentSegment.text);
-        case `glob`:
-            return argumentSegment.pattern;
-        case `shell`:
-            return doubleQuoteIfRequested(`$(${stringifyShellLine(argumentSegment.shell)})`, argumentSegment.quoted);
-        case `variable`:
-            return doubleQuoteIfRequested(typeof argumentSegment.defaultValue === `undefined`
-                ? typeof argumentSegment.alternativeValue === `undefined`
-                    ? `\${${argumentSegment.name}}`
-                    : argumentSegment.alternativeValue.length === 0
-                        ? `\${${argumentSegment.name}:+}`
-                        : `\${${argumentSegment.name}:+${argumentSegment.alternativeValue.map(argument => stringifyValueArgument(argument)).join(` `)}}`
-                : argumentSegment.defaultValue.length === 0
-                    ? `\${${argumentSegment.name}:-}`
-                    : `\${${argumentSegment.name}:-${argumentSegment.defaultValue.map(argument => stringifyValueArgument(argument)).join(` `)}}`, argumentSegment.quoted);
-        case `arithmetic`:
-            return `$(( ${stringifyArithmeticExpression(argumentSegment.arithmetic)} ))`;
-        default:
-            throw new Error(`Unsupported argument segment type: "${argumentSegment.type}"`);
-    }
-}
-function stringifyArithmeticExpression(argument) {
-    const getOperator = (type) => {
-        switch (type) {
-            case `addition`:
-                return `+`;
-            case `subtraction`:
-                return `-`;
-            case `multiplication`:
-                return `*`;
-            case `division`:
-                return `/`;
-            default:
-                throw new Error(`Can't extract operator from arithmetic expression of type "${type}"`);
-        }
-    };
-    const parenthesizeIfRequested = (string, parenthesize) => parenthesize ? `( ${string} )` : string;
-    const stringifyAndParenthesizeIfNeeded = (expression) => 
-    // Right now we parenthesize all arithmetic operator expressions because it's easier
-    parenthesizeIfRequested(stringifyArithmeticExpression(expression), ![`number`, `variable`].includes(expression.type));
-    switch (argument.type) {
-        case `number`:
-            return String(argument.value);
-        case `variable`:
-            return argument.name;
-        default:
-            return `${stringifyAndParenthesizeIfNeeded(argument.left)} ${getOperator(argument.type)} ${stringifyAndParenthesizeIfNeeded(argument.right)}`;
-    }
-}

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/syml.d.ts

@@ -1,11 +0,0 @@
-export declare class PreserveOrdering {
-    readonly data: any;
-    constructor(data: any);
-}
-export declare function stringifySyml(value: any): string;
-export declare namespace stringifySyml {
-    var PreserveOrdering: typeof import("./syml").PreserveOrdering;
-}
-export declare function parseSyml(source: string): {
-    [key: string]: any;
-};

package/dist/wasm/node_modules/@yarnpkg/parsers/lib/syml.js

@@ -1,132 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PreserveOrdering = void 0;
-exports.stringifySyml = stringifySyml;
-exports.parseSyml = parseSyml;
-const js_yaml_1 = require("js-yaml");
-const syml_1 = require("./grammars/syml");
-const simpleStringPattern = /^(?![-?:,\][{}#&*!|>'"%@` \t\r\n]).([ \t]*(?![,\][{}:# \t\r\n]).)*$/;
-// The following keys will always be stored at the top of the object, in the
-// specified order. It's not fair but life isn't fair either.
-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
-                : ``;
-            // Yaml 1.2 spec says that keys over 1024 characters need to be prefixed with ? and the : goes in a new line
-            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;
-    }
-}
-stringifySyml.PreserveOrdering = PreserveOrdering;
-function parseViaPeg(source) {
-    if (!source.endsWith(`\n`))
-        source += `\n`;
-    return (0, syml_1.parse)(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 = (0, js_yaml_1.load)(source, {
-        schema: js_yaml_1.FAILSAFE_SCHEMA,
-        json: true,
-    });
-    // Empty files are parsed as `undefined` instead of an empty object
-    // Empty files with 2 newlines or more are `null` instead
-    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);
-}

package/dist/wasm/node_modules/@yarnpkg/parsers/package.json

@@ -1,46 +0,0 @@
-{
-  "name": "@yarnpkg/parsers",
-  "version": "3.1.0",
-  "license": "BSD-2-Clause",
-  "main": "./lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./package.json": "./package.json"
-  },
-  "dependencies": {
-    "js-yaml": "^4.3.0",
-    "tslib": "^2.4.0"
-  },
-  "devDependencies": {
-    "@types/js-yaml": "^3.11.1",
-    "pegjs": "^0.10.0"
-  },
-  "scripts": {
-    "grammar:shell": "run pegjs -o sources/grammars/shell.js sources/grammars/shell.pegjs",
-    "grammar:resolution": "run pegjs -o sources/grammars/resolution.js sources/grammars/resolution.pegjs",
-    "grammar:syml": "run pegjs -o sources/grammars/syml.js sources/grammars/syml.pegjs",
-    "grammar:all": "run grammar:shell & run grammar:resolution & run grammar:syml &",
-    "postpack": "rm -rf lib",
-    "prepack": "run build:compile \"$(pwd)\"",
-    "release": "yarn npm publish",
-    "test:parsers": "run test:unit packages/yarnpkg-parsers"
-  },
-  "publishConfig": {
-    "main": "./lib/index.js",
-    "exports": {
-      ".": "./lib/index.js",
-      "./package.json": "./package.json"
-    }
-  },
-  "files": [
-    "/lib/**/*"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yarnpkg/berry.git",
-    "directory": "packages/yarnpkg-parsers"
-  },
-  "engines": {
-    "node": ">=18.12.0"
-  }
-}

package/dist/wasm/node_modules/@yarnpkg/shell/README.md

@@ -1,38 +0,0 @@
-# `@yarnpkg/shell`
-
-A JavaScript implementation of a bash-like shell (we use it in Yarn 2 to provide cross-platform scripting). This package exposes an API that abstracts both the parser and the interpreter; should you only need the parser you can check out `@yarnpkg/parsers`, but you probably won't need it.
-
-## Usage
-
-```ts
-import {execute} from '@yarnpkg/shell';
-
-process.exitCode = await execute(`ls "$0" | wc -l`, [process.cwd()]);
-```
-
-## Features
-
-- Typechecked
-- Portable across systems
-- Supports custom JS builtins
-- Supports pipes
-- Supports glob patterns (**only** for files that exist on the filesystem: `ls *.txt`)
-- Supports logical operators
-- Supports subshells
-- Supports variables
-- Supports string manipulators
-- Supports argc/argv
-- Supports background jobs with color-coded output
-- Supports the most classic builtins
-- Doesn't necessarily need to access the fs
-
-## Help Wanted
-
-- Full glob support (`mv build/{index.js,index.build.js}`, `echo {foo,bar}`, `FOO=a,b echo {$FOO,x}`)
-- More string manipulators
-
-## Non-Goals
-
-- Perfect POSIX compliance (basic scripting is enough for now)
-- Multiline scripts (we mostly target one-liners)
-- Control structures (same reason)

package/dist/wasm/node_modules/@yarnpkg/shell/lib/boot-cli-dev.js

@@ -1,3 +0,0 @@
-require(`@yarnpkg/monorepo/scripts/setup-ts-execution`);
-
-require(`./cli`);

package/dist/wasm/node_modules/@yarnpkg/shell/lib/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/wasm/node_modules/@yarnpkg/shell/lib/cli.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const clipanion_1 = require("clipanion");
-const entry_1 = tslib_1.__importDefault(require("./commands/entry"));
-const cli = new clipanion_1.Cli({
-    binaryLabel: `Yarn Shell`,
-    binaryName: `yarn shell`,
-    binaryVersion: require(`@yarnpkg/shell/package.json`).version || `<unknown>`,
-});
-cli.register(entry_1.default);
-cli.register(clipanion_1.Builtins.HelpCommand);
-cli.register(clipanion_1.Builtins.VersionCommand);
-cli.runExit(process.argv.slice(2), {
-    stdin: process.stdin,
-    stdout: process.stdout,
-    stderr: process.stderr,
-});

package/dist/wasm/node_modules/@yarnpkg/shell/lib/commands/entry.d.ts

@@ -1,8 +0,0 @@
-import { Command, Usage } from 'clipanion';
-export default class EntryCommand extends Command {
-    static usage: Usage;
-    cwd: string;
-    commandName: string;
-    args: string[];
-    execute(): Promise<number>;
-}