eslint-plugin-yaml/dist/index.cjs.map

Lint YAML files

{"version":3,"file":"index.cjs","sources":["../node_modules/.pnpm/estree-util-value-to-estree@3.3.2/node_modules/estree-util-value-to-estree/dist/estree-util-value-to-estree.js","../src/YamlProcessor.ts","../src/getPackageJson.ts","../src/index.ts","../src/index.cts"],"sourcesContent":["/**\n * Create an ESTree identifier node for a given name.\n *\n * @param name\n *   The name of the identifier.\n * @returns\n *   The identifier node.\n */\nfunction identifier(name) {\n    return { type: 'Identifier', name };\n}\n/**\n * Create an ESTree literal node for a given value.\n *\n * @param value\n *   The value for which to create a literal.\n * @returns\n *   The literal node.\n */\nfunction literal(value) {\n    return { type: 'Literal', value };\n}\n/**\n * Create an ESTree call expression on an object member.\n *\n * @param object\n *   The object to call the method on.\n * @param name\n *   The name of the method to call.\n * @param args\n *   Arguments to pass to the function call\n * @returns\n *   The call expression node.\n */\nfunction methodCall(object, name, args) {\n    return {\n        type: 'CallExpression',\n        optional: false,\n        callee: {\n            type: 'MemberExpression',\n            computed: false,\n            optional: false,\n            object,\n            property: identifier(name)\n        },\n        arguments: args\n    };\n}\n/**\n * Turn a number or bigint into an ESTree expression. This handles positive and negative numbers and\n * bigints as well as special numbers.\n *\n * @param number\n *   The value to turn into an ESTree expression.\n * @returns\n *   An expression that represents the given value.\n */\nfunction processNumber(number) {\n    if (number < 0 || Object.is(number, -0)) {\n        return {\n            type: 'UnaryExpression',\n            operator: '-',\n            prefix: true,\n            argument: processNumber(-number)\n        };\n    }\n    if (typeof number === 'bigint') {\n        return { type: 'Literal', bigint: String(number) };\n    }\n    if (number === Number.POSITIVE_INFINITY || Number.isNaN(number)) {\n        return identifier(String(number));\n    }\n    return literal(number);\n}\n/**\n * Process an array of numbers. This is a shortcut for iterables whose constructor takes an array of\n * numbers as input.\n *\n * @param numbers\n *   The numbers to add to the array expression.\n * @returns\n *   An ESTree array expression whose elements match the input numbers.\n */\nfunction processNumberArray(numbers) {\n    const elements = [];\n    for (const value of numbers) {\n        elements.push(processNumber(value));\n    }\n    return { type: 'ArrayExpression', elements };\n}\n/**\n * Check whether a value can be constructed from its string representation.\n *\n * @param value\n *   The value to check\n * @returns\n *   Whether or not the value can be constructed from its string representation.\n */\nfunction isStringReconstructable(value) {\n    return value instanceof URL || value instanceof URLSearchParams;\n}\n/**\n * Check whether a value can be constructed from its `valueOf()` result.\n *\n * @param value\n *   The value to check\n * @returns\n *   Whether or not the value can be constructed from its `valueOf()` result.\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isValueReconstructable(value) {\n    return (value instanceof Boolean ||\n        value instanceof Date ||\n        value instanceof Number ||\n        value instanceof String);\n}\nconst wellKnownSymbols = new Map();\nfor (const name of Reflect.ownKeys(Symbol)) {\n    const value = Symbol[name];\n    if (typeof value === 'symbol') {\n        wellKnownSymbols.set(value, name);\n    }\n}\n/**\n * Check whether a value is a typed array.\n *\n * @param value\n *   The value to check\n * @returns\n *   Whether or not the value is a typed array.\n */\nfunction isTypedArray(value) {\n    return (value instanceof BigInt64Array ||\n        value instanceof BigUint64Array ||\n        value instanceof Float32Array ||\n        value instanceof Float64Array ||\n        value instanceof Int8Array ||\n        value instanceof Int16Array ||\n        value instanceof Int32Array ||\n        value instanceof Uint8Array ||\n        value instanceof Uint8ClampedArray ||\n        value instanceof Uint16Array ||\n        value instanceof Uint32Array);\n}\n/**\n * Compare two value contexts for sorting them based on reference count.\n *\n * @param a\n *   The first context to compare.\n * @param b\n *   The second context to compare.\n * @returns\n *   The count of context a minus the count of context b.\n */\nfunction compareContexts(a, b) {\n    const aReferencedByB = a.referencedBy.has(b.value);\n    const bReferencedByA = b.referencedBy.has(a.value);\n    if (aReferencedByB) {\n        if (bReferencedByA) {\n            return a.count - b.count;\n        }\n        return -1;\n    }\n    if (bReferencedByA) {\n        return 1;\n    }\n    return a.count - b.count;\n}\n/**\n * Replace the assigned right hand expression with the new expression.\n *\n * If there is no assignment expression, the original expression is returned. Otherwise the\n * assignment is modified and returned,\n *\n * @param expression\n *   The expression to use for the assignment.\n * @param assignment\n *   The existing assignmentexpression\n * @returns\n *   The new expression.\n */\nfunction replaceAssignment(expression, assignment) {\n    if (!assignment || assignment.type !== 'AssignmentExpression') {\n        return expression;\n    }\n    let node = assignment;\n    while (node.right.type === 'AssignmentExpression') {\n        node = node.right;\n    }\n    node.right = expression;\n    return assignment;\n}\n/**\n * Create an ESTree epxression to represent a symbol. Global and well-known symbols are supported.\n *\n * @param symbol\n *   THe symbol to represent.\n * @returns\n *   An ESTree expression to represent the symbol.\n */\nfunction symbolToEstree(symbol) {\n    const name = wellKnownSymbols.get(symbol);\n    if (name) {\n        return {\n            type: 'MemberExpression',\n            computed: false,\n            optional: false,\n            object: identifier('Symbol'),\n            property: identifier(name)\n        };\n    }\n    if (symbol.description && symbol === Symbol.for(symbol.description)) {\n        return methodCall(identifier('Symbol'), 'for', [literal(symbol.description)]);\n    }\n    throw new TypeError(`Only global symbols are supported, got: ${String(symbol)}`, {\n        cause: symbol\n    });\n}\n/**\n * Create an ESTree property from a key and a value expression.\n *\n * @param key\n *   The property key value\n * @param value\n *   The property value as an ESTree expression.\n * @returns\n *   The ESTree properry node.\n */\nfunction property(key, value) {\n    const computed = typeof key !== 'string';\n    return {\n        type: 'Property',\n        method: false,\n        shorthand: false,\n        computed,\n        kind: 'init',\n        key: computed ? symbolToEstree(key) : literal(key),\n        value\n    };\n}\n/**\n * Convert a Temporal value to a constructor call.\n *\n * @param name\n *   The name of the constructor.\n * @param values\n *   The numeric values to pass to the constructor.\n * @param calendar\n *   The calendar name to pass to the constructor.\n * @param defaultReferenceValue\n *   The default reference value of the temporal object.\n * @param referenceValue\n *   The reference value of the temporal object.\n * @returns\n *   An ESTree expression which represents the constructor call.\n */\nfunction temporalConstructor(name, values, calendar = 'iso8601', defaultReferenceValue, referenceValue) {\n    if (calendar && typeof calendar !== 'string') {\n        throw new Error(`Unsupported calendar: ${calendar}`, { cause: calendar });\n    }\n    const args = [];\n    if (referenceValue != null &&\n        (calendar !== 'iso8601' || referenceValue !== defaultReferenceValue)) {\n        args.push(literal(referenceValue));\n    }\n    if (calendar !== 'iso8601' || args.length !== 0) {\n        args.unshift(literal(calendar));\n    }\n    for (let index = values.length - 1; index >= 0; index -= 1) {\n        const value = values[index];\n        if ((value !== 0 && value !== 0n) || args.length !== 0) {\n            args.unshift(typeof value === 'string' ? literal(value) : processNumber(value));\n        }\n    }\n    return {\n        type: 'NewExpression',\n        callee: {\n            type: 'MemberExpression',\n            computed: false,\n            optional: false,\n            object: identifier('Temporal'),\n            property: identifier(name)\n        },\n        arguments: args\n    };\n}\n/**\n * Convert a value to an ESTree node.\n *\n * @param value\n *   The value to convert.\n * @param options\n *   Additional options to configure the output.\n * @returns\n *   The ESTree node.\n */\nexport function valueToEstree(value, options = {}) {\n    const stack = [];\n    const collectedContexts = new Map();\n    const namedContexts = [];\n    /**\n     * Analyze a value and collect all reference contexts.\n     *\n     * @param val\n     *   The value to analyze.\n     */\n    function analyze(val) {\n        if (typeof val === 'function') {\n            throw new TypeError(`Unsupported value: ${val}`, { cause: val });\n        }\n        if (typeof val !== 'object') {\n            return;\n        }\n        if (val == null) {\n            return;\n        }\n        const context = collectedContexts.get(val);\n        if (context) {\n            if (options.preserveReferences) {\n                context.count += 1;\n            }\n            for (const ancestor of stack) {\n                context.referencedBy.add(ancestor);\n            }\n            if (stack.includes(val)) {\n                if (!options.preserveReferences) {\n                    throw new Error(`Found circular reference: ${val}`, { cause: val });\n                }\n                const parent = stack.at(-1);\n                const parentContext = collectedContexts.get(parent);\n                parentContext.recursive = true;\n                context.recursive = true;\n            }\n            return;\n        }\n        collectedContexts.set(val, {\n            count: 1,\n            recursive: false,\n            referencedBy: new Set(stack),\n            value: val\n        });\n        if (isTypedArray(val)) {\n            return;\n        }\n        if (isStringReconstructable(val)) {\n            return;\n        }\n        if (isValueReconstructable(val)) {\n            return;\n        }\n        if (value instanceof RegExp) {\n            return;\n        }\n        if (typeof Temporal !== 'undefined' &&\n            (value instanceof Temporal.Duration ||\n                value instanceof Temporal.Instant ||\n                value instanceof Temporal.PlainDate ||\n                value instanceof Temporal.PlainDateTime ||\n                value instanceof Temporal.PlainYearMonth ||\n                value instanceof Temporal.PlainMonthDay ||\n                value instanceof Temporal.PlainTime ||\n                value instanceof Temporal.ZonedDateTime)) {\n            return;\n        }\n        stack.push(val);\n        if (val instanceof Map) {\n            for (const pair of val) {\n                analyze(pair[0]);\n                analyze(pair[1]);\n            }\n        }\n        else if (Array.isArray(val) || val instanceof Set) {\n            for (const entry of val) {\n                analyze(entry);\n            }\n        }\n        else {\n            const proto = Object.getPrototypeOf(val);\n            if (proto != null && proto !== Object.prototype && !options.instanceAsObject) {\n                throw new TypeError(`Unsupported value: ${val}`, { cause: val });\n            }\n            for (const key of Reflect.ownKeys(val)) {\n                analyze(val[key]);\n            }\n        }\n        stack.pop();\n    }\n    /**\n     * Recursively generate the ESTree expression needed to reconstruct the value.\n     *\n     * @param val\n     *   The value to process.\n     * @param isDeclaration\n     *   Whether or not this is for a variable declaration.\n     * @returns\n     *   The ESTree expression to reconstruct the value.\n     */\n    function generate(val, isDeclaration) {\n        if (val === undefined) {\n            return identifier(String(val));\n        }\n        if (val == null || typeof val === 'string' || typeof val === 'boolean') {\n            return literal(val);\n        }\n        if (typeof val === 'bigint' || typeof val === 'number') {\n            return processNumber(val);\n        }\n        if (typeof val === 'symbol') {\n            return symbolToEstree(val);\n        }\n        const context = collectedContexts.get(val);\n        if (!isDeclaration && context?.name) {\n            return identifier(context.name);\n        }\n        if (isValueReconstructable(val)) {\n            return {\n                type: 'NewExpression',\n                callee: identifier(val.constructor.name),\n                arguments: [generate(val.valueOf())]\n            };\n        }\n        if (val instanceof RegExp) {\n            return {\n                type: 'Literal',\n                regex: { pattern: val.source, flags: val.flags }\n            };\n        }\n        if (typeof Buffer !== 'undefined' && Buffer.isBuffer(val)) {\n            return methodCall(identifier('Buffer'), 'from', [processNumberArray(val)]);\n        }\n        if (isTypedArray(val)) {\n            return {\n                type: 'NewExpression',\n                callee: identifier(val.constructor.name),\n                arguments: [processNumberArray(val)]\n            };\n        }\n        if (isStringReconstructable(val)) {\n            return {\n                type: 'NewExpression',\n                callee: identifier(val.constructor.name),\n                arguments: [literal(String(val))]\n            };\n        }\n        if (typeof Temporal !== 'undefined') {\n            if (val instanceof Temporal.Duration) {\n                return temporalConstructor('Duration', [\n                    val.years,\n                    val.months,\n                    val.weeks,\n                    val.days,\n                    val.hours,\n                    val.minutes,\n                    val.seconds,\n                    val.milliseconds,\n                    val.microseconds,\n                    val.nanoseconds\n                ]);\n            }\n            if (val instanceof Temporal.Instant) {\n                return temporalConstructor('Instant', [val.epochNanoseconds]);\n            }\n            if (val instanceof Temporal.PlainDate) {\n                const iso = val.getISOFields();\n                return temporalConstructor('PlainDate', [iso.isoYear, iso.isoMonth, iso.isoDay], iso.calendar);\n            }\n            if (val instanceof Temporal.PlainDateTime) {\n                const iso = val.getISOFields();\n                return temporalConstructor('PlainDateTime', [\n                    iso.isoYear,\n                    iso.isoMonth,\n                    iso.isoDay,\n                    iso.isoHour,\n                    iso.isoMinute,\n                    iso.isoSecond,\n                    iso.isoMillisecond,\n                    iso.isoMicrosecond,\n                    iso.isoNanosecond\n                ], iso.calendar);\n            }\n            if (val instanceof Temporal.PlainMonthDay) {\n                const iso = val.getISOFields();\n                return temporalConstructor('PlainMonthDay', [iso.isoMonth, iso.isoDay], iso.calendar, 1972, iso.isoYear);\n            }\n            if (val instanceof Temporal.PlainTime) {\n                const iso = val.getISOFields();\n                return temporalConstructor('PlainTime', [\n                    iso.isoHour,\n                    iso.isoMinute,\n                    iso.isoSecond,\n                    iso.isoMillisecond,\n                    iso.isoMicrosecond,\n                    iso.isoNanosecond\n                ]);\n            }\n            if (val instanceof Temporal.PlainYearMonth) {\n                const iso = val.getISOFields();\n                return temporalConstructor('PlainYearMonth', [iso.isoYear, iso.isoMonth], iso.calendar, 1, iso.isoDay);\n            }\n            if (val instanceof Temporal.ZonedDateTime) {\n                const iso = val.getISOFields();\n                return temporalConstructor('ZonedDateTime', [val.epochNanoseconds, val.timeZoneId], iso.calendar);\n            }\n        }\n        if (Array.isArray(val)) {\n            const elements = Array.from({ length: val.length });\n            let trimmable;\n            for (let index = 0; index < val.length; index += 1) {\n                if (!(index in val)) {\n                    elements[index] = null;\n                    trimmable = undefined;\n                    continue;\n                }\n                const child = val[index];\n                const childContext = collectedContexts.get(child);\n                if (context &&\n                    childContext &&\n                    namedContexts.indexOf(childContext) >= namedContexts.indexOf(context)) {\n                    elements[index] = null;\n                    trimmable ||= index;\n                    childContext.assignment = {\n                        type: 'AssignmentExpression',\n                        operator: '=',\n                        left: {\n                            type: 'MemberExpression',\n                            computed: true,\n                            optional: false,\n                            object: identifier(context.name),\n                            property: literal(index)\n                        },\n                        right: childContext.assignment || identifier(childContext.name)\n                    };\n                }\n                else {\n                    elements[index] = generate(child);\n                    trimmable = undefined;\n                }\n            }\n            if (trimmable != null) {\n                elements.splice(trimmable);\n            }\n            return {\n                type: 'ArrayExpression',\n                elements\n            };\n        }\n        if (val instanceof Set) {\n            const elements = [];\n            let finalizer;\n            for (const child of val) {\n                if (finalizer) {\n                    finalizer = methodCall(finalizer, 'add', [generate(child)]);\n                }\n                else {\n                    const childContext = collectedContexts.get(child);\n                    if (context &&\n                        childContext &&\n                        namedContexts.indexOf(childContext) >= namedContexts.indexOf(context)) {\n                        finalizer = methodCall(identifier(context.name), 'add', [generate(child)]);\n                    }\n                    else {\n                        elements.push(generate(child));\n                    }\n                }\n            }\n            if (context && finalizer) {\n                context.assignment = replaceAssignment(finalizer, context.assignment);\n            }\n            return {\n                type: 'NewExpression',\n                callee: identifier('Set'),\n                arguments: elements.length ? [{ type: 'ArrayExpression', elements }] : []\n            };\n        }\n        if (val instanceof Map) {\n            const elements = [];\n            let finalizer;\n            for (const [key, item] of val) {\n                if (finalizer) {\n                    finalizer = methodCall(finalizer, 'set', [generate(key), generate(item)]);\n                }\n                else {\n                    const keyContext = collectedContexts.get(key);\n                    const itemContext = collectedContexts.get(item);\n                    if (context &&\n                        ((keyContext && namedContexts.indexOf(keyContext) >= namedContexts.indexOf(context)) ||\n                            (itemContext && namedContexts.indexOf(itemContext) >= namedContexts.indexOf(context)))) {\n                        finalizer = methodCall(identifier(context.name), 'set', [\n                            generate(key),\n                            generate(item)\n                        ]);\n                    }\n                    else {\n                        elements.push({\n                            type: 'ArrayExpression',\n                            elements: [generate(key), generate(item)]\n                        });\n                    }\n                }\n            }\n            if (context && finalizer) {\n                context.assignment = replaceAssignment(finalizer, context.assignment);\n            }\n            return {\n                type: 'NewExpression',\n                callee: identifier('Map'),\n                arguments: elements.length ? [{ type: 'ArrayExpression', elements }] : []\n            };\n        }\n        const properties = [];\n        if (Object.getPrototypeOf(val) == null) {\n            properties.push(property('__proto__', literal(null)));\n        }\n        const object = val;\n        const propertyDescriptors = [];\n        for (const key of Reflect.ownKeys(val)) {\n            // TODO [>=4] Throw an error for getters.\n            const child = object[key];\n            const { configurable, enumerable, writable } = Object.getOwnPropertyDescriptor(val, key);\n            const childContext = collectedContexts.get(child);\n            if (!configurable || !enumerable || !writable) {\n                const propertyDescriptor = [property('value', generate(child))];\n                if (configurable) {\n                    propertyDescriptor.push(property('configurable', literal(true)));\n                }\n                if (enumerable) {\n                    propertyDescriptor.push(property('enumerable', literal(true)));\n                }\n                if (writable) {\n                    propertyDescriptor.push(property('writable', literal(true)));\n                }\n                propertyDescriptors.push(property(key, {\n                    type: 'ObjectExpression',\n                    properties: propertyDescriptor\n                }));\n            }\n            else if (context &&\n                childContext &&\n                namedContexts.indexOf(childContext) >= namedContexts.indexOf(context)) {\n                childContext.assignment = {\n                    type: 'AssignmentExpression',\n                    operator: '=',\n                    left: {\n                        type: 'MemberExpression',\n                        computed: true,\n                        optional: false,\n                        object: identifier(context.name),\n                        property: generate(key)\n                    },\n                    right: childContext.assignment || generate(child)\n                };\n            }\n            else {\n                properties.push(property(key, generate(child)));\n            }\n        }\n        const objectExpression = {\n            type: 'ObjectExpression',\n            properties\n        };\n        if (propertyDescriptors.length) {\n            if (!context) {\n                return methodCall(identifier('Object'), 'defineProperties', [\n                    objectExpression,\n                    {\n                        type: 'ObjectExpression',\n                        properties: propertyDescriptors\n                    }\n                ]);\n            }\n            context.assignment = replaceAssignment(methodCall(identifier('Object'), 'defineProperties', [\n                identifier(context.name),\n                {\n                    type: 'ObjectExpression',\n                    properties: propertyDescriptors\n                }\n            ]), context.assignment);\n        }\n        return objectExpression;\n    }\n    analyze(value);\n    for (const [val, context] of collectedContexts) {\n        if (context.recursive || context.count > 1) {\n            // Assign reused or recursive references to a variable.\n            context.name = `$${namedContexts.length}`;\n            namedContexts.push(context);\n        }\n        else {\n            // Otherwise don’t treat it as a reference.\n            collectedContexts.delete(val);\n        }\n    }\n    if (!namedContexts.length) {\n        return generate(value);\n    }\n    const params = namedContexts.sort(compareContexts).map((context) => ({\n        type: 'AssignmentPattern',\n        left: identifier(context.name),\n        right: generate(context.value, true)\n    }));\n    const rootContext = collectedContexts.get(value);\n    const finalizers = [];\n    for (const context of collectedContexts.values()) {\n        if (context !== rootContext && context.assignment) {\n            finalizers.push(context.assignment);\n        }\n    }\n    finalizers.push(rootContext ? rootContext.assignment || identifier(rootContext.name) : generate(value));\n    return {\n        type: 'CallExpression',\n        optional: false,\n        arguments: [],\n        callee: {\n            type: 'ArrowFunctionExpression',\n            expression: false,\n            params,\n            body: {\n                type: 'SequenceExpression',\n                expressions: finalizers\n            }\n        }\n    };\n}\n//# sourceMappingURL=estree-util-value-to-estree.js.map","import type { Linter, AST } from \"eslint\"\nimport type * as estree from \"estree\"\nimport { valueToEstree } from \"estree-util-value-to-estree\"\nimport { loadAll, type YAMLException } from \"js-yaml\"\nimport { type LintError as JsHintLintErrors, JSHINT as jshint } from \"jshint\"\nimport path from \"path\"\n\n// it seems mark can be undefined issue #67\ntype LoadYamlException = {\n  message: string\n  mark?: { buffer: string; line: number; column: number }\n}\ntype LoadYamlValue = {\n  value: unknown[]\n  messages: Linter.LintMessage[]\n}\n\ntype Path = string\n\nexport class YamlProcessor implements Linter.Processor<Linter.ProcessorFile> {\n  /** Map of file paths to their YAML value and warnings. */\n  private parsedFiles = new Map<Path, LoadYamlValue>()\n\n  // TODO: Implement autofix\n  public supportsAutofix = false\n\n  /** The preprocess method is called by ESLint before the parser is run. */\n  public preprocess(text: string, path: Path): Linter.ProcessorFile[] {\n    return [{ text, filename: path }]\n  }\n\n  /** Parser for YAML files. */\n  public parseForESLint(code: string, options?: { filePath?: Path }): Linter.ESLintParseResult {\n    // initialize AST\n    const ast: AST.Program = {\n      type: \"Program\",\n      body: [],\n      sourceType: \"script\",\n      tokens: [],\n      comments: [],\n      range: [0, code.length],\n      loc: {\n        start: { line: 1, column: 0 },\n        end: {\n          line: code.split(\"\\n\")?.length ?? 1,\n          column: code.split(\"\\n\")?.slice(-1)?.[0]?.length ?? 0,\n        },\n      },\n    }\n\n    try {\n      // load YAML\n      const { yamlDocs, warnings } = this.loadYaml(code, options?.filePath)\n\n      // build AST\n      const statement: estree.ExpressionStatement = {\n        type: \"ExpressionStatement\",\n        expression: valueToEstree(yamlDocs),\n      }\n      ast.body.push(statement)\n\n      // save warnings for postprocess\n      this.parsedFiles.set(code, {\n        value: yamlDocs,\n        messages: warnings.map((warning) => ({\n          ruleId: \"yaml-warning\",\n          severity: 2,\n          message: warning.message,\n          source: warning.mark?.buffer,\n          line: warning.mark?.line ?? 0,\n          column: warning.mark?.column ?? 0,\n        })),\n      })\n    } catch (err) {\n      const { message, mark } = err as LoadYamlException\n      const key = options?.filePath ?? code\n      this.parsedFiles.set(key, {\n        value: [],\n        messages: [\n          {\n            ruleId: \"invalid-yaml\",\n            severity: 2,\n            message,\n            line: mark?.line ?? 0,\n            column: mark?.column ?? 0,\n          },\n        ],\n      })\n    }\n\n    return { ast }\n  }\n\n  /** The postprocess method is called by ESLint after the parser is run. */\n  public postprocess(_messages: Linter.LintMessage[][], filePath: Path): Linter.LintMessage[] {\n    if (!this.isYaml(filePath)) {\n      return []\n    }\n\n    let value = this.parsedFiles.get(filePath)\n    if (value === undefined) {\n      // search all the keys that end with filePath\n      const key = Array.from(this.parsedFiles.keys()).find((key) => key.endsWith(filePath))\n      if (key === undefined) {\n        return [] // no value found\n      }\n      value = this.parsedFiles.get(key)!\n    }\n\n    if (value.messages.length > 0) {\n      this.parsedFiles.delete(filePath)\n      return value.messages\n    }\n\n    const errors = value.value.flatMap((yamlDoc) => this.lintJSON(yamlDoc))\n    const linter_messages: Linter.LintMessage[] = errors.map((error) => {\n      const { reason, evidence, line, character } = error\n      return {\n        ruleId: \"bad-yaml\",\n        severity: 2,\n        message: reason,\n        source: evidence,\n        line,\n        column: character,\n      }\n    })\n\n    this.parsedFiles.delete(filePath)\n    return linter_messages\n  }\n\n  private isYaml(filePath: Path) {\n    const fileExtension = path.extname(filePath)\n    return [\".yaml\", \".yml\"].includes(fileExtension)\n  }\n\n  private loadYaml(fileContent: string, filePath?: Path) {\n    const warnings: YAMLException[] = []\n    const yamlDocs = loadAll(fileContent, undefined, {\n      filename: filePath,\n      json: false,\n      onWarning: (exception) => {\n        warnings.push(exception)\n      },\n    })\n    return { yamlDocs, warnings }\n  }\n\n  private lintJSON(yamlDoc: LoadYamlValue[\"value\"][0]): JsHintLintErrors[] {\n    const yaml_json = JSON.stringify(yamlDoc, null, 2)\n    jshint(yaml_json)\n    const data = jshint.data()\n    const errors = data?.errors ?? []\n    return errors\n  }\n}\n","import fs from \"fs\"\nimport path from \"path\"\nimport { fileURLToPath } from \"url\"\n\nexport function getPackageJson(): { name: string; version: string } {\n  try {\n    const dirname = typeof __dirname === \"string\" ? __dirname : path.dirname(fileURLToPath(import.meta.url))\n    const pkgPath = path.join(path.dirname(dirname), \"package.json\")\n    return JSON.parse(fs.readFileSync(pkgPath, \"utf8\"))\n  } catch (err) {\n    console.error(err)\n    return {\n      name: \"eslint-plugin-yaml\",\n      version: \"1.0.3\",\n    }\n  }\n}\n","import type { Linter, ESLint } from \"eslint\"\nimport { YamlProcessor } from \"./YamlProcessor.js\"\nimport { getPackageJson } from \"./getPackageJson.js\"\n\nconst pkg = getPackageJson()\n\n// Create singleton instance\nconst yamlProcessor = new YamlProcessor()\n\nconst parser: Linter.ESTreeParser = {\n  meta: {\n    name: \"yaml-eslint-parser\",\n    version: pkg.version,\n  },\n  parseForESLint: yamlProcessor.parseForESLint.bind(yamlProcessor),\n}\n\nconst processors = {\n  [pkg.name]: {\n    meta: {\n      name: pkg.name,\n      version: pkg.version,\n    },\n    postprocess: yamlProcessor.postprocess.bind(yamlProcessor),\n  },\n} satisfies ESLint.Plugin[\"processors\"]\n\nconst meta = {\n  name: pkg.name,\n  version: pkg.version,\n  type: \"problem\",\n  docs: {\n    description: \"YAML linting\",\n    category: \"Parsing Issues\",\n    recommended: false,\n    url: \"https://github.com/aminya/eslint-plugin-yaml\",\n  },\n  fixable: \"code\",\n  schema: [],\n}\n\nconst plugin = {\n  meta,\n  processors,\n  configs: {\n    recommended: {} as Linter.Config,\n    legacy: {} as Linter.LegacyConfig,\n  },\n} satisfies ESLint.Plugin\n\nconst files = [\"**/*.yml\", \"**/*.yaml\", \"!**/node_modules/**\", \"!**/pnpm-lock.yaml\", \"**/.github/**.{yml,yaml}\"]\n\nconst recommendedConfig: Linter.Config = {\n  name: `${pkg.name}/recommended}`,\n  files,\n  processor: {\n    name: pkg.name,\n    preprocess: yamlProcessor.preprocess.bind(yamlProcessor),\n    postprocess: yamlProcessor.postprocess.bind(yamlProcessor),\n  },\n  plugins: {\n    [pkg.name]: plugin,\n  },\n  languageOptions: {\n    parser,\n  },\n}\n\nplugin.configs.recommended = recommendedConfig\n\nconst legacyConfig: Linter.LegacyConfig = {\n  overrides: [\n    {\n      plugins: [pkg.name],\n      files,\n      processor: `yaml/${pkg.name}`,\n    },\n  ],\n}\n\nplugin.configs.legacy = legacyConfig\n\nexport default plugin\n","import eslintPluginYaml from \"./index.js\"\nexport default eslintPluginYaml\nmodule.exports = eslintPluginYaml\nmodule.exports.default = eslintPluginYaml\n"],"names":["identifier","name","type","literal","value","methodCall","object","args","optional","callee","computed","property","arguments","processNumber","number","Object","is","operator","prefix","argument","bigint","String","Number","POSITIVE_INFINITY","isNaN","processNumberArray","numbers","elements","push","isStringReconstructable","URL","URLSearchParams","isValueReconstructable","Boolean","Date","wellKnownSymbols","Map","Reflect","ownKeys","Symbol","set","isTypedArray","BigInt64Array","BigUint64Array","Float32Array","Float64Array","Int8Array","Int16Array","Int32Array","Uint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","compareContexts","a","b","aReferencedByB","referencedBy","has","bReferencedByA","count","replaceAssignment","expression","assignment","node","right","symbolToEstree","symbol","get","description","for","TypeError","cause","key","method","shorthand","kind","temporalConstructor","values","calendar","defaultReferenceValue","referenceValue","Error","length","unshift","index","valueToEstree","options","stack","collectedContexts","namedContexts","analyze","val","context","preserveReferences","ancestor","add","includes","parent","at","parentContext","recursive","Set","RegExp","Temporal","Duration","Instant","PlainDate","PlainDateTime","PlainYearMonth","PlainMonthDay","PlainTime","ZonedDateTime","pair","Array","isArray","entry","proto","getPrototypeOf","prototype","instanceAsObject","pop","generate","isDeclaration","undefined","constructor","valueOf","regex","pattern","source","flags","Buffer","isBuffer","years","months","weeks","days","hours","minutes","seconds","milliseconds","microseconds","nanoseconds","epochNanoseconds","iso","getISOFields","isoYear","isoMonth","isoDay","isoHour","isoMinute","isoSecond","isoMillisecond","isoMicrosecond","isoNanosecond","timeZoneId","from","trimmable","child","childContext","indexOf","left","splice","finalizer","item","keyContext","itemContext","properties","propertyDescriptors","configurable","enumerable","writable","getOwnPropertyDescriptor","propertyDescriptor","objectExpression","delete","params","sort","map","rootContext","finalizers","body","expressions","path","_a","_c","_b","_e","_d","loadAll","jshint","fileURLToPath","eslintPluginYaml"],"mappings":"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