rork-xcode 0.2.0 → 0.4.0

package/dist/index.js

@@ -259,6 +259,51 @@ var PbxprojParseError = class extends Error {
 	}
 };
 /**
+* Thrown when the source text is not a well-formed scheme document (the
+* XML dialect of `.xcscheme` 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 XcschemeParseError = 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 = "XcschemeParseError";
+		this.position = position;
+	}
+};
+/**
+* Thrown when a scheme 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 XcschemeBuildError = class extends Error {
+	/** Path to the offending element from the root, e.g. `Scheme.BuildAction[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 = "XcschemeBuildError";
+		this.path = path;
+	}
+};
+/**
 * Thrown by the object model when an operation cannot proceed: the
 * document lacks the structure the operation needs (no objects dictionary,
 * no root project object), a view's object was removed from the document,
@@ -961,9 +1006,9 @@ function stringItems(value) {
 *
 * Views are lightweight, identity-mapped facades over entries of the
 * document's `objects` dictionary. All state lives in the parsed document
-* itself; a view holds only its id and a reference back to the project, so
-* document text produced from the model reflects every mutation with no
-* separate serialization step.
+* itself, and a view holds only its id and a reference back to the
+* project, so document text produced from the model reflects every
+* mutation with no separate serialization step.
 *
 * @module
 */
@@ -985,7 +1030,7 @@ var XcodeObject = class {
 	/** The object's 24-character identifier (its key in `objects`). */
 	id;
 	/**
-	* Views are created by the project's identity map; use
+	* Views are created by the project's identity map. Use
 	* {@link XcodeProject.get} or a typed query instead of constructing
 	* views directly.
 	*/
@@ -994,9 +1039,28 @@ var XcodeObject = class {
 		this.id = id;
 	}
 	/**
-	* The object's raw dictionary inside the document. Mutations through the
-	* model write here, and direct writes are equally valid; the model adds
-	* no caching over these properties.
+	* Whether a value is a view of this class, narrowing it when so. Views
+	* come typed out of the factory, and this is the readable way to
+	* discriminate them when iterating mixed objects.
+	*
+	* ```ts
+	* for (const [, object] of project.objects()) {
+	*   if (NativeTarget.is(object)) {
+	*     console.log(object.name);
+	*   }
+	* }
+	* ```
+	*
+	* Subclass views match their parent class too, the way `instanceof`
+	* does, so a `VersionGroup` is a `Group`.
+	*/
+	static is(value) {
+		return value instanceof this;
+	}
+	/**
+	* The object's raw dictionary inside the document. Mutations through
+	* the model write here, direct writes are equally valid, and the model
+	* adds no caching over these properties.
 	*
 	* The typed shape is asserted, not checked. It describes what a
 	* well-formed object of this kind carries (see `properties.ts`).
@@ -1297,6 +1361,59 @@ var VersionGroup = class extends Group {
 	}
 };
 /**
+* An `XCBuildConfiguration` holds one named settings dictionary of a
+* target or of the project, for example Debug or Release.
+*/
+var BuildConfiguration = class extends XcodeObject {
+	/**
+	* The configuration's name, when present.
+	*/
+	get name() {
+		return this.getString("name");
+	}
+	/**
+	* The configuration's settings dictionary, typed with the keys
+	* programmatic edits touch most, or `undefined` when the configuration
+	* carries none. The dictionary is live. Writes through it land in the
+	* document.
+	*/
+	get buildSettings() {
+		return asDictionary(this.properties["buildSettings"]);
+	}
+};
+/**
+* A `PBXFileReference` names one file on disk, from source files to the
+* built products themselves.
+*/
+var FileReference = class extends XcodeObject {
+	/**
+	* The reference's path, relative to its `sourceTree`, when present.
+	*/
+	get path() {
+		return this.getString("path");
+	}
+	/**
+	* The reference's display name, when it carries one distinct from the
+	* path.
+	*/
+	get name() {
+		return this.getString("name");
+	}
+};
+/**
+* A `PBXContainerItemProxy` is the indirection Xcode places between a
+* target dependency and the target it points at.
+*/
+var ContainerItemProxy = class extends XcodeObject {
+	/**
+	* The display name of the object the proxy points at, when present.
+	* For target dependencies this is the target's name.
+	*/
+	get remoteInfo() {
+		return this.getString("remoteInfo");
+	}
+};
+/**
 * A `PBXReferenceProxy` stands in for a product built by a target of
 * another project referenced from this one.
 */
@@ -1595,11 +1712,11 @@ const IS_LITERAL_CHAR = (() => {
 	for (const ch of "_$/:.-") table[ch.charCodeAt(0)] = 1;
 	return table;
 })();
-const CODE_TAB = 9;
-const CODE_LINE_FEED = 10;
-const CODE_CARRIAGE_RETURN = 13;
-const CODE_SPACE = 32;
-const CODE_QUOTE = 34;
+const CODE_TAB$1 = 9;
+const CODE_LINE_FEED$1 = 10;
+const CODE_CARRIAGE_RETURN$1 = 13;
+const CODE_SPACE$1 = 32;
+const CODE_QUOTE$1 = 34;
 const CODE_SINGLE_QUOTE = 39;
 const CODE_OPEN_PAREN = 40;
 const CODE_CLOSE_PAREN = 41;
@@ -1607,13 +1724,13 @@ const CODE_ASTERISK = 42;
 const CODE_COMMA = 44;
 const CODE_MINUS = 45;
 const CODE_DOT = 46;
-const CODE_SLASH = 47;
+const CODE_SLASH$1 = 47;
 const CODE_ZERO = 48;
 const CODE_NINE = 57;
 const CODE_SEMICOLON = 59;
-const CODE_LESS_THAN = 60;
-const CODE_EQUALS = 61;
-const CODE_GREATER_THAN = 62;
+const CODE_LESS_THAN$1 = 60;
+const CODE_EQUALS$1 = 61;
+const CODE_GREATER_THAN$1 = 62;
 const CODE_BACKSLASH = 92;
 const CODE_OPEN_BRACE = 123;
 const CODE_CLOSE_BRACE = 125;
@@ -1625,10 +1742,10 @@ const CODE_CLOSE_BRACE = 125;
 */
 const IS_WHITESPACE = (() => {
 	const table = /* @__PURE__ */ new Uint8Array(256);
-	table[CODE_SPACE] = 1;
-	table[CODE_TAB] = 1;
-	table[CODE_CARRIAGE_RETURN] = 1;
-	table[CODE_LINE_FEED] = 1;
+	table[CODE_SPACE$1] = 1;
+	table[CODE_TAB$1] = 1;
+	table[CODE_CARRIAGE_RETURN$1] = 1;
+	table[CODE_LINE_FEED$1] = 1;
 	return table;
 })();
 /**
@@ -1644,7 +1761,7 @@ function isDigit(code) {
 * through the `read*` and `parse*` methods; there is no separate tokenizer
 * stage and no token objects.
 */
-var Parser = class {
+var Parser$1 = class {
 	/** Source text of the document being parsed. */
 	input;
 	/** Cursor position as a UTF-16 code unit offset into {@link input}. */
@@ -1691,7 +1808,7 @@ var Parser = class {
 		const length = input.length;
 		let pos = this.pos;
 		while (pos < length && IS_WHITESPACE[input.charCodeAt(pos)] === 1) pos++;
-		if (pos < length && input.charCodeAt(pos) === CODE_SLASH) pos = this.skipCommentedTrivia(pos);
+		if (pos < length && input.charCodeAt(pos) === CODE_SLASH$1) pos = this.skipCommentedTrivia(pos);
 		this.pos = pos;
 	}
 	/**
@@ -1711,7 +1828,7 @@ var Parser = class {
 		const length = input.length;
 		for (;;) {
 			const next = input.charCodeAt(pos + 1);
-			if (next === CODE_SLASH) {
+			if (next === CODE_SLASH$1) {
 				const lineEnd = input.indexOf("\n", pos + 2);
 				pos = lineEnd === -1 ? length : lineEnd;
 			} else if (next === CODE_ASTERISK) {
@@ -1723,7 +1840,7 @@ var Parser = class {
 				pos = commentEnd + 2;
 			} else return pos;
 			while (pos < length && IS_WHITESPACE[input.charCodeAt(pos)] === 1) pos++;
-			if (pos >= length || input.charCodeAt(pos) !== CODE_SLASH) return pos;
+			if (pos >= length || input.charCodeAt(pos) !== CODE_SLASH$1) return pos;
 		}
 	}
 	/**
@@ -1806,7 +1923,7 @@ var Parser = class {
 		const input = this.input;
 		const length = input.length;
 		const start = ++this.pos;
-		while (this.pos < length && input.charCodeAt(this.pos) !== CODE_GREATER_THAN) this.pos++;
+		while (this.pos < length && input.charCodeAt(this.pos) !== CODE_GREATER_THAN$1) this.pos++;
 		if (this.pos >= length) this.fail("Unterminated data run", start - 1);
 		let hex = "";
 		for (let i = start; i < this.pos; i++) {
@@ -1849,10 +1966,10 @@ var Parser = class {
 				return result;
 			}
 			let key;
-			if (code === CODE_QUOTE || code === CODE_SINGLE_QUOTE) key = this.readQuotedString();
+			if (code === CODE_QUOTE$1 || 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, "=");
+			this.expect(CODE_EQUALS$1, "=");
 			const value = this.parseValue();
 			this.expect(CODE_SEMICOLON, ";");
 			if (key === "__proto__") Object.defineProperty(result, key, {
@@ -1905,9 +2022,9 @@ var Parser = 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 || code === CODE_SINGLE_QUOTE) return this.readQuotedString();
+		if (code === CODE_QUOTE$1 || code === CODE_SINGLE_QUOTE) return this.readQuotedString();
 		if (IS_LITERAL_CHAR[code] === 1) return interpretLiteral(this.readLiteral());
-		if (code === CODE_LESS_THAN) return this.readData();
+		if (code === CODE_LESS_THAN$1) return this.readData();
 		this.fail(`Expected a value but found '${this.input[this.pos]}'`);
 	}
 };
@@ -1961,7 +2078,7 @@ function interpretLiteral(literal) {
 *   carries the line and column of the failure.
 */
 function parsePbxproj(text) {
-	return new Parser(text).parseDocument();
+	return new Parser$1(text).parseDocument();
 }
 //#endregion
 //#region src/md5.ts
@@ -3325,6 +3442,9 @@ var XcodeProject = class XcodeProject {
 			case Isa.versionGroup: return new VersionGroup(this, id);
 			case Isa.fileSystemSynchronizedRootGroup: return new SyncRootGroup(this, id);
 			case Isa.buildRule: return new BuildRule(this, id);
+			case Isa.buildConfiguration: return new BuildConfiguration(this, id);
+			case Isa.fileReference: return new FileReference(this, id);
+			case Isa.containerItemProxy: return new ContainerItemProxy(this, id);
 			case Isa.referenceProxy: return new ReferenceProxy(this, id);
 			default: return isa.endsWith("BuildPhase") ? new BuildPhase(this, id) : new XcodeObject(this, id);
 		}
@@ -3397,4 +3517,648 @@ function stripReferences(properties, id) {
 	}
 }
 //#endregion
-export { AggregateTarget, BuildPhase, BuildRule, CopyFilesDestination, Group, Isa, LegacyTarget, NativeTarget, PbxprojBuildError, PbxprojParseError, ProductType, ReferenceProxy, RootProject, SyncRootGroup, Target, VersionGroup, XcodeModelError, XcodeObject, XcodeProject, buildPbxproj, generateObjectId, parsePbxproj };
+//#region src/scheme/types.ts
+/**
+* Whether a node is an element rather than a comment.
+*/
+function isXcschemeElement(node) {
+	return "name" in node;
+}
+//#endregion
+//#region src/scheme/build.ts
+/**
+* Serializer for the `.xcscheme` XML dialect.
+*
+* 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
+* back therefore yields the identical file, and any other input reaches
+* that canonical form in one build.
+*
+* @module
+*/
+/** The declaration line Xcode writes at the top of every scheme file. */
+const XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+/** One indentation step of Xcode's scheme writer. */
+const INDENT = "   ";
+/**
+* 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.
+*/
+const UNENCODABLE_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/u;
+/**
+* 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.
+*/
+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;
+}
+/**
+* Renders one element with Xcode's layout. Attributes go each on their
+* own line indented one step past the tag, the `>` glues to the last
+* 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);
+	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;
+		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);
+			const terminator = i === names.length - 1 ? ">" : "";
+			output += `${attributeIndent}${name} = "${value}"${terminator}\n`;
+		}
+	}
+	output += renderChildren(element.children, depth + 1, path);
+	output += `${indent}</${element.name}>\n`;
+	return output;
+}
+/**
+* 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;
+}
+/**
+* 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);
+	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
+/**
+* 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.
+*
+* @module
+*/
+const CODE_TAB = 9;
+const CODE_LINE_FEED = 10;
+const CODE_CARRIAGE_RETURN = 13;
+const CODE_SPACE = 32;
+const CODE_BANG = 33;
+const CODE_QUOTE = 34;
+const CODE_AMPERSAND = 38;
+const CODE_APOSTROPHE = 39;
+const CODE_HYPHEN = 45;
+const CODE_SLASH = 47;
+const CODE_LESS_THAN = 60;
+const CODE_EQUALS = 61;
+const CODE_GREATER_THAN = 62;
+const CODE_QUESTION = 63;
+const CODE_HASH = 35;
+const CODE_BOM = 65279;
+/**
+* Whether a code unit is XML whitespace (space, tab, line feed, or
+* carriage return).
+*/
+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
+* ASCII, so the accepted alphabet is letters, underscore, and colon.
+*/
+function isNameStart(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code === 58;
+}
+/**
+* Whether a code unit can continue an XML name.
+*/
+function isNameChar(code) {
+	return isNameStart(code) || code >= 48 && code <= 57 || code === CODE_HYPHEN || code === 46;
+}
+/** The named character entities XML 1.0 predefines. */
+const NAMED_ENTITIES = {
+	amp: "&",
+	apos: "'",
+	gt: ">",
+	lt: "<",
+	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.
+*/
+function parseXcscheme(text) {
+	return new Parser(text).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. */
+	input;
+	/** Cursor into {@link input}, in UTF-16 code units. */
+	pos = 0;
+	constructor(input) {
+		this.input = input;
+		if (input.charCodeAt(0) === CODE_BOM) this.pos = 1;
+	}
+	/**
+	* Parses the whole document. The XML declaration is skipped, comments
+	* around the root element are collected, and anything left after the
+	* root fails.
+	*/
+	parseDocument() {
+		this.skipWhitespace();
+		this.skipDeclaration();
+		const leading = [];
+		const trailing = [];
+		this.skipWhitespace();
+		while (this.peekIsCommentStart()) {
+			leading.push(this.parseComment());
+			this.skipWhitespace();
+		}
+		const root = this.parseElement();
+		this.skipWhitespace();
+		while (this.peekIsCommentStart()) {
+			trailing.push(this.parseComment());
+			this.skipWhitespace();
+		}
+		if (this.pos < this.input.length) this.fail("Expected end of document after the root element");
+		return {
+			leading,
+			root,
+			trailing
+		};
+	}
+	/**
+	* Skips the `<?xml ... ?>` declaration when present. Its attributes are
+	* not retained, since the writer always emits the canonical UTF-8
+	* declaration.
+	*/
+	skipDeclaration() {
+		if (this.input.charCodeAt(this.pos) !== CODE_LESS_THAN || this.input.charCodeAt(this.pos + 1) !== CODE_QUESTION) return;
+		const end = this.input.indexOf("?>", this.pos + 2);
+		if (end === -1) this.fail("Unterminated XML declaration");
+		this.pos = end + 2;
+	}
+	/**
+	* Parses one element with the cursor on its opening `<`, including its
+	* attributes and children, through to the matching close tag. Xcode
+	* never writes self-closing tags, but other generators do, so both
+	* forms are accepted.
+	*/
+	parseElement() {
+		if (this.input.charCodeAt(this.pos) !== CODE_LESS_THAN) this.fail("Expected an element");
+		this.pos++;
+		const name = this.parseName("element name");
+		const attributes = Object.create(null);
+		for (;;) {
+			const hadWhitespace = this.skipWhitespace();
+			const code = this.input.charCodeAt(this.pos);
+			if (code === CODE_GREATER_THAN) {
+				this.pos++;
+				break;
+			}
+			if (code === CODE_SLASH && this.input.charCodeAt(this.pos + 1) === CODE_GREATER_THAN) {
+				this.pos += 2;
+				return {
+					name,
+					attributes,
+					children: []
+				};
+			}
+			if (Number.isNaN(code)) this.fail(`Unterminated <${name}> tag`);
+			if (!hadWhitespace) this.fail("Expected whitespace before an attribute");
+			const attributeName = this.parseName("attribute name");
+			this.skipWhitespace();
+			if (this.input.charCodeAt(this.pos) !== CODE_EQUALS) this.fail(`Expected = after attribute ${attributeName}`);
+			this.pos++;
+			this.skipWhitespace();
+			if (attributeName in attributes) this.fail(`Duplicate attribute ${attributeName} on <${name}>`);
+			attributes[attributeName] = this.parseAttributeValue();
+		}
+		const children = [];
+		for (;;) {
+			this.skipWhitespace();
+			const code = this.input.charCodeAt(this.pos);
+			if (Number.isNaN(code)) this.fail(`Missing </${name}> close tag`);
+			if (code !== CODE_LESS_THAN) this.fail("Unexpected text content inside an element");
+			if (this.input.charCodeAt(this.pos + 1) === CODE_SLASH) {
+				this.pos += 2;
+				const closeName = this.parseName("close tag name");
+				if (closeName !== name) this.fail(`Expected </${name}> but found </${closeName}>`);
+				this.skipWhitespace();
+				if (this.input.charCodeAt(this.pos) !== CODE_GREATER_THAN) this.fail(`Malformed </${closeName}> close tag`);
+				this.pos++;
+				return {
+					name,
+					attributes,
+					children
+				};
+			}
+			if (this.peekIsCommentStart()) children.push(this.parseComment());
+			else children.push(this.parseElement());
+		}
+	}
+	/**
+	* Whether the cursor sits on a `<!--` comment opener.
+	*/
+	peekIsCommentStart() {
+		return this.input.charCodeAt(this.pos) === CODE_LESS_THAN && this.input.charCodeAt(this.pos + 1) === CODE_BANG && this.input.charCodeAt(this.pos + 2) === CODE_HYPHEN && this.input.charCodeAt(this.pos + 3) === CODE_HYPHEN;
+	}
+	/**
+	* Parses one comment with the cursor on its `<!--` opener. The text
+	* between the markers is kept verbatim.
+	*/
+	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);
+		this.pos = end + 3;
+		return { comment };
+	}
+	/**
+	* Parses an XML name at the cursor. The `what` label names the
+	* expectation in the error when no name starts here.
+	*/
+	parseName(what) {
+		const start = this.pos;
+		if (!isNameStart(this.input.charCodeAt(this.pos))) this.fail(`Expected ${what}`);
+		this.pos++;
+		while (isNameChar(this.input.charCodeAt(this.pos))) this.pos++;
+		return this.input.slice(start, this.pos);
+	}
+	/**
+	* Parses a quoted attribute value with the cursor on the opening quote,
+	* resolving character and entity references along the way. Both quote
+	* styles are accepted, and a raw `<` inside the value fails as XML
+	* requires.
+	*/
+	parseAttributeValue() {
+		const quote = this.input.charCodeAt(this.pos);
+		if (quote !== CODE_QUOTE && quote !== CODE_APOSTROPHE) this.fail("Expected a quoted attribute value");
+		this.pos++;
+		let value = "";
+		let runStart = this.pos;
+		for (;;) {
+			const code = this.input.charCodeAt(this.pos);
+			if (Number.isNaN(code)) this.fail("Unterminated attribute value");
+			if (code === quote) {
+				value += this.input.slice(runStart, this.pos);
+				this.pos++;
+				return value;
+			}
+			if (code === CODE_LESS_THAN) this.fail("Attribute values cannot contain a raw <");
+			if (code === CODE_AMPERSAND) {
+				value += this.input.slice(runStart, this.pos);
+				value += this.parseReference();
+				runStart = this.pos;
+			} else this.pos++;
+		}
+	}
+	/**
+	* 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;`,
+	* and `&#10;`-style whitespace).
+	*/
+	parseReference() {
+		const start = this.pos;
+		const end = this.input.indexOf(";", start + 1);
+		if (end === -1 || end - start > 12) this.fail("Unterminated character reference");
+		const body = this.input.slice(start + 1, end);
+		this.pos = end + 1;
+		if (body.charCodeAt(0) === CODE_HASH) {
+			const isHex = body.charCodeAt(1) === 120 || body.charCodeAt(1) === 88;
+			const digits = body.slice(isHex ? 2 : 1);
+			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);
+			return String.fromCodePoint(codePoint);
+		}
+		const named = Object.hasOwn(NAMED_ENTITIES, body) ? NAMED_ENTITIES[body] : void 0;
+		if (named == null) this.failAt(`Unknown entity &${body};`, start);
+		return named;
+	}
+	/**
+	* Skips whitespace and reports whether any was consumed, which attribute
+	* parsing uses to require separation between attributes.
+	*/
+	skipWhitespace() {
+		const start = this.pos;
+		while (isWhitespace(this.input.charCodeAt(this.pos))) this.pos++;
+		return this.pos > start;
+	}
+	/**
+	* Throws a parse error at the cursor.
+	*/
+	fail(message) {
+		this.failAt(message, this.pos);
+	}
+	/**
+	* Throws a parse error at an explicit offset, which reference parsing
+	* uses to point at the start of a bad reference rather than its end.
+	*/
+	failAt(message, offset) {
+		throw new XcschemeParseError(message, this.input, offset);
+	}
+};
+//#endregion
+//#region src/scheme/model.ts
+/**
+* The scheme object model and its helpers.
+*
+* {@link Xcscheme} wraps a parsed document with the typed access editing
+* flows want, {@link BuildableReference} gives buildable references
+* property-style attribute access, {@link xcschemeElements} is the
+* recursive query underneath it all, and {@link createXcscheme} produces
+* the scheme Xcode's own "New Scheme" action writes. 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
+*/
+/**
+* Collects elements of the given name anywhere in the tree, in document
+* order, the subtree root included. Passing no name collects every
+* 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;
+}
+/**
+* A `BuildableReference` element with property-style attribute access.
+*
+* Buildable references are the elements editing flows touch most, since
+* every action points at its target through one. The view reads and
+* writes the element's attributes directly, so it never goes stale and
+* needs no separate save step.
+*/
+var BuildableReference = class {
+	/** The underlying element inside the document tree. */
+	element;
+	constructor(element) {
+		this.element = element;
+	}
+	/**
+	* The referenced target's object id in the project document, when
+	* present. Xcode repairs a missing or stale identifier on first open.
+	*/
+	get blueprintIdentifier() {
+		return this.element.attributes["BlueprintIdentifier"];
+	}
+	set blueprintIdentifier(value) {
+		this.element.attributes["BlueprintIdentifier"] = value;
+	}
+	/**
+	* The referenced target's name, when present.
+	*/
+	get blueprintName() {
+		return this.element.attributes["BlueprintName"];
+	}
+	set blueprintName(value) {
+		this.element.attributes["BlueprintName"] = value;
+	}
+	/**
+	* The built product's file name, for example `DemoApp.app`, when
+	* present.
+	*/
+	get buildableName() {
+		return this.element.attributes["BuildableName"];
+	}
+	set buildableName(value) {
+		this.element.attributes["BuildableName"] = value;
+	}
+	/**
+	* The container the target lives in, for example
+	* `container:DemoApp.xcodeproj`, when present.
+	*/
+	get referencedContainer() {
+		return this.element.attributes["ReferencedContainer"];
+	}
+	set referencedContainer(value) {
+		this.element.attributes["ReferencedContainer"] = value;
+	}
+};
+/**
+* A scheme 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 scheme = Xcscheme.parse(xcschemeText);
+* for (const reference of scheme.buildableReferences()) {
+*   reference.blueprintName = "RenamedApp";
+*   reference.buildableName = "RenamedApp.app";
+* }
+* const text = scheme.build();
+* ```
+*/
+var Xcscheme = class Xcscheme {
+	/** The underlying parsed document. */
+	document;
+	constructor(document) {
+		this.document = document;
+	}
+	/**
+	* Parses the text of a `.xcscheme` file into a scheme model.
+	*
+	* @throws XcschemeParseError when the text is not a well-formed scheme
+	*   document, with the line and column of the failure.
+	*/
+	static parse(text) {
+		return new Xcscheme(parseXcscheme(text));
+	}
+	/**
+	* Creates the scheme Xcode writes for an application target. See
+	* {@link createXcscheme} for the shape it produces.
+	*/
+	static create(options) {
+		return new Xcscheme(createXcscheme(options));
+	}
+	/**
+	* The document's `Scheme` element.
+	*/
+	get root() {
+		return this.document.root;
+	}
+	/**
+	* Serializes the scheme to the text of a `.xcscheme` file in Xcode's
+	* canonical layout.
+	*/
+	build() {
+		return buildXcscheme(this.document);
+	}
+	/**
+	* Collects elements of the given name anywhere in the document, in
+	* document order. Passing no name collects every element.
+	*/
+	elements(name) {
+		return xcschemeElements(this.document.root, name);
+	}
+	/**
+	* The views of every buildable reference in the document, in document
+	* order. Build entries, testables, macro expansions, runnables, and
+	* action environment buildables all point at their target through one
+	* of these, so rename flows iterate this list.
+	*/
+	buildableReferences() {
+		return this.elements("BuildableReference").map((element) => new BuildableReference(element));
+	}
+};
+/**
+* Creates the scheme Xcode writes for an application target. The
+* document carries build, launch, profile, analyze, and archive actions
+* wired to the app product, with Xcode's default configuration choices
+* of Debug for development actions and Release for profiling and
+* archiving.
+*/
+function createXcscheme(options) {
+	const xcodeprojName = options.xcodeprojName ?? `${options.appName}.xcodeproj`;
+	/**
+	* Buildable references appear once per action. Each site gets its own
+	* element so a mutation through one action cannot alias into another.
+	*/
+	const buildableReference = () => ({
+		name: "BuildableReference",
+		attributes: {
+			BuildableIdentifier: "primary",
+			BlueprintIdentifier: options.blueprintIdentifier ?? "",
+			BuildableName: `${options.appName}.app`,
+			BlueprintName: options.appName,
+			ReferencedContainer: `container:${xcodeprojName}`
+		},
+		children: []
+	});
+	return {
+		leading: [],
+		root: {
+			name: "Scheme",
+			attributes: { version: "1.7" },
+			children: [
+				{
+					name: "BuildAction",
+					attributes: {
+						parallelizeBuildables: "YES",
+						buildImplicitDependencies: "YES"
+					},
+					children: [{
+						name: "BuildActionEntries",
+						attributes: {},
+						children: [{
+							name: "BuildActionEntry",
+							attributes: {
+								buildForTesting: "YES",
+								buildForRunning: "YES",
+								buildForProfiling: "YES",
+								buildForArchiving: "YES",
+								buildForAnalyzing: "YES"
+							},
+							children: [buildableReference()]
+						}]
+					}]
+				},
+				{
+					name: "LaunchAction",
+					attributes: {
+						buildConfiguration: "Debug",
+						selectedDebuggerIdentifier: "Xcode.DebuggerFoundation.Debugger.LLDB",
+						selectedLauncherIdentifier: "Xcode.DebuggerFoundation.Launcher.LLDB",
+						launchStyle: "0",
+						useCustomWorkingDirectory: "NO",
+						ignoresPersistentStateOnLaunch: "NO",
+						debugDocumentVersioning: "YES",
+						debugServiceExtension: "internal",
+						allowLocationSimulation: "YES"
+					},
+					children: [{
+						name: "BuildableProductRunnable",
+						attributes: { runnableDebuggingMode: "0" },
+						children: [buildableReference()]
+					}]
+				},
+				{
+					name: "ProfileAction",
+					attributes: {
+						buildConfiguration: "Release",
+						shouldUseLaunchSchemeArgsEnv: "YES",
+						savedToolIdentifier: "",
+						useCustomWorkingDirectory: "NO",
+						debugDocumentVersioning: "YES"
+					},
+					children: [{
+						name: "BuildableProductRunnable",
+						attributes: { runnableDebuggingMode: "0" },
+						children: [buildableReference()]
+					}]
+				},
+				{
+					name: "AnalyzeAction",
+					attributes: { buildConfiguration: "Debug" },
+					children: []
+				},
+				{
+					name: "ArchiveAction",
+					attributes: {
+						buildConfiguration: "Release",
+						revealArchiveInOrganizer: "YES"
+					},
+					children: []
+				}
+			]
+		},
+		trailing: []
+	};
+}
+//#endregion
+export { AggregateTarget, BuildConfiguration, BuildPhase, BuildRule, BuildableReference, ContainerItemProxy, CopyFilesDestination, FileReference, Group, Isa, LegacyTarget, NativeTarget, PbxprojBuildError, PbxprojParseError, ProductType, ReferenceProxy, RootProject, SyncRootGroup, Target, VersionGroup, XcodeModelError, XcodeObject, XcodeProject, Xcscheme, XcschemeBuildError, XcschemeParseError, buildPbxproj, buildXcscheme, createXcscheme, generateObjectId, isXcschemeElement, parsePbxproj, parseXcscheme, xcschemeElements };