@no-mess/client 0.4.0 → 0.5.1

package/dist/schema/parse-schema.js

@@ -1,24 +1,24 @@
 import { FIELD_TYPES, } from "./schema-types";
 const FIELD_TYPE_SET = new Set(FIELD_TYPES);
+const DEFINITION_CALL_PATTERN = /define(ContentType|Template|Fragment)\s*\(/g;
+const VARIABLE_DEFINITION_PATTERN = /(?:const|let|var|export\s+const)\s+(\w+)\s*=\s*define(ContentType|Template|Fragment)\s*\(/g;
 /**
- * Parses schema DSL source text and extracts ContentTypeDefinition[].
- * Custom recursive-descent parser — no TS compiler, no eval.
+ * Parses schema DSL source text and extracts template/fragment definitions.
  * Never throws; returns partial results + errors.
  */
 export function parseSchemaSource(source) {
     const errors = [];
     const warnings = [];
     const contentTypes = [];
-    // Strip comments (line and block) while preserving line positions
     const stripped = stripComments(source);
-    // Find all defineContentType( occurrences
-    const pattern = /defineContentType\s*\(/g;
+    const references = collectDefinitionReferences(stripped);
     let match;
-    while ((match = pattern.exec(stripped)) !== null) {
+    while ((match = DEFINITION_CALL_PATTERN.exec(stripped)) !== null) {
+        const definitionName = match[1];
         const startIdx = match.index + match[0].length;
         const line = lineAt(source, match.index);
         try {
-            const result = parseDefineContentTypeArgs(stripped, startIdx, line);
+            const result = parseDefinitionArgs(stripped, startIdx, line, definitionName, references);
             if (result.contentType) {
                 contentTypes.push(result.contentType);
             }
@@ -33,12 +33,10 @@ export function parseSchemaSource(source) {
             errors.push({
                 line,
                 column: 0,
-                message: "Failed to parse defineContentType call",
+                message: `Failed to parse define${definitionName} call`,
             });
         }
     }
-    // Also support standalone defineSchema({ contentTypes: [...] }) wrapping
-    // The individual defineContentType calls inside are already captured above
     return {
         success: errors.length === 0 && contentTypes.length > 0,
         contentTypes,
@@ -46,282 +44,530 @@ export function parseSchemaSource(source) {
         warnings,
     };
 }
-/**
- * Strip line comments (//) and block comments while preserving newlines.
- */
-function stripComments(source) {
-    let result = "";
-    let i = 0;
-    let inString = null;
-    let escaped = false;
-    while (i < source.length) {
-        const ch = source[i];
-        const next = source[i + 1];
-        if (escaped) {
-            result += ch;
-            escaped = false;
-            i++;
-            continue;
-        }
-        if (inString) {
-            if (ch === "\\") {
-                escaped = true;
-                result += ch;
-                i++;
-                continue;
-            }
-            if (ch === inString) {
-                inString = null;
-            }
-            result += ch;
-            i++;
-            continue;
-        }
-        // Template literals
-        if (ch === "`") {
-            inString = "`";
-            result += ch;
-            i++;
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            inString = ch;
-            result += ch;
-            i++;
-            continue;
-        }
-        // Line comment
-        if (ch === "/" && next === "/") {
-            while (i < source.length && source[i] !== "\n") {
-                result += " ";
-                i++;
-            }
-            continue;
-        }
-        // Block comment
-        if (ch === "/" && next === "*") {
-            i += 2;
-            while (i < source.length) {
-                if (source[i] === "*" && source[i + 1] === "/") {
-                    i += 2;
-                    break;
-                }
-                result += source[i] === "\n" ? "\n" : " ";
-                i++;
-            }
+function collectDefinitionReferences(source) {
+    const refs = new Map();
+    let match;
+    while ((match = VARIABLE_DEFINITION_PATTERN.exec(source)) !== null) {
+        const variableName = match[1];
+        const definitionName = match[2];
+        const slugStart = skipWhitespace(source, match.index + match[0].length);
+        const slug = parseStringLiteral(source, slugStart)?.value;
+        if (!slug) {
             continue;
         }
-        result += ch;
-        i++;
-    }
-    return result;
-}
-function lineAt(source, index) {
-    let line = 1;
-    for (let i = 0; i < index && i < source.length; i++) {
-        if (source[i] === "\n")
-            line++;
-    }
-    return line;
-}
-function columnAt(source, index) {
-    let col = 1;
-    for (let i = index - 1; i >= 0; i--) {
-        if (source[i] === "\n")
-            break;
-        col++;
+        refs.set(variableName, {
+            kind: definitionName === "Fragment" ? "fragment" : "template",
+            slug,
+        });
     }
-    return col;
+    return refs;
 }
-/**
- * Parse the arguments of defineContentType(slug, config).
- * `startIdx` points to the character after the opening `(`.
- */
-function parseDefineContentTypeArgs(source, startIdx, baseLine) {
+function parseDefinitionArgs(source, startIdx, baseLine, definitionName, references) {
     const errors = [];
     const warnings = [];
-    let i = skipWhitespace(source, startIdx);
-    // Parse slug (first string argument)
-    const slugResult = parseStringLiteral(source, i);
+    let index = skipWhitespace(source, startIdx);
+    const slugResult = parseStringLiteral(source, index);
     if (!slugResult) {
         errors.push({
             line: baseLine,
-            column: columnAt(source, i),
-            message: "Expected string literal for content type slug",
+            column: columnAt(source, index),
+            message: "Expected string literal for schema slug",
         });
         return { contentType: null, errors, warnings };
     }
     const slug = slugResult.value;
-    i = skipWhitespace(source, slugResult.end);
-    // Expect comma
-    if (source[i] !== ",") {
+    index = skipWhitespace(source, slugResult.end);
+    if (source[index] !== ",") {
         errors.push({
-            line: lineAt(source, i),
-            column: columnAt(source, i),
+            line: lineAt(source, index),
+            column: columnAt(source, index),
             message: "Expected comma after slug",
         });
         return { contentType: null, errors, warnings };
     }
-    i = skipWhitespace(source, i + 1);
-    // Parse config object
-    if (source[i] !== "{") {
+    index = skipWhitespace(source, index + 1);
+    if (source[index] !== "{") {
         errors.push({
-            line: lineAt(source, i),
-            column: columnAt(source, i),
-            message: "Expected object literal for content type config",
+            line: lineAt(source, index),
+            column: columnAt(source, index),
+            message: "Expected object literal for schema config",
         });
         return { contentType: null, errors, warnings };
     }
-    const configResult = extractBalanced(source, i, "{", "}");
-    if (!configResult) {
+    const configBlock = extractBalanced(source, index, "{", "}");
+    if (!configBlock) {
         errors.push({
-            line: lineAt(source, i),
-            column: columnAt(source, i),
+            line: lineAt(source, index),
+            column: columnAt(source, index),
             message: "Unterminated config object",
         });
         return { contentType: null, errors, warnings };
     }
-    const configBody = configResult.inner;
-    // Extract name
-    const name = extractPropertyString(configBody, "name");
+    const configEntries = parseObjectEntries(configBlock.inner);
+    const name = parseStringValue(findObjectEntry(configEntries, "name")?.value);
     if (!name) {
         warnings.push({
             line: baseLine,
-            message: `Missing "name" for content type "${slug}" — using slug as name`,
+            message: `Missing "name" for schema "${slug}"; using slug as name`,
         });
     }
-    // Extract description
-    const description = extractPropertyString(configBody, "description");
-    // Extract fields block
-    const fields = [];
-    const fieldsMatch = /fields\s*:\s*\{/.exec(configBody);
-    if (fieldsMatch) {
-        const fieldsStart = configBody.indexOf("{", fieldsMatch.index + fieldsMatch[0].length - 1);
-        const fieldsBlock = extractBalanced(configBody, fieldsStart, "{", "}");
-        if (fieldsBlock) {
-            const fieldEntries = parseFieldEntries(fieldsBlock.inner, lineAt(source, startIdx), errors, warnings);
-            fields.push(...fieldEntries);
-        }
-    }
-    const contentType = {
-        slug,
-        name: name || slug,
-        fields,
-    };
-    if (description) {
-        contentType.description = description;
+    const description = parseStringValue(findObjectEntry(configEntries, "description")?.value);
+    const route = parseStringValue(findObjectEntry(configEntries, "route")?.value);
+    const rawMode = parseStringValue(findObjectEntry(configEntries, "mode")?.value);
+    const mode = rawMode === "singleton" ? "singleton" : "collection";
+    const fieldsEntry = findObjectEntry(configEntries, "fields");
+    const fields = fieldsEntry
+        ? parseFieldEntries(unwrapObjectLiteral(fieldsEntry.value), baseLine, errors, warnings, references)
+        : [];
+    if (!fieldsEntry) {
+        warnings.push({
+            line: baseLine,
+            message: `Schema "${slug}" is missing a fields object`,
+        });
+    }
+    if (definitionName === "Fragment") {
+        return {
+            contentType: {
+                kind: "fragment",
+                slug,
+                name: name || slug,
+                ...(description ? { description } : {}),
+                fields,
+            },
+            errors,
+            warnings,
+        };
     }
-    return { contentType, errors, warnings };
+    return {
+        contentType: {
+            kind: "template",
+            slug,
+            name: name || slug,
+            ...(description ? { description } : {}),
+            ...(route ? { route } : {}),
+            mode,
+            fields,
+        },
+        errors,
+        warnings,
+    };
 }
-/**
- * Parse field entries from the fields object body.
- * Each entry is: fieldName: field.type({ ... }) or field.type()
- */
-function parseFieldEntries(body, baseLine, errors, warnings) {
+function parseFieldEntries(body, baseLine, errors, warnings, references) {
     const fields = [];
-    // Match patterns like: fieldName: field.type(...) or fieldName: field.type()
-    const fieldPattern = /(\w+)\s*:\s*field\s*\.\s*(\w+)\s*\(/g;
-    let match;
-    while ((match = fieldPattern.exec(body)) !== null) {
-        const fieldName = match[1];
-        const fieldType = match[2];
-        const argsStart = match.index + match[0].length;
-        if (!FIELD_TYPE_SET.has(fieldType)) {
+    const entries = parseObjectEntries(body);
+    for (const entry of entries) {
+        const definition = parseFieldExpression(entry.value, baseLine, entry.key, errors, warnings, references);
+        if (definition) {
+            fields.push({
+                name: entry.key,
+                ...definition,
+            });
+        }
+    }
+    return fields;
+}
+function parseFieldExpression(expression, baseLine, fieldName, errors, warnings, references) {
+    const trimmed = expression.trim();
+    const match = /^field\s*\.\s*(\w+)\s*\(/.exec(trimmed);
+    if (!match) {
+        errors.push({
+            line: baseLine,
+            column: 0,
+            message: `Expected field builder for "${fieldName}"`,
+        });
+        return null;
+    }
+    const fieldType = match[1];
+    if (!FIELD_TYPE_SET.has(fieldType)) {
+        errors.push({
+            line: baseLine,
+            column: 0,
+            message: `Unknown field type "${fieldType}" for field "${fieldName}"`,
+        });
+        return null;
+    }
+    const argsBlock = extractBalancedFrom(trimmed, match[0].length - 1, "(", ")");
+    const rawArgs = argsBlock?.inner.trim() ?? "";
+    if (fieldType === "object") {
+        const options = parseFieldOptionsObject(rawArgs);
+        const nestedFieldsEntry = findObjectEntry(options, "fields");
+        if (!nestedFieldsEntry) {
+            warnings.push({
+                line: baseLine,
+                message: `Object field "${fieldName}" is missing nested fields`,
+            });
+        }
+        return {
+            type: "object",
+            required: parseBooleanValue(findObjectEntry(options, "required")?.value) ?? false,
+            label: parseStringValue(findObjectEntry(options, "label")?.value),
+            description: parseStringValue(findObjectEntry(options, "description")?.value),
+            fields: nestedFieldsEntry
+                ? parseFieldEntries(unwrapObjectLiteral(nestedFieldsEntry.value), baseLine, errors, warnings, references)
+                : [],
+        };
+    }
+    if (fieldType === "array") {
+        const options = parseFieldOptionsObject(rawArgs);
+        const ofEntry = findObjectEntry(options, "of");
+        const of = ofEntry
+            ? parseFieldExpression(ofEntry.value, baseLine, `${fieldName}[]`, errors, warnings, references)
+            : null;
+        if (!of) {
             errors.push({
                 line: baseLine,
                 column: 0,
-                message: `Unknown field type "${fieldType}" for field "${fieldName}"`,
+                message: `Array field "${fieldName}" is missing a valid "of" definition`,
             });
-            continue;
+            return null;
+        }
+        return {
+            type: "array",
+            required: parseBooleanValue(findObjectEntry(options, "required")?.value) ?? false,
+            label: parseStringValue(findObjectEntry(options, "label")?.value),
+            description: parseStringValue(findObjectEntry(options, "description")?.value),
+            of,
+            minItems: parseNumberValue(findObjectEntry(options, "minItems")?.value),
+            maxItems: parseNumberValue(findObjectEntry(options, "maxItems")?.value),
+        };
+    }
+    if (fieldType === "fragment") {
+        const args = splitTopLevel(rawArgs);
+        const fragmentToken = args[0]?.trim() ?? "";
+        const fragment = parseStringValue(fragmentToken) ??
+            references.get(fragmentToken)?.slug ??
+            fragmentToken.replace(/[^\w-]/g, "");
+        if (!fragment) {
+            errors.push({
+                line: baseLine,
+                column: 0,
+                message: `Fragment field "${fieldName}" is missing a fragment reference`,
+            });
+            return null;
         }
-        // Extract the arguments to field.type(...)
-        // Find matching closing paren
-        const argsResult = extractBalancedFrom(body, argsStart - 1, "(", ")");
-        const argsBody = argsResult ? argsResult.inner : "";
-        const fieldDef = {
-            name: fieldName,
-            type: fieldType,
-            required: false,
+        const options = args.length > 1 ? parseFieldOptionsObject(args.slice(1).join(",")) : [];
+        return {
+            type: "fragment",
+            required: parseBooleanValue(findObjectEntry(options, "required")?.value) ?? false,
+            label: parseStringValue(findObjectEntry(options, "label")?.value),
+            description: parseStringValue(findObjectEntry(options, "description")?.value),
+            fragment,
         };
-        // Parse options from args body
-        if (argsBody.trim()) {
-            // Look for required
-            const requiredMatch = /required\s*:\s*(true|false)/.exec(argsBody);
-            if (requiredMatch) {
-                fieldDef.required = requiredMatch[1] === "true";
+    }
+    const options = rawArgs ? parseFieldOptionsObject(rawArgs) : [];
+    const label = parseStringValue(findObjectEntry(options, "label")?.value);
+    const description = parseStringValue(findObjectEntry(options, "description")?.value);
+    const required = parseBooleanValue(findObjectEntry(options, "required")?.value) ?? false;
+    if (fieldType === "select") {
+        const choices = parseChoicesArray(findObjectEntry(options, "choices")?.value);
+        return {
+            type: "select",
+            required,
+            ...(label ? { label } : {}),
+            ...(description ? { description } : {}),
+            ...(choices ? { options: { choices } } : {}),
+        };
+    }
+    return {
+        type: fieldType,
+        required,
+        ...(label ? { label } : {}),
+        ...(description ? { description } : {}),
+    };
+}
+function parseFieldOptionsObject(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return [];
+    }
+    if (!trimmed.startsWith("{")) {
+        return [];
+    }
+    return parseObjectEntries(unwrapObjectLiteral(trimmed));
+}
+function parseChoicesArray(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("[")) {
+        return undefined;
+    }
+    const items = splitTopLevel(unwrapArrayLiteral(trimmed));
+    const choices = [];
+    for (const item of items) {
+        const entries = parseObjectEntries(unwrapObjectLiteral(item));
+        const label = parseStringValue(findObjectEntry(entries, "label")?.value);
+        const choiceValue = parseStringValue(findObjectEntry(entries, "value")?.value);
+        if (label !== undefined && choiceValue !== undefined) {
+            choices.push({ label, value: choiceValue });
+        }
+    }
+    return choices;
+}
+function parseObjectEntries(body) {
+    const entries = splitTopLevel(body);
+    const result = [];
+    for (const entry of entries) {
+        const separatorIndex = findTopLevelColon(entry);
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const rawKey = entry.slice(0, separatorIndex).trim();
+        const rawValue = entry.slice(separatorIndex + 1).trim();
+        if (!rawKey || !rawValue) {
+            continue;
+        }
+        result.push({
+            key: parseObjectKey(rawKey),
+            value: rawValue,
+        });
+    }
+    return result;
+}
+function findObjectEntry(entries, key) {
+    return entries.find((entry) => entry.key === key);
+}
+function parseObjectKey(rawKey) {
+    return parseStringValue(rawKey) ?? rawKey;
+}
+function splitTopLevel(source) {
+    const parts = [];
+    let current = "";
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let inString = null;
+    let escaped = false;
+    for (const char of source) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (inString) {
+            current += char;
+            if (char === "\\") {
+                escaped = true;
             }
-            // Look for description
-            const descMatch = /description\s*:\s*/.exec(argsBody);
-            if (descMatch) {
-                const descStart = descMatch.index + descMatch[0].length;
-                const descStr = parseStringLiteral(argsBody, skipWhitespace(argsBody, descStart));
-                if (descStr) {
-                    fieldDef.description = descStr.value;
-                }
+            else if (char === inString) {
+                inString = null;
             }
-            // Look for choices (select type)
-            if (fieldType === "select") {
-                const choices = parseChoicesArray(argsBody);
-                if (choices.length > 0) {
-                    fieldDef.options = { choices };
-                }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            inString = char;
+            current += char;
+            continue;
+        }
+        if (char === "(")
+            parenDepth++;
+        if (char === ")")
+            parenDepth--;
+        if (char === "{")
+            braceDepth++;
+        if (char === "}")
+            braceDepth--;
+        if (char === "[")
+            bracketDepth++;
+        if (char === "]")
+            bracketDepth--;
+        if (char === "," &&
+            parenDepth === 0 &&
+            braceDepth === 0 &&
+            bracketDepth === 0) {
+            if (current.trim()) {
+                parts.push(current.trim());
             }
+            current = "";
+            continue;
         }
-        fields.push(fieldDef);
+        current += char;
     }
-    return fields;
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
 }
-/**
- * Parse a choices array from text like:
- * choices: [{ label: "Foo", value: "foo" }, ...]
- */
-function parseChoicesArray(text) {
-    const choices = [];
-    const choicesMatch = /choices\s*:\s*\[/.exec(text);
-    if (!choicesMatch)
-        return choices;
-    const arrayStart = text.indexOf("[", choicesMatch.index);
-    const arrayBlock = extractBalanced(text, arrayStart, "[", "]");
-    if (!arrayBlock)
-        return choices;
-    // Find each { ... } in the array
-    const objPattern = /\{/g;
-    let objMatch;
-    while ((objMatch = objPattern.exec(arrayBlock.inner)) !== null) {
-        const objBlock = extractBalanced(arrayBlock.inner, objMatch.index, "{", "}");
-        if (!objBlock)
+function findTopLevelColon(source) {
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let inString = null;
+    let escaped = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (inString) {
+            if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === inString) {
+                inString = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            inString = char;
             continue;
-        const label = extractPropertyString(objBlock.inner, "label");
-        const value = extractPropertyString(objBlock.inner, "value");
-        if (label && value) {
-            choices.push({ label, value });
+        }
+        if (char === "(")
+            parenDepth++;
+        if (char === ")")
+            parenDepth--;
+        if (char === "{")
+            braceDepth++;
+        if (char === "}")
+            braceDepth--;
+        if (char === "[")
+            bracketDepth++;
+        if (char === "]")
+            bracketDepth--;
+        if (char === ":" &&
+            parenDepth === 0 &&
+            braceDepth === 0 &&
+            bracketDepth === 0) {
+            return index;
         }
     }
-    return choices;
+    return -1;
+}
+function parseStringValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    return parseStringLiteral(value.trim(), 0)?.value;
+}
+function parseBooleanValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    return undefined;
+}
+function parseNumberValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value.trim());
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function unwrapObjectLiteral(value) {
+    const trimmed = value.trim();
+    const block = extractBalanced(trimmed, 0, "{", "}");
+    return block?.inner ?? "";
+}
+function unwrapArrayLiteral(value) {
+    const trimmed = value.trim();
+    const block = extractBalanced(trimmed, 0, "[", "]");
+    return block?.inner ?? "";
+}
+function stripComments(source) {
+    let result = "";
+    let index = 0;
+    let inString = null;
+    let escaped = false;
+    while (index < source.length) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (escaped) {
+            result += char;
+            escaped = false;
+            index += 1;
+            continue;
+        }
+        if (inString) {
+            if (char === "\\") {
+                escaped = true;
+                result += char;
+                index += 1;
+                continue;
+            }
+            if (char === inString) {
+                inString = null;
+            }
+            result += char;
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            inString = char;
+            result += char;
+            index += 1;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            while (index < source.length && source[index] !== "\n") {
+                result += " ";
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            index += 2;
+            while (index < source.length) {
+                if (source[index] === "*" && source[index + 1] === "/") {
+                    index += 2;
+                    break;
+                }
+                result += source[index] === "\n" ? "\n" : " ";
+                index += 1;
+            }
+            continue;
+        }
+        result += char;
+        index += 1;
+    }
+    return result;
+}
+function lineAt(source, index) {
+    let line = 1;
+    for (let i = 0; i < index && i < source.length; i += 1) {
+        if (source[i] === "\n") {
+            line += 1;
+        }
+    }
+    return line;
+}
+function columnAt(source, index) {
+    let column = 1;
+    for (let i = index - 1; i >= 0; i -= 1) {
+        if (source[i] === "\n") {
+            break;
+        }
+        column += 1;
+    }
+    return column;
 }
-// === Utility functions ===
 function skipWhitespace(source, index) {
-    while (index < source.length && /\s/.test(source[index])) {
-        index++;
+    let current = index;
+    while (current < source.length && /\s/.test(source[current])) {
+        current += 1;
     }
-    return index;
+    return current;
 }
-/**
- * Parse a string literal (single-quoted, double-quoted, or backtick) at position i.
- */
-function parseStringLiteral(source, i) {
-    if (i >= source.length)
+function parseStringLiteral(source, startIdx) {
+    if (startIdx >= source.length) {
         return null;
-    const quote = source[i];
-    if (quote !== '"' && quote !== "'" && quote !== "`")
+    }
+    const quote = source[startIdx];
+    if (quote !== '"' && quote !== "'" && quote !== "`") {
         return null;
+    }
     let value = "";
-    let j = i + 1;
+    let index = startIdx + 1;
     let escaped = false;
-    while (j < source.length) {
-        const ch = source[j];
+    while (index < source.length) {
+        const char = source[index];
         if (escaped) {
-            switch (ch) {
+            switch (char) {
                 case "n":
                     value += "\n";
                     break;
@@ -332,88 +578,70 @@ function parseStringLiteral(source, i) {
                     value += "\\";
                     break;
                 default:
-                    value += ch;
+                    value += char;
                     break;
             }
             escaped = false;
-            j++;
+            index += 1;
             continue;
         }
-        if (ch === "\\") {
+        if (char === "\\") {
             escaped = true;
-            j++;
+            index += 1;
             continue;
         }
-        if (ch === quote) {
-            return { value, end: j + 1 };
+        if (char === quote) {
+            return { value, end: index + 1 };
         }
-        value += ch;
-        j++;
+        value += char;
+        index += 1;
     }
-    return null; // unterminated string
+    return null;
 }
-/**
- * Extract balanced delimiters starting at position i (which must be the opening delimiter).
- */
-function extractBalanced(source, i, open, close) {
-    if (source[i] !== open)
+function extractBalanced(source, startIdx, open, close) {
+    if (source[startIdx] !== open) {
         return null;
-    return extractBalancedFrom(source, i, open, close);
+    }
+    return extractBalancedFrom(source, startIdx, open, close);
 }
-function extractBalancedFrom(source, i, open, close) {
+function extractBalancedFrom(source, openIdx, open, close) {
     let depth = 0;
     let inString = null;
     let escaped = false;
-    const start = i + 1;
-    while (i < source.length) {
-        const ch = source[i];
+    const contentStart = openIdx + 1;
+    for (let index = openIdx; index < source.length; index += 1) {
+        const char = source[index];
         if (escaped) {
             escaped = false;
-            i++;
             continue;
         }
         if (inString) {
-            if (ch === "\\") {
+            if (char === "\\") {
                 escaped = true;
-                i++;
-                continue;
             }
-            if (ch === inString) {
+            else if (char === inString) {
                 inString = null;
             }
-            i++;
             continue;
         }
-        if (ch === '"' || ch === "'" || ch === "`") {
-            inString = ch;
-            i++;
+        if (char === '"' || char === "'" || char === "`") {
+            inString = char;
             continue;
         }
-        if (ch === open) {
-            depth++;
+        if (char === open) {
+            depth += 1;
+            continue;
         }
-        else if (ch === close) {
-            depth--;
+        if (char === close) {
+            depth -= 1;
             if (depth === 0) {
-                return { inner: source.slice(start, i), end: i + 1 };
+                return {
+                    inner: source.slice(contentStart, index),
+                    end: index + 1,
+                };
             }
         }
-        i++;
     }
     return null;
 }
-/**
- * Extract a string property value from an object literal body.
- * Matches: propName: "value" or propName: 'value'
- */
-function extractPropertyString(body, propName) {
-    const pattern = new RegExp(`(?<![\\w])${propName}\\s*:\\s*`);
-    const match = pattern.exec(body);
-    if (!match)
-        return null;
-    const valueStart = match.index + match[0].length;
-    const i = skipWhitespace(body, valueStart);
-    const result = parseStringLiteral(body, i);
-    return result ? result.value : null;
-}
 //# sourceMappingURL=parse-schema.js.map