@pnpm/exe 12.8.2 → 12.9.0

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

@@ -0,0 +1,125 @@
+{
+  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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,24 @@
+"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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,31 @@
+"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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,170 @@
+"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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,132 @@
+"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

@@ -0,0 +1,46 @@
+{
+  "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

@@ -0,0 +1,38 @@
+# `@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

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

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

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

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

@@ -0,0 +1,19 @@
+#!/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

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