rork-xcode 0.1.0

package/dist/index.js

@@ -0,0 +1,1376 @@
+//#region src/comments.ts
+/**
+* Narrows a value to a dictionary.
+*
+* Arrays and `Uint8Array` data are objects at runtime too, so a bare
+* `typeof` check is not enough.
+*/
+function isDictionary(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Uint8Array);
+}
+/**
+* Returns the value when it is a string, and `undefined` otherwise.
+*
+* Field access on parsed documents goes through this because any field of
+* an untrusted document can hold any value type.
+*/
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Records `id → info` for every string in `ids` not yet present, keeping
+* the first occurrence in document order.
+*/
+function indexFirst(index, ids, info) {
+	if (!Array.isArray(ids)) return;
+	for (const id of ids) if (typeof id === "string" && !index.has(id)) index.set(id, info);
+}
+/**
+* Derives the display name of a build phase from its isa:
+* `PBXSourcesBuildPhase` becomes `Sources`. Returns `undefined` for isa
+* names outside the `PBX…BuildPhase` pattern.
+*/
+function defaultBuildPhaseName(isa) {
+	if (isa.startsWith("PBX") && isa.endsWith("BuildPhase")) return isa.slice(3, isa.length - 10);
+}
+/**
+* Extracts the repository name for a Swift package reference comment.
+*
+* GitHub URLs reduce to their last path segment without the `.git` suffix;
+* anything else is used verbatim, which matches how Xcode renders unknown
+* hosts.
+*/
+function repoNameFromUrl(repoUrl) {
+	for (const prefix of ["https://github.com/", "http://github.com/"]) if (repoUrl.startsWith(prefix)) {
+		const last = repoUrl.slice(prefix.length).split("/").at(-1) ?? "";
+		const name = last.endsWith(".git") ? last.slice(0, -4) : last;
+		if (name.length > 0) return name;
+	}
+	return repoUrl;
+}
+/**
+* Builds the uuid-to-comment map for a parsed project document.
+*
+* Objects that should render without a comment (unnamed groups) map to the
+* empty string; uuids absent from the map are not references at all.
+* Derivation is linear over the object graph: reverse indexes are built in
+* one pass, and every object's comment is computed once and cached.
+*/
+function createReferenceComments(root) {
+	const cache = /* @__PURE__ */ new Map();
+	const inProgress = /* @__PURE__ */ new Set();
+	const objectsValue = isDictionary(root) ? root["objects"] : void 0;
+	if (!isDictionary(objectsValue)) return cache;
+	const objects = objectsValue;
+	const fileToPhase = /* @__PURE__ */ new Map();
+	const configurationListOwners = /* @__PURE__ */ new Map();
+	const proxyRemoteInfoByPortal = /* @__PURE__ */ new Map();
+	const syncGroupByExceptionSet = /* @__PURE__ */ new Map();
+	const targetByBuildPhase = /* @__PURE__ */ new Map();
+	for (const ownerId of Object.keys(objects)) {
+		const owner = objects[ownerId];
+		if (!isDictionary(owner)) continue;
+		const isa = asString(owner["isa"]) ?? "";
+		if (isa.endsWith("BuildPhase")) indexFirst(fileToPhase, owner["files"], {
+			isa,
+			name: asString(owner["name"])
+		});
+		else if (isa === "PBXContainerItemProxy") {
+			const portal = asString(owner["containerPortal"]);
+			const remoteInfo = asString(owner["remoteInfo"]);
+			if (portal != null && remoteInfo != null && !proxyRemoteInfoByPortal.has(portal)) proxyRemoteInfoByPortal.set(portal, remoteInfo);
+		}
+		indexFirst(syncGroupByExceptionSet, owner["exceptions"], owner);
+		indexFirst(targetByBuildPhase, owner["buildPhases"], owner);
+		const listId = asString(owner["buildConfigurationList"]);
+		if (listId != null && !configurationListOwners.has(listId)) configurationListOwners.set(listId, [ownerId, owner]);
+	}
+	/**
+	* The name an object displays as when nothing more specific applies:
+	* `name`, then `productName`, then `path`, then its isa.
+	*/
+	const defaultName = (object, isa) => asString(object["name"]) ?? asString(object["productName"]) ?? asString(object["path"]) ?? isa;
+	/**
+	* The display name of the synchronized folder an exception set belongs
+	* to, found through the sync group whose `exceptions` array lists it.
+	*/
+	const exceptionSetFolderName = (id) => {
+		const group = syncGroupByExceptionSet.get(id);
+		return group == null ? void 0 : asString(group["name"]) ?? asString(group["path"]);
+	};
+	/**
+	* Comment for a `PBXFileSystemSynchronizedBuildFileExceptionSet`,
+	* matching current Xcode: `Exceptions for "clip" folder in "clip"
+	* target`. Falls back to the isa when the folder or target cannot be
+	* resolved (older documents and hand-edited graphs).
+	*/
+	const buildFileExceptionSetComment = (id, set) => {
+		const folder = exceptionSetFolderName(id);
+		const targetId = asString(set["target"]);
+		const target = targetId == null ? void 0 : objects[targetId];
+		if (folder == null || !isDictionary(target)) return;
+		const targetName = asString(target["name"]) ?? asString(target["productName"]) ?? asString(target["path"]);
+		return targetName == null ? void 0 : `Exceptions for "${folder}" folder in "${targetName}" target`;
+	};
+	/**
+	* Comment for a `PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet`,
+	* matching current Xcode: `Exceptions for "Tophat" folder in "CopyFiles"
+	* phase from "Tophat" target`. Falls back to the isa when any of the
+	* three names cannot be resolved.
+	*/
+	const membershipExceptionSetComment = (id, set) => {
+		const folder = exceptionSetFolderName(id);
+		const phaseId = asString(set["buildPhase"]);
+		const phase = phaseId == null ? void 0 : objects[phaseId];
+		if (folder == null || phaseId == null || !isDictionary(phase)) return;
+		const phaseName = asString(phase["name"]) ?? defaultBuildPhaseName(asString(phase["isa"]) ?? "");
+		const target = targetByBuildPhase.get(phaseId);
+		const targetName = target == null ? void 0 : asString(target["name"]) ?? asString(target["productName"]) ?? asString(target["path"]);
+		if (phaseName == null || targetName == null) return;
+		return `Exceptions for "${folder}" folder in "${phaseName}" phase from "${targetName}" target`;
+	};
+	/**
+	* Comment for a `PBXBuildFile`: the referenced file's own comment plus
+	* the phase it belongs to, e.g. `AppDelegate.swift in Sources`.
+	*/
+	const buildFileComment = (id, buildFile) => {
+		const phase = fileToPhase.get(id);
+		const phaseName = phase == null ? "[missing build phase]" : phase.name ?? defaultBuildPhaseName(phase.isa) ?? "";
+		const refId = asString(buildFile["fileRef"]) ?? asString(buildFile["productRef"]);
+		const referenced = refId == null ? void 0 : objects[refId];
+		return `${(refId != null && isDictionary(referenced) ? commentFor(refId, referenced) : void 0) ?? "(null)"} in ${phaseName}`;
+	};
+	/**
+	* Comment for an `XCConfigurationList`, naming the target or project that
+	* owns it, e.g. `Build configuration list for PBXNativeTarget "App"`.
+	*/
+	const configurationListComment = (id) => {
+		const ownerEntry = configurationListOwners.get(id);
+		if (ownerEntry == null) return "Build configuration list for [unknown]";
+		const [ownerId, owner] = ownerEntry;
+		const isa = asString(owner["isa"]) ?? "";
+		const ownName = asString(owner["name"]) ?? asString(owner["path"]) ?? asString(owner["productName"]);
+		if (ownName != null) return `Build configuration list for ${isa} "${ownName}"`;
+		const targets = owner["targets"];
+		if (Array.isArray(targets)) {
+			const firstTargetId = targets.find((target) => typeof target === "string");
+			const firstTarget = firstTargetId == null ? void 0 : objects[firstTargetId];
+			if (isDictionary(firstTarget)) {
+				const targetName = asString(firstTarget["productName"]) ?? asString(firstTarget["name"]);
+				if (targetName != null) return `Build configuration list for ${isa} "${targetName}"`;
+			}
+		}
+		const remoteInfo = proxyRemoteInfoByPortal.get(ownerId);
+		if (remoteInfo != null) return `Build configuration list for ${isa} "${remoteInfo}"`;
+		return `Build configuration list for ${isa}`;
+	};
+	/**
+	* Derives (and caches) the comment for one object, dispatching on its
+	* isa. Returns `undefined` for objects with no isa and for re-entrant
+	* lookups on a reference cycle.
+	*/
+	const commentFor = (id, object) => {
+		const cached = cache.get(id);
+		if (cached != null) return cached;
+		const isa = asString(object["isa"]);
+		if (isa == null) return;
+		if (inProgress.has(id)) return;
+		inProgress.add(id);
+		let comment;
+		if (isa === "PBXBuildFile") comment = buildFileComment(id, object);
+		else if (isa === "XCConfigurationList") comment = configurationListComment(id);
+		else if (isa === "XCRemoteSwiftPackageReference") {
+			const repoUrl = asString(object["repositoryURL"]);
+			comment = repoUrl == null ? isa : `${isa} "${repoNameFromUrl(repoUrl)}"`;
+		} else if (isa === "XCLocalSwiftPackageReference") {
+			const relativePath = asString(object["relativePath"]);
+			comment = relativePath == null ? isa : `${isa} "${relativePath}"`;
+		} else if (isa === "PBXProject") comment = "Project object";
+		else if (isa === "PBXFileSystemSynchronizedBuildFileExceptionSet") comment = buildFileExceptionSetComment(id, object) ?? isa;
+		else if (isa === "PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet") comment = membershipExceptionSetComment(id, object) ?? isa;
+		else if (isa === "PBXTargetDependency") comment = isa;
+		else if (isa.endsWith("BuildPhase")) comment = asString(object["name"]) ?? defaultBuildPhaseName(isa) ?? "";
+		else if (isa === "PBXGroup" && asString(object["name"]) == null && asString(object["path"]) == null) comment = "";
+		else comment = defaultName(object, isa);
+		inProgress.delete(id);
+		cache.set(id, comment);
+		return comment;
+	};
+	for (const id of Object.keys(objects)) {
+		const object = objects[id];
+		if (isDictionary(object)) commentFor(id, object);
+	}
+	return cache;
+}
+//#endregion
+//#region src/errors.ts
+/**
+* Error types raised by this library.
+*
+* Both error classes are exported so callers can distinguish "the document is
+* malformed" ({@link PbxprojParseError}) from "this value cannot be written"
+* ({@link PbxprojBuildError}) and report precise context for each.
+*
+* @module
+*/
+/** UTF-16 code unit of `\n`, used to count lines when reporting a failure. */
+const LINE_FEED = 10;
+/**
+* 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.
+*/
+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;
+	}
+	return {
+		offset,
+		line,
+		column: offset - lineStart + 1
+	};
+}
+/**
+* Thrown when the source text is not a well-formed OpenStep-style property
+* list (the format of `project.pbxproj` 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 PbxprojParseError = 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 = "PbxprojParseError";
+		this.position = position;
+	}
+};
+/**
+* Thrown when a value cannot be represented in a `project.pbxproj` document.
+*
+* Raised for `null`, `undefined`, booleans, bigints, functions, symbols,
+* class instances, and non-finite numbers. The format itself has no boolean
+* or null notation (Xcode models booleans as the strings `YES`/`NO`), so
+* rejecting them loudly beats writing a value Xcode would misread. The
+* {@link path} pinpoints the offending value inside the input, which matters
+* when serializing a project with thousands of objects.
+*/
+var PbxprojBuildError = class extends Error {
+	/** Path to the offending value from the root, e.g. `$.objects.13B07F86.name`. */
+	path;
+	/**
+	* @param message Failure description without location; the value path is
+	*   appended automatically.
+	* @param path Path to the offending value from the root, `$`.
+	*/
+	constructor(message, path) {
+		super(`${message} (at ${path})`);
+		this.name = "PbxprojBuildError";
+		this.path = path;
+	}
+};
+//#endregion
+//#region src/quotes.ts
+/**
+* Quoting and escaping rules for `project.pbxproj` output.
+*
+* The unquoted-safe alphabet is deliberately narrower than what the parser
+* accepts: Xcode itself quotes values containing `-`, so emitting them
+* unquoted would produce documents Xcode rewrites on next save.
+*
+* @module
+*/
+/**
+* The writer's unquoted-safe alphabet. The `+` also rejects the empty
+* string, which must render as `""`.
+*/
+const UNQUOTED_SAFE_PATTERN = /^[A-Za-z0-9_$/:.]+$/u;
+/**
+* Whether the value can render without quotes: every character is in the
+* unquoted-safe alphabet and the string is not empty.
+*
+* Quoting decisions scan every string a document carries, and many of those
+* strings are substring slices of the source text. The regex engine flattens
+* and scans them in bulk, which measures faster here than a per-character
+* `charCodeAt` loop.
+*/
+function isSafeUnquoted(value) {
+	return UNQUOTED_SAFE_PATTERN.test(value);
+}
+/**
+* Whether the string contains characters that require escape sequences
+* inside a quoted string: control characters, `"`, `\`, or DEL.
+*/
+function needsEscaping(value) {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code < 32 || code === 34 || code === 92 || code === 127) return true;
+	}
+	return false;
+}
+/**
+* Escapes special characters for a quoted string: the named C-style escapes
+* plus `\Uxxxx` for remaining control characters.
+*/
+function escapeString(value) {
+	let result = "";
+	for (const ch of value) switch (ch) {
+		case "\x07":
+			result += "\\a";
+			break;
+		case "\b":
+			result += "\\b";
+			break;
+		case "\f":
+			result += "\\f";
+			break;
+		case "\r":
+			result += "\\r";
+			break;
+		case "	":
+			result += "\\t";
+			break;
+		case "\v":
+			result += "\\v";
+			break;
+		case "\n":
+			result += "\\n";
+			break;
+		case "\"":
+			result += "\\\"";
+			break;
+		case "\\":
+			result += "\\\\";
+			break;
+		default: {
+			const code = ch.charCodeAt(0);
+			if (code < 32 || code === 127) result += `\\U${code.toString(16).padStart(4, "0")}`;
+			else result += ch;
+		}
+	}
+	return result;
+}
+/**
+* Renders a string value with quotes exactly when required.
+*
+* Safe literals stay bare, everything else is wrapped in double quotes, and
+* escape processing runs only when an escapable character is present.
+*/
+function ensureQuotes(value) {
+	if (isSafeUnquoted(value)) return value;
+	if (!needsEscaping(value)) return `"${value}"`;
+	return `"${escapeString(value)}"`;
+}
+/**
+* Renders binary data as an uppercase hex run: `<DEADBEEF>`.
+*/
+function formatData(data) {
+	let hex = "";
+	for (const byte of data) hex += byte.toString(16).padStart(2, "0").toUpperCase();
+	return `<${hex}>`;
+}
+//#endregion
+//#region src/build.ts
+/**
+* Serializer producing the exact layout Xcode writes.
+*
+* The layout rules that matter for diffability against Xcode's own output:
+*
+* - the `// !$*UTF8*$!` marker on the first line;
+* - tab indentation, one level per nesting depth;
+* - the root `objects` dictionary grouped into `/* Begin <isa> section *​/`
+*   blocks, sections ordered by isa and entries ordered by uuid;
+* - `PBXBuildFile` and `PBXFileReference` entries rendered on a single line;
+* - reference comments (`13B07F86… /* AppDelegate.swift in Sources *​/`)
+*   derived from the object graph.
+*
+* Numbers render exactly as JavaScript formats them; the version-like
+* settings Xcode writes with a trailing zero (`SWIFT_VERSION = 5.0`) arrive
+* from the parser as strings and round-trip verbatim, so no reformatting
+* heuristic is needed or applied.
+*
+* @module
+*/
+/** The encoding marker Xcode writes on the first line of every document. */
+const SHEBANG = "// !$*UTF8*$!";
+/**
+* Creates the error for a `NaN` or infinite number at the given value path.
+*/
+function nonFiniteNumber(value, path) {
+	return new PbxprojBuildError(`Cannot serialize non-finite number ${String(value)}`, path);
+}
+/**
+* Creates the error for a value outside the pbxproj value model (`null`,
+* booleans, bigints, functions, symbols, class instances) at the given
+* value path.
+*/
+function invalidValue(value, path) {
+	return new PbxprojBuildError(`Cannot serialize a ${value === null ? "null" : typeof value} value; the pbxproj format carries strings, numbers, data, arrays, and dictionaries`, path);
+}
+/**
+* Defuses `*​/` sequences inside derived comment text.
+*
+* Comments derive from document fields (names, paths), so a crafted value
+* containing `*​/` could otherwise terminate the comment early and corrupt
+* the surrounding document.
+*/
+function sanitizeComment(comment) {
+	return comment.includes("*/") ? comment.replaceAll("*/", "* /") : comment;
+}
+/**
+* Indentation strings by depth, extended on demand.
+*
+* Sharing the strings avoids a `"\t".repeat(depth)` allocation on every
+* line of output.
+*/
+const INDENTS = [""];
+/**
+* Returns the shared indentation string for a nesting depth.
+*/
+function indentString(depth) {
+	const cached = INDENTS[depth];
+	if (cached != null) return cached;
+	let known = INDENTS.at(-1);
+	while (INDENTS.length <= depth) {
+		known += "	";
+		INDENTS.push(known);
+	}
+	return known;
+}
+/**
+* Serialization state for one {@link buildPbxproj} call.
+*
+* The `write*` methods append directly to the output string; the `render*`
+* methods return fragments for the caller to place. Output accumulates by
+* appending, because engines represent growing strings as ropes: appends
+* stay cheap where template interpolation would allocate an intermediate
+* string per line.
+*/
+var Writer = class {
+	/** The document text accumulated so far. */
+	out = "";
+	/** Current nesting depth; one tab per level. */
+	indent = 0;
+	/** Display comment per referenced uuid, derived once from the object graph. */
+	comments;
+	/**
+	* Rendered string values by input string: `id /* comment *​/` for
+	* referenced uuids, quoted text for everything else. Referenced objects
+	* render at least twice (their section entry plus each referencing site)
+	* and build settings repeat across configurations, so most renders are
+	* cache hits. The map lives for one build call only.
+	*/
+	renderedReferences = /* @__PURE__ */ new Map();
+	/**
+	* Quoting decisions for dictionary keys, which draw from a small repeated
+	* vocabulary (`isa`, `fileRef`, build-setting names).
+	*/
+	quotedKeys = /* @__PURE__ */ new Map();
+	/**
+	* Serializes the whole document eagerly; read it back with
+	* {@link toString}.
+	*
+	* @param root The document root dictionary.
+	*/
+	constructor(root) {
+		this.comments = createReferenceComments(root);
+		this.out = `${SHEBANG}\n`;
+		this.writeLine("{");
+		this.indent++;
+		this.writeObjectBody(root, true, "$");
+		this.indent--;
+		this.writeLine("}");
+	}
+	/**
+	* Returns the serialized document text.
+	*/
+	toString() {
+		return this.out;
+	}
+	/**
+	* Appends the indentation for the current depth.
+	*/
+	writeIndent() {
+		this.out += indentString(this.indent);
+	}
+	/**
+	* Appends one indented line followed by a newline.
+	*/
+	writeLine(text) {
+		this.out += `${indentString(this.indent)}${text}\n`;
+	}
+	/**
+	* Renders a string as a uuid reference with its display comment, or as a
+	* plain quoted value when no comment is derived for it.
+	*
+	* Most calls hit the cache, and the writers call this for every key and
+	* reference, so the method body stays small enough for the engine to
+	* inline; the miss path lives in {@link renderReferenceUncached}.
+	*/
+	renderReference(id) {
+		const cached = this.renderedReferences.get(id);
+		if (cached != null) return cached;
+		return this.renderReferenceUncached(id);
+	}
+	/**
+	* Renders and caches one reference on its first occurrence. Annotated ids
+	* are quoted too when the format requires it: Xcode ids never need
+	* quotes, but object keys in hand-written documents can.
+	*/
+	renderReferenceUncached(id) {
+		const comment = this.comments.get(id);
+		const quoted = ensureQuotes(id);
+		const rendered = comment != null && comment.length > 0 ? `${quoted} /* ${sanitizeComment(comment)} */` : quoted;
+		this.renderedReferences.set(id, rendered);
+		return rendered;
+	}
+	/**
+	* Renders a dictionary key with quotes when the format requires them,
+	* memoized across the document. As with {@link renderReference}, the
+	* cache-hit path stays small and the miss path is a separate method.
+	*/
+	renderKey(key) {
+		const cached = this.quotedKeys.get(key);
+		if (cached != null) return cached;
+		return this.renderKeyUncached(key);
+	}
+	/**
+	* Quotes and caches one dictionary key on its first occurrence.
+	*/
+	renderKeyUncached(key) {
+		const quoted = ensureQuotes(key);
+		this.quotedKeys.set(key, quoted);
+		return quoted;
+	}
+	/**
+	* Renders a string value in its key's context.
+	*
+	* `remoteGlobalIDString` and `TestTargetID` hold uuids of objects in
+	* another container; annotating them with this container's comments would
+	* be wrong, so they render bare.
+	*/
+	renderStringValue(key, value) {
+		if (key === "remoteGlobalIDString" || key === "TestTargetID") return ensureQuotes(value);
+		return this.renderReference(value);
+	}
+	/**
+	* Appends the entries of a dictionary, one `key = value;` line each.
+	*
+	* Value paths (`$.objects.AA….name`) exist for error messages and are
+	* only constructed in the branches that recurse or throw; the flat string
+	* and number lines that dominate documents skip the concatenation.
+	*
+	* @param object The dictionary whose entries to write.
+	* @param isBase Whether this is the document root, where the `objects`
+	*   dictionary gets section grouping and empty dictionaries render
+	*   multi-line.
+	* @param path Value path of `object`, for error messages.
+	*/
+	writeObjectBody(object, isBase, path) {
+		for (const key of Object.keys(object)) {
+			const value = object[key];
+			if (typeof value === "string") {
+				this.out += indentString(this.indent);
+				this.out += this.renderKey(key);
+				this.out += " = ";
+				this.out += this.renderStringValue(key, value);
+				this.out += ";\n";
+			} else if (typeof value === "number") {
+				if (!Number.isFinite(value)) throw nonFiniteNumber(value, `${path}.${key}`);
+				this.out += indentString(this.indent);
+				this.out += this.renderKey(key);
+				this.out += " = ";
+				this.out += String(value);
+				this.out += ";\n";
+			} else if (value instanceof Uint8Array) this.writeLine(`${this.renderKey(key)} = ${formatData(value)};`);
+			else if (Array.isArray(value)) this.writeArray(key, value, `${path}.${key}`);
+			else if (isDictionary(value)) {
+				if (!isBase && Object.keys(value).length === 0) {
+					this.writeLine(`${this.renderKey(key)} = {};`);
+					continue;
+				}
+				this.writeLine(`${this.renderKey(key)} = {`);
+				this.indent++;
+				if (isBase && key === "objects") this.writeObjectsSections(value, `${path}.${key}`);
+				else this.writeObjectBody(value, false, `${path}.${key}`);
+				this.indent--;
+				this.writeLine("};");
+			} else throw invalidValue(value, `${path}.${key}`);
+		}
+	}
+	/**
+	* Appends the root `objects` dictionary grouped into per-isa sections.
+	*
+	* Sections are ordered by isa name and entries within a section by uuid,
+	* exactly as Xcode sorts them.
+	*/
+	writeObjectsSections(objects, path) {
+		const byIsa = /* @__PURE__ */ new Map();
+		for (const id of Object.keys(objects)) {
+			const object = objects[id];
+			if (!isDictionary(object)) throw invalidValue(object, `${path}.${id}`);
+			const isaValue = object["isa"];
+			const isa = typeof isaValue === "string" ? isaValue : "Unknown";
+			const entries = byIsa.get(isa);
+			if (entries == null) byIsa.set(isa, [[id, object]]);
+			else entries.push([id, object]);
+		}
+		for (const isa of [...byIsa.keys()].toSorted()) {
+			this.out += `\n/* Begin ${sanitizeComment(isa)} section */\n`;
+			const entries = (byIsa.get(isa) ?? []).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+			for (const [id, object] of entries) {
+				this.writeIndent();
+				if (isa === "PBXBuildFile" || isa === "PBXFileReference") {
+					let text = this.renderInlineObject(id, object, `${path}.${id}`);
+					if (text.endsWith(" ")) text = text.slice(0, -1);
+					this.out += text;
+					this.out += "\n";
+				} else {
+					this.out += `${this.renderReference(id)} = {\n`;
+					this.indent++;
+					this.writeObjectBody(object, false, `${path}.${id}`);
+					this.indent--;
+					this.writeLine("};");
+				}
+			}
+			this.out += `/* End ${sanitizeComment(isa)} section */\n`;
+		}
+	}
+	/**
+	* Renders one object as a single `uuid /* comment *​/ = {isa = …; };`
+	* fragment, recursing into nested dictionaries inline.
+	*/
+	renderInlineObject(key, object, path) {
+		let text = `${this.renderReference(key)} = {`;
+		for (const innerKey of Object.keys(object)) {
+			const value = object[innerKey];
+			if (typeof value === "string") text += `${this.renderKey(innerKey)} = ${this.renderStringValue(innerKey, value)}; `;
+			else if (typeof value === "number") {
+				if (!Number.isFinite(value)) throw nonFiniteNumber(value, `${path}.${innerKey}`);
+				text += `${this.renderKey(innerKey)} = ${String(value)}; `;
+			} else if (value instanceof Uint8Array) text += `${this.renderKey(innerKey)} = ${formatData(value)}; `;
+			else if (Array.isArray(value)) {
+				text += `${this.renderKey(innerKey)} = (`;
+				for (let index = 0; index < value.length; index++) {
+					const item = value[index];
+					if (typeof item === "string") text += `${ensureQuotes(item)}, `;
+					else if (typeof item === "number" && Number.isFinite(item)) text += `${String(item)}, `;
+					else throw typeof item === "number" ? nonFiniteNumber(item, `${path}.${innerKey}[${index}]`) : invalidValue(item, `${path}.${innerKey}[${index}]`);
+				}
+				text += "); ";
+			} else if (isDictionary(value)) text += this.renderInlineObject(innerKey, value, `${path}.${innerKey}`);
+			else throw invalidValue(value, `${path}.${innerKey}`);
+		}
+		text += "}; ";
+		return text;
+	}
+	/**
+	* Appends a `key = ( item, … );` array with one indented line per item,
+	* the layout Xcode uses for every multi-line list.
+	*/
+	writeArray(key, items, path) {
+		this.writeLine(`${this.renderKey(key)} = (`);
+		this.indent++;
+		for (let index = 0; index < items.length; index++) {
+			const item = items[index];
+			if (typeof item === "string") {
+				this.out += indentString(this.indent);
+				this.out += this.renderReference(item);
+				this.out += ",\n";
+			} else if (typeof item === "number") {
+				if (!Number.isFinite(item)) throw nonFiniteNumber(item, `${path}[${index}]`);
+				this.writeLine(`${String(item)},`);
+			} else if (item instanceof Uint8Array) this.writeLine(`${formatData(item)},`);
+			else if (isDictionary(item)) {
+				this.writeLine("{");
+				this.indent++;
+				this.writeObjectBody(item, false, `${path}[${index}]`);
+				this.indent--;
+				this.writeLine("},");
+			} else throw invalidValue(item, `${path}[${index}]`);
+		}
+		this.indent--;
+		this.writeLine(");");
+	}
+};
+/**
+* Serializes a project document to `project.pbxproj` text.
+*
+* The input is the same shape {@link parsePbxproj} produces; see the module
+* documentation of `types.ts` for the value model. Output is stable: two
+* calls with semantically equal documents produce identical text, and the
+* layout matches what Xcode itself writes so diffs stay minimal.
+*
+* @param root The document root. Real project documents carry `objects`,
+*   `rootObject`, and the version fields, but any dictionary serializes.
+* @returns The document text, terminated by a newline.
+* @throws PbxprojBuildError when a value has no pbxproj representation:
+*   `null`, `undefined`, booleans, bigints, functions, symbols, class
+*   instances, or non-finite numbers. The error names the path of the
+*   offending value.
+*/
+function buildPbxproj(root) {
+	if (!isDictionary(root)) throw new PbxprojBuildError("The document root must be a dictionary", "$");
+	return new Writer(root).toString();
+}
+//#endregion
+//#region src/escape.ts
+/**
+* Escape handling for quoted strings.
+*
+* OpenStep-style property lists inherit their escape syntax from NeXTSTEP:
+* C-style character escapes, `\Uxxxx` Unicode escapes, and octal escapes
+* whose values above 0x7F select characters from the NeXTSTEP character set
+* rather than Latin-1.
+*
+* @module
+*/
+/**
+* NeXTSTEP character set for byte values 0x80-0xFF, indexed by `byte - 0x80`.
+*
+* Octal escapes are how pre-Unicode NeXTSTEP text encoded non-ASCII
+* characters; mapping them through this table is what makes `\341` decode to
+* `Æ` instead of the Latin-1 `á`. Values are Unicode code points, per the
+* published NEXTSTEP.TXT vendor mapping in the Unicode Character Database.
+*/
+const NEXT_STEP_MAPPINGS = [
+	160,
+	192,
+	193,
+	194,
+	195,
+	196,
+	197,
+	199,
+	200,
+	201,
+	202,
+	203,
+	204,
+	205,
+	206,
+	207,
+	208,
+	209,
+	210,
+	211,
+	212,
+	213,
+	214,
+	217,
+	218,
+	219,
+	220,
+	221,
+	222,
+	181,
+	215,
+	247,
+	169,
+	161,
+	162,
+	163,
+	8260,
+	165,
+	402,
+	167,
+	164,
+	8217,
+	8220,
+	171,
+	8249,
+	8250,
+	64257,
+	64258,
+	174,
+	8211,
+	8224,
+	8225,
+	183,
+	166,
+	182,
+	8226,
+	8218,
+	8222,
+	8221,
+	187,
+	8230,
+	8240,
+	172,
+	191,
+	185,
+	715,
+	180,
+	710,
+	732,
+	175,
+	728,
+	729,
+	168,
+	178,
+	730,
+	184,
+	179,
+	733,
+	731,
+	711,
+	8212,
+	177,
+	188,
+	189,
+	190,
+	224,
+	225,
+	226,
+	227,
+	228,
+	229,
+	231,
+	232,
+	233,
+	234,
+	235,
+	236,
+	198,
+	237,
+	170,
+	238,
+	239,
+	240,
+	241,
+	321,
+	216,
+	338,
+	186,
+	242,
+	243,
+	244,
+	245,
+	246,
+	230,
+	249,
+	250,
+	251,
+	305,
+	252,
+	253,
+	322,
+	248,
+	339,
+	223,
+	254,
+	255,
+	65533,
+	65533
+];
+/**
+* Maps an octal escape value to its Unicode code point.
+*
+* Values below 0x80 are ASCII and pass through; values in 0x80-0xFF select
+* from the NeXTSTEP character set.
+*/
+function nextStepToUnicode(code) {
+	if (code < 128 || code > 255) return code;
+	return NEXT_STEP_MAPPINGS[code - 128] ?? code;
+}
+const CODE_ZERO$1 = 48;
+const CODE_SEVEN = 55;
+const CODE_BACKSLASH$1 = 92;
+/**
+* Whether the code unit is an ASCII hexadecimal digit (`0-9A-Fa-f`).
+*/
+function isHexDigit(code) {
+	return code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
+}
+/**
+* Single-character escapes and their decoded text. An escaped line break
+* decodes to a newline, like the C escape it mirrors.
+*/
+const SIMPLE_ESCAPES = {
+	a: "\x07",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	v: "\v",
+	"\"": "\"",
+	"'": "'",
+	"\\": "\\",
+	"\n": "\n"
+};
+/**
+* Decodes a `\Uxxxx` escape whose backslash sits at `index`. Returns the
+* decoded text and the index after the escape, or `undefined` when the
+* sequence is not exactly four hex digits.
+*/
+function readUnicodeEscape(input, index) {
+	const hex = input.slice(index + 2, index + 6);
+	if (hex.length !== 4) return;
+	for (let i = 0; i < 4; i++) if (!isHexDigit(hex.charCodeAt(i))) return;
+	const code = Number.parseInt(hex, 16);
+	return [code < 55296 || code > 57343 ? String.fromCharCode(code) : "", index + 6];
+}
+/**
+* Decodes a `\NNN` octal escape (1-3 digits) whose backslash sits at
+* `index`, mapping values at or above 0x80 through the NeXTSTEP character
+* set. Returns the decoded text and the index after the escape.
+*/
+function readOctalEscape(input, index) {
+	let end = index + 1;
+	while (end < input.length && end < index + 4) {
+		const code = input.charCodeAt(end);
+		if (code < CODE_ZERO$1 || code > CODE_SEVEN) break;
+		end++;
+	}
+	const octal = Number.parseInt(input.slice(index + 1, end), 8);
+	return [String.fromCharCode(nextStepToUnicode(octal)), end];
+}
+/**
+* Decodes one escape sequence whose backslash sits at `index`. Returns the
+* decoded text and the index after the sequence. Unknown escapes preserve
+* both characters, the lenient behavior needed to read files written by
+* tools with sloppier escaping than Xcode's.
+*/
+function decodeEscape(input, index) {
+	const next = input[index + 1];
+	const simple = SIMPLE_ESCAPES[next];
+	if (simple != null) return [simple, index + 2];
+	if (next === "U") return readUnicodeEscape(input, index) ?? ["\\", index + 1];
+	const code = next.charCodeAt(0);
+	if (code >= CODE_ZERO$1 && code <= CODE_SEVEN) return readOctalEscape(input, index);
+	return [`\\${next}`, index + 2];
+}
+/**
+* Processes escape sequences in a quoted string (quotes already stripped).
+*
+* Handles the standard escapes (`\a \b \f \n \r \t \v \" \' \\` and an
+* escaped line break), `\Uxxxx` Unicode escapes (exactly 4 hex digits), and
+* `\NNN` octal escapes (1-3 digits, values at or above 0x80 mapped through
+* the NeXTSTEP character set).
+*/
+function unescapeString(input) {
+	const length = input.length;
+	let result = "";
+	let i = 0;
+	while (i < length) if (input.charCodeAt(i) === CODE_BACKSLASH$1 && i + 1 < length) {
+		const [text, next] = decodeEscape(input, i);
+		result += text;
+		i = next;
+	} else {
+		result += input[i];
+		i += 1;
+	}
+	return result;
+}
+//#endregion
+//#region src/parse.ts
+/**
+* Single-pass recursive-descent parser for `project.pbxproj` files.
+*
+* The grammar is the OpenStep-style property list Xcode reads and writes:
+* `{ key = value; ... }` dictionaries, `( item, ... )` arrays, quoted and
+* unquoted strings, `<hex>` data runs, and `//` and `/* *​/` comments as
+* insignificant trivia.
+*
+* @module
+*/
+/**
+* Characters allowed in unquoted string literals: `[A-Za-z0-9_$/:.-]`.
+*
+* A 256-entry lookup table keyed by code unit keeps classification to a
+* single array read in the hot loop. Non-ASCII units index past the table
+* and read `undefined`, which is correctly falsy, because non-ASCII text
+* only appears inside quoted strings.
+*/
+const IS_LITERAL_CHAR = (() => {
+	const table = /* @__PURE__ */ new Uint8Array(256);
+	for (let i = 97; i <= 122; i++) table[i] = 1;
+	for (let i = 65; i <= 90; i++) table[i] = 1;
+	for (let i = 48; i <= 57; i++) table[i] = 1;
+	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_SINGLE_QUOTE = 39;
+const CODE_OPEN_PAREN = 40;
+const CODE_CLOSE_PAREN = 41;
+const CODE_ASTERISK = 42;
+const CODE_COMMA = 44;
+const CODE_MINUS = 45;
+const CODE_DOT = 46;
+const CODE_SLASH = 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_BACKSLASH = 92;
+const CODE_OPEN_BRACE = 123;
+const CODE_CLOSE_BRACE = 125;
+/**
+* Whitespace classification as a 256-entry table.
+*
+* This is the single hottest check in the scanner, so it compiles to one
+* array read instead of four comparisons.
+*/
+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;
+	return table;
+})();
+/**
+* Whether the code unit is an ASCII decimal digit (`0-9`).
+*/
+function isDigit(code) {
+	return code >= CODE_ZERO && code <= CODE_NINE;
+}
+/**
+* Scanner state and grammar productions for one parse call.
+*
+* The parser holds a single cursor into the source string and advances it
+* through the `read*` and `parse*` methods; there is no separate tokenizer
+* stage and no token objects.
+*/
+var Parser = class {
+	/** Source text of the document being parsed. */
+	input;
+	/** Cursor position as a UTF-16 code unit offset into {@link input}. */
+	pos = 0;
+	/**
+	* Offset of an unterminated block comment the trivia scanner consumed, or
+	* -1. Recording it instead of throwing keeps the trivia scanner free of
+	* failure branches; see {@link fail}.
+	*/
+	unterminatedCommentAt = -1;
+	/**
+	* @param input Source text of the document.
+	*/
+	constructor(input) {
+		this.input = input;
+	}
+	/**
+	* Throws a {@link PbxprojParseError} carrying the line and column of the
+	* failure.
+	*
+	* An unterminated block comment swallows the rest of the input, so any
+	* failure raised after one (always some end-of-input error) is a symptom;
+	* the comment itself is reported instead. Content after the root value is
+	* never scanned, so a trailing unterminated comment still parses, as
+	* Apple's parser accepts it too.
+	*
+	* @param message Failure description without location.
+	* @param offset Offset of the failure; defaults to the current cursor.
+	*/
+	fail(message, offset = this.pos) {
+		if (this.unterminatedCommentAt !== -1) throw new PbxprojParseError("Unterminated block comment", this.input, this.unterminatedCommentAt);
+		throw new PbxprojParseError(message, this.input, offset);
+	}
+	/**
+	* Skips whitespace and `//` / `/* *​/` comments in bulk.
+	*
+	* Most trivia gaps are pure whitespace, so this hot method is only the
+	* whitespace loop plus one slash check, small enough for the engine to
+	* inline into the parse loops. Gaps containing comments continue in
+	* {@link skipCommentedTrivia}.
+	*/
+	skipTrivia() {
+		const input = this.input;
+		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);
+		this.pos = pos;
+	}
+	/**
+	* Continues a trivia scan whose cursor sits on a `/`, consuming comments
+	* and any whitespace between them until significant content follows.
+	* Returns the position of that content (`pos` unchanged when the slash
+	* does not open a comment, since `/` also starts unquoted path literals).
+	*
+	* Comment bodies are jumped over with `indexOf` rather than scanned per
+	* character. Reference comments make up a sizable share of a canonical
+	* document's bytes, and `indexOf` uses the engine's vectorized search. An
+	* unterminated block comment consumes the rest of the input and records
+	* its offset for {@link fail}, keeping throw sites off the scanner paths.
+	*/
+	skipCommentedTrivia(pos) {
+		const input = this.input;
+		const length = input.length;
+		for (;;) {
+			const next = input.charCodeAt(pos + 1);
+			if (next === CODE_SLASH) {
+				const lineEnd = input.indexOf("\n", pos + 2);
+				pos = lineEnd === -1 ? length : lineEnd;
+			} else if (next === CODE_ASTERISK) {
+				const commentEnd = input.indexOf("*/", pos + 2);
+				if (commentEnd === -1) {
+					this.unterminatedCommentAt = pos;
+					return length;
+				}
+				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;
+		}
+	}
+	/**
+	* Returns the next significant code unit without consuming it, or -1 at
+	* end of input. Trivia before it is consumed.
+	*/
+	peek() {
+		this.skipTrivia();
+		return this.pos < this.input.length ? this.input.charCodeAt(this.pos) : -1;
+	}
+	/**
+	* Consumes the expected code unit or fails with a message naming it.
+	*
+	* @param code The expected UTF-16 code unit.
+	* @param description How the character reads in the error message.
+	*/
+	expect(code, description) {
+		if (this.input.charCodeAt(this.pos) === code) {
+			this.pos++;
+			return;
+		}
+		this.skipTrivia();
+		if (this.pos < this.input.length && this.input.charCodeAt(this.pos) === code) {
+			this.pos++;
+			return;
+		}
+		const found = this.pos < this.input.length ? `'${this.input[this.pos]}'` : "end of input";
+		this.fail(`Expected '${description}' but found ${found}`);
+	}
+	/**
+	* Reads an unquoted literal run and returns it as text.
+	*
+	* The caller guarantees the cursor is on at least one literal character.
+	*/
+	readLiteral() {
+		const input = this.input;
+		const length = input.length;
+		const start = this.pos;
+		let pos = start;
+		while (pos < length && IS_LITERAL_CHAR[input.charCodeAt(pos)] === 1) pos++;
+		this.pos = pos;
+		return input.slice(start, pos);
+	}
+	/**
+	* Reads a quoted string; the opening quote is at the current position.
+	*
+	* The scan tracks whether any escape sequence occurred: unescaped strings
+	* (the overwhelming majority) return as a direct slice, and only escaped
+	* ones pay for {@link unescapeString}.
+	*/
+	readQuotedString() {
+		const input = this.input;
+		const length = input.length;
+		const quote = input.charCodeAt(this.pos);
+		const start = ++this.pos;
+		let hasEscape = false;
+		let end = start;
+		while (end < length) {
+			const code = input.charCodeAt(end);
+			if (code === quote) break;
+			if (code === CODE_BACKSLASH) {
+				hasEscape = true;
+				end += 2;
+			} else end += 1;
+		}
+		if (end >= length) this.fail("Unterminated string", start - 1);
+		const raw = input.slice(start, end);
+		this.pos = end + 1;
+		return hasEscape ? unescapeString(raw) : raw;
+	}
+	/**
+	* Reads a `<hex bytes>` data run into a `Uint8Array`; the `<` is at the
+	* current position.
+	*
+	* Whitespace between digits is allowed (Xcode writes `<AB CD>`), and the
+	* digit count must be even: Apple's parser rejects odd counts, and
+	* padding would guess a byte.
+	*/
+	readData() {
+		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++;
+		if (this.pos >= length) this.fail("Unterminated data run", start - 1);
+		let hex = "";
+		for (let i = start; i < this.pos; i++) {
+			const code = input.charCodeAt(i);
+			if (isHexDigit(code)) hex += input[i];
+			else if (IS_WHITESPACE[code] !== 1) this.fail(`Invalid character '${input[i]}' in data run`, i);
+		}
+		this.pos++;
+		if (hex.length % 2 !== 0) this.fail("Data run has an odd number of hex digits", start);
+		const bytes = new Uint8Array(hex.length / 2);
+		for (let i = 0; i < hex.length; i += 2) bytes[i >> 1] = Number.parseInt(hex.slice(i, i + 2), 16);
+		return bytes;
+	}
+	/**
+	* Parses the document root: a dictionary or an array.
+	*/
+	parseDocument() {
+		const code = this.peek();
+		if (code === CODE_OPEN_BRACE) return this.parseObject();
+		if (code === CODE_OPEN_PAREN) return this.parseArray();
+		if (code === -1) this.fail("Empty input");
+		this.fail(`Expected '{' or '(' at the start of the document but found '${this.input[this.pos]}'`);
+	}
+	/**
+	* Parses a `{ key = value; ... }` dictionary; the `{` is at the current
+	* position. Keys may be quoted or unquoted, and every entry requires the
+	* `=` and terminating `;`.
+	*/
+	parseObject() {
+		const input = this.input;
+		const length = input.length;
+		this.pos++;
+		const result = {};
+		for (;;) {
+			this.skipTrivia();
+			if (this.pos >= length) this.fail("Unterminated dictionary");
+			const code = input.charCodeAt(this.pos);
+			if (code === CODE_CLOSE_BRACE) {
+				this.pos++;
+				return result;
+			}
+			let key;
+			if (code === CODE_QUOTE || 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, "=");
+			const value = this.parseValue();
+			this.expect(CODE_SEMICOLON, ";");
+			if (key === "__proto__") Object.defineProperty(result, key, {
+				value,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			else result[key] = value;
+		}
+	}
+	/**
+	* Parses a `( item, item, ... )` array; the `(` is at the current
+	* position. A trailing comma before `)` is allowed; Xcode writes one
+	* after every item.
+	*/
+	parseArray() {
+		const input = this.input;
+		const length = input.length;
+		this.pos++;
+		const items = [];
+		for (;;) {
+			this.skipTrivia();
+			if (this.pos >= length) this.fail("Unterminated array");
+			if (input.charCodeAt(this.pos) === CODE_CLOSE_PAREN) {
+				this.pos++;
+				return items;
+			}
+			items.push(this.parseValueAtCursor());
+			const next = this.peek();
+			if (next === CODE_COMMA) this.pos++;
+			else if (next !== CODE_CLOSE_PAREN) this.fail(next === -1 ? "Unterminated array" : "Expected ',' or ')' after an array item");
+		}
+	}
+	/**
+	* Parses any value after consuming leading trivia.
+	*/
+	parseValue() {
+		this.skipTrivia();
+		if (this.pos >= this.input.length) this.fail("Expected a value but found end of input");
+		return this.parseValueAtCursor();
+	}
+	/**
+	* Parses the value starting exactly at the cursor, dispatching on its
+	* first character. The caller has already skipped trivia and checked
+	* bounds, so the loops that call this in sequence skip one redundant
+	* trivia scan per element.
+	*/
+	parseValueAtCursor() {
+		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 (IS_LITERAL_CHAR[code] === 1) return interpretLiteral(this.readLiteral());
+		if (code === CODE_LESS_THAN) return this.readData();
+		this.fail(`Expected a value but found '${this.input[this.pos]}'`);
+	}
+};
+/**
+* Decides whether an unquoted literal is a number or a string.
+*
+* One loop with an early exit: the first character outside `[0-9.]` (after
+* an optional leading `-`) settles the token as a string, so the
+* 24-character identifiers that dominate project documents are classified
+* within their first few characters.
+*
+* Numeric-looking candidates convert under a single print-back rule: the
+* literal becomes a number exactly when the number formats back to the
+* identical text. Any literal the conversion would reshape stays a string,
+* so a parse and build cycle cannot change a single byte of any scalar.
+* That covers leading zeros like `0755`, trailing-zero decimals like `5.0`,
+* bare-dot decimals like `.5`, negative zero, and digit runs beyond double
+* precision. See the module documentation of `types.ts` for the value
+* model.
+*/
+function interpretLiteral(literal) {
+	const first = literal.charCodeAt(0);
+	if (!isDigit(first) && first !== CODE_DOT && first !== CODE_MINUS) return literal;
+	const digitsStart = first === CODE_MINUS ? 1 : 0;
+	let dots = 0;
+	let integer = 0;
+	for (let i = digitsStart; i < literal.length; i++) {
+		const code = literal.charCodeAt(i);
+		if (isDigit(code)) integer = integer * 10 + (code - CODE_ZERO);
+		else if (code === CODE_DOT && dots === 0) dots = 1;
+		else return literal;
+	}
+	if (dots === 0 && literal.length - digitsStart <= 15) {
+		if ((literal.charCodeAt(digitsStart) !== CODE_ZERO || literal.length - digitsStart === 1) && !(integer === 0 && digitsStart === 1)) return digitsStart === 1 ? -integer : integer;
+	}
+	const value = Number(literal);
+	return String(value) === literal ? value : literal;
+}
+/**
+* Parses a `project.pbxproj` document into JavaScript values.
+*
+* Accepts the leading `// !$*UTF8*$!` marker and any other comments as
+* trivia. Content after the root value is ignored. See the module
+* documentation of `types.ts` for how source shapes map to JavaScript
+* values.
+*
+* @param text Source text of the document.
+* @returns The document's root value. For real project files this is the
+*   root dictionary with `objects`, `rootObject`, and version fields.
+* @throws PbxprojParseError when the document is malformed; the error
+*   carries the line and column of the failure.
+*/
+function parsePbxproj(text) {
+	return new Parser(text).parseDocument();
+}
+//#endregion
+export { PbxprojBuildError, PbxprojParseError, buildPbxproj, parsePbxproj };