rork-xcode 0.10.0 → 0.12.0

package/dist/index.js

@@ -213,20 +213,25 @@ function createReferenceComments(root) {
 *
 * @module
 */
-/** UTF-16 code unit of `\n`, used to count lines when reporting a failure. */
 const LINE_FEED = 10;
+const CARRIAGE_RETURN = 13;
 /**
 * Converts a source offset into a position.
 *
 * Runs only when an error is actually thrown, so parsing never pays for line
-* tracking on the happy path.
+* tracking on the happy path. All three line-ending conventions count as
+* one break each, with the carriage return of a `\r\n` pair deferring to
+* its line feed.
 */
 function positionAt(source, offset) {
 	let line = 1;
 	let lineStart = 0;
-	for (let i = 0; i < offset && i < source.length; i++) if (source.charCodeAt(i) === LINE_FEED) {
-		line++;
-		lineStart = i + 1;
+	for (let i = 0; i < offset && i < source.length; i++) {
+		const code = source.charCodeAt(i);
+		if (code === LINE_FEED || code === CARRIAGE_RETURN && source.charCodeAt(i + 1) !== LINE_FEED) {
+			line++;
+			lineStart = i + 1;
+		}
 	}
 	return {
 		offset,
@@ -283,6 +288,30 @@ var XcschemeParseError = class extends Error {
 	}
 };
 /**
+* Thrown when the source text is not a well-formed workspace data file
+* (the XML dialect of `contents.xcworkspacedata` files).
+*
+* The message always embeds the line and column of the failure, and the
+* same information is available in structured form on {@link position}
+* for programmatic use.
+*/
+var XcworkspaceParseError = class extends Error {
+	/** Where in the source text parsing failed. */
+	position;
+	/**
+	* @param message Failure description without location. The location is
+	*   appended automatically.
+	* @param source Full source text, used to compute the position.
+	* @param offset Character offset of the failure inside `source`.
+	*/
+	constructor(message, source, offset) {
+		const position = positionAt(source, offset);
+		super(`${message} (line ${position.line}, column ${position.column})`);
+		this.name = "XcworkspaceParseError";
+		this.position = position;
+	}
+};
+/**
 * Thrown when the source text is not a well-formed build configuration
 * file (the line-based format of `.xcconfig` files).
 *
@@ -328,6 +357,27 @@ var XcschemeBuildError = class extends Error {
 	}
 };
 /**
+* Thrown when a workspace element cannot be written as XML.
+*
+* Raised for element and attribute names that are not valid XML names and
+* for attribute values carrying control characters XML 1.0 cannot encode.
+* The {@link path} pinpoints the offending element inside the tree.
+*/
+var XcworkspaceBuildError = class extends Error {
+	/** Path to the offending element from the root, e.g. `Workspace.FileRef[0]`. */
+	path;
+	/**
+	* @param message Failure description without location. The element path
+	*   is appended automatically.
+	* @param path Path to the offending element from the root.
+	*/
+	constructor(message, path) {
+		super(`${message} (at ${path})`);
+		this.name = "XcworkspaceBuildError";
+		this.path = path;
+	}
+};
+/**
 * Thrown by the object model when an operation cannot proceed, because the
 * document lacks the structure the operation needs (no objects dictionary,
 * no root project object), a view's object was removed from the document,
@@ -524,17 +574,17 @@ function sanitizeComment(comment) {
 * Sharing the strings avoids a `"\t".repeat(depth)` allocation on every
 * line of output.
 */
-const INDENTS = [""];
+const INDENTS$1 = [""];
 /**
 * Returns the shared indentation string for a nesting depth.
 */
 function indentString(depth) {
-	const cached = INDENTS[depth];
+	const cached = INDENTS$1[depth];
 	if (cached != null) return cached;
-	let known = INDENTS.at(-1);
-	while (INDENTS.length <= depth) {
+	let known = INDENTS$1.at(-1);
+	while (INDENTS$1.length <= depth) {
 		known += "	";
-		INDENTS.push(known);
+		INDENTS$1.push(known);
 	}
 	return known;
 }
@@ -815,6 +865,153 @@ function buildPbxproj(root) {
 	return new Writer(root).toString();
 }
 //#endregion
+//#region src/expansion.ts
+/**
+* Expands every `$(NAME)` and `${NAME}` reference in a value through the
+* lookup. Substituted text is expanded again, so references are followed
+* through chains of values, and reference names may themselves contain
+* references (`$(SETTING_$(VARIANT))`), which expand innermost first.
+*
+* A lookup answer of `undefined` leaves the reference in the output
+* verbatim, so partial resolution loses no information. A reference
+* whose expansion would recurse into itself also stays verbatim, which
+* keeps cyclic definitions finite. Xcode's `:` operators are honored for
+* the forms below, and a reference carrying any other operator stays
+* verbatim rather than expanding to a wrongly transformed value.
+*
+* The supported operators are `lower` and `upper` for case mapping,
+* `rfc1034identifier` and `c99extidentifier` for the identifier
+* mappings bundle identifiers and product module names use, and
+* `default=value` for substituting a fallback when the setting resolves
+* empty or is not known to the lookup.
+*/
+function expandBuildSettingReferences(value, lookup, options) {
+	return expand(value, lookup, options?.expandLookupValues !== false, /* @__PURE__ */ new Set());
+}
+/** The UTF-16 code unit of `$`, which starts every reference. */
+const CODE_DOLLAR = 36;
+/**
+* One expansion pass over a value. Active names carry the references
+* currently being expanded up the call stack, so a cycle is detected the
+* moment a name would expand inside its own expansion.
+*/
+function expand(value, lookup, expandLookupValues, active) {
+	if (!value.includes("$")) return value;
+	let out = "";
+	let index = 0;
+	while (index < value.length) {
+		const open = value.charCodeAt(index) === CODE_DOLLAR ? value[index + 1] : void 0;
+		if (open !== "(" && open !== "{") {
+			out += value[index];
+			index++;
+			continue;
+		}
+		const end = findClosingDelimiter(value, index + 2, open === "(" ? ")" : "}");
+		if (end === -1) {
+			out += value.slice(index);
+			break;
+		}
+		const reference = value.slice(index, end + 1);
+		const inner = expand(value.slice(index + 2, end), lookup, expandLookupValues, active);
+		out += expandReference(reference, inner, lookup, expandLookupValues, active);
+		index = end + 1;
+	}
+	return out;
+}
+/**
+* Finds the index of the closing delimiter matching an opener at
+* `start - 1`, honoring nested delimiters of the same kind, or -1 when
+* the reference is unterminated.
+*/
+function findClosingDelimiter(value, start, close) {
+	const open = close === ")" ? "(" : "{";
+	let depth = 0;
+	for (let i = start; i < value.length; i++) {
+		const ch = value[i];
+		if (ch === open) depth++;
+		else if (ch === close) {
+			if (depth === 0) return i;
+			depth--;
+		}
+	}
+	return -1;
+}
+/**
+* Expands one reference whose name and operators have already had their
+* own references resolved. Returns the original reference text whenever
+* the expansion cannot honestly produce a value.
+*/
+function expandReference(reference, inner, lookup, expandLookupValues, active) {
+	const colon = inner.indexOf(":");
+	const name = colon === -1 ? inner : inner.slice(0, colon);
+	if (active.has(name)) return reference;
+	const raw = lookup(name);
+	const nested = /* @__PURE__ */ new Set([...active, name]);
+	let value = raw;
+	if (raw != null && expandLookupValues) value = expand(raw, lookup, expandLookupValues, nested);
+	if (colon !== -1) {
+		for (const operator of splitOperators(inner.slice(colon + 1))) if (operator.startsWith("default=")) {
+			if (value == null || value === "") value = operator.slice(8);
+		} else if (value != null) {
+			const applied = applyOperator(operator, value);
+			if (applied == null) return reference;
+			value = applied;
+		} else if (applyOperator(operator, "") == null) return reference;
+	}
+	return value ?? reference;
+}
+/**
+* Splits an operator chain at colons, keeping a `default=` value intact
+* even when it contains colons of its own, the way Xcode consumes the
+* rest of the reference as the default.
+*/
+function splitOperators(operators) {
+	const parts = [];
+	let rest = operators;
+	while (rest.length > 0) {
+		if (rest.startsWith("default=")) {
+			parts.push(rest);
+			break;
+		}
+		const colon = rest.indexOf(":");
+		if (colon === -1) {
+			parts.push(rest);
+			break;
+		}
+		parts.push(rest.slice(0, colon));
+		rest = rest.slice(colon + 1);
+	}
+	return parts;
+}
+/**
+* The transforming operators the expander supports, keyed by the name
+* they are written with. `default=` is not listed because it carries an
+* argument and substitutes rather than transforms, so the reference
+* expansion handles it structurally.
+*/
+const OPERATOR_TRANSFORMS = {
+	c99extidentifier: (value) => value.replaceAll(/[^A-Za-z0-9_]/gu, "_"),
+	lower: (value) => value.toLowerCase(),
+	rfc1034identifier: (value) => value.replaceAll(/[^A-Za-z0-9-]/gu, "-"),
+	upper: (value) => value.toUpperCase()
+};
+/**
+* Whether a parsed operator names one of the supported transforms. The
+* check is an own-property test, so document text like `toString` cannot
+* reach the table's prototype.
+*/
+function isBuildSettingOperator(operator) {
+	return Object.hasOwn(OPERATOR_TRANSFORMS, operator);
+}
+/**
+* Applies one operator to a resolved value, or returns `undefined` for
+* operators outside {@link BuildSettingOperator}, which the caller turns
+* into a verbatim reference.
+*/
+function applyOperator(operator, value) {
+	return isBuildSettingOperator(operator) ? OPERATOR_TRANSFORMS[operator](value) : void 0;
+}
+//#endregion
 //#region src/model/isa.ts
 /**
 * Names and well-known values of the pbxproj object vocabulary.
@@ -2080,11 +2277,11 @@ const IS_LITERAL_CHAR = (() => {
 	for (const ch of "_$/:.-") table[ch.charCodeAt(0)] = 1;
 	return table;
 })();
-const CODE_TAB$1 = 9;
-const CODE_LINE_FEED$1 = 10;
-const CODE_CARRIAGE_RETURN$1 = 13;
+const CODE_TAB$2 = 9;
+const CODE_LINE_FEED$2 = 10;
+const CODE_CARRIAGE_RETURN$2 = 13;
 const CODE_SPACE$1 = 32;
-const CODE_QUOTE$1 = 34;
+const CODE_QUOTE$2 = 34;
 const CODE_SINGLE_QUOTE = 39;
 const CODE_OPEN_PAREN = 40;
 const CODE_CLOSE_PAREN = 41;
@@ -2096,9 +2293,9 @@ const CODE_SLASH$1 = 47;
 const CODE_ZERO = 48;
 const CODE_NINE = 57;
 const CODE_SEMICOLON = 59;
-const CODE_LESS_THAN$1 = 60;
+const CODE_LESS_THAN$2 = 60;
 const CODE_EQUALS$1 = 61;
-const CODE_GREATER_THAN$1 = 62;
+const CODE_GREATER_THAN$2 = 62;
 const CODE_BACKSLASH = 92;
 const CODE_OPEN_BRACE = 123;
 const CODE_CLOSE_BRACE = 125;
@@ -2111,9 +2308,9 @@ const CODE_CLOSE_BRACE = 125;
 const IS_WHITESPACE = (() => {
 	const table = /* @__PURE__ */ new Uint8Array(256);
 	table[CODE_SPACE$1] = 1;
-	table[CODE_TAB$1] = 1;
-	table[CODE_CARRIAGE_RETURN$1] = 1;
-	table[CODE_LINE_FEED$1] = 1;
+	table[CODE_TAB$2] = 1;
+	table[CODE_CARRIAGE_RETURN$2] = 1;
+	table[CODE_LINE_FEED$2] = 1;
 	return table;
 })();
 /**
@@ -2291,7 +2488,7 @@ var Parser$1 = class {
 		const input = this.input;
 		const length = input.length;
 		const start = ++this.pos;
-		while (this.pos < length && input.charCodeAt(this.pos) !== CODE_GREATER_THAN$1) this.pos++;
+		while (this.pos < length && input.charCodeAt(this.pos) !== CODE_GREATER_THAN$2) this.pos++;
 		if (this.pos >= length) this.fail("Unterminated data run", start - 1);
 		let hex = "";
 		for (let i = start; i < this.pos; i++) {
@@ -2334,7 +2531,7 @@ var Parser$1 = class {
 				return result;
 			}
 			let key;
-			if (code === CODE_QUOTE$1 || code === CODE_SINGLE_QUOTE) key = this.readQuotedString();
+			if (code === CODE_QUOTE$2 || code === CODE_SINGLE_QUOTE) key = this.readQuotedString();
 			else if (IS_LITERAL_CHAR[code] === 1) key = this.readLiteral();
 			else this.fail(`Expected a key but found '${input[this.pos]}'`);
 			this.expect(CODE_EQUALS$1, "=");
@@ -2390,9 +2587,9 @@ var Parser$1 = class {
 		const code = this.input.charCodeAt(this.pos);
 		if (code === CODE_OPEN_BRACE) return this.parseObject();
 		if (code === CODE_OPEN_PAREN) return this.parseArray();
-		if (code === CODE_QUOTE$1 || code === CODE_SINGLE_QUOTE) return this.readQuotedString();
+		if (code === CODE_QUOTE$2 || code === CODE_SINGLE_QUOTE) return this.readQuotedString();
 		if (IS_LITERAL_CHAR[code] === 1) return interpretLiteral(this.readLiteral());
-		if (code === CODE_LESS_THAN$1) return this.readData();
+		if (code === CODE_LESS_THAN$2) return this.readData();
 		this.fail(`Expected a value but found '${this.input[this.pos]}'`);
 	}
 };
@@ -3034,6 +3231,47 @@ var Target = class extends XcodeObject {
 		return (projectConfiguration == null ? void 0 : this.project.xcconfigSettingsOf(projectConfiguration))?.[key];
 	}
 	/**
+	* Reads a build setting like {@link getBuildSetting} and expands the
+	* `$(NAME)` and `${NAME}` references in it. Referenced settings resolve
+	* through the same layering, `$(inherited)` and a setting referencing
+	* itself continue from the next layer down the way Xcode composes
+	* values, and `$(TARGET_NAME)` falls back to the target's name, so the
+	* common `PRODUCT_NAME = "$(TARGET_NAME)"` resolves without any caller
+	* setup.
+	*
+	* References the model cannot resolve (build-system paths like
+	* `$(BUILT_PRODUCTS_DIR)`, environment values) stay in the result
+	* verbatim unless the caller's lookup answers them, so no information
+	* is invented. See {@link expandBuildSettingReferences} for the
+	* operator forms honored during expansion.
+	*/
+	resolveBuildSetting(key, options) {
+		const targetConfiguration = defaultConfigurationOf(this.project, this.getString("buildConfigurationList"));
+		const projectConfiguration = defaultConfigurationOf(this.project, this.project.rootProject.getString("buildConfigurationList"));
+		const layers = [
+			asDictionary(targetConfiguration?.properties["buildSettings"]),
+			targetConfiguration == null ? void 0 : this.project.xcconfigSettingsOf(targetConfiguration),
+			asDictionary(projectConfiguration?.properties["buildSettings"]),
+			projectConfiguration == null ? void 0 : this.project.xcconfigSettingsOf(projectConfiguration)
+		];
+		const resolve = (name, fromLayer, active) => {
+			const guard = `${fromLayer}:${name}`;
+			if (active.has(guard)) return;
+			const nested = /* @__PURE__ */ new Set([...active, guard]);
+			for (let layer = fromLayer; layer < layers.length; layer++) {
+				const settings = layers[layer];
+				if (settings == null || !(name in settings)) continue;
+				const value = asString(settings[name]);
+				if (value == null) return;
+				return expandBuildSettingReferences(value, (reference) => {
+					if (reference === "inherited" || reference === name) return resolve(name, layer + 1, nested) ?? "";
+					return resolve(reference, 0, nested) ?? options?.lookup?.(reference) ?? builtinSetting(this, reference);
+				}, { expandLookupValues: false });
+			}
+		};
+		return resolve(key, 0, /* @__PURE__ */ new Set());
+	}
+	/**
 	* Writes a build setting on every configuration of the target, so Debug
 	* and Release stay consistent.
 	*/
@@ -3147,6 +3385,15 @@ var Target = class extends XcodeObject {
 	}
 };
 /**
+* The settings the build system defines from the target itself rather
+* than from the document. `TARGET_NAME` is the one programmatic reads
+* meet constantly, through the template's `PRODUCT_NAME` of
+* `$(TARGET_NAME)`.
+*/
+function builtinSetting(target, name) {
+	return name === "TARGET_NAME" ? target.name : void 0;
+}
+/**
 * A `PBXNativeTarget` is a product the project compiles and packages
 * itself, such as an application or an app extension.
 */
@@ -4087,57 +4334,159 @@ function stripReferences(properties, id) {
 	}
 }
 //#endregion
-//#region src/scheme/types.ts
+//#region src/xml/types.ts
 /**
 * Whether a node is an element rather than a comment.
 */
-function isXcschemeElement(node) {
+function isXmlElement(node) {
 	return "name" in node;
 }
+/**
+* Collects elements of the given name anywhere under a root, in document
+* order, root included. Passing no name collects every element. Scheme
+* and workspace models both build their typed views over this query.
+*/
+function xmlElements(root, name) {
+	const found = [];
+	const visit = (element) => {
+		if (name == null || element.name === name) found.push(element);
+		for (const child of element.children) if (isXmlElement(child)) visit(child);
+	};
+	visit(root);
+	return found;
+}
 //#endregion
-//#region src/scheme/build.ts
+//#region src/xml/build.ts
 /**
-* Serializer for the `.xcscheme` XML dialect.
+* Serializer for Xcode's XML dialect, shared by scheme and workspace
+* files.
 *
 * The output reproduces Xcode's own layout byte for byte. Xcode writes
 * the UTF-8 declaration, indents with three spaces, puts each attribute
 * on its own line with spaces around the equals sign, glues the closing
 * angle bracket to the last attribute, and closes every element with an
-* explicit close tag. Parsing an Xcode-written scheme and building it
+* explicit close tag. Parsing an Xcode-written file and building it
 * back therefore yields the identical file, and any other input reaches
 * that canonical form in one build.
 *
+* Each file format wraps this core with its own error type, so a caller
+* always sees the error class of the format it asked for.
+*
 * @module
 */
-/** The declaration line Xcode writes at the top of every scheme file. */
+/**
+* The internal failure the renderers throw. It carries the offending
+* node instead of a path, and {@link buildXmlDocument} resolves the path
+* by searching the tree only when a failure actually happens, so the
+* happy path never pays for path bookkeeping.
+*/
+var XmlBuildFailure = class extends Error {
+	/** The element or comment node the failure points at. */
+	node;
+	constructor(message, node) {
+		super(message);
+		this.name = "XmlBuildFailure";
+		this.node = node;
+	}
+};
+/** The declaration line Xcode writes at the top of every file. */
 const XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-/** One indentation step of Xcode's scheme writer. */
+/** One indentation step of Xcode's writer. */
 const INDENT = "   ";
 /**
+* Indentation strings by depth, extended on demand. Documents nest a
+* handful of levels, and reusing the strings keeps the writer from
+* re-allocating the same prefixes for every node.
+*/
+const INDENTS = [""];
+/**
+* The indentation prefix for a nesting depth.
+*/
+function indentAt(depth) {
+	for (let known = INDENTS.length; known <= depth; known++) INDENTS.push(INDENTS[known - 1] + INDENT);
+	return INDENTS[depth];
+}
+/**
 * Matches valid XML names. A stray non-name, such as an empty string or
 * one carrying spaces or XML syntax, must fail rather than produce a
 * document no parser accepts.
 */
 const NAME_PATTERN = /^[A-Za-z_:][A-Za-z0-9_:.-]*$/u;
 /**
-* Matches characters that cannot appear in an attribute value. XML 1.0
-* has no representation for control characters other than tab, line
-* feed, and carriage return.
+* Names that already passed {@link NAME_PATTERN}, capped so hostile
+* documents cannot grow the set without bound. Element and attribute
+* vocabularies repeat heavily, so nearly every check after the first is
+* a set lookup instead of a regex test.
 */
-const UNENCODABLE_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/u;
+const VALID_NAMES = /* @__PURE__ */ new Set();
 /**
-* Serializes a scheme document to the text of a `.xcscheme` file.
-*
-* @throws XcschemeBuildError for element or attribute names that are not
-*   XML names and for attribute values carrying unencodable control
-*   characters, with the path of the offending node.
+* Whether a name is a valid XML name, memoized across documents.
 */
-function buildXcscheme(document) {
-	let output = XML_DECLARATION;
-	for (const comment of document.leading) output += `<!--${comment.comment}-->\n`;
-	output += renderElement(document.root, 0, document.root.name);
-	for (const comment of document.trailing) output += `<!--${comment.comment}-->\n`;
-	return output;
+function isValidName(name) {
+	if (VALID_NAMES.has(name)) return true;
+	if (!NAME_PATTERN.test(name)) return false;
+	if (VALID_NAMES.size < 512) VALID_NAMES.add(name);
+	return true;
+}
+/**
+* Serializes a document to text in Xcode's canonical layout, reporting
+* failures through the given error factory.
+*/
+function buildXmlDocument(document, makeError) {
+	try {
+		let output = XML_DECLARATION;
+		for (const comment of document.leading) output += renderComment(comment, 0);
+		output += renderElement(document.root, 0);
+		for (const comment of document.trailing) output += renderComment(comment, 0);
+		return output;
+	} catch (error) {
+		if (error instanceof XmlBuildFailure) throw makeError(error.message, pathOf(document, error.node));
+		throw error;
+	}
+}
+/**
+* Resolves the path of a node for an error message, in the
+* `Scheme.BuildAction[0]` form, by walking the tree. This runs only when
+* a build actually fails.
+*/
+function pathOf(document, node) {
+	if (node == null || document.leading.includes(node) || document.trailing.includes(node)) return "document";
+	const search = (element, path) => {
+		if (element === node) return path;
+		const seen = /* @__PURE__ */ new Map();
+		for (const child of element.children) {
+			if (!isXmlElement(child)) {
+				if (child === node) return path;
+				continue;
+			}
+			const index = seen.get(child.name) ?? 0;
+			seen.set(child.name, index + 1);
+			const found = search(child, `${path}.${child.name}[${index}]`);
+			if (found != null) return found;
+		}
+	};
+	return search(document.root, document.root.name) ?? document.root.name;
+}
+/**
+* Matches the characters no XML document can carry, in any context. The
+* alternatives are the control characters XML cannot represent,
+* unpaired surrogate halves, and the two noncharacters at the end of
+* the basic plane. Comments validate against this directly, since
+* comment text has no escapes to fall back on.
+*/
+const UNCARRIABLE_PATTERN$1 = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uFFFE\uFFFF]/u;
+/**
+* Renders one comment, failing on text the comment grammar cannot hold.
+* A `--` inside the text or a `-` against the closing marker would
+* reparse at a different terminator, and characters outside XML's
+* character set have no escaped form inside a comment, so emitting
+* either would corrupt the document.
+*/
+function renderComment(node, depth) {
+	const comment = node.comment;
+	if (comment.includes("--") || comment.endsWith("-")) throw new XmlBuildFailure("Comments cannot contain -- or end with -", node);
+	if (UNCARRIABLE_PATTERN$1.test(comment)) throw new XmlBuildFailure("Comments cannot contain characters XML cannot carry", node);
+	return `${indentAt(depth)}<!--${comment}-->\n`;
 }
 /**
 * Renders one element with Xcode's layout. Attributes go each on their
@@ -4145,67 +4494,109 @@ function buildXcscheme(document) {
 * attribute, children indent one step, and the close tag is always
 * explicit.
 */
-function renderElement(element, depth, path) {
-	if (!NAME_PATTERN.test(element.name)) throw new XcschemeBuildError(`Element name ${JSON.stringify(element.name)} is not a valid XML name`, path);
-	const indent = INDENT.repeat(depth);
+function renderElement(element, depth) {
+	if (!isValidName(element.name)) throw new XmlBuildFailure(`Element name ${JSON.stringify(element.name)} is not a valid XML name`, element);
+	const indent = indentAt(depth);
 	const names = Object.keys(element.attributes);
 	let output;
 	if (names.length === 0) output = `${indent}<${element.name}>\n`;
 	else {
 		output = `${indent}<${element.name}\n`;
-		const attributeIndent = indent + INDENT;
+		const attributeIndent = indentAt(depth + 1);
 		for (let i = 0; i < names.length; i++) {
 			const name = names[i];
-			if (!NAME_PATTERN.test(name)) throw new XcschemeBuildError(`Attribute name ${JSON.stringify(name)} is not a valid XML name`, path);
-			const value = escapeAttribute(element.attributes[name], path, name);
+			if (!isValidName(name)) throw new XmlBuildFailure(`Attribute name ${JSON.stringify(name)} is not a valid XML name`, element);
+			const value = escapeAttribute(element.attributes[name], element, name);
 			const terminator = i === names.length - 1 ? ">" : "";
 			output += `${attributeIndent}${name} = "${value}"${terminator}\n`;
 		}
 	}
-	output += renderChildren(element.children, depth + 1, path);
+	const children = element.children;
+	const childDepth = depth + 1;
+	for (const child of children) output += isXmlElement(child) ? renderElement(child, childDepth) : renderComment(child, childDepth);
 	output += `${indent}</${element.name}>\n`;
 	return output;
 }
+const CODE_TAB$1 = 9;
+const CODE_LINE_FEED$1 = 10;
+const CODE_CARRIAGE_RETURN$1 = 13;
+const CODE_QUOTE$1 = 34;
+const CODE_AMPERSAND$1 = 38;
+const CODE_APOSTROPHE$1 = 39;
+const CODE_LESS_THAN$1 = 60;
+const CODE_GREATER_THAN$1 = 62;
 /**
-* Renders an element's children in document order, numbering repeated
-* element names in the error path so a failure points at one node.
-*/
-function renderChildren(children, depth, path) {
-	let output = "";
-	const seen = /* @__PURE__ */ new Map();
-	for (const child of children) if (isXcschemeElement(child)) {
-		const index = seen.get(child.name) ?? 0;
-		seen.set(child.name, index + 1);
-		output += renderElement(child, depth, `${path}.${child.name}[${index}]`);
-	} else output += `${INDENT.repeat(depth)}<!--${child.comment}-->\n`;
-	return output;
-}
+* Matches every code unit the writer must escape, validate, or reject.
+* Nearly all attribute values contain none of them, and the single
+* regex test is the cheapest full-string scan the engine offers, so a
+* miss returns the value with no further work.
+*/
+const NEEDS_WORK_PATTERN = /[\u0000-\u001F&<>"'\uD800-\uDFFF\uFFFE\uFFFF]/u;
 /**
 * Escapes an attribute value the way Xcode's writer does. XML syntax
 * characters become the five named entities, and tab, line feed, and
 * carriage return become character references so they survive
 * attribute-value normalization on the next parse.
-*/
-function escapeAttribute(value, path, attributeName) {
-	const unencodable = UNENCODABLE_PATTERN.exec(value);
-	if (unencodable != null) throw new XcschemeBuildError(`Attribute ${attributeName} contains the control character U+${unencodable[0].charCodeAt(0).toString(16).padStart(4, "0").toUpperCase()}, which XML cannot encode`, path);
+*
+* The common value with nothing to escape returns as-is after one regex
+* scan. Only values carrying an interesting code unit take the
+* classifying pass, which escapes what has an escape and rejects what
+* no XML document can carry, meaning the control characters XML cannot
+* represent, unpaired surrogate halves, and the two noncharacters at
+* the end of the basic plane.
+*/
+function escapeAttribute(value, element, attributeName) {
+	if (!NEEDS_WORK_PATTERN.test(value)) return value;
+	let needsEscaping = false;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code < 32) {
+			if (code === CODE_TAB$1 || code === CODE_LINE_FEED$1 || code === CODE_CARRIAGE_RETURN$1) {
+				needsEscaping = true;
+				continue;
+			}
+			throw new XmlBuildFailure(`Attribute ${attributeName} contains the control character U+${code.toString(16).padStart(4, "0").toUpperCase()}, which XML cannot encode`, element);
+		}
+		if (code === CODE_AMPERSAND$1 || code === CODE_LESS_THAN$1 || code === CODE_GREATER_THAN$1 || code === CODE_QUOTE$1 || code === CODE_APOSTROPHE$1) {
+			needsEscaping = true;
+			continue;
+		}
+		if (code >= 55296) {
+			if (code <= 56319) {
+				const next = value.charCodeAt(i + 1);
+				if (next >= 56320 && next <= 57343) {
+					i++;
+					continue;
+				}
+			}
+			if (code <= 57343 || code === 65534 || code === 65535) throw new XmlBuildFailure(`Attribute ${attributeName} contains a code point XML cannot carry (U+${code.toString(16).padStart(4, "0").toUpperCase()})`, element);
+		}
+	}
+	if (!needsEscaping) return value;
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;").replaceAll("	", "&#9;").replaceAll("\n", "&#10;").replaceAll("\r", "&#13;");
 }
 //#endregion
-//#region src/scheme/parse.ts
+//#region src/scheme/build.ts
 /**
-* Parser for the `.xcscheme` XML dialect.
-*
-* Scheme files are XML with a narrow shape. Elements carry attributes and
-* child elements, and there is no text content, no namespace, and no
-* DOCTYPE. The parser accepts that shape from any writer, since attribute
-* order, quoting style, and whitespace vary across tools. Character and
-* entity references in attribute values resolve to their characters, and
-* comments are preserved. Anything outside the shape fails loudly with a
-* position, in line with the pbxproj parser.
+* Serializer entry point for the `.xcscheme` dialect. The layout rules
+* live in the shared XML core, and this wrapper binds them to the scheme
+* error type.
 *
 * @module
 */
+/**
+* Serializes a scheme document to the text of a `.xcscheme` file in
+* Xcode's canonical layout.
+*
+* @throws XcschemeBuildError for element or attribute names that are not
+*   XML names and for attribute values carrying unencodable control
+*   characters, with the path of the offending node.
+*/
+function buildXcscheme(document) {
+	return buildXmlDocument(document, (message, path) => new XcschemeBuildError(message, path));
+}
+//#endregion
+//#region src/xml/parse.ts
 const CODE_TAB = 9;
 const CODE_LINE_FEED = 10;
 const CODE_CARRIAGE_RETURN = 13;
@@ -4230,7 +4621,7 @@ function isWhitespace(code) {
 	return code === CODE_SPACE || code === CODE_TAB || code === CODE_LINE_FEED || code === CODE_CARRIAGE_RETURN;
 }
 /**
-* Whether a code unit can start an XML name. The scheme vocabulary is
+* Whether a code unit can start an XML name. The dialect's vocabulary is
 * ASCII, so the accepted alphabet is letters, underscore, and colon.
 */
 function isNameStart(code) {
@@ -4251,25 +4642,41 @@ const NAMED_ENTITIES = {
 	quot: "\""
 };
 /**
-* Parses the text of a `.xcscheme` file into its node tree.
-*
-* @throws XcschemeParseError when the text is not a well-formed scheme
-*   document, with the line and column of the failure.
+* Matches the characters no XML document can carry, mirroring the
+* writer's validation so a comment the parser accepts is one the
+* serializer reproduces.
 */
-function parseXcscheme(text) {
-	return new Parser(text).parseDocument();
+const UNCARRIABLE_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uFFFE\uFFFF]/u;
+/**
+* Whether a code point is a character XML 1.0 allows in a document.
+* The excluded ranges are the control characters other than tab, line
+* feed, and carriage return, the surrogate halves, and the two
+* noncharacters at the end of the basic plane.
+*/
+function isXmlChar(codePoint) {
+	return codePoint === CODE_TAB || codePoint === CODE_LINE_FEED || codePoint === CODE_CARRIAGE_RETURN || codePoint >= 32 && codePoint <= 55295 || codePoint >= 57344 && codePoint <= 65533 || codePoint >= 65536 && codePoint <= 1114111;
+}
+/**
+* Parses the text of a document in the dialect into its node tree,
+* reporting failures through the given error factory.
+*/
+function parseXmlDocument(text, makeError) {
+	return new Parser(text, makeError).parseDocument();
 }
 /**
 * Single-pass recursive-descent parser over the source text. One instance
 * parses one document and is discarded.
 */
 var Parser = class {
-	/** The full source text of the scheme file. */
+	/** The full source text of the file. */
 	input;
+	/** Constructs the format's parse error for a failure. */
+	makeError;
 	/** Cursor into {@link input}, in UTF-16 code units. */
 	pos = 0;
-	constructor(input) {
+	constructor(input, makeError) {
 		this.input = input;
+		this.makeError = makeError;
 		if (input.charCodeAt(0) === CODE_BOM) this.pos = 1;
 	}
 	/**
@@ -4303,10 +4710,14 @@ var Parser = class {
 	/**
 	* Skips the `<?xml ... ?>` declaration when present. Its attributes are
 	* not retained, since the writer always emits the canonical UTF-8
-	* declaration.
+	* declaration. Other processing instructions fail, because the dialect
+	* has no place to keep them and dropping one silently would make the
+	* round-trip lossy.
 	*/
 	skipDeclaration() {
 		if (this.input.charCodeAt(this.pos) !== CODE_LESS_THAN || this.input.charCodeAt(this.pos + 1) !== CODE_QUESTION) return;
+		const after = this.input.charCodeAt(this.pos + 5);
+		if (this.input.slice(this.pos + 2, this.pos + 5) !== "xml" || !isWhitespace(after) && after !== CODE_QUESTION) this.fail("Unsupported processing instruction");
 		const end = this.input.indexOf("?>", this.pos + 2);
 		if (end === -1) this.fail("Unterminated XML declaration");
 		this.pos = end + 2;
@@ -4378,12 +4789,17 @@ var Parser = class {
 	}
 	/**
 	* Parses one comment with the cursor on its `<!--` opener. The text
-	* between the markers is kept verbatim.
+	* between the markers is kept verbatim. A `--` inside the text or a
+	* `-` against the closing marker fails the way XML requires, which
+	* also keeps every accepted comment rebuildable, since such text would
+	* reparse at a different terminator.
 	*/
 	parseComment() {
 		const end = this.input.indexOf("-->", this.pos + 4);
 		if (end === -1) this.fail("Unterminated comment");
 		const comment = this.input.slice(this.pos + 4, end);
+		if (comment.includes("--") || comment.endsWith("-")) this.fail("Comments cannot contain -- or end with -");
+		if (UNCARRIABLE_PATTERN.test(comment)) this.fail("Comments cannot contain characters XML cannot carry");
 		this.pos = end + 3;
 		return { comment };
 	}
@@ -4423,14 +4839,37 @@ var Parser = class {
 				value += this.input.slice(runStart, this.pos);
 				value += this.parseReference();
 				runStart = this.pos;
-			} else this.pos++;
+				continue;
+			}
+			if (code < 32 && !isWhitespace(code)) this.fail("Attribute values cannot contain a raw control character");
+			if (code >= 55296) {
+				this.validateUpperCharacter(code);
+				this.pos += code <= 56319 ? 2 : 1;
+				continue;
+			}
+			this.pos++;
+		}
+	}
+	/**
+	* Validates a code unit in the surrogate or upper basic-plane range at
+	* the cursor. A high surrogate must pair with a low one, a bare low
+	* surrogate is not a character, and the two noncharacters at the end
+	* of the plane have no XML representation.
+	*/
+	validateUpperCharacter(code) {
+		if (code <= 56319) {
+			const next = this.input.charCodeAt(this.pos + 1);
+			if (Number.isNaN(next) || next < 56320 || next > 57343) this.fail("Attribute values cannot contain an unpaired surrogate");
+			return;
 		}
+		if (code <= 57343) this.fail("Attribute values cannot contain an unpaired surrogate");
+		if (code === 65534 || code === 65535) this.fail("Attribute values cannot contain a noncharacter");
 	}
 	/**
 	* Resolves one `&...;` reference with the cursor on the ampersand. The
 	* accepted forms are the five XML named entities and decimal or hex
 	* character references, which covers everything observed in
-	* Xcode-written schemes (`&quot;`, `&amp;`, `&apos;`, `&lt;`, `&gt;`,
+	* Xcode-written files (`&quot;`, `&amp;`, `&apos;`, `&lt;`, `&gt;`,
 	* and `&#10;`-style whitespace).
 	*/
 	parseReference() {
@@ -4442,9 +4881,10 @@ var Parser = class {
 		if (body.charCodeAt(0) === CODE_HASH) {
 			const isHex = body.charCodeAt(1) === 120 || body.charCodeAt(1) === 88;
 			const digits = body.slice(isHex ? 2 : 1);
+			if (!(isHex ? /^[0-9A-Fa-f]+$/u : /^[0-9]+$/u).test(digits)) this.failAt(`Invalid character reference &${body};`, start);
 			const radix = isHex ? 16 : 10;
 			const codePoint = Number.parseInt(digits, radix);
-			if (digits.length === 0 || Number.isNaN(codePoint) || codePoint > 1114111) this.failAt(`Invalid character reference &${body};`, start);
+			if (!isXmlChar(codePoint)) this.failAt(`Character reference &${body}; is not an XML character`, start);
 			return String.fromCodePoint(codePoint);
 		}
 		const named = Object.hasOwn(NAMED_ENTITIES, body) ? NAMED_ENTITIES[body] : void 0;
@@ -4471,10 +4911,28 @@ var Parser = class {
 	* uses to point at the start of a bad reference rather than its end.
 	*/
 	failAt(message, offset) {
-		throw new XcschemeParseError(message, this.input, offset);
+		throw this.makeError(message, this.input, offset);
 	}
 };
 //#endregion
+//#region src/scheme/parse.ts
+/**
+* Parser entry point for the `.xcscheme` dialect. The grammar lives in
+* the shared XML core, and this wrapper binds it to the scheme error
+* type.
+*
+* @module
+*/
+/**
+* Parses the text of a `.xcscheme` file into its node tree.
+*
+* @throws XcschemeParseError when the text is not a well-formed scheme
+*   document, with the line and column of the failure.
+*/
+function parseXcscheme(text) {
+	return parseXmlDocument(text, (message, source, offset) => new XcschemeParseError(message, source, offset));
+}
+//#endregion
 //#region src/scheme/model.ts
 /**
 * The scheme object model and its helpers.
@@ -4495,13 +4953,7 @@ var Parser = class {
 * element.
 */
 function xcschemeElements(root, name) {
-	const found = [];
-	const visit = (element) => {
-		if (name == null || element.name === name) found.push(element);
-		for (const child of element.children) if (isXcschemeElement(child)) visit(child);
-	};
-	visit(root);
-	return found;
+	return xmlElements(root, name);
 }
 /**
 * A `BuildableReference` element with property-style attribute access.
@@ -4771,6 +5223,273 @@ function createXcscheme(options) {
 	};
 }
 //#endregion
+//#region src/scheme/types.ts
+/**
+* The node model of a scheme document. Scheme files share Xcode's XML
+* dialect with workspace data files, so the shapes here are the shared
+* XML node types under their scheme names.
+*
+* A parsed `.xcscheme` is a tree of plain objects. Elements carry ordered
+* attributes and child nodes, and comments survive as their own nodes.
+* All state lives in this tree. There is no wrapper to keep in sync, so
+* callers mutate nodes directly and serialize whatever the tree currently
+* says.
+*
+* @module
+*/
+/**
+* Whether a node is an element rather than a comment.
+*/
+function isXcschemeElement(node) {
+	return isXmlElement(node);
+}
+//#endregion
+//#region src/workspace/build.ts
+/**
+* Serializer entry point for the `contents.xcworkspacedata` dialect. The
+* layout rules live in the shared XML core, and this wrapper binds them
+* to the workspace error type.
+*
+* @module
+*/
+/**
+* Serializes a workspace document to the text of a
+* `contents.xcworkspacedata` file in Xcode's canonical layout.
+*
+* @throws XcworkspaceBuildError for element or attribute names that are
+*   not XML names and for attribute values carrying unencodable control
+*   characters, with the path of the offending node.
+*/
+function buildXcworkspace(document) {
+	return buildXmlDocument(document, (message, path) => new XcworkspaceBuildError(message, path));
+}
+//#endregion
+//#region src/workspace/parse.ts
+/**
+* Parser entry point for the `contents.xcworkspacedata` dialect. The
+* grammar lives in the shared XML core, and this wrapper binds it to the
+* workspace error type.
+*
+* @module
+*/
+/**
+* Parses the text of a `contents.xcworkspacedata` file into its node
+* tree.
+*
+* @throws XcworkspaceParseError when the text is not a well-formed
+*   workspace document, with the line and column of the failure.
+*/
+function parseXcworkspace(text) {
+	return parseXmlDocument(text, (message, source, offset) => new XcworkspaceParseError(message, source, offset));
+}
+//#endregion
+//#region src/workspace/model.ts
+/**
+* The workspace object model.
+*
+* A `.xcworkspace` directory carries a `contents.xcworkspacedata` file
+* listing the projects and folders the workspace shows, in the same XML
+* dialect scheme files use. {@link Xcworkspace} wraps the parsed
+* document with typed access to the file references, so tooling resolves
+* which projects a workspace opens instead of globbing the directory
+* tree. The node tree stays the single source of truth. Views hold only
+* a reference into it, so model calls and direct tree edits compose
+* freely.
+*
+* @module
+*/
+/**
+* Splits a location attribute into its kind and path. Xcode writes the
+* kinds `group` (relative to the enclosing group), `container` (relative
+* to the directory containing the `.xcworkspace`), `absolute`, `self`
+* (the containing `.xcodeproj` itself), and `developer` (inside the
+* developer directory).
+*/
+function parseWorkspaceLocation(location) {
+	const colon = location.indexOf(":");
+	if (colon === -1) return {
+		kind: "group",
+		path: location
+	};
+	return {
+		kind: location.slice(0, colon),
+		path: location.slice(colon + 1)
+	};
+}
+/**
+* A `FileRef` element with property-style attribute access. File
+* references are the elements workspace edits touch, since each one
+* names a project or folder the workspace shows. The view reads and
+* writes the element's attributes directly, so it never goes stale and
+* needs no separate save step.
+*/
+var WorkspaceFileRef = class {
+	/** The underlying element inside the document tree. */
+	element;
+	constructor(element) {
+		this.element = element;
+	}
+	/**
+	* The reference's location attribute, when present, for example
+	* `group:Pods/Pods.xcodeproj`.
+	*/
+	get location() {
+		return this.element.attributes["location"];
+	}
+	set location(value) {
+		this.element.attributes["location"] = value;
+	}
+};
+/**
+* A workspace document with typed access to the elements editing flows
+* touch.
+*
+* The model is a thin layer over the node tree. All state lives in the
+* document itself, and {@link build} serializes whatever the tree
+* currently says, so typed edits and direct tree edits compose freely.
+*
+* ```ts
+* const workspace = Xcworkspace.parse(xcworkspacedataText);
+* workspace.projectFilePaths(); // ["DemoApp.xcodeproj", "Pods/Pods.xcodeproj"]
+* ```
+*/
+var Xcworkspace = class Xcworkspace {
+	/** The underlying parsed document. */
+	document;
+	constructor(document) {
+		this.document = document;
+	}
+	/**
+	* Parses the text of a `contents.xcworkspacedata` file into a
+	* workspace model.
+	*
+	* @throws XcworkspaceParseError when the text is not a well-formed
+	*   workspace document, with the line and column of the failure.
+	*/
+	static parse(text) {
+		return new Xcworkspace(parseXcworkspace(text));
+	}
+	/**
+	* Creates the workspace document Xcode writes, listing the given
+	* locations as file references.
+	*/
+	static create(options) {
+		const children = (options?.locations ?? []).map((location) => ({
+			name: "FileRef",
+			attributes: { location },
+			children: []
+		}));
+		return new Xcworkspace({
+			leading: [],
+			root: {
+				name: "Workspace",
+				attributes: { version: "1.0" },
+				children
+			},
+			trailing: []
+		});
+	}
+	/**
+	* The document's `Workspace` element.
+	*/
+	get root() {
+		return this.document.root;
+	}
+	/**
+	* Serializes the workspace to the text of a `contents.xcworkspacedata`
+	* file in Xcode's canonical layout.
+	*/
+	build() {
+		return buildXcworkspace(this.document);
+	}
+	/**
+	* Collects elements of the given name anywhere in the document, in
+	* document order. Passing no name collects every element.
+	*/
+	elements(name) {
+		return xmlElements(this.document.root, name);
+	}
+	/**
+	* The views of every file reference in the document, in document
+	* order, references nested inside groups included.
+	*/
+	fileRefs() {
+		return this.elements("FileRef").map((element) => new WorkspaceFileRef(element));
+	}
+	/**
+	* Appends a file reference to the workspace's top level and returns
+	* its view.
+	*/
+	addFileRef(location) {
+		const element = {
+			name: "FileRef",
+			attributes: { location },
+			children: []
+		};
+		this.root.children.push(element);
+		return new WorkspaceFileRef(element);
+	}
+	/**
+	* Removes a file reference from whichever element holds it. Returns
+	* whether the reference was found and removed.
+	*/
+	removeFileRef(reference) {
+		for (const parent of this.elements()) {
+			const index = parent.children.indexOf(reference.element);
+			if (index !== -1) {
+				parent.children.splice(index, 1);
+				return true;
+			}
+		}
+		return false;
+	}
+	/**
+	* The paths of every `.xcodeproj` the workspace references, in
+	* document order, resolved relative to the directory containing the
+	* `.xcworkspace`. Group locations compose through their enclosing
+	* groups, container locations anchor at the workspace's directory, and
+	* absolute locations pass through unchanged.
+	*
+	* The resolution is textual. The library never touches the
+	* filesystem, so locations that only the running Xcode can resolve
+	* (`self` and `developer`) are not listed.
+	*/
+	projectFilePaths() {
+		const paths = [];
+		const visit = (element, base) => {
+			for (const child of element.children) {
+				if (!isXmlElement(child)) continue;
+				const resolved = resolveLocationPath(parseWorkspaceLocation(child.attributes["location"] ?? ""), base);
+				if (child.name === "Group") visit(child, resolved ?? base);
+				else if (child.name === "FileRef" && resolved != null && resolved.endsWith(".xcodeproj")) paths.push(resolved);
+			}
+		};
+		visit(this.document.root, "");
+		return paths;
+	}
+};
+/**
+* Resolves a location against the enclosing group's base path, or
+* `undefined` for the kinds only a running Xcode can resolve. The empty
+* string names the workspace's own directory.
+*/
+function resolveLocationPath(location, base) {
+	switch (location.kind) {
+		case "group": return joinPaths(base, location.path);
+		case "container": return location.path;
+		case "absolute": return location.path;
+		default: return;
+	}
+}
+/**
+* Joins two textual path segments, keeping the result free of empty
+* segments when either side is empty.
+*/
+function joinPaths(base, path) {
+	if (base === "" || path === "") return base === "" ? path : base;
+	return `${base}/${path}`;
+}
+//#endregion
 //#region src/xcconfig/build.ts
 /**
 * Serializes a document back to `.xcconfig` text.
@@ -5095,4 +5814,4 @@ var Xcconfig = class Xcconfig {
 	}
 };
 //#endregion
-export { AggregateTarget, AppleScriptBuildPhase, BuildConfiguration, BuildFile, BuildFileExceptionSet, BuildPhase, BuildPhaseMembershipExceptionSet, BuildRule, BuildStyle, BuildableReference, ConfigurationList, ContainerItemProxy, CopyFilesBuildPhase, CopyFilesDestination, ExceptionSet, FileReference, FrameworksBuildPhase, Group, HeadersBuildPhase, Isa, LegacyTarget, LocalSwiftPackageReference, NativeTarget, PbxprojBuildError, PbxprojParseError, ProductType, ReferenceProxy, RemoteSwiftPackageReference, ResourcesBuildPhase, RezBuildPhase, RootProject, ShellScriptBuildPhase, SourcesBuildPhase, SwiftPackageProductDependency, SwiftPackageReference, SyncRootGroup, Target, TargetDependency, VariantGroup, VersionGroup, Xcconfig, XcconfigParseError, XcodeModelError, XcodeObject, XcodeProject, Xcscheme, XcschemeBuildError, XcschemeParseError, buildPbxproj, buildXcconfig, buildXcscheme, createXcscheme, generateObjectId, isXcschemeElement, parseApplePlatform, parsePbxproj, parseXcconfig, parseXcscheme, xcschemeElements };
+export { AggregateTarget, AppleScriptBuildPhase, BuildConfiguration, BuildFile, BuildFileExceptionSet, BuildPhase, BuildPhaseMembershipExceptionSet, BuildRule, BuildStyle, BuildableReference, ConfigurationList, ContainerItemProxy, CopyFilesBuildPhase, CopyFilesDestination, ExceptionSet, FileReference, FrameworksBuildPhase, Group, HeadersBuildPhase, Isa, LegacyTarget, LocalSwiftPackageReference, NativeTarget, PbxprojBuildError, PbxprojParseError, ProductType, ReferenceProxy, RemoteSwiftPackageReference, ResourcesBuildPhase, RezBuildPhase, RootProject, ShellScriptBuildPhase, SourcesBuildPhase, SwiftPackageProductDependency, SwiftPackageReference, SyncRootGroup, Target, TargetDependency, VariantGroup, VersionGroup, WorkspaceFileRef, Xcconfig, XcconfigParseError, XcodeModelError, XcodeObject, XcodeProject, Xcscheme, XcschemeBuildError, XcschemeParseError, Xcworkspace, XcworkspaceBuildError, XcworkspaceParseError, buildPbxproj, buildXcconfig, buildXcscheme, buildXcworkspace, createXcscheme, expandBuildSettingReferences, generateObjectId, isXcschemeElement, isXmlElement, parseApplePlatform, parsePbxproj, parseWorkspaceLocation, parseXcconfig, parseXcscheme, parseXcworkspace, xcschemeElements, xmlElements };