@gaialabs/core 0.2.2 → 0.2.4

package/dist/index.cjs

@@ -1344,7 +1344,13 @@ var CopCommandProcessor = class {
 	* Parses a COP command based on its definition
 	*/
 	parseCopCommand(copDef, operands) {
-		for (const partStr of copDef.parts) {
+		for (let partStr of copDef.parts) {
+			let bank = null;
+			const bankHintIx = partStr.indexOf("$");
+			if (bankHintIx > 0) {
+				bank = parseInt(partStr.substring(bankHintIx + 1), 16);
+				partStr = partStr.substring(0, bankHintIx);
+			}
 			const addrType = Address.typeFromCode(partStr[0]);
 			const isPtr = addrType !== AddressType.Unknown;
 			const referenceType = isPtr ? partStr.substring(1) : this._blockReader._currentAsmBlock.structName ?? "Binary";
@@ -1355,7 +1361,7 @@ var CopCommandProcessor = class {
 			if (label) {
 				this._romDataReader.position += this.getMemberTypeSize(memberType);
 				operands.push(label);
-			} else operands.push(this.readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType));
+			} else operands.push(this.readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType, bank));
 		}
 	}
 	tryParseMemberType(memberTypeName) {
@@ -1372,11 +1378,11 @@ var CopCommandProcessor = class {
 			default: throw new Error("Unsupported COP member type");
 		}
 	}
-	readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType) {
+	readMemberTypeValue(memberType, partStr, isPtr, referenceType, addrType, bank) {
 		switch (memberType) {
 			case MemberType.Byte: return new Byte(this._romDataReader.readByte());
 			case MemberType.Word: return new Word(this._romDataReader.readUShort());
-			case MemberType.Offset: return this.createCopLocation(this._romDataReader.readUShort(), null, partStr, isPtr, referenceType, addrType);
+			case MemberType.Offset: return this.createCopLocation(this._romDataReader.readUShort(), bank, partStr, isPtr, referenceType, addrType);
 			case MemberType.Address: return this.createCopLocation(this._romDataReader.readUShort(), this._romDataReader.readByte(), partStr, isPtr, referenceType, addrType);
 			default: throw new Error("Unsupported COP member type");
 		}
@@ -1784,12 +1790,14 @@ var DbStringCommand = class {
 	types;
 	delimiter;
 	halt;
+	dictionary;
 	constructor(data) {
 		this.id = data.id ?? void 0;
 		this.name = data.name ?? "";
 		this.types = data.types ?? [];
 		this.delimiter = data.delimiter ?? void 0;
 		this.halt = data.halt ?? false;
+		this.dictionary = data.dictionary ?? void 0;
 		if (!this.id && this.id !== 0) throw new Error("Id is required");
 		if (!this.name) throw new Error("Name is required");
 	}
@@ -1820,19 +1828,16 @@ var DbStringType = class {
 	name;
 	delimiter;
 	terminator;
-	shiftType;
-	characterMap;
 	commands;
 	commandLookup;
 	layers;
 	greedyTerminator;
 	dictionaries;
+	dictionaryLookup;
 	constructor(data) {
 		this.name = data.name ?? "";
 		this.delimiter = data.delimiter ?? "";
 		this.terminator = data.terminator ?? 0;
-		this.shiftType = data.shiftType ?? void 0;
-		this.characterMap = data.characterMap;
 		this.commands = data.commands ?? {};
 		this.layers = data.layers ?? [];
 		this.greedyTerminator = data.greedyTerminator ?? false;
@@ -1841,10 +1846,14 @@ var DbStringType = class {
 			acc[x.id] = x;
 			return acc;
 		}, {});
+		this.dictionaryLookup = Object.values(this.dictionaries).flatMap((y) => y.entries.map((z, ix) => ({
+			text: z,
+			id: y.command << 8 | y.base + ix
+		}))).sort((a, b) => b.text.length - a.text.length);
 		if (!this.name) throw new Error("Name is required");
 		if (!this.delimiter) throw new Error("Delimiter is required");
 		if (!this.terminator && this.terminator !== 0) throw new Error("Terminator is required");
-		if (!this.characterMap) throw new Error("Character map is required");
+		if (!this.layers.length) throw new Error("Layers are required");
 	}
 };
 /**
@@ -3339,14 +3348,17 @@ var TypeParser = class {
 					name: targetType.name,
 					parts
 				};
-				for (let i = 0; i < memberCount; i++) parts[i] = this.parseType(types[i], null, depth + 1, bank);
+				for (let i = 0; i < memberCount; i++) parts[i] = this.parseType(types[i], reg, depth + 1, bank);
 				if (discOffset !== void 0 && discOffset === this._romDataReader.position - prevPosition) this._romDataReader.position++;
 				objects.push(def);
 			}
 			let checkPosition = startPosition;
-			while (++checkPosition < this._romDataReader.position) if (this._referenceManager.containsStruct(checkPosition)) {
-				this._romDataReader.position = checkPosition;
-				break;
+			while (++checkPosition < this._romDataReader.position) {
+				const struct = this._referenceManager.tryGetStruct(checkPosition);
+				if (struct.found && struct.chunkType !== "Code") {
+					this._romDataReader.position = checkPosition;
+					break;
+				}
 			}
 			if (!this._blockReader.partCanContinue()) break;
 		}
@@ -4413,6 +4425,8 @@ var DbRootUtils = class {
 			group: groupName,
 			scene: sceneName
 		}));
+		const stringDelimiterLookup = {};
+		const stringDelimiterList = [];
 		const stringLookup = Object.entries(module.strings).reduce((acc, x) => {
 			const stringType = x[1];
 			const name = x[0];
@@ -4424,18 +4438,27 @@ var DbRootUtils = class {
 				return acc$1;
 			}, {});
 			const dictionaries = Object.entries(stringType.dictionaries ?? {}).reduce((acc$1, y) => {
-				acc$1[y[0]] = new DbStringDictionary({
+				const dictionary = new DbStringDictionary({
 					...y[1],
 					name: y[0]
 				});
+				acc$1[y[0]] = dictionary;
+				if (dictionary.command !== void 0) commands[dictionary.command] = new DbStringCommand({
+					id: dictionary.command,
+					name: dictionary.name,
+					dictionary
+				});
 				return acc$1;
 			}, {});
-			acc[name] = new DbStringType({
+			const st = new DbStringType({
 				...stringType,
 				name,
 				commands,
 				dictionaries
 			});
+			acc[name] = st;
+			stringDelimiterLookup[st.delimiter] = st;
+			stringDelimiterList.push(st.delimiter);
 			return acc;
 		}, {});
 		const structLookup = Object.entries(module.structs).reduce((acc, x) => {
@@ -4497,7 +4520,8 @@ var DbRootUtils = class {
 			addrLookup,
 			entryPoints: cfg.entryPoints,
 			stringTypes: stringLookup,
-			stringDelimiters: Object.values(stringLookup).map((x) => x.delimiter),
+			stringDelimiters: stringDelimiterList,
+			stringDelimiterLookup,
 			compression,
 			groups: groupLookup,
 			scenes: sceneLookup
@@ -4557,6 +4581,7 @@ var DbRootUtils = class {
 		var sourceFiles = [];
 		for (const path of inPath) sourceFiles = await this.applyFolder(root, path, sourceFiles);
 		await saveFileAsBinary(outPath, await new RomWriter(root, "TEST", "TEST").repack(sourceFiles));
+		return sourceFiles;
 	}
 };
 
@@ -4603,7 +4628,8 @@ var StringReader = class StringReader {
 		this._romDataReader = blockReader._romDataReader;
 	}
 	resolveCommand(cmd, builder) {
-		if (cmd.types && cmd.types.length > 0) {
+		if (cmd.dictionary) builder.push(cmd.dictionary.entries[this._romDataReader.readByte() - (cmd.dictionary.base ?? 0)]);
+		else if (cmd.types && cmd.types.length > 0) {
 			builder.push(`[${cmd.name}`);
 			let first = true;
 			for (const t of cmd.types) {
@@ -4646,8 +4672,8 @@ var StringReader = class StringReader {
 		const dictionaries = stringType.dictionaries;
 		const builder = [];
 		const strLoc = this._romDataReader.position;
-		const map = stringType.characterMap;
 		const terminator = stringType.terminator;
+		let currentLayer = stringType.layers[0];
 		do {
 			const c = this._romDataReader.readByte();
 			if (c === terminator) {
@@ -4666,8 +4692,25 @@ var StringReader = class StringReader {
 					break;
 				}
 				if (!found) {
-					const index = DbStringTypeUtils.getShiftDown(stringType.shiftType)(c);
-					if (index >= 0 && index < map.length) builder.push(map[index]);
+					for (const layer of stringType.layers) if (layer.on !== void 0) {
+						if (c === layer.on) {
+							currentLayer = layer;
+							found = true;
+							break;
+						}
+					} else if (c >= (layer.base ?? 0) && c <= (layer.range ?? 255)) {
+						let index = c - (layer.base ?? 0);
+						if (index >= 0 && index < layer.map.length) {
+							if (layer.shift) index = DbStringTypeUtils.getShiftDown(layer.shift)(index);
+							builder.push(layer.map[index]);
+							found = true;
+							break;
+						}
+					}
+				}
+				if (!found) {
+					const index = currentLayer.shift ? DbStringTypeUtils.getShiftDown(currentLayer.shift)(c) : c - (currentLayer.base ?? 0);
+					if (index >= 0 && index < currentLayer.map.length) builder.push(currentLayer.map[index]);
 					else builder.push(`[${c.toString(16).toUpperCase()}]`);
 				}
 			}
@@ -4729,13 +4772,13 @@ var StringProcessor = class {
 	context;
 	root;
 	stringCharLookup;
+	testRegex;
+	inShift = false;
 	constructor(context) {
 		this.context = context;
 		this.root = context.root;
-		this.stringCharLookup = Object.values(this.root.stringTypes).reduce((acc, x) => {
-			acc[x.delimiter] = x;
-			return acc;
-		}, {});
+		this.stringCharLookup = context.root.stringDelimiterLookup;
+		this.testRegex = /* @__PURE__ */ new RegExp(/^[0-9A-F]+$/i);
 	}
 	consumeString(typeChar) {
 		let str = null;
@@ -4758,8 +4801,7 @@ var StringProcessor = class {
 		this.memBuffer.length = 0;
 		this.totalSize = 0;
 		this.fixedStr = fixedStr;
-		const stringType = this.stringCharLookup[typeChar];
-		this.processString(str, stringType);
+		this.processString(str, typeChar);
 	}
 	flushBuffer(stringType, wrap = false) {
 		const size = this.memBuffer.length;
@@ -4779,32 +4821,25 @@ var StringProcessor = class {
 			this.memBuffer.length = 0;
 		}
 	}
-	processString(str, stringType) {
+	processString(str, typeChar) {
+		const stringType = this.stringCharLookup[typeChar];
+		const dictionary = stringType.dictionaryLookup;
 		const cmdLookup = stringType.commands;
-		const dictLookup = stringType.dictionaries;
+		let currentLayer = stringType.layers[0];
 		let lastCmd = null;
-		for (const dictionary of Object.values(dictLookup)) for (let ix = 0; ix < dictionary.entries.length; ix++) {
-			const entry = dictionary.entries[ix];
-			if (str.indexOf(entry) >= 0) if (dictionary.command !== void 0) str = str.replace(entry, `[${dictionary.command}:${(ix + dictionary.base).toString(16).toUpperCase()}]`);
-			else str = str.replace(entry, `[${(ix + dictionary.base).toString(16).toUpperCase()}]`);
+		for (const entry of dictionary) {
+			let index;
+			while ((index = str.indexOf(entry.text)) >= 0) str = str.substring(0, index) + `[${entry.id.toString(16).toUpperCase()}]` + str.substring(index + entry.text.length);
 		}
 		for (let x = 0; x < str.length; x++) {
 			const c = str[x];
 			if (c === "[") {
 				const endIx = str.indexOf("]", x + 1);
-				const splitChars = [
+				const parts = str.substring(x + 1, endIx).split(/* @__PURE__ */ new RegExp(`[${[
 					":",
 					",",
 					" "
-				];
-				const subStr = str.substring(x + 1, endIx);
-				let ix = subStr.length === 2 ? parseInt(subStr, 16) : NaN;
-				if (!isNaN(ix)) {
-					this.memBuffer.push(ix);
-					x = endIx;
-					continue;
-				}
-				const parts = str.substring(x + 1, endIx).split(/* @__PURE__ */ new RegExp(`[${splitChars.join("")}]`)).filter((p) => p.length > 0);
+				].join("")}]`)).filter((p) => p.length > 0);
 				x = endIx;
 				if (parts.length === 0) {
 					this.flushBuffer(stringType, true);
@@ -4818,9 +4853,29 @@ var StringProcessor = class {
 					this.processStringCommand(cmd, stringType, parts);
 					continue;
 				}
+				if (parts.length === 1 && this.testRegex.test(parts[0])) {
+					const value = parseInt(parts[0], 16);
+					if (value < 256) this.memBuffer.push(value);
+					else this.memBuffer.push(value >> 8 & 255, value & 255);
+					continue;
+				}
 			}
 			lastCmd = null;
-			if (this.applyLayers(c, stringType)) continue;
+			let found = false;
+			for (const layer of stringType.layers) {
+				for (let i = 0, len = layer.map.length; i < len; i++) if (c === layer.map[i]) {
+					if (layer.on !== void 0 && currentLayer !== layer) {
+						this.memBuffer.push(layer.on);
+						currentLayer = layer;
+					}
+					let value = i + (layer.base ?? 0);
+					if (layer.shift) value = DbStringTypeUtils.getShiftUp(layer.shift)(value);
+					this.memBuffer.push(value);
+					found = true;
+					break;
+				}
+				if (found) break;
+			}
 		}
 		if (this.fixedStr) {
 			let count = this.fixedStr - this.totalSize;
@@ -4828,23 +4883,6 @@ var StringProcessor = class {
 		} else if (lastCmd === null || !lastCmd.halt) this.memBuffer.push(stringType.terminator);
 		this.flushBuffer(stringType, true);
 	}
-	applyLayers(c, stringType) {
-		if (this.applyMap(c, stringType.characterMap, DbStringTypeUtils.getShiftUp(stringType.shiftType))) return true;
-		if (stringType.layers) {
-			for (const layer of stringType.layers) if (this.applyMap(c, layer.map, (x) => x + layer.base)) return true;
-		}
-		return false;
-	}
-	applyMap(c, map, shift) {
-		for (let i = 0, len = map.length; i < len; i++) {
-			const v = map[i];
-			if (v != null && c === v[0]) {
-				this.memBuffer.push(shift(i));
-				return true;
-			}
-		}
-		return false;
-	}
 	processStringCommand(cmd, stringType, parts) {
 		const hasPointer = cmd.types.includes(MemberType.Address) || cmd.types.includes(MemberType.Offset);
 		if (hasPointer) this.flushBuffer(stringType, true);
@@ -4958,7 +4996,7 @@ var AssemblerState = class AssemblerState {
 		this.dbStruct = structType === null ? null : Object.values(this.root.structs).find((x) => x.name.toLowerCase() === structType.toLowerCase()) || null;
 		this.parentStruct = !this.dbStruct || !this.dbStruct.parent ? null : Object.values(this.root.structs).find((x) => x.name.toLowerCase() === this.dbStruct.parent.toLowerCase()) || null;
 		this.discriminator = this.parentStruct?.discriminator ?? null;
-		this.delimiter = this.dbStruct?.delimiter || null;
+		this.delimiter = this.dbStruct?.delimiter ?? null;
 		this.memberOffset = 0;
 		this.dataOffset = 0;
 		this.memberTypes = this.dbStruct?.types || null;