@mcp-native/a2ui 0.1.0 → 0.3.0

package/dist/v1/capabilities.js

@@ -0,0 +1,134 @@
+import { parseJsonObject } from "@mcp-native/core";
+import { A2uiParseError } from "../errors.js";
+import { formatAjvErrors, getA2uiV1AgentCapabilitiesValidator, getA2uiV1RendererCapabilitiesValidator, } from "./schemas.js";
+import { A2UI_V1_MAX_SOURCE_LENGTH } from "./types.js";
+const VERSION_KEY = "v1.0";
+/** Parses untrusted agent capability metadata and applies the normative v1 requirements. */
+export function parseA2uiV1AgentCapabilities(input) {
+    const source = reconstructCapabilities(input, "agent capabilities");
+    const version = expectClosedVersionObject(source, [
+        "acceptsInlineCatalogs",
+        "supportedCatalogIds",
+    ]);
+    const validate = getA2uiV1AgentCapabilitiesValidator();
+    if (!validate(source)) {
+        throw new A2uiParseError(`A2UI v1 agent capability schema validation failed: ${formatAjvErrors(validate)}`);
+    }
+    if (!Object.hasOwn(version, "supportedCatalogIds")) {
+        throw new A2uiParseError("A2UI v1 agent capabilities must declare supportedCatalogIds as required by the protocol");
+    }
+    return freezeAgentCapabilities(parseCatalogIds(version.supportedCatalogIds, "agent capabilities.v1.0.supportedCatalogIds"), version.acceptsInlineCatalogs === true);
+}
+/**
+ * Parses renderer capability metadata without activating inline catalogs.
+ * Catalog IDs are declarations only; callers must advertise only fully implemented host catalogs.
+ */
+export function parseA2uiV1RendererCapabilities(input) {
+    const source = reconstructCapabilities(input, "renderer capabilities");
+    const version = expectClosedVersionObject(source, ["inlineCatalogs", "supportedCatalogIds"]);
+    if (Object.hasOwn(version, "inlineCatalogs")) {
+        throw new A2uiParseError("A2UI v1 inline renderer catalogs are not supported without an explicit host catalog policy");
+    }
+    const validate = getA2uiV1RendererCapabilitiesValidator();
+    if (!validate(source)) {
+        throw new A2uiParseError(`A2UI v1 renderer capability schema validation failed: ${formatAjvErrors(validate)}`);
+    }
+    return freezeRendererCapabilities(parseCatalogIds(version.supportedCatalogIds, "renderer capabilities.v1.0.supportedCatalogIds"));
+}
+/** Constructs closed renderer metadata from host-owned catalog declarations. */
+export function createA2uiV1RendererCapabilities(options) {
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new A2uiParseError("Expected A2UI v1 renderer capability options to be an object");
+    }
+    const source = options;
+    rejectUnknownKeys(source, ["supportedCatalogIds"], "renderer capability options");
+    return parseA2uiV1RendererCapabilities({
+        [VERSION_KEY]: { supportedCatalogIds: source.supportedCatalogIds },
+    });
+}
+/** Finds exact catalog IDs that both peers explicitly declare. */
+export function negotiateA2uiV1Capabilities(agentInput, rendererInput) {
+    const agent = parseA2uiV1AgentCapabilities(agentInput);
+    const renderer = parseA2uiV1RendererCapabilities(rendererInput);
+    const agentCatalogIds = new Set(agent[VERSION_KEY].supportedCatalogIds);
+    const supportedCatalogIds = renderer[VERSION_KEY].supportedCatalogIds.filter((catalogId) => agentCatalogIds.has(catalogId));
+    if (supportedCatalogIds.length === 0) {
+        return Object.freeze({
+            kind: "fallback",
+            protocolVersion: VERSION_KEY,
+            reason: "no-shared-catalog",
+        });
+    }
+    return Object.freeze({
+        kind: "negotiated",
+        protocolVersion: VERSION_KEY,
+        supportedCatalogIds: Object.freeze(supportedCatalogIds),
+        inlineCatalogsEnabled: false,
+    });
+}
+function reconstructCapabilities(input, path) {
+    let value = input;
+    if (typeof input === "string") {
+        if (input.length > A2UI_V1_MAX_SOURCE_LENGTH) {
+            throw new A2uiParseError(`A2UI v1 ${path} exceed maximum length of ${A2UI_V1_MAX_SOURCE_LENGTH}`);
+        }
+        try {
+            value = JSON.parse(input);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "unknown JSON error";
+            throw new A2uiParseError(`Invalid A2UI v1 ${path} JSON: ${message}`, { cause: error });
+        }
+    }
+    try {
+        return parseJsonObject(value, path);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : `Invalid A2UI v1 ${path}`;
+        throw new A2uiParseError(message, { cause: error });
+    }
+}
+function expectClosedVersionObject(source, allowedVersionKeys) {
+    rejectUnknownKeys(source, [VERSION_KEY], "capabilities");
+    const version = source[VERSION_KEY];
+    if (version === null || typeof version !== "object" || Array.isArray(version)) {
+        throw new A2uiParseError(`Expected an object at capabilities.${VERSION_KEY}`);
+    }
+    rejectUnknownKeys(version, allowedVersionKeys, `capabilities.${VERSION_KEY}`);
+    return version;
+}
+function parseCatalogIds(value, path) {
+    if (!Array.isArray(value)) {
+        throw new A2uiParseError(`Expected an array at ${path}`);
+    }
+    const ids = new Set();
+    for (const [index, catalogId] of value.entries()) {
+        if (typeof catalogId !== "string" || catalogId.length === 0) {
+            throw new A2uiParseError(`Expected a non-empty string at ${path}[${index}]`);
+        }
+        if (ids.has(catalogId)) {
+            throw new A2uiParseError(`Duplicate A2UI catalog ID ${JSON.stringify(catalogId)} at ${path}`);
+        }
+        ids.add(catalogId);
+    }
+    return Object.freeze([...ids]);
+}
+function freezeAgentCapabilities(supportedCatalogIds, acceptsInlineCatalogs) {
+    return Object.freeze({
+        [VERSION_KEY]: Object.freeze({ supportedCatalogIds, acceptsInlineCatalogs }),
+    });
+}
+function freezeRendererCapabilities(supportedCatalogIds) {
+    return Object.freeze({
+        [VERSION_KEY]: Object.freeze({ supportedCatalogIds }),
+    });
+}
+function rejectUnknownKeys(value, allowed, path) {
+    const allowedKeys = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!allowedKeys.has(key)) {
+            throw new A2uiParseError(`Unexpected field ${JSON.stringify(key)} at ${path}`);
+        }
+    }
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/v1/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../src/v1/capabilities.ts"],"names":[],"mappings":"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"}

package/dist/v1/format-string.d.ts

@@ -0,0 +1,21 @@
+import type { JsonValue } from "@mcp-native/core";
+export interface A2uiV1ParsedFormatString {
+    readonly expressionCount: number;
+    readonly expressions: readonly JsonValue[];
+    readonly parts: readonly A2uiV1FormatStringPart[];
+}
+type A2uiV1FormatStringPart = {
+    readonly kind: "expression";
+    readonly value: JsonValue;
+} | {
+    readonly kind: "literal";
+    readonly value: string;
+};
+export type A2uiV1FormatStringExpressionResolver = (expression: JsonValue, index: number) => JsonValue | undefined;
+export type A2uiV1FormatStringExpressionBudgetConsumer = (expressionCount: number) => void;
+/** Parses the expression language embedded in one pinned-catalog formatString value. */
+export declare function parseA2uiV1FormatString(source: string, path: string): A2uiV1ParsedFormatString;
+/** Evaluates one parsed formatString source with a host-owned expression resolver. */
+export declare function evaluateA2uiV1FormatString(source: string, resolveExpression: A2uiV1FormatStringExpressionResolver, path?: string, consumeExpressionBudget?: A2uiV1FormatStringExpressionBudgetConsumer): string;
+export {};
+//# sourceMappingURL=format-string.d.ts.map

package/dist/v1/format-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-string.d.ts","sourceRoot":"","sources":["../../src/v1/format-string.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI9D,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,SAAS,EAAE,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACnD;AAED,KAAK,sBAAsB,GACvB;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,MAAM,MAAM,oCAAoC,GAAG,CACjD,UAAU,EAAE,SAAS,EACrB,KAAK,EAAE,MAAM,KACV,SAAS,GAAG,SAAS,CAAC;AAE3B,MAAM,MAAM,0CAA0C,GAAG,CAAC,eAAe,EAAE,MAAM,KAAK,IAAI,CAAC;AAW3F,wFAAwF;AACxF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,wBAAwB,CAG9F;AAED,sFAAsF;AACtF,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,oCAAoC,EACvD,IAAI,SAAiB,EACrB,uBAAuB,CAAC,EAAE,0CAA0C,GACnE,MAAM,CAwCR"}

package/dist/v1/format-string.js

@@ -0,0 +1,487 @@
+import { JSON_MAX_DEPTH, JSON_MAX_STRING_LENGTH, JSON_MAX_VALUES, parseJsonValue, } from "@mcp-native/core";
+import { A2uiParseError } from "../errors.js";
+const IDENTIFIER = /^[\p{XID_Start}_][\p{XID_Continue}]*$/u;
+const JSON_NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/;
+/** Parses the expression language embedded in one pinned-catalog formatString value. */
+export function parseA2uiV1FormatString(source, path) {
+    const parser = new FormatStringParser(path);
+    return parser.parse(source);
+}
+/** Evaluates one parsed formatString source with a host-owned expression resolver. */
+export function evaluateA2uiV1FormatString(source, resolveExpression, path = "formatString", consumeExpressionBudget) {
+    if (typeof source !== "string") {
+        throw new A2uiParseError(`Expected a string at ${path}`);
+    }
+    if (source.length > JSON_MAX_STRING_LENGTH) {
+        throw new A2uiParseError(`A2UI formatString source at ${path} exceeds maximum length of ${JSON_MAX_STRING_LENGTH}`);
+    }
+    if (typeof resolveExpression !== "function") {
+        throw new A2uiParseError(`Expected an A2UI formatString expression resolver at ${path}`);
+    }
+    if (typeof path !== "string" || path.length === 0) {
+        throw new A2uiParseError("Expected a non-empty A2UI formatString diagnostic path");
+    }
+    if (consumeExpressionBudget !== undefined && typeof consumeExpressionBudget !== "function") {
+        throw new A2uiParseError(`Expected an A2UI formatString budget consumer at ${path}`);
+    }
+    const parsed = parseA2uiV1FormatString(source, path);
+    consumeExpressionBudget?.(parsed.expressionCount);
+    const chunks = [];
+    let outputLength = 0;
+    let expressionIndex = 0;
+    for (const part of parsed.parts) {
+        const chunk = part.kind === "literal"
+            ? part.value
+            : coerceFormatStringValue(resolveExpression(part.value, expressionIndex++), `${path}.interpolations[${expressionIndex - 1}]`, JSON_MAX_STRING_LENGTH - outputLength);
+        outputLength += chunk.length;
+        if (outputLength > JSON_MAX_STRING_LENGTH) {
+            throwFormatStringOutputLimit(path);
+        }
+        chunks.push(chunk);
+    }
+    return chunks.join("");
+}
+class FormatStringParser {
+    #path;
+    #expressionCount = 0;
+    constructor(path) {
+        this.#path = path;
+    }
+    parse(source) {
+        const expressions = [];
+        const parts = [];
+        let literalStart = 0;
+        for (let index = 0; index < source.length; index += 1) {
+            if (source[index] !== "$" || source[index + 1] !== "{" || isEscaped(source, index)) {
+                continue;
+            }
+            const interpolation = this.#readInterpolation(source, index);
+            appendLiteralPart(parts, source.slice(literalStart, index));
+            const expression = this.#parseExpression(interpolation.content, interpolation.offset, 1);
+            expressions.push(expression);
+            parts.push({ kind: "expression", value: expression });
+            index = interpolation.end - 1;
+            literalStart = interpolation.end;
+        }
+        appendLiteralPart(parts, source.slice(literalStart));
+        return {
+            expressionCount: this.#expressionCount,
+            expressions,
+            parts,
+        };
+    }
+    #parseExpression(source, offset, depth) {
+        this.#expressionCount += 1;
+        if (this.#expressionCount > JSON_MAX_VALUES) {
+            this.#fail(`exceeds maximum of ${JSON_MAX_VALUES} interpolation expressions`, offset);
+        }
+        if (depth > JSON_MAX_DEPTH) {
+            this.#fail(`exceeds maximum expression depth of ${JSON_MAX_DEPTH}`, offset);
+        }
+        const expression = source.trim();
+        if (expression.length === 0) {
+            this.#fail("contains an empty interpolation expression", offset);
+        }
+        if (expression.startsWith("${")) {
+            const interpolation = this.#readInterpolation(expression, 0);
+            if (expression.slice(interpolation.end).trim().length !== 0) {
+                this.#fail("contains trailing content after a nested expression", offset);
+            }
+            return this.#parseExpression(interpolation.content, offset + interpolation.offset, depth + 1);
+        }
+        if (expression[0] === '"' || expression[0] === "'") {
+            return parseQuotedLiteral(expression, this.#path, offset);
+        }
+        if (expression === "true") {
+            return true;
+        }
+        if (expression === "false") {
+            return false;
+        }
+        if (expression === "null") {
+            return null;
+        }
+        if (JSON_NUMBER.test(expression)) {
+            const value = Number(expression);
+            if (!Number.isFinite(value)) {
+                this.#fail("contains a non-finite numeric literal", offset);
+            }
+            return value;
+        }
+        const openParenthesis = findFirstParenthesis(expression);
+        if (openParenthesis === -1) {
+            return { path: expression };
+        }
+        const functionName = expression.slice(0, openParenthesis).trim();
+        if (!isFunctionIdentifier(functionName)) {
+            return { path: expression };
+        }
+        const closeParenthesis = findClosingParenthesis(expression, openParenthesis, this.#path);
+        if (expression.slice(closeParenthesis + 1).trim().length !== 0) {
+            this.#fail("contains trailing content after a function call", offset);
+        }
+        const args = this.#parseArguments(expression.slice(openParenthesis + 1, closeParenthesis), offset + openParenthesis + 1, depth);
+        return {
+            call: functionName,
+            ...(Object.keys(args).length === 0 ? {} : { args }),
+        };
+    }
+    #parseArguments(source, offset, depth) {
+        const args = {};
+        if (source.trim().length === 0) {
+            return args;
+        }
+        for (const segment of splitTopLevel(source, ",", this.#path)) {
+            const separator = findTopLevelCharacter(segment.value, ":", this.#path);
+            if (separator === -1) {
+                this.#fail("requires every function argument to be named", offset + segment.offset);
+            }
+            const name = segment.value.slice(0, separator).trim();
+            if (!IDENTIFIER.test(name)) {
+                this.#fail(`contains invalid argument name ${JSON.stringify(name)}`, offset + segment.offset);
+            }
+            if (Object.hasOwn(args, name)) {
+                this.#fail(`contains duplicate argument ${JSON.stringify(name)}`, offset + segment.offset);
+            }
+            const valueSource = segment.value.slice(separator + 1).trim();
+            if (valueSource.length === 0) {
+                this.#fail(`contains an empty value for argument ${JSON.stringify(name)}`, offset + segment.offset);
+            }
+            defineJsonProperty(args, name, this.#parseArgumentValue(valueSource, offset + segment.offset + separator + 1, depth + 1));
+        }
+        return args;
+    }
+    #parseArgumentValue(source, offset, depth) {
+        if (source.startsWith("${")) {
+            const interpolation = this.#readInterpolation(source, 0);
+            if (source.slice(interpolation.end).trim().length !== 0) {
+                this.#fail("contains trailing content after a nested expression", offset);
+            }
+            return this.#parseExpression(interpolation.content, offset + interpolation.offset, depth);
+        }
+        if (source[0] === '"' || source[0] === "'") {
+            return parseQuotedLiteral(source, this.#path, offset);
+        }
+        if (source === "true") {
+            return true;
+        }
+        if (source === "false") {
+            return false;
+        }
+        if (JSON_NUMBER.test(source)) {
+            const value = Number(source);
+            if (!Number.isFinite(value)) {
+                this.#fail("contains a non-finite numeric literal", offset);
+            }
+            return value;
+        }
+        this.#fail(`contains unsupported argument literal ${JSON.stringify(source)}`, offset);
+    }
+    #readInterpolation(source, start) {
+        let nesting = 1;
+        let quote;
+        let escaped = false;
+        for (let index = start + 2; index < source.length; index += 1) {
+            const character = source[index];
+            if (quote !== undefined) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (character === "\\") {
+                    escaped = true;
+                }
+                else if (character === quote) {
+                    quote = undefined;
+                }
+                continue;
+            }
+            if (character === '"' || character === "'") {
+                quote = character;
+                continue;
+            }
+            if (character === "$" && source[index + 1] === "{" && !isEscaped(source, index)) {
+                nesting += 1;
+                index += 1;
+                continue;
+            }
+            if (character === "}") {
+                nesting -= 1;
+                if (nesting === 0) {
+                    return {
+                        content: source.slice(start + 2, index),
+                        end: index + 1,
+                        offset: start + 2,
+                    };
+                }
+            }
+        }
+        this.#fail("contains an unterminated interpolation expression", start);
+    }
+    #fail(message, offset) {
+        throw new A2uiParseError(`A2UI formatString at ${this.#path} ${message} near offset ${offset}`);
+    }
+}
+function appendLiteralPart(parts, source) {
+    if (source.length === 0) {
+        return;
+    }
+    parts.push({ kind: "literal", value: source.replaceAll("\\${", "${") });
+}
+function coerceFormatStringValue(value, path, remainingLength) {
+    if (value === undefined || value === null) {
+        return "";
+    }
+    const reconstructed = parseJsonValue(value, path);
+    if (typeof reconstructed === "string") {
+        return reconstructed;
+    }
+    if (typeof reconstructed === "number" || typeof reconstructed === "boolean") {
+        return String(reconstructed);
+    }
+    measureJsonSerialization(reconstructed, remainingLength, path);
+    const serialized = JSON.stringify(reconstructed);
+    if (serialized === undefined) {
+        throw new A2uiParseError(`Expected a JSON value at ${path}`);
+    }
+    return serialized;
+}
+function measureJsonSerialization(value, limit, path) {
+    let length;
+    if (value === null) {
+        length = 4;
+    }
+    else if (typeof value === "boolean") {
+        length = value ? 4 : 5;
+    }
+    else if (typeof value === "number") {
+        length = String(value).length;
+    }
+    else if (typeof value === "string") {
+        length = JSON.stringify(value).length;
+    }
+    else if (Array.isArray(value)) {
+        length = 2;
+        for (const [index, child] of value.entries()) {
+            length += index === 0 ? 0 : 1;
+            length += measureJsonSerialization(child, limit - length, `${path}[${index}]`);
+            if (length > limit) {
+                throwFormatStringOutputLimit(path);
+            }
+        }
+    }
+    else {
+        length = 2;
+        let index = 0;
+        for (const [key, child] of Object.entries(value)) {
+            length += index++ === 0 ? 0 : 1;
+            length += JSON.stringify(key).length + 1;
+            length += measureJsonSerialization(child, limit - length, `${path}.${key}`);
+            if (length > limit) {
+                throwFormatStringOutputLimit(path);
+            }
+        }
+    }
+    if (length > limit) {
+        throwFormatStringOutputLimit(path);
+    }
+    return length;
+}
+function throwFormatStringOutputLimit(path) {
+    throw new A2uiParseError(`A2UI formatString output at ${path} exceeds maximum length of ${JSON_MAX_STRING_LENGTH}`);
+}
+function findFirstParenthesis(source) {
+    for (let index = 0; index < source.length; index += 1) {
+        if (source[index] === "(") {
+            return index;
+        }
+    }
+    return -1;
+}
+function findClosingParenthesis(source, open, path) {
+    let depth = 1;
+    let quote;
+    let escaped = false;
+    for (let index = open + 1; index < source.length; index += 1) {
+        const character = source[index];
+        if (quote !== undefined) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+        }
+        else if (character === "(") {
+            depth += 1;
+        }
+        else if (character === ")") {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    throw new A2uiParseError(`A2UI formatString at ${path} contains an unclosed function call`);
+}
+function splitTopLevel(source, separator, path) {
+    const segments = [];
+    let start = 0;
+    walkTopLevel(source, path, (character, index, isTopLevel) => {
+        if (isTopLevel && character === separator) {
+            segments.push({ offset: start, value: source.slice(start, index) });
+            start = index + 1;
+        }
+    });
+    segments.push({ offset: start, value: source.slice(start) });
+    return segments;
+}
+function findTopLevelCharacter(source, target, path) {
+    let result = -1;
+    walkTopLevel(source, path, (character, index, isTopLevel) => {
+        if (result === -1 && isTopLevel && character === target) {
+            result = index;
+        }
+    });
+    return result;
+}
+function walkTopLevel(source, path, visit) {
+    let interpolationDepth = 0;
+    let parenthesisDepth = 0;
+    let quote;
+    let escaped = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        if (quote !== undefined) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === quote) {
+                quote = undefined;
+            }
+            visit(character, index, false);
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            visit(character, index, false);
+            continue;
+        }
+        if (character === "$" && source[index + 1] === "{") {
+            interpolationDepth += 1;
+            visit(character, index, false);
+            index += 1;
+            continue;
+        }
+        if (character === "}" && interpolationDepth > 0) {
+            interpolationDepth -= 1;
+            visit(character, index, false);
+            continue;
+        }
+        if (character === "(" && interpolationDepth === 0) {
+            parenthesisDepth += 1;
+        }
+        else if (character === ")" && interpolationDepth === 0) {
+            parenthesisDepth -= 1;
+            if (parenthesisDepth < 0) {
+                throw new A2uiParseError(`A2UI formatString at ${path} contains an unmatched ")"`);
+            }
+        }
+        visit(character, index, interpolationDepth === 0 && parenthesisDepth === 0);
+    }
+    if (quote !== undefined || interpolationDepth !== 0 || parenthesisDepth !== 0) {
+        throw new A2uiParseError(`A2UI formatString at ${path} contains unbalanced argument syntax`);
+    }
+}
+function parseQuotedLiteral(source, path, offset) {
+    const quote = source[0];
+    let result = "";
+    for (let index = 1; index < source.length; index += 1) {
+        const character = source[index];
+        if (character === quote) {
+            if (source.slice(index + 1).trim().length !== 0) {
+                throw new A2uiParseError(`A2UI formatString at ${path} contains trailing quoted-literal content near offset ${offset}`);
+            }
+            return result;
+        }
+        if (character.charCodeAt(0) < 0x20) {
+            throw new A2uiParseError(`A2UI formatString at ${path} contains a control character near offset ${offset + index}`);
+        }
+        if (character !== "\\") {
+            result += character;
+            continue;
+        }
+        const escaped = source[index + 1];
+        if (escaped === undefined) {
+            break;
+        }
+        index += 1;
+        switch (escaped) {
+            case "\\":
+            case "/":
+                result += escaped;
+                break;
+            case '"':
+                result += '"';
+                break;
+            case "'":
+                result += "'";
+                break;
+            case "b":
+                result += "\b";
+                break;
+            case "f":
+                result += "\f";
+                break;
+            case "n":
+                result += "\n";
+                break;
+            case "r":
+                result += "\r";
+                break;
+            case "t":
+                result += "\t";
+                break;
+            case "u": {
+                const digits = source.slice(index + 1, index + 5);
+                if (!/^[0-9a-fA-F]{4}$/.test(digits)) {
+                    throw new A2uiParseError(`A2UI formatString at ${path} contains an invalid Unicode escape near offset ${offset + index}`);
+                }
+                result += String.fromCharCode(Number.parseInt(digits, 16));
+                index += 4;
+                break;
+            }
+            default:
+                throw new A2uiParseError(`A2UI formatString at ${path} contains unsupported escape ${JSON.stringify(`\\${escaped}`)} near offset ${offset + index}`);
+        }
+    }
+    throw new A2uiParseError(`A2UI formatString at ${path} contains an unterminated quoted literal near offset ${offset}`);
+}
+function isFunctionIdentifier(value) {
+    return value === "@index" || IDENTIFIER.test(value);
+}
+function isEscaped(source, index) {
+    let backslashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1) {
+        backslashes += 1;
+    }
+    return backslashes % 2 === 1;
+}
+function defineJsonProperty(object, key, value) {
+    Object.defineProperty(object, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true,
+    });
+}
+//# sourceMappingURL=format-string.js.map