@jsprismarine/mcfunction 0.0.0-stage → 0.16.0-unstable-20261029132853

package/dist/macro.cjs.cjs

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/macro.ts
+var VARIABLE_PATTERN = /^[A-Za-z0-9_]+$/;
+/**
+* The most fraction digits a non-integer macro argument prints. Java formats
+* the value with a `DecimalFormat` under `Locale.ROOT`; Mojang does not state
+* the digit count, so this is a choice that keeps every double exactly
+* representable in decimal form rather than a confirmed vanilla number.
+*/
+var MAX_FRACTION_DIGITS = 17;
+/**
+* Compiles one macro line into a reusable template.
+*
+* `$` is literal unless it is followed by `(`, which is the only escape the
+* format has. A line marked as a macro but carrying no substitution is an
+* error, as is an unterminated `$(` or a name outside letters, digits and `_`.
+*/
+var compileMacroLine = (command) => {
+	const segments = [];
+	const variables = [];
+	let literal = "";
+	for (let index = 0; index < command.length; index += 1) {
+		if (command[index] !== "$" || command[index + 1] !== "(") {
+			literal += command[index];
+			continue;
+		}
+		const close = command.indexOf(")", index + 2);
+		if (close === -1) return {
+			ok: false,
+			message: "unterminated macro variable"
+		};
+		const variable = command.slice(index + 2, close);
+		if (!VARIABLE_PATTERN.test(variable)) return {
+			ok: false,
+			message: `invalid macro variable name '${variable}'`
+		};
+		if (literal.length > 0) {
+			segments.push({ text: literal });
+			literal = "";
+		}
+		segments.push({ variable });
+		if (!variables.includes(variable)) variables.push(variable);
+		index = close;
+	}
+	if (variables.length === 0) return {
+		ok: false,
+		message: "no variables in macro"
+	};
+	if (literal.length > 0) segments.push({ text: literal });
+	return {
+		ok: true,
+		template: {
+			segments,
+			variables
+		}
+	};
+};
+/**
+* Fills a compiled macro line from an argument compound.
+*
+* @returns The command to parse, or the reason the call cannot be instantiated.
+*/
+var substituteMacro = (template, args) => {
+	let command = "";
+	for (const segment of template.segments) {
+		if ("text" in segment) {
+			command += segment.text;
+			continue;
+		}
+		const value = args[segment.variable];
+		if (value === void 0 || value === null) return {
+			ok: false,
+			message: `the macro arguments have no entry for '${segment.variable}'`
+		};
+		command += renderMacroValue(value);
+	}
+	return {
+		ok: true,
+		command
+	};
+};
+/**
+* Renders one argument the way a substitution inserts it: a string goes in
+* raw, with no quoting and no escaping, so a value carrying quotes can produce
+* a command that no longer parses. Numbers lose the type suffix they would
+* carry in NBT, matching the 1.20.2 fix. A compound or list becomes SNBT,
+* where suffixes are back because the text is NBT again.
+*/
+var renderMacroValue = (value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return renderNumber(value);
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "boolean") return value ? "1" : "0";
+	return renderSnbt(value);
+};
+/** Prints a number in plain decimal, never in exponent form and never with a suffix. */
+var renderNumber = (value) => {
+	if (!Number.isFinite(value)) return String(value);
+	if (Number.isInteger(value) && Math.abs(value) < Number.MAX_SAFE_INTEGER) return value.toFixed(0);
+	const fixed = value.toFixed(MAX_FRACTION_DIGITS);
+	return fixed.includes(".") ? fixed.replace(/0+$/, "").replace(/\.$/, "") : fixed;
+};
+/** Renders a nested value as SNBT, the text form a command argument expects. */
+var renderSnbt = (value) => {
+	if (value === null || value === void 0) return "{}";
+	if (typeof value === "string") return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+	if (typeof value === "number") return renderNumber(value);
+	if (typeof value === "bigint") return `${value}L`;
+	if (typeof value === "boolean") return value ? "1b" : "0b";
+	if (Array.isArray(value)) return `[${value.map(renderSnbt).join(",")}]`;
+	if (typeof value === "object") return `{${Object.entries(value).map(([key, entry]) => `${key}:${renderSnbt(entry)}`).join(",")}}`;
+	return String(value);
+};
+exports.compileMacroLine = compileMacroLine;
+exports.renderMacroValue = renderMacroValue;
+exports.substituteMacro = substituteMacro;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"macro.cjs.cjs","names":[],"sources":["../src/macro.ts"],"sourcesContent":["/**\n * Macro lines and their `$(variable)` substitutions, as 1.20.2 defined them.\n * A macro line is compiled once into a template of literal text and variable\n * holes; a call fills the holes from a compound of arguments and the resulting\n * command is parsed fresh, which is the cost a macro adds over a plain line.\n */\n\n/** The compound a macro call substitutes from. Extra entries are ignored. */\nexport type MacroArguments = Readonly<Record<string, unknown>>;\n\n/** One piece of a compiled macro line: literal text, or a hole naming a variable. */\nexport type MacroSegment = { text: string } | { variable: string };\n\n/** A macro line compiled into the pieces a call concatenates. */\nexport interface MacroTemplate {\n    segments: readonly MacroSegment[];\n    /** Every variable the line substitutes, once each, in first-use order. */\n    variables: readonly string[];\n}\n\n/** The outcome of compiling a macro line. */\nexport type MacroTemplateResult = { ok: true; template: MacroTemplate } | { ok: false; message: string };\n\n/** The outcome of filling a template from an argument compound. */\nexport type MacroSubstitutionResult = { ok: true; command: string } | { ok: false; message: string };\n\nconst VARIABLE_PATTERN = /^[A-Za-z0-9_]+$/;\n\n/**\n * The most fraction digits a non-integer macro argument prints. Java formats\n * the value with a `DecimalFormat` under `Locale.ROOT`; Mojang does not state\n * the digit count, so this is a choice that keeps every double exactly\n * representable in decimal form rather than a confirmed vanilla number.\n */\nconst MAX_FRACTION_DIGITS = 17;\n\n/**\n * Compiles one macro line into a reusable template.\n *\n * `$` is literal unless it is followed by `(`, which is the only escape the\n * format has. A line marked as a macro but carrying no substitution is an\n * error, as is an unterminated `$(` or a name outside letters, digits and `_`.\n */\nexport const compileMacroLine = (command: string): MacroTemplateResult => {\n    const segments: MacroSegment[] = [];\n    const variables: string[] = [];\n    let literal = '';\n\n    for (let index = 0; index < command.length; index += 1) {\n        if (command[index] !== '$' || command[index + 1] !== '(') {\n            literal += command[index];\n            continue;\n        }\n\n        const close = command.indexOf(')', index + 2);\n        if (close === -1) return { ok: false, message: 'unterminated macro variable' };\n\n        const variable = command.slice(index + 2, close);\n        if (!VARIABLE_PATTERN.test(variable)) {\n            return { ok: false, message: `invalid macro variable name '${variable}'` };\n        }\n\n        if (literal.length > 0) {\n            segments.push({ text: literal });\n            literal = '';\n        }\n        segments.push({ variable });\n        if (!variables.includes(variable)) variables.push(variable);\n        index = close;\n    }\n\n    if (variables.length === 0) return { ok: false, message: 'no variables in macro' };\n    if (literal.length > 0) segments.push({ text: literal });\n\n    return { ok: true, template: { segments, variables } };\n};\n\n/**\n * Fills a compiled macro line from an argument compound.\n *\n * @returns The command to parse, or the reason the call cannot be instantiated.\n */\nexport const substituteMacro = (template: MacroTemplate, args: MacroArguments): MacroSubstitutionResult => {\n    let command = '';\n\n    for (const segment of template.segments) {\n        if ('text' in segment) {\n            command += segment.text;\n            continue;\n        }\n\n        const value = args[segment.variable];\n        if (value === undefined || value === null) {\n            return { ok: false, message: `the macro arguments have no entry for '${segment.variable}'` };\n        }\n        command += renderMacroValue(value);\n    }\n\n    return { ok: true, command };\n};\n\n/**\n * Renders one argument the way a substitution inserts it: a string goes in\n * raw, with no quoting and no escaping, so a value carrying quotes can produce\n * a command that no longer parses. Numbers lose the type suffix they would\n * carry in NBT, matching the 1.20.2 fix. A compound or list becomes SNBT,\n * where suffixes are back because the text is NBT again.\n */\nexport const renderMacroValue = (value: unknown): string => {\n    if (typeof value === 'string') return value;\n    if (typeof value === 'number') return renderNumber(value);\n    if (typeof value === 'bigint') return value.toString();\n    if (typeof value === 'boolean') return value ? '1' : '0';\n    return renderSnbt(value);\n};\n\n/** Prints a number in plain decimal, never in exponent form and never with a suffix. */\nconst renderNumber = (value: number): string => {\n    if (!Number.isFinite(value)) return String(value);\n    if (Number.isInteger(value) && Math.abs(value) < Number.MAX_SAFE_INTEGER) return value.toFixed(0);\n\n    const fixed = value.toFixed(MAX_FRACTION_DIGITS);\n    return fixed.includes('.') ? fixed.replace(/0+$/, '').replace(/\\.$/, '') : fixed;\n};\n\n/** Renders a nested value as SNBT, the text form a command argument expects. */\nconst renderSnbt = (value: unknown): string => {\n    if (value === null || value === undefined) return '{}';\n    if (typeof value === 'string') return `\"${value.replaceAll('\\\\', '\\\\\\\\').replaceAll('\"', '\\\\\"')}\"`;\n    if (typeof value === 'number') return renderNumber(value);\n    if (typeof value === 'bigint') return `${value}L`;\n    if (typeof value === 'boolean') return value ? '1b' : '0b';\n    if (Array.isArray(value)) return `[${value.map(renderSnbt).join(',')}]`;\n    if (typeof value === 'object') {\n        const entries = Object.entries(value).map(([key, entry]) => `${key}:${renderSnbt(entry)}`);\n        return `{${entries.join(',')}}`;\n    }\n    return String(value);\n};\n"],"mappings":"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"}

package/dist/macro.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Macro lines and their `$(variable)` substitutions, as 1.20.2 defined them.
+ * A macro line is compiled once into a template of literal text and variable
+ * holes; a call fills the holes from a compound of arguments and the resulting
+ * command is parsed fresh, which is the cost a macro adds over a plain line.
+ */
+/** The compound a macro call substitutes from. Extra entries are ignored. */
+export type MacroArguments = Readonly<Record<string, unknown>>;
+/** One piece of a compiled macro line: literal text, or a hole naming a variable. */
+export type MacroSegment = {
+    text: string;
+} | {
+    variable: string;
+};
+/** A macro line compiled into the pieces a call concatenates. */
+export interface MacroTemplate {
+    segments: readonly MacroSegment[];
+    /** Every variable the line substitutes, once each, in first-use order. */
+    variables: readonly string[];
+}
+/** The outcome of compiling a macro line. */
+export type MacroTemplateResult = {
+    ok: true;
+    template: MacroTemplate;
+} | {
+    ok: false;
+    message: string;
+};
+/** The outcome of filling a template from an argument compound. */
+export type MacroSubstitutionResult = {
+    ok: true;
+    command: string;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Compiles one macro line into a reusable template.
+ *
+ * `$` is literal unless it is followed by `(`, which is the only escape the
+ * format has. A line marked as a macro but carrying no substitution is an
+ * error, as is an unterminated `$(` or a name outside letters, digits and `_`.
+ */
+export declare const compileMacroLine: (command: string) => MacroTemplateResult;
+/**
+ * Fills a compiled macro line from an argument compound.
+ *
+ * @returns The command to parse, or the reason the call cannot be instantiated.
+ */
+export declare const substituteMacro: (template: MacroTemplate, args: MacroArguments) => MacroSubstitutionResult;
+/**
+ * Renders one argument the way a substitution inserts it: a string goes in
+ * raw, with no quoting and no escaping, so a value carrying quotes can produce
+ * a command that no longer parses. Numbers lose the type suffix they would
+ * carry in NBT, matching the 1.20.2 fix. A compound or list becomes SNBT,
+ * where suffixes are back because the text is NBT again.
+ */
+export declare const renderMacroValue: (value: unknown) => string;
+//# sourceMappingURL=macro.d.ts.map

package/dist/macro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"macro.d.ts","sourceRoot":"","sources":["../src/macro.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAE/D,qFAAqF;AACrF,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC1B,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAClC,0EAA0E;IAC1E,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzG,mEAAmE;AACnE,MAAM,MAAM,uBAAuB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAYrG;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,YAAa,MAAM,KAAG,mBAgClD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,aAAc,aAAa,QAAQ,cAAc,KAAG,uBAiB/E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,UAAW,OAAO,KAAG,MAMjD,CAAC"}

package/dist/macro.es.js

@@ -0,0 +1,115 @@
+// src/macro.ts
+var VARIABLE_PATTERN = /^[A-Za-z0-9_]+$/;
+/**
+* The most fraction digits a non-integer macro argument prints. Java formats
+* the value with a `DecimalFormat` under `Locale.ROOT`; Mojang does not state
+* the digit count, so this is a choice that keeps every double exactly
+* representable in decimal form rather than a confirmed vanilla number.
+*/
+var MAX_FRACTION_DIGITS = 17;
+/**
+* Compiles one macro line into a reusable template.
+*
+* `$` is literal unless it is followed by `(`, which is the only escape the
+* format has. A line marked as a macro but carrying no substitution is an
+* error, as is an unterminated `$(` or a name outside letters, digits and `_`.
+*/
+var compileMacroLine = (command) => {
+	const segments = [];
+	const variables = [];
+	let literal = "";
+	for (let index = 0; index < command.length; index += 1) {
+		if (command[index] !== "$" || command[index + 1] !== "(") {
+			literal += command[index];
+			continue;
+		}
+		const close = command.indexOf(")", index + 2);
+		if (close === -1) return {
+			ok: false,
+			message: "unterminated macro variable"
+		};
+		const variable = command.slice(index + 2, close);
+		if (!VARIABLE_PATTERN.test(variable)) return {
+			ok: false,
+			message: `invalid macro variable name '${variable}'`
+		};
+		if (literal.length > 0) {
+			segments.push({ text: literal });
+			literal = "";
+		}
+		segments.push({ variable });
+		if (!variables.includes(variable)) variables.push(variable);
+		index = close;
+	}
+	if (variables.length === 0) return {
+		ok: false,
+		message: "no variables in macro"
+	};
+	if (literal.length > 0) segments.push({ text: literal });
+	return {
+		ok: true,
+		template: {
+			segments,
+			variables
+		}
+	};
+};
+/**
+* Fills a compiled macro line from an argument compound.
+*
+* @returns The command to parse, or the reason the call cannot be instantiated.
+*/
+var substituteMacro = (template, args) => {
+	let command = "";
+	for (const segment of template.segments) {
+		if ("text" in segment) {
+			command += segment.text;
+			continue;
+		}
+		const value = args[segment.variable];
+		if (value === void 0 || value === null) return {
+			ok: false,
+			message: `the macro arguments have no entry for '${segment.variable}'`
+		};
+		command += renderMacroValue(value);
+	}
+	return {
+		ok: true,
+		command
+	};
+};
+/**
+* Renders one argument the way a substitution inserts it: a string goes in
+* raw, with no quoting and no escaping, so a value carrying quotes can produce
+* a command that no longer parses. Numbers lose the type suffix they would
+* carry in NBT, matching the 1.20.2 fix. A compound or list becomes SNBT,
+* where suffixes are back because the text is NBT again.
+*/
+var renderMacroValue = (value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return renderNumber(value);
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "boolean") return value ? "1" : "0";
+	return renderSnbt(value);
+};
+/** Prints a number in plain decimal, never in exponent form and never with a suffix. */
+var renderNumber = (value) => {
+	if (!Number.isFinite(value)) return String(value);
+	if (Number.isInteger(value) && Math.abs(value) < Number.MAX_SAFE_INTEGER) return value.toFixed(0);
+	const fixed = value.toFixed(MAX_FRACTION_DIGITS);
+	return fixed.includes(".") ? fixed.replace(/0+$/, "").replace(/\.$/, "") : fixed;
+};
+/** Renders a nested value as SNBT, the text form a command argument expects. */
+var renderSnbt = (value) => {
+	if (value === null || value === void 0) return "{}";
+	if (typeof value === "string") return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+	if (typeof value === "number") return renderNumber(value);
+	if (typeof value === "bigint") return `${value}L`;
+	if (typeof value === "boolean") return value ? "1b" : "0b";
+	if (Array.isArray(value)) return `[${value.map(renderSnbt).join(",")}]`;
+	if (typeof value === "object") return `{${Object.entries(value).map(([key, entry]) => `${key}:${renderSnbt(entry)}`).join(",")}}`;
+	return String(value);
+};
+export { compileMacroLine, renderMacroValue, substituteMacro };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"macro.es.js","names":[],"sources":["../src/macro.ts"],"sourcesContent":["/**\n * Macro lines and their `$(variable)` substitutions, as 1.20.2 defined them.\n * A macro line is compiled once into a template of literal text and variable\n * holes; a call fills the holes from a compound of arguments and the resulting\n * command is parsed fresh, which is the cost a macro adds over a plain line.\n */\n\n/** The compound a macro call substitutes from. Extra entries are ignored. */\nexport type MacroArguments = Readonly<Record<string, unknown>>;\n\n/** One piece of a compiled macro line: literal text, or a hole naming a variable. */\nexport type MacroSegment = { text: string } | { variable: string };\n\n/** A macro line compiled into the pieces a call concatenates. */\nexport interface MacroTemplate {\n    segments: readonly MacroSegment[];\n    /** Every variable the line substitutes, once each, in first-use order. */\n    variables: readonly string[];\n}\n\n/** The outcome of compiling a macro line. */\nexport type MacroTemplateResult = { ok: true; template: MacroTemplate } | { ok: false; message: string };\n\n/** The outcome of filling a template from an argument compound. */\nexport type MacroSubstitutionResult = { ok: true; command: string } | { ok: false; message: string };\n\nconst VARIABLE_PATTERN = /^[A-Za-z0-9_]+$/;\n\n/**\n * The most fraction digits a non-integer macro argument prints. Java formats\n * the value with a `DecimalFormat` under `Locale.ROOT`; Mojang does not state\n * the digit count, so this is a choice that keeps every double exactly\n * representable in decimal form rather than a confirmed vanilla number.\n */\nconst MAX_FRACTION_DIGITS = 17;\n\n/**\n * Compiles one macro line into a reusable template.\n *\n * `$` is literal unless it is followed by `(`, which is the only escape the\n * format has. A line marked as a macro but carrying no substitution is an\n * error, as is an unterminated `$(` or a name outside letters, digits and `_`.\n */\nexport const compileMacroLine = (command: string): MacroTemplateResult => {\n    const segments: MacroSegment[] = [];\n    const variables: string[] = [];\n    let literal = '';\n\n    for (let index = 0; index < command.length; index += 1) {\n        if (command[index] !== '$' || command[index + 1] !== '(') {\n            literal += command[index];\n            continue;\n        }\n\n        const close = command.indexOf(')', index + 2);\n        if (close === -1) return { ok: false, message: 'unterminated macro variable' };\n\n        const variable = command.slice(index + 2, close);\n        if (!VARIABLE_PATTERN.test(variable)) {\n            return { ok: false, message: `invalid macro variable name '${variable}'` };\n        }\n\n        if (literal.length > 0) {\n            segments.push({ text: literal });\n            literal = '';\n        }\n        segments.push({ variable });\n        if (!variables.includes(variable)) variables.push(variable);\n        index = close;\n    }\n\n    if (variables.length === 0) return { ok: false, message: 'no variables in macro' };\n    if (literal.length > 0) segments.push({ text: literal });\n\n    return { ok: true, template: { segments, variables } };\n};\n\n/**\n * Fills a compiled macro line from an argument compound.\n *\n * @returns The command to parse, or the reason the call cannot be instantiated.\n */\nexport const substituteMacro = (template: MacroTemplate, args: MacroArguments): MacroSubstitutionResult => {\n    let command = '';\n\n    for (const segment of template.segments) {\n        if ('text' in segment) {\n            command += segment.text;\n            continue;\n        }\n\n        const value = args[segment.variable];\n        if (value === undefined || value === null) {\n            return { ok: false, message: `the macro arguments have no entry for '${segment.variable}'` };\n        }\n        command += renderMacroValue(value);\n    }\n\n    return { ok: true, command };\n};\n\n/**\n * Renders one argument the way a substitution inserts it: a string goes in\n * raw, with no quoting and no escaping, so a value carrying quotes can produce\n * a command that no longer parses. Numbers lose the type suffix they would\n * carry in NBT, matching the 1.20.2 fix. A compound or list becomes SNBT,\n * where suffixes are back because the text is NBT again.\n */\nexport const renderMacroValue = (value: unknown): string => {\n    if (typeof value === 'string') return value;\n    if (typeof value === 'number') return renderNumber(value);\n    if (typeof value === 'bigint') return value.toString();\n    if (typeof value === 'boolean') return value ? '1' : '0';\n    return renderSnbt(value);\n};\n\n/** Prints a number in plain decimal, never in exponent form and never with a suffix. */\nconst renderNumber = (value: number): string => {\n    if (!Number.isFinite(value)) return String(value);\n    if (Number.isInteger(value) && Math.abs(value) < Number.MAX_SAFE_INTEGER) return value.toFixed(0);\n\n    const fixed = value.toFixed(MAX_FRACTION_DIGITS);\n    return fixed.includes('.') ? fixed.replace(/0+$/, '').replace(/\\.$/, '') : fixed;\n};\n\n/** Renders a nested value as SNBT, the text form a command argument expects. */\nconst renderSnbt = (value: unknown): string => {\n    if (value === null || value === undefined) return '{}';\n    if (typeof value === 'string') return `\"${value.replaceAll('\\\\', '\\\\\\\\').replaceAll('\"', '\\\\\"')}\"`;\n    if (typeof value === 'number') return renderNumber(value);\n    if (typeof value === 'bigint') return `${value}L`;\n    if (typeof value === 'boolean') return value ? '1b' : '0b';\n    if (Array.isArray(value)) return `[${value.map(renderSnbt).join(',')}]`;\n    if (typeof value === 'object') {\n        const entries = Object.entries(value).map(([key, entry]) => `${key}:${renderSnbt(entry)}`);\n        return `{${entries.join(',')}}`;\n    }\n    return String(value);\n};\n"],"mappings":"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"}

package/dist/parse.cjs.cjs

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/parse.ts
+/**
+* The longest a single command may be, in characters. Java's
+* `CommandFunction` carries 2000000 as its only integer constant and rejects a
+* longer line with "Command too long".
+*/
+var MAX_COMMAND_LENGTH = 2e6;
+/** Whether a line asks for the next line to be appended to it. */
+var continues = (text) => text.endsWith("\\");
+/**
+* Parses the text of one `.mcfunction` file into its command lines.
+*
+* A line is dropped when it is blank or starts with `#`. A line whose last
+* non-whitespace character is `\` continues into the next line, which is
+* trimmed before being appended. A line whose first non-whitespace character
+* is `$` is a macro line and keeps its substitutions unevaluated.
+*
+* Problems are reported rather than thrown; the caller decides whether a
+* function with errors is registered.
+*/
+var parseFunctionSource = (source) => {
+	const lines = [];
+	const diagnostics = [];
+	const sourceLines = source.split(/\r?\n/);
+	if (sourceLines.at(-1) === "") sourceLines.pop();
+	let pending;
+	for (const [index, raw] of sourceLines.entries()) {
+		const number = index + 1;
+		const text = raw.trim();
+		if (pending) {
+			pending.text += text;
+			if (continues(pending.text)) {
+				pending.text = pending.text.slice(0, -1);
+				continue;
+			}
+			emit(lines, diagnostics, pending.line, pending.text, pending.macro);
+			pending = void 0;
+			continue;
+		}
+		if (text.length === 0 || text.startsWith("#")) continue;
+		const macro = text.startsWith("$");
+		const command = macro ? text.slice(1).trim() : text;
+		if (continues(command)) {
+			pending = {
+				line: number,
+				text: command.slice(0, -1),
+				macro
+			};
+			continue;
+		}
+		emit(lines, diagnostics, number, command, macro);
+	}
+	if (pending) diagnostics.push({
+		severity: "error",
+		code: "line.dangling-continuation",
+		line: pending.line,
+		message: "the file ends with a line continuation"
+	});
+	return {
+		lines,
+		diagnostics
+	};
+};
+/** Validates one assembled command and records it, or reports why it was rejected. */
+var emit = (lines, diagnostics, line, command, macro) => {
+	if (command.length === 0) return;
+	if (command.startsWith("//")) {
+		diagnostics.push({
+			severity: "error",
+			code: "line.double-slash-comment",
+			line,
+			message: `'${preview(command)}' is not a command; comments use '#', not '//'`
+		});
+		return;
+	}
+	if (command.startsWith("/")) {
+		diagnostics.push({
+			severity: "error",
+			code: "line.leading-slash",
+			line,
+			message: `'${preview(command)}' has a leading slash; function commands are written without one`
+		});
+		return;
+	}
+	if (command.length > 2e6) {
+		diagnostics.push({
+			severity: "error",
+			code: "line.too-long",
+			line,
+			message: `the command is ${command.length} characters, over the ${MAX_COMMAND_LENGTH} character limit`
+		});
+		return;
+	}
+	lines.push({
+		line,
+		command,
+		macro
+	});
+};
+/** Shortens a command for a diagnostic message. */
+var preview = (command) => command.length <= 40 ? command : `${command.slice(0, 40)}...`;
+exports.MAX_COMMAND_LENGTH = MAX_COMMAND_LENGTH;
+exports.parseFunctionSource = parseFunctionSource;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"parse.cjs.cjs","names":[],"sources":["../src/parse.ts"],"sourcesContent":["/**\n * The mcfunction file format: one command per line with no leading slash,\n * `#` comments, blank lines, `\\` line continuation (1.20.2) and `$` macro\n * lines (1.20.2). Parsing happens once per file at load, which is the point of\n * the format: a non-macro command line is never re-read at run time.\n */\n\nimport type { Diagnostic } from './diagnostics';\n\n/**\n * The longest a single command may be, in characters. Java's\n * `CommandFunction` carries 2000000 as its only integer constant and rejects a\n * longer line with \"Command too long\".\n */\nexport const MAX_COMMAND_LENGTH = 2_000_000;\n\n/** One command the file declares, after comments, blank lines and continuations are resolved. */\nexport interface FunctionLine {\n    /** The 1-based number of the line the command starts on. */\n    line: number;\n    /** The command text, without the leading `$` of a macro line. */\n    command: string;\n    /** Whether the line is a macro line, so its `$(name)` substitutions run per call. */\n    macro: boolean;\n}\n\n/** What {@link parseFunctionSource} produces. */\nexport interface ParsedFunction {\n    lines: readonly FunctionLine[];\n    diagnostics: readonly Diagnostic[];\n}\n\n/** Whether a line asks for the next line to be appended to it. */\nconst continues = (text: string): boolean => text.endsWith('\\\\');\n\n/**\n * Parses the text of one `.mcfunction` file into its command lines.\n *\n * A line is dropped when it is blank or starts with `#`. A line whose last\n * non-whitespace character is `\\` continues into the next line, which is\n * trimmed before being appended. A line whose first non-whitespace character\n * is `$` is a macro line and keeps its substitutions unevaluated.\n *\n * Problems are reported rather than thrown; the caller decides whether a\n * function with errors is registered.\n */\nexport const parseFunctionSource = (source: string): ParsedFunction => {\n    const lines: FunctionLine[] = [];\n    const diagnostics: Diagnostic[] = [];\n    const sourceLines = source.split(/\\r?\\n/);\n    // A trailing newline is a terminator, not an empty last line, so a file that\n    // ends mid-continuation reports the continuation instead of closing it.\n    if (sourceLines.at(-1) === '') sourceLines.pop();\n\n    let pending: { line: number; text: string; macro: boolean } | undefined;\n\n    for (const [index, raw] of sourceLines.entries()) {\n        const number = index + 1;\n        const text = raw.trim();\n\n        if (pending) {\n            pending.text += text;\n            if (continues(pending.text)) {\n                pending.text = pending.text.slice(0, -1);\n                continue;\n            }\n            emit(lines, diagnostics, pending.line, pending.text, pending.macro);\n            pending = undefined;\n            continue;\n        }\n\n        if (text.length === 0 || text.startsWith('#')) continue;\n\n        const macro = text.startsWith('$');\n        const command = macro ? text.slice(1).trim() : text;\n\n        if (continues(command)) {\n            pending = { line: number, text: command.slice(0, -1), macro };\n            continue;\n        }\n\n        emit(lines, diagnostics, number, command, macro);\n    }\n\n    if (pending) {\n        diagnostics.push({\n            severity: 'error',\n            code: 'line.dangling-continuation',\n            line: pending.line,\n            message: 'the file ends with a line continuation'\n        });\n    }\n\n    return { lines, diagnostics };\n};\n\n/** Validates one assembled command and records it, or reports why it was rejected. */\nconst emit = (\n    lines: FunctionLine[],\n    diagnostics: Diagnostic[],\n    line: number,\n    command: string,\n    macro: boolean\n): void => {\n    if (command.length === 0) return;\n\n    if (command.startsWith('//')) {\n        diagnostics.push({\n            severity: 'error',\n            code: 'line.double-slash-comment',\n            line,\n            message: `'${preview(command)}' is not a command; comments use '#', not '//'`\n        });\n        return;\n    }\n\n    if (command.startsWith('/')) {\n        diagnostics.push({\n            severity: 'error',\n            code: 'line.leading-slash',\n            line,\n            message: `'${preview(command)}' has a leading slash; function commands are written without one`\n        });\n        return;\n    }\n\n    if (command.length > MAX_COMMAND_LENGTH) {\n        diagnostics.push({\n            severity: 'error',\n            code: 'line.too-long',\n            line,\n            message: `the command is ${command.length} characters, over the ${MAX_COMMAND_LENGTH} character limit`\n        });\n        return;\n    }\n\n    lines.push({ line, command, macro });\n};\n\n/** Shortens a command for a diagnostic message. */\nconst preview = (command: string): string => (command.length <= 40 ? command : `${command.slice(0, 40)}...`);\n"],"mappings":";;;;;;;;AAcA,IAAa,qBAAqB;;AAmBlC,IAAM,aAAa,SAA0B,KAAK,SAAS,IAAI;;;;;;;;;;;;AAa/D,IAAa,uBAAuB,WAAmC;CACnE,MAAM,QAAwB,CAAC;CAC/B,MAAM,cAA4B,CAAC;CACnC,MAAM,cAAc,OAAO,MAAM,OAAO;CAGxC,IAAI,YAAY,GAAG,EAAE,MAAM,IAAI,YAAY,IAAI;CAE/C,IAAI;CAEJ,KAAK,MAAM,CAAC,OAAO,QAAQ,YAAY,QAAQ,GAAG;EAC9C,MAAM,SAAS,QAAQ;EACvB,MAAM,OAAO,IAAI,KAAK;EAEtB,IAAI,SAAS;GACT,QAAQ,QAAQ;GAChB,IAAI,UAAU,QAAQ,IAAI,GAAG;IACzB,QAAQ,OAAO,QAAQ,KAAK,MAAM,GAAG,EAAE;IACvC;GACJ;GACA,KAAK,OAAO,aAAa,QAAQ,MAAM,QAAQ,MAAM,QAAQ,KAAK;GAClE,UAAU,KAAA;GACV;EACJ;EAEA,IAAI,KAAK,WAAW,KAAK,KAAK,WAAW,GAAG,GAAG;EAE/C,MAAM,QAAQ,KAAK,WAAW,GAAG;EACjC,MAAM,UAAU,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI;EAE/C,IAAI,UAAU,OAAO,GAAG;GACpB,UAAU;IAAE,MAAM;IAAQ,MAAM,QAAQ,MAAM,GAAG,EAAE;IAAG;GAAM;GAC5D;EACJ;EAEA,KAAK,OAAO,aAAa,QAAQ,SAAS,KAAK;CACnD;CAEA,IAAI,SACA,YAAY,KAAK;EACb,UAAU;EACV,MAAM;EACN,MAAM,QAAQ;EACd,SAAS;CACb,CAAC;CAGL,OAAO;EAAE;EAAO;CAAY;AAChC;;AAGA,IAAM,QACF,OACA,aACA,MACA,SACA,UACO;CACP,IAAI,QAAQ,WAAW,GAAG;CAE1B,IAAI,QAAQ,WAAW,IAAI,GAAG;EAC1B,YAAY,KAAK;GACb,UAAU;GACV,MAAM;GACN;GACA,SAAS,IAAI,QAAQ,OAAO,EAAE;EAClC,CAAC;EACD;CACJ;CAEA,IAAI,QAAQ,WAAW,GAAG,GAAG;EACzB,YAAY,KAAK;GACb,UAAU;GACV,MAAM;GACN;GACA,SAAS,IAAI,QAAQ,OAAO,EAAE;EAClC,CAAC;EACD;CACJ;CAEA,IAAI,QAAQ,SAAA,KAA6B;EACrC,YAAY,KAAK;GACb,UAAU;GACV,MAAM;GACN;GACA,SAAS,kBAAkB,QAAQ,OAAO,wBAAwB,mBAAmB;EACzF,CAAC;EACD;CACJ;CAEA,MAAM,KAAK;EAAE;EAAM;EAAS;CAAM,CAAC;AACvC;;AAGA,IAAM,WAAW,YAA6B,QAAQ,UAAU,KAAK,UAAU,GAAG,QAAQ,MAAM,GAAG,EAAE,EAAE"}

package/dist/parse.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The mcfunction file format: one command per line with no leading slash,
+ * `#` comments, blank lines, `\` line continuation (1.20.2) and `$` macro
+ * lines (1.20.2). Parsing happens once per file at load, which is the point of
+ * the format: a non-macro command line is never re-read at run time.
+ */
+import type { Diagnostic } from './diagnostics';
+/**
+ * The longest a single command may be, in characters. Java's
+ * `CommandFunction` carries 2000000 as its only integer constant and rejects a
+ * longer line with "Command too long".
+ */
+export declare const MAX_COMMAND_LENGTH = 2000000;
+/** One command the file declares, after comments, blank lines and continuations are resolved. */
+export interface FunctionLine {
+    /** The 1-based number of the line the command starts on. */
+    line: number;
+    /** The command text, without the leading `$` of a macro line. */
+    command: string;
+    /** Whether the line is a macro line, so its `$(name)` substitutions run per call. */
+    macro: boolean;
+}
+/** What {@link parseFunctionSource} produces. */
+export interface ParsedFunction {
+    lines: readonly FunctionLine[];
+    diagnostics: readonly Diagnostic[];
+}
+/**
+ * Parses the text of one `.mcfunction` file into its command lines.
+ *
+ * A line is dropped when it is blank or starts with `#`. A line whose last
+ * non-whitespace character is `\` continues into the next line, which is
+ * trimmed before being appended. A line whose first non-whitespace character
+ * is `$` is a macro line and keeps its substitutions unevaluated.
+ *
+ * Problems are reported rather than thrown; the caller decides whether a
+ * function with errors is registered.
+ */
+export declare const parseFunctionSource: (source: string) => ParsedFunction;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,UAAY,CAAC;AAE5C,iGAAiG;AACjG,MAAM,WAAW,YAAY;IACzB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,KAAK,EAAE,OAAO,CAAC;CAClB;AAED,iDAAiD;AACjD,MAAM,WAAW,cAAc;IAC3B,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;IAC/B,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CACtC;AAKD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,WAAY,MAAM,KAAG,cAgDpD,CAAC"}

package/dist/parse.es.js

@@ -0,0 +1,104 @@
+// src/parse.ts
+/**
+* The longest a single command may be, in characters. Java's
+* `CommandFunction` carries 2000000 as its only integer constant and rejects a
+* longer line with "Command too long".
+*/
+var MAX_COMMAND_LENGTH = 2e6;
+/** Whether a line asks for the next line to be appended to it. */
+var continues = (text) => text.endsWith("\\");
+/**
+* Parses the text of one `.mcfunction` file into its command lines.
+*
+* A line is dropped when it is blank or starts with `#`. A line whose last
+* non-whitespace character is `\` continues into the next line, which is
+* trimmed before being appended. A line whose first non-whitespace character
+* is `$` is a macro line and keeps its substitutions unevaluated.
+*
+* Problems are reported rather than thrown; the caller decides whether a
+* function with errors is registered.
+*/
+var parseFunctionSource = (source) => {
+	const lines = [];
+	const diagnostics = [];
+	const sourceLines = source.split(/\r?\n/);
+	if (sourceLines.at(-1) === "") sourceLines.pop();
+	let pending;
+	for (const [index, raw] of sourceLines.entries()) {
+		const number = index + 1;
+		const text = raw.trim();
+		if (pending) {
+			pending.text += text;
+			if (continues(pending.text)) {
+				pending.text = pending.text.slice(0, -1);
+				continue;
+			}
+			emit(lines, diagnostics, pending.line, pending.text, pending.macro);
+			pending = void 0;
+			continue;
+		}
+		if (text.length === 0 || text.startsWith("#")) continue;
+		const macro = text.startsWith("$");
+		const command = macro ? text.slice(1).trim() : text;
+		if (continues(command)) {
+			pending = {
+				line: number,
+				text: command.slice(0, -1),
+				macro
+			};
+			continue;
+		}
+		emit(lines, diagnostics, number, command, macro);
+	}
+	if (pending) diagnostics.push({
+		severity: "error",
+		code: "line.dangling-continuation",
+		line: pending.line,
+		message: "the file ends with a line continuation"
+	});
+	return {
+		lines,
+		diagnostics
+	};
+};
+/** Validates one assembled command and records it, or reports why it was rejected. */
+var emit = (lines, diagnostics, line, command, macro) => {
+	if (command.length === 0) return;
+	if (command.startsWith("//")) {
+		diagnostics.push({
+			severity: "error",
+			code: "line.double-slash-comment",
+			line,
+			message: `'${preview(command)}' is not a command; comments use '#', not '//'`
+		});
+		return;
+	}
+	if (command.startsWith("/")) {
+		diagnostics.push({
+			severity: "error",
+			code: "line.leading-slash",
+			line,
+			message: `'${preview(command)}' has a leading slash; function commands are written without one`
+		});
+		return;
+	}
+	if (command.length > 2e6) {
+		diagnostics.push({
+			severity: "error",
+			code: "line.too-long",
+			line,
+			message: `the command is ${command.length} characters, over the ${MAX_COMMAND_LENGTH} character limit`
+		});
+		return;
+	}
+	lines.push({
+		line,
+		command,
+		macro
+	});
+};
+/** Shortens a command for a diagnostic message. */
+var preview = (command) => command.length <= 40 ? command : `${command.slice(0, 40)}...`;
+export { MAX_COMMAND_LENGTH, parseFunctionSource };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"parse.es.js","names":[],"sources":["../src/parse.ts"],"sourcesContent":["/**\n * The mcfunction file format: one command per line with no leading slash,\n * `#` comments, blank lines, `\\` line continuation (1.20.2) and `$` macro\n * lines (1.20.2). Parsing happens once per file at load, which is the point of\n * the format: a non-macro command line is never re-read at run time.\n */\n\nimport type { Diagnostic } from './diagnostics';\n\n/**\n * The longest a single command may be, in characters. Java's\n * `CommandFunction` carries 2000000 as its only integer constant and rejects a\n * longer line with \"Command too long\".\n */\nexport const MAX_COMMAND_LENGTH = 2_000_000;\n\n/** One command the file declares, after comments, blank lines and continuations are resolved. */\nexport interface FunctionLine {\n    /** The 1-based number of the line the command starts on. */\n    line: number;\n    /** The command text, without the leading `$` of a macro line. */\n    command: string;\n    /** Whether the line is a macro line, so its `$(name)` substitutions run per call. */\n    macro: boolean;\n}\n\n/** What {@link parseFunctionSource} produces. */\nexport interface ParsedFunction {\n    lines: readonly FunctionLine[];\n    diagnostics: readonly Diagnostic[];\n}\n\n/** Whether a line asks for the next line to be appended to it. */\nconst continues = (text: string): boolean => text.endsWith('\\\\');\n\n/**\n * Parses the text of one `.mcfunction` file into its command lines.\n *\n * A line is dropped when it is blank or starts with `#`. A line whose last\n * non-whitespace character is `\\` continues into the next line, which is\n * trimmed before being appended. A line whose first non-whitespace character\n * is `$` is a macro line and keeps its substitutions unevaluated.\n *\n * Problems are reported rather than thrown; the caller decides whether a\n * function with errors is registered.\n */\nexport const parseFunctionSource = (source: string): ParsedFunction => {\n    const lines: FunctionLine[] = [];\n    const diagnostics: Diagnostic[] = [];\n    const sourceLines = source.split(/\\r?\\n/);\n    // A trailing newline is a terminator, not an empty last line, so a file that\n    // ends mid-continuation reports the continuation instead of closing it.\n    if (sourceLines.at(-1) === '') sourceLines.pop();\n\n    let pending: { line: number; text: string; macro: boolean } | undefined;\n\n    for (const [index, raw] of sourceLines.entries()) {\n        const number = index + 1;\n        const text = raw.trim();\n\n        if (pending) {\n            pending.text += text;\n            if (continues(pending.text)) {\n                pending.text = pending.text.slice(0, -1);\n                continue;\n            }\n            emit(lines, diagnostics, pending.line, pending.text, pending.macro);\n            pending = undefined;\n            continue;\n        }\n\n        if (text.length === 0 || text.startsWith('#')) continue;\n\n        const macro = text.startsWith('$');\n        const command = macro ? text.slice(1).trim() : text;\n\n        if (continues(command)) {\n            pending = { line: number, text: command.slice(0, -1), macro };\n            continue;\n        }\n\n        emit(lines, diagnostics, number, command, macro);\n    }\n\n    if (pending) {\n        diagnostics.push({\n            severity: 'error',\n            code: 'line.dangling-continuation',\n            line: pending.line,\n            message: 'the file ends with a line continuation'\n        });\n    }\n\n    return { lines, diagnostics };\n};\n\n/** Validates one assembled command and records it, or reports why it was rejected. */\nconst emit = (\n    lines: FunctionLine[],\n    diagnostics: Diagnostic[],\n    line: number,\n    command: string,\n    macro: boolean\n): void => {\n    if (command.length === 0) return;\n\n    if (command.startsWith('//')) {\n        diagnostics.push({\n            severity: 'error',\n            code: 'line.double-slash-comment',\n            line,\n            message: `'${preview(command)}' is not a command; comments use '#', not '//'`\n        });\n        return;\n    }\n\n    if (command.startsWith('/')) {\n        diagnostics.push({\n            severity: 'error',\n            code: 'line.leading-slash',\n            line,\n            message: `'${preview(command)}' has a leading slash; function commands are written without one`\n        });\n        return;\n    }\n\n    if (command.length > MAX_COMMAND_LENGTH) {\n        diagnostics.push({\n            severity: 'error',\n            code: 'line.too-long',\n            line,\n            message: `the command is ${command.length} characters, over the ${MAX_COMMAND_LENGTH} character limit`\n        });\n        return;\n    }\n\n    lines.push({ line, command, macro });\n};\n\n/** Shortens a command for a diagnostic message. */\nconst preview = (command: string): string => (command.length <= 40 ? command : `${command.slice(0, 40)}...`);\n"],"mappings":";;;;;;AAcA,IAAa,qBAAqB;;AAmBlC,IAAM,aAAa,SAA0B,KAAK,SAAS,IAAI;;;;;;;;;;;;AAa/D,IAAa,uBAAuB,WAAmC;CACnE,MAAM,QAAwB,CAAC;CAC/B,MAAM,cAA4B,CAAC;CACnC,MAAM,cAAc,OAAO,MAAM,OAAO;CAGxC,IAAI,YAAY,GAAG,EAAE,MAAM,IAAI,YAAY,IAAI;CAE/C,IAAI;CAEJ,KAAK,MAAM,CAAC,OAAO,QAAQ,YAAY,QAAQ,GAAG;EAC9C,MAAM,SAAS,QAAQ;EACvB,MAAM,OAAO,IAAI,KAAK;EAEtB,IAAI,SAAS;GACT,QAAQ,QAAQ;GAChB,IAAI,UAAU,QAAQ,IAAI,GAAG;IACzB,QAAQ,OAAO,QAAQ,KAAK,MAAM,GAAG,EAAE;IACvC;GACJ;GACA,KAAK,OAAO,aAAa,QAAQ,MAAM,QAAQ,MAAM,QAAQ,KAAK;GAClE,UAAU,KAAA;GACV;EACJ;EAEA,IAAI,KAAK,WAAW,KAAK,KAAK,WAAW,GAAG,GAAG;EAE/C,MAAM,QAAQ,KAAK,WAAW,GAAG;EACjC,MAAM,UAAU,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI;EAE/C,IAAI,UAAU,OAAO,GAAG;GACpB,UAAU;IAAE,MAAM;IAAQ,MAAM,QAAQ,MAAM,GAAG,EAAE;IAAG;GAAM;GAC5D;EACJ;EAEA,KAAK,OAAO,aAAa,QAAQ,SAAS,KAAK;CACnD;CAEA,IAAI,SACA,YAAY,KAAK;EACb,UAAU;EACV,MAAM;EACN,MAAM,QAAQ;EACd,SAAS;CACb,CAAC;CAGL,OAAO;EAAE;EAAO;CAAY;AAChC;;AAGA,IAAM,QACF,OACA,aACA,MACA,SACA,UACO;CACP,IAAI,QAAQ,WAAW,GAAG;CAE1B,IAAI,QAAQ,WAAW,IAAI,GAAG;EAC1B,YAAY,KAAK;GACb,UAAU;GACV,MAAM;GACN;GACA,SAAS,IAAI,QAAQ,OAAO,EAAE;EAClC,CAAC;EACD;CACJ;CAEA,IAAI,QAAQ,WAAW,GAAG,GAAG;EACzB,YAAY,KAAK;GACb,UAAU;GACV,MAAM;GACN;GACA,SAAS,IAAI,QAAQ,OAAO,EAAE;EAClC,CAAC;EACD;CACJ;CAEA,IAAI,QAAQ,SAAA,KAA6B;EACrC,YAAY,KAAK;GACb,UAAU;GACV,MAAM;GACN;GACA,SAAS,kBAAkB,QAAQ,OAAO,wBAAwB,mBAAmB;EACzF,CAAC;EACD;CACJ;CAEA,MAAM,KAAK;EAAE;EAAM;EAAS;CAAM,CAAC;AACvC;;AAGA,IAAM,WAAW,YAA6B,QAAQ,UAAU,KAAK,UAAU,GAAG,QAAQ,MAAM,GAAG,EAAE,EAAE"}