@openrewrite/rewrite 8.69.0-20251211-200238 → 8.69.0-20251212-132620

package/dist/yaml/parser.js

@@ -0,0 +1,803 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YamlParser = void 0;
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const markers_1 = require("../markers");
+const parser_1 = require("../parser");
+const uuid_1 = require("../uuid");
+const tree_1 = require("./tree");
+const parse_error_1 = require("../parse-error");
+const yaml_1 = require("yaml");
+class YamlParser extends parser_1.Parser {
+    parse(...sourcePaths) {
+        return __asyncGenerator(this, arguments, function* parse_1() {
+            for (const sourcePath of sourcePaths) {
+                const text = (0, parser_1.parserInputRead)(sourcePath);
+                try {
+                    yield yield __await(Object.assign(Object.assign({}, new YamlCstReader(text).parse()), { sourcePath: this.relativePath(sourcePath) }));
+                }
+                catch (e) {
+                    // Return a ParseError for files that can't be parsed
+                    const parseError = {
+                        kind: parse_error_1.ParseErrorKind,
+                        id: (0, uuid_1.randomId)(),
+                        markers: (0, markers_1.markers)({
+                            kind: markers_1.MarkersKind.ParseExceptionResult,
+                            id: (0, uuid_1.randomId)(),
+                            parserType: "YamlParser",
+                            exceptionType: e.name || "Error",
+                            message: e.message || "Unknown parse error"
+                        }),
+                        sourcePath: this.relativePath(sourcePath),
+                        text
+                    };
+                    yield yield __await(parseError);
+                }
+            }
+        });
+    }
+}
+exports.YamlParser = YamlParser;
+/**
+ * Converts YAML CST from the 'yaml' package to our Yaml AST.
+ * The CST preserves all whitespace, comments, and formatting.
+ */
+class YamlCstReader {
+    constructor(source) {
+        const parser = new yaml_1.Parser();
+        this.cstTokens = [...parser.parse(source)];
+    }
+    parse() {
+        const documents = [];
+        let pendingPrefix = "";
+        for (let i = 0; i < this.cstTokens.length; i++) {
+            const token = this.cstTokens[i];
+            if (token.type === 'document') {
+                const cstDoc = token;
+                // Check if next token is doc-end
+                const nextToken = this.cstTokens[i + 1];
+                let docEnd;
+                if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === 'doc-end') {
+                    docEnd = nextToken;
+                    i++; // Skip the doc-end in the main loop
+                }
+                const { doc, afterEnd } = this.convertDocument(cstDoc, docEnd, pendingPrefix);
+                documents.push(doc);
+                pendingPrefix = afterEnd; // Content after ... becomes next doc's prefix
+            }
+            else if (token.type === 'doc-end') {
+                // Standalone doc-end without preceding document
+                const docEnd = token;
+                pendingPrefix += this.concatenateSources(docEnd.end || []);
+            }
+            else if (token.type === 'comment' || token.type === 'newline' || token.type === 'space') {
+                // Content before document (comments, whitespace) becomes document prefix
+                pendingPrefix += token.source;
+            }
+        }
+        return {
+            kind: tree_1.Yaml.Kind.Documents,
+            id: (0, uuid_1.randomId)(),
+            prefix: "",
+            markers: markers_1.emptyMarkers,
+            documents,
+            suffix: undefined
+        };
+    }
+    convertDocument(cstDoc, cstDocEnd, pendingPrefix = "") {
+        // Extract prefix from document start tokens
+        // The document prefix is content BEFORE the --- marker
+        // Content AFTER --- goes into the block's first entry
+        const startTokens = cstDoc.start || [];
+        let prefix = pendingPrefix; // Content before this document
+        let explicit = false;
+        let afterDocStart = ""; // Content after ---
+        let seenDocStart = false;
+        for (const token of startTokens) {
+            if (token.type === 'doc-start') {
+                explicit = true;
+                seenDocStart = true;
+            }
+            else if (seenDocStart) {
+                // Content after --- goes into block's prefix
+                afterDocStart += token.source;
+            }
+            else {
+                // Content before --- goes into document prefix
+                prefix += token.source;
+            }
+        }
+        // Convert the document body and get trailing content
+        let block;
+        let trailing = "";
+        if (cstDoc.value) {
+            const result = this.convertTokenWithTrailing(cstDoc.value);
+            block = result.node;
+            trailing = result.trailing;
+            // Prepend the whitespace after --- to the block
+            if (afterDocStart) {
+                block = this.prependWhitespaceToValue(block, afterDocStart);
+            }
+        }
+        else {
+            block = this.createEmptyScalar(afterDocStart);
+        }
+        // Convert document end, passing the trailing content from block
+        const { end, afterEnd } = this.convertDocumentEnd(cstDoc.end, cstDocEnd, trailing);
+        return {
+            doc: {
+                kind: tree_1.Yaml.Kind.Document,
+                id: (0, uuid_1.randomId)(),
+                prefix,
+                markers: markers_1.emptyMarkers,
+                explicit,
+                block,
+                end
+            },
+            afterEnd
+        };
+    }
+    convertDocumentEnd(docEndTokens, cstDocEnd, trailing = "") {
+        // Prefix is the trailing content from the block, plus any content before ...
+        let prefix = trailing;
+        let explicit = false;
+        let afterEnd = "";
+        // Content after the document body (before ... if present)
+        if (docEndTokens) {
+            prefix += this.concatenateSources(docEndTokens);
+        }
+        // Explicit document end marker (...)
+        if (cstDocEnd) {
+            explicit = true;
+            // cstDocEnd.end contains tokens AFTER the ... marker - these become next doc's prefix
+            if (cstDocEnd.end) {
+                afterEnd = this.concatenateSources(cstDocEnd.end);
+            }
+        }
+        return {
+            end: {
+                kind: tree_1.Yaml.Kind.DocumentEnd,
+                id: (0, uuid_1.randomId)(),
+                prefix,
+                markers: markers_1.emptyMarkers,
+                explicit
+            },
+            afterEnd
+        };
+    }
+    convertTokenWithTrailing(token) {
+        switch (token.type) {
+            case 'block-map':
+                return this.convertBlockMapWithTrailing(token);
+            case 'block-seq':
+                return this.convertBlockSequenceWithTrailing(token);
+            case 'flow-collection':
+                return this.convertFlowCollectionWithTrailing(token);
+            case 'scalar':
+            case 'single-quoted-scalar':
+            case 'double-quoted-scalar':
+                return this.convertFlowScalarWithTrailing(token);
+            case 'block-scalar':
+                return this.convertBlockScalarWithTrailing(token);
+            case 'alias':
+                return this.convertAliasWithTrailing(token);
+            default:
+                // For unknown types, create an empty scalar
+                return { node: this.createEmptyScalar(), trailing: "" };
+        }
+    }
+    convertBlockMapWithTrailing(cst) {
+        const entries = [];
+        let pendingPrefix = "";
+        for (const item of cst.items) {
+            if (item.key !== undefined || item.value !== undefined) {
+                const entry = this.convertMappingEntry(item, pendingPrefix);
+                entries.push(entry.entry);
+                pendingPrefix = entry.trailingContent;
+            }
+            else {
+                // Entry with no key or value - capture start tokens (comments, whitespace)
+                // into pending prefix for the next entry or as trailing content
+                pendingPrefix += this.concatenateSources(item.start || []);
+            }
+        }
+        return {
+            node: {
+                kind: tree_1.Yaml.Kind.Mapping,
+                id: (0, uuid_1.randomId)(),
+                prefix: "",
+                markers: markers_1.emptyMarkers,
+                openingBracePrefix: undefined, // Block map has no braces
+                entries,
+                closingBracePrefix: undefined,
+                anchor: undefined,
+                tag: undefined
+            },
+            trailing: pendingPrefix // Trailing content from last entry
+        };
+    }
+    convertMappingEntry(item, pendingPrefix = "") {
+        // Prefix comes from start tokens plus any pending prefix from previous entry's trailing content
+        const prefix = pendingPrefix + this.concatenateSources(item.start || []);
+        // Convert key and get its trailing content
+        let keyTrailing = "";
+        let key;
+        if (item.key) {
+            const keyResult = this.convertTokenWithTrailing(item.key);
+            key = keyResult.node;
+            keyTrailing = keyResult.trailing;
+        }
+        else {
+            key = this.createEmptyScalar();
+        }
+        // Extract whitespace before ':' and any anchor/tag after it
+        let beforeMappingValueIndicator = keyTrailing;
+        let anchorForValue;
+        let tagForValue;
+        let afterColonWhitespace = "";
+        let seenColon = false;
+        if (item.sep) {
+            const sepTokens = item.sep;
+            for (let i = 0; i < sepTokens.length; i++) {
+                const sepToken = sepTokens[i];
+                if (sepToken.type === 'map-value-ind') {
+                    seenColon = true;
+                }
+                else if (!seenColon) {
+                    // Before the ':'
+                    beforeMappingValueIndicator += sepToken.source;
+                }
+                else if (sepToken.type === 'anchor') {
+                    // Collect all remaining tokens after anchor as postfix
+                    let postfix = "";
+                    for (let j = i + 1; j < sepTokens.length; j++) {
+                        const nextToken = sepTokens[j];
+                        if (nextToken.type === 'tag') {
+                            tagForValue = this.parseTagTokenWithSuffix(nextToken.source, postfix, sepTokens, j + 1);
+                            postfix = "";
+                            break; // Tag handler consumed remaining tokens
+                        }
+                        else {
+                            postfix += nextToken.source;
+                        }
+                    }
+                    anchorForValue = {
+                        kind: tree_1.Yaml.Kind.Anchor,
+                        id: (0, uuid_1.randomId)(),
+                        prefix: afterColonWhitespace,
+                        markers: markers_1.emptyMarkers,
+                        postfix,
+                        key: sepToken.source.substring(1) // Remove &
+                    };
+                    afterColonWhitespace = "";
+                    break; // We've consumed all remaining tokens
+                }
+                else if (sepToken.type === 'tag') {
+                    // Parse tag with its suffix (whitespace after the tag)
+                    tagForValue = this.parseTagTokenWithSuffix(sepToken.source, afterColonWhitespace, sepTokens, i + 1);
+                    afterColonWhitespace = ""; // Remaining whitespace is in tag suffix, not value prefix
+                    break; // Tag handler consumed remaining tokens
+                }
+                else {
+                    // After the ':'
+                    afterColonWhitespace += sepToken.source;
+                }
+            }
+        }
+        // Convert value
+        let value;
+        let valueTrailing = "";
+        if (item.value) {
+            const valueResult = this.convertTokenWithTrailing(item.value);
+            value = valueResult.node;
+            valueTrailing = valueResult.trailing;
+            // Apply anchor and tag if found in separator
+            if (anchorForValue && 'anchor' in value) {
+                value = Object.assign(Object.assign({}, value), { anchor: anchorForValue });
+            }
+            if (tagForValue && 'tag' in value) {
+                value = Object.assign(Object.assign({}, value), { tag: tagForValue });
+            }
+            // Prepend accumulated whitespace based on value type
+            if (afterColonWhitespace) {
+                value = this.prependWhitespaceToValue(value, afterColonWhitespace);
+            }
+        }
+        else {
+            value = this.createEmptyScalar(afterColonWhitespace);
+        }
+        return {
+            entry: {
+                kind: tree_1.Yaml.Kind.MappingEntry,
+                id: (0, uuid_1.randomId)(),
+                prefix,
+                markers: markers_1.emptyMarkers,
+                key,
+                beforeMappingValueIndicator,
+                value
+            },
+            trailingContent: valueTrailing
+        };
+    }
+    convertBlockSequenceWithTrailing(cst) {
+        const entries = [];
+        let pendingPrefix = "";
+        for (const item of cst.items) {
+            const result = this.convertSequenceEntry(item, true, pendingPrefix);
+            entries.push(result.entry);
+            pendingPrefix = result.trailingContent;
+        }
+        return {
+            node: {
+                kind: tree_1.Yaml.Kind.Sequence,
+                id: (0, uuid_1.randomId)(),
+                prefix: "",
+                markers: markers_1.emptyMarkers,
+                openingBracketPrefix: undefined, // Block sequence has no brackets
+                entries,
+                closingBracketPrefix: undefined,
+                anchor: undefined,
+                tag: undefined
+            },
+            trailing: pendingPrefix // Trailing content from last entry
+        };
+    }
+    convertSequenceEntry(item, dash, pendingPrefix = "") {
+        // Build prefix from start tokens, but exclude the dash indicator itself
+        let prefix = pendingPrefix;
+        let afterDashSpace = "";
+        let seenDash = false;
+        for (const token of item.start || []) {
+            if (token.type === 'seq-item-ind') {
+                seenDash = true;
+            }
+            else if (seenDash) {
+                afterDashSpace += token.source;
+            }
+            else {
+                prefix += token.source;
+            }
+        }
+        // Convert value
+        let block;
+        let trailing = "";
+        if (item.value) {
+            const valueResult = this.convertTokenWithTrailing(item.value);
+            block = valueResult.node;
+            trailing = valueResult.trailing;
+            // Prepend the space after dash to the block's prefix
+            block = Object.assign(Object.assign({}, block), { prefix: afterDashSpace + block.prefix });
+        }
+        else {
+            block = this.createEmptyScalar(afterDashSpace);
+        }
+        return {
+            entry: {
+                kind: tree_1.Yaml.Kind.SequenceEntry,
+                id: (0, uuid_1.randomId)(),
+                prefix,
+                markers: markers_1.emptyMarkers,
+                block,
+                dash,
+                trailingCommaPrefix: undefined // Block sequence has no commas
+            },
+            trailingContent: trailing
+        };
+    }
+    convertFlowCollectionWithTrailing(cst) {
+        const isMap = cst.start.source === '{';
+        const openingPrefix = "";
+        // End tokens include closing bracket/brace plus any trailing content
+        // We need to separate the closing delimiter from trailing whitespace
+        const endTokens = cst.end || [];
+        let closingPrefix = "";
+        let trailing = "";
+        let seenClosing = false;
+        for (const token of endTokens) {
+            if (token.type === 'flow-map-end' || token.type === 'flow-seq-end') {
+                seenClosing = true;
+            }
+            else if (seenClosing) {
+                trailing += token.source;
+            }
+            else {
+                closingPrefix += token.source;
+            }
+        }
+        if (isMap) {
+            const entries = [];
+            let pendingPrefix = "";
+            for (const item of cst.items) {
+                if (item.key !== undefined || item.value !== undefined) {
+                    const result = this.convertFlowMappingEntry(item, pendingPrefix);
+                    entries.push(result.entry);
+                    pendingPrefix = result.trailingContent;
+                }
+                else {
+                    // Empty item (trailing comma) - capture start tokens including the comma
+                    pendingPrefix += this.concatenateSources(item.start || []);
+                }
+            }
+            // Trailing content from last entry becomes part of closing brace prefix
+            const finalClosingPrefix = pendingPrefix + closingPrefix;
+            return {
+                node: {
+                    kind: tree_1.Yaml.Kind.Mapping,
+                    id: (0, uuid_1.randomId)(),
+                    prefix: "",
+                    markers: markers_1.emptyMarkers,
+                    openingBracePrefix: openingPrefix,
+                    entries,
+                    closingBracePrefix: finalClosingPrefix,
+                    anchor: undefined,
+                    tag: undefined
+                },
+                trailing
+            };
+        }
+        else {
+            // Flow sequence [a, b, c]
+            const entries = [];
+            let pendingPrefix = "";
+            for (let i = 0; i < cst.items.length; i++) {
+                const item = cst.items[i];
+                const isLast = i === cst.items.length - 1;
+                const result = this.convertFlowSequenceEntry(item, isLast, pendingPrefix);
+                entries.push(result.entry);
+                pendingPrefix = result.trailingContent;
+            }
+            // Trailing content from last entry becomes part of closing bracket prefix
+            const finalClosingPrefix = pendingPrefix + closingPrefix;
+            return {
+                node: {
+                    kind: tree_1.Yaml.Kind.Sequence,
+                    id: (0, uuid_1.randomId)(),
+                    prefix: "",
+                    markers: markers_1.emptyMarkers,
+                    openingBracketPrefix: openingPrefix,
+                    entries,
+                    closingBracketPrefix: finalClosingPrefix,
+                    anchor: undefined,
+                    tag: undefined
+                },
+                trailing
+            };
+        }
+    }
+    convertFlowMappingEntry(item, pendingPrefix) {
+        const prefix = pendingPrefix + this.concatenateSources(item.start || []);
+        let keyTrailing = "";
+        let key;
+        if (item.key) {
+            const keyResult = this.convertTokenWithTrailing(item.key);
+            key = keyResult.node;
+            keyTrailing = keyResult.trailing;
+        }
+        else {
+            key = this.createEmptyScalar();
+        }
+        let beforeMappingValueIndicator = keyTrailing;
+        let afterColonSpace = "";
+        let seenColon = false;
+        if (item.sep) {
+            for (const token of item.sep) {
+                if (token.type === 'map-value-ind') {
+                    seenColon = true;
+                }
+                else if (seenColon) {
+                    afterColonSpace += token.source;
+                }
+                else if (token.type === 'comma') {
+                    // This is the comma after the entry, not before
+                    // Skip it as we handle comma separately
+                }
+                else {
+                    beforeMappingValueIndicator += token.source;
+                }
+            }
+        }
+        let value;
+        let valueTrailing = "";
+        if (item.value) {
+            const valueResult = this.convertTokenWithTrailing(item.value);
+            value = valueResult.node;
+            valueTrailing = valueResult.trailing;
+            value = Object.assign(Object.assign({}, value), { prefix: afterColonSpace + value.prefix });
+        }
+        else {
+            value = this.createEmptyScalar(afterColonSpace);
+        }
+        return {
+            entry: {
+                kind: tree_1.Yaml.Kind.MappingEntry,
+                id: (0, uuid_1.randomId)(),
+                prefix,
+                markers: markers_1.emptyMarkers,
+                key,
+                beforeMappingValueIndicator,
+                value
+            },
+            trailingContent: valueTrailing
+        };
+    }
+    convertFlowSequenceEntry(item, isLast, pendingPrefix) {
+        // Start tokens may include comma from previous item
+        let prefix = pendingPrefix;
+        let hasComma = false;
+        for (const token of item.start || []) {
+            if (token.type === 'comma') {
+                hasComma = true;
+            }
+            else {
+                prefix += token.source;
+            }
+        }
+        let block;
+        let trailing = "";
+        if (item.value) {
+            const valueResult = this.convertTokenWithTrailing(item.value);
+            block = valueResult.node;
+            trailing = valueResult.trailing;
+        }
+        else if (item.key !== undefined) {
+            // Flow sequence can contain mapping entries: [a: 1, b: 2]
+            const entryResult = this.convertFlowMappingEntry(item, "");
+            block = {
+                kind: tree_1.Yaml.Kind.Mapping,
+                id: (0, uuid_1.randomId)(),
+                prefix: "",
+                markers: markers_1.emptyMarkers,
+                openingBracePrefix: undefined,
+                entries: [entryResult.entry],
+                closingBracePrefix: undefined,
+                anchor: undefined,
+                tag: undefined
+            };
+            trailing = entryResult.trailingContent;
+        }
+        else {
+            block = this.createEmptyScalar();
+        }
+        // Trailing comma prefix captures space after value before comma
+        let trailingCommaPrefix;
+        if (!isLast) {
+            trailingCommaPrefix = trailing;
+            trailing = "";
+        }
+        return {
+            entry: {
+                kind: tree_1.Yaml.Kind.SequenceEntry,
+                id: (0, uuid_1.randomId)(),
+                prefix,
+                markers: markers_1.emptyMarkers,
+                block,
+                dash: false, // Flow sequences don't use dashes
+                trailingCommaPrefix
+            },
+            trailingContent: trailing
+        };
+    }
+    convertFlowScalarWithTrailing(cst) {
+        var _a;
+        const resolved = yaml_1.CST.resolveAsScalar(cst);
+        const value = (_a = resolved === null || resolved === void 0 ? void 0 : resolved.value) !== null && _a !== void 0 ? _a : "";
+        // Determine scalar style
+        let style;
+        switch (cst.type) {
+            case 'single-quoted-scalar':
+                style = tree_1.Yaml.ScalarStyle.SINGLE_QUOTED;
+                break;
+            case 'double-quoted-scalar':
+                style = tree_1.Yaml.ScalarStyle.DOUBLE_QUOTED;
+                break;
+            default:
+                style = tree_1.Yaml.ScalarStyle.PLAIN;
+        }
+        // End tokens contain trailing whitespace/newlines
+        const trailing = this.concatenateSources(cst.end || []);
+        return {
+            node: {
+                kind: tree_1.Yaml.Kind.Scalar,
+                id: (0, uuid_1.randomId)(),
+                prefix: "",
+                markers: markers_1.emptyMarkers,
+                style,
+                anchor: undefined,
+                tag: undefined,
+                value
+            },
+            trailing
+        };
+    }
+    convertBlockScalarWithTrailing(cst) {
+        // Use CST.stringify to get the exact original source including header
+        const fullSource = yaml_1.CST.stringify(cst);
+        // Determine style from the first character (| or >)
+        const headerChar = fullSource.charAt(0);
+        const style = headerChar === '|' ? tree_1.Yaml.ScalarStyle.LITERAL : tree_1.Yaml.ScalarStyle.FOLDED;
+        // The value is everything after the header indicator (| or >)
+        const value = fullSource.substring(1);
+        // Extract anchor and tag from props if present
+        let anchor;
+        let tag;
+        for (const prop of cst.props || []) {
+            if ('type' in prop) {
+                const propTyped = prop;
+                if (propTyped.type === 'anchor') {
+                    anchor = this.parseAnchorToken(propTyped.source, "");
+                }
+                else if (propTyped.type === 'tag') {
+                    tag = this.parseTagToken(propTyped.source, "");
+                }
+            }
+        }
+        return {
+            node: {
+                kind: tree_1.Yaml.Kind.Scalar,
+                id: (0, uuid_1.randomId)(),
+                prefix: "",
+                markers: markers_1.emptyMarkers,
+                style,
+                anchor,
+                tag,
+                value
+            },
+            trailing: "" // Block scalars don't have separate end tokens
+        };
+    }
+    convertAliasWithTrailing(cst) {
+        // Alias source is like "*anchorName"
+        const key = cst.source.substring(1); // Remove the *
+        const anchor = {
+            kind: tree_1.Yaml.Kind.Anchor,
+            id: (0, uuid_1.randomId)(),
+            prefix: "",
+            markers: markers_1.emptyMarkers,
+            postfix: "",
+            key
+        };
+        // End tokens contain trailing whitespace
+        const trailing = this.concatenateSources(cst.end || []);
+        return {
+            node: {
+                kind: tree_1.Yaml.Kind.Alias,
+                id: (0, uuid_1.randomId)(),
+                prefix: "",
+                markers: markers_1.emptyMarkers,
+                anchor
+            },
+            trailing
+        };
+    }
+    parseAnchorToken(source, prefix) {
+        // Anchor source is like "&anchorName"
+        const key = source.substring(1); // Remove the &
+        return {
+            kind: tree_1.Yaml.Kind.Anchor,
+            id: (0, uuid_1.randomId)(),
+            prefix,
+            markers: markers_1.emptyMarkers,
+            postfix: "",
+            key
+        };
+    }
+    parseTagToken(source, prefix) {
+        return this.parseTagTokenWithSuffix(source, prefix, [], 0);
+    }
+    parseTagTokenWithSuffix(source, prefix, remainingTokens, startIndex) {
+        let name;
+        let tagKind;
+        if (source.startsWith('!<') && source.endsWith('>')) {
+            // Explicit global tag: !<tag:yaml.org,2002:str>
+            name = source.substring(2, source.length - 1);
+            tagKind = tree_1.Yaml.TagKind.EXPLICIT_GLOBAL;
+        }
+        else if (source.startsWith('!!')) {
+            // Implicit global tag: !!str
+            name = source.substring(2);
+            tagKind = tree_1.Yaml.TagKind.IMPLICIT_GLOBAL;
+        }
+        else {
+            // Local tag: !custom
+            name = source.substring(1);
+            tagKind = tree_1.Yaml.TagKind.LOCAL;
+        }
+        // Collect remaining tokens as suffix (whitespace after the tag)
+        let suffix = "";
+        for (let i = startIndex; i < remainingTokens.length; i++) {
+            suffix += remainingTokens[i].source;
+        }
+        return {
+            kind: tree_1.Yaml.Kind.Tag,
+            id: (0, uuid_1.randomId)(),
+            prefix,
+            markers: markers_1.emptyMarkers,
+            name,
+            suffix,
+            tagKind
+        };
+    }
+    createEmptyScalar(prefix = "") {
+        return {
+            kind: tree_1.Yaml.Kind.Scalar,
+            id: (0, uuid_1.randomId)(),
+            prefix,
+            markers: markers_1.emptyMarkers,
+            style: tree_1.Yaml.ScalarStyle.PLAIN,
+            anchor: undefined,
+            tag: undefined,
+            value: ""
+        };
+    }
+    /**
+     * Prepends whitespace to a value node in the appropriate location based on its type.
+     * - For Scalars and Aliases: prepend to prefix
+     * - For flow Mappings (with braces): prepend to openingBracePrefix
+     * - For flow Sequences (with brackets): prepend to openingBracketPrefix
+     * - For block Mappings/Sequences: prepend to first entry's prefix
+     */
+    prependWhitespaceToValue(value, whitespace) {
+        if (value.kind === tree_1.Yaml.Kind.Scalar || value.kind === tree_1.Yaml.Kind.Alias) {
+            return Object.assign(Object.assign({}, value), { prefix: whitespace + value.prefix });
+        }
+        if (value.kind === tree_1.Yaml.Kind.Mapping) {
+            const mapping = value;
+            if (mapping.openingBracePrefix !== undefined) {
+                // Flow mapping: prepend to opening brace prefix
+                return Object.assign(Object.assign({}, mapping), { openingBracePrefix: whitespace + mapping.openingBracePrefix });
+            }
+            else if (mapping.entries.length > 0) {
+                // Block mapping: prepend to first entry's prefix
+                const firstEntry = mapping.entries[0];
+                const updatedFirstEntry = Object.assign(Object.assign({}, firstEntry), { prefix: whitespace + firstEntry.prefix });
+                return Object.assign(Object.assign({}, mapping), { entries: [updatedFirstEntry, ...mapping.entries.slice(1)] });
+            }
+        }
+        if (value.kind === tree_1.Yaml.Kind.Sequence) {
+            const sequence = value;
+            if (sequence.openingBracketPrefix !== undefined) {
+                // Flow sequence: prepend to opening bracket prefix
+                return Object.assign(Object.assign({}, sequence), { openingBracketPrefix: whitespace + sequence.openingBracketPrefix });
+            }
+            else if (sequence.entries.length > 0) {
+                // Block sequence: prepend to first entry's prefix
+                const firstEntry = sequence.entries[0];
+                const updatedFirstEntry = Object.assign(Object.assign({}, firstEntry), { prefix: whitespace + firstEntry.prefix });
+                return Object.assign(Object.assign({}, sequence), { entries: [updatedFirstEntry, ...sequence.entries.slice(1)] });
+            }
+        }
+        // Fallback: prepend to prefix (shouldn't normally reach here)
+        return Object.assign(Object.assign({}, value), { prefix: whitespace + value.prefix });
+    }
+    concatenateSources(tokens) {
+        return tokens.map(t => t.source).join('');
+    }
+}
+//# sourceMappingURL=parser.js.map