@vue/language-core 3.0.3 → 3.0.5

package/lib/parsers/scriptSetupRanges.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptSetupRanges = parseScriptSetupRanges;
 exports.parseBindingRanges = parseBindingRanges;
-exports.findBindingVars = findBindingVars;
-const utils_1 = require("../codegen/utils");
+const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
 const tsCheckReg = /^\/\/\s*@ts-(?:no)?check($|\s)/;
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
@@ -147,7 +146,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 };
                 if (ts.isVariableDeclaration(parent) && ts.isObjectBindingPattern(parent.name)) {
                     defineProps.destructured = new Map();
-                    const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name);
+                    const identifiers = (0, collectBindings_1.collectBindingIdentifiers)(ts, parent.name);
                     for (const { id, isRest, initializer } of identifiers) {
                         const name = _getNodeText(id);
                         if (isRest) {
@@ -267,8 +266,8 @@ function parseBindingRanges(ts, ast) {
     ts.forEachChild(ast, node => {
         if (ts.isVariableStatement(node)) {
             for (const decl of node.declarationList.declarations) {
-                const vars = _findBindingVars(decl.name);
-                bindings.push(...vars.map(range => ({ range })));
+                const ranges = (0, collectBindings_1.collectBindingRanges)(ts, decl.name, ast);
+                bindings.push(...ranges.map(range => ({ range })));
             }
         }
         else if (ts.isFunctionDeclaration(node)) {
@@ -332,41 +331,6 @@ function parseBindingRanges(ts, ast) {
     function _getNodeText(node) {
         return (0, shared_1.getNodeText)(ts, node, ast);
     }
-    function _findBindingVars(left) {
-        return findBindingVars(ts, left, ast);
-    }
-}
-function findBindingVars(ts, left, ast) {
-    const vars = [];
-    worker(left);
-    return vars;
-    function worker(node) {
-        if (ts.isIdentifier(node)) {
-            vars.push((0, shared_1.getStartEnd)(ts, node, ast));
-        }
-        // { ? } = ...
-        // [ ? ] = ...
-        else if (ts.isObjectBindingPattern(node) || ts.isArrayBindingPattern(node)) {
-            for (const property of node.elements) {
-                if (ts.isBindingElement(property)) {
-                    worker(property.name);
-                }
-            }
-        }
-        // { foo: ? } = ...
-        else if (ts.isPropertyAssignment(node)) {
-            worker(node.initializer);
-        }
-        // { foo } = ...
-        else if (ts.isShorthandPropertyAssignment(node)) {
-            vars.push((0, shared_1.getStartEnd)(ts, node.name, ast));
-        }
-        // { ...? } = ...
-        // [ ...? ] = ...
-        else if (ts.isSpreadAssignment(node) || ts.isSpreadElement(node)) {
-            worker(node.expression);
-        }
-    }
 }
 function getStatementRange(ts, parents, node, ast) {
     let statementRange;

package/lib/parsers/utils.d.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+import type { TextRange } from '../types';
+export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile): {
+    range: TextRange;
+    moduleName?: string;
+    isDefaultImport?: boolean;
+    isNamespace?: boolean;
+}[];
+export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): {
+    start: number;
+    end: number;
+} | undefined;

package/lib/parsers/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBindingRanges = parseBindingRanges;
+exports.getClosestMultiLineCommentRange = getClosestMultiLineCommentRange;
+const collectBindings_1 = require("../utils/collectBindings");
+const shared_1 = require("../utils/shared");
+function parseBindingRanges(ts, ast) {
+    const bindings = [];
+    ts.forEachChild(ast, node => {
+        if (ts.isVariableStatement(node)) {
+            for (const decl of node.declarationList.declarations) {
+                const ranges = (0, collectBindings_1.collectBindingRanges)(ts, decl.name, ast);
+                bindings.push(...ranges.map(range => ({ range })));
+            }
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                bindings.push({
+                    range: _getStartEnd(node.name),
+                });
+            }
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name) {
+                bindings.push({
+                    range: _getStartEnd(node.name),
+                });
+            }
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            bindings.push({
+                range: _getStartEnd(node.name),
+            });
+        }
+        if (ts.isImportDeclaration(node)) {
+            const moduleName = _getNodeText(node.moduleSpecifier).slice(1, -1);
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                const { name, namedBindings } = node.importClause;
+                if (name) {
+                    bindings.push({
+                        range: _getStartEnd(name),
+                        moduleName,
+                        isDefaultImport: true,
+                    });
+                }
+                if (namedBindings) {
+                    if (ts.isNamedImports(namedBindings)) {
+                        for (const element of namedBindings.elements) {
+                            if (element.isTypeOnly) {
+                                continue;
+                            }
+                            bindings.push({
+                                range: _getStartEnd(element.name),
+                                moduleName,
+                                isDefaultImport: element.propertyName?.text === 'default',
+                            });
+                        }
+                    }
+                    else {
+                        bindings.push({
+                            range: _getStartEnd(namedBindings.name),
+                            moduleName,
+                            isNamespace: true,
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return bindings;
+    function _getStartEnd(node) {
+        return (0, shared_1.getStartEnd)(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return (0, shared_1.getNodeText)(ts, node, ast);
+    }
+}
+function getClosestMultiLineCommentRange(ts, node, parents, ast) {
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(node)) {
+            break;
+        }
+        node = parents[i];
+    }
+    const comment = ts.getLeadingCommentRanges(ast.text, node.pos)
+        ?.reverse()
+        .find(range => range.kind === 3);
+    if (comment) {
+        return {
+            start: comment.pos,
+            end: comment.end,
+        };
+    }
+}
+//# sourceMappingURL=utils.js.map

package/lib/plugins/file-css.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/file-css.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSfc_1 = require("../utils/parseSfc");
+const plugin = ({ vueCompilerOptions }) => {
+    return {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext))) {
+                return 'vue';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'vue';
+        },
+        parseSFC2(_fileName, languageId, content) {
+            if (languageId !== 'vue') {
+                return;
+            }
+            return (0, parseSfc_1.parse)(content);
+        },
+        updateSFC(sfc, change) {
+            const blocks = [
+                sfc.descriptor.template,
+                sfc.descriptor.script,
+                sfc.descriptor.scriptSetup,
+                ...sfc.descriptor.styles,
+                ...sfc.descriptor.customBlocks,
+            ].filter(block => !!block);
+            const hitBlock = blocks.find(block => change.start >= block.loc.start.offset && change.end <= block.loc.end.offset);
+            if (!hitBlock) {
+                return;
+            }
+            const oldContent = hitBlock.content;
+            const newContent = hitBlock.content = hitBlock.content.slice(0, change.start - hitBlock.loc.start.offset)
+                + change.newText
+                + hitBlock.content.slice(change.end - hitBlock.loc.start.offset);
+            // #3449
+            const endTagRegex = new RegExp(`</\\s*${hitBlock.type}\\s*>`);
+            const insertedEndTag = endTagRegex.test(oldContent) !== endTagRegex.test(newContent);
+            if (insertedEndTag) {
+                return;
+            }
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            for (const block of blocks) {
+                if (block.loc.start.offset > change.end) {
+                    block.loc.start.offset += lengthDiff;
+                }
+                if (block.loc.end.offset >= change.end) {
+                    block.loc.end.offset += lengthDiff;
+                }
+            }
+            return sfc;
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-css.js.map

package/lib/plugins/file-vue.js

@@ -16,7 +16,22 @@ const plugin = ({ vueCompilerOptions }) => {
             if (languageId !== 'vue') {
                 return;
             }
-            return (0, parseSfc_1.parse)(content);
+            const sfc = (0, parseSfc_1.parse)(content);
+            for (const error of sfc.errors) {
+                // Handle 'Element is missing end tag.' error, see #4893
+                if ('code' in error && error.code === 24 && sfc.descriptor.template
+                    && error.loc?.start.line === sfc.descriptor.template.loc.start.line) {
+                    const template = sfc.descriptor.template;
+                    const templateText = template.content;
+                    const endTagOffset = templateText.lastIndexOf('<');
+                    const endTagText = templateText.slice(endTagOffset).trimEnd();
+                    if ('</template>'.startsWith(endTagText)) {
+                        sfc.descriptor.template.loc.end.offset = template.loc.start.offset + endTagOffset;
+                        template.content = templateText.slice(0, endTagOffset);
+                    }
+                }
+            }
+            return sfc;
         },
         updateSFC(sfc, change) {
             const blocks = [

package/lib/plugins/vue-root-tags.js

@@ -15,23 +15,16 @@ const plugin = () => {
             if (embeddedFile.id === 'root_tags') {
                 embeddedFile.content.push([sfc.content, undefined, 0, shared_1.allCodeFeatures]);
                 for (const block of [
+                    sfc.template,
                     sfc.script,
                     sfc.scriptSetup,
-                    sfc.template,
                     ...sfc.styles,
                     ...sfc.customBlocks,
                 ]) {
                     if (!block) {
                         continue;
                     }
-                    let content = block.content;
-                    if (content.endsWith('\r\n')) {
-                        content = content.slice(0, -2);
-                    }
-                    else if (content.endsWith('\n')) {
-                        content = content.slice(0, -1);
-                    }
-                    const offset = content.lastIndexOf('\n') + 1;
+                    const offset = block.content.lastIndexOf('\n', block.content.lastIndexOf('\n') - 1) + 1;
                     // fix folding range end position failed to mapping
                     (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, sfc.content.slice(block.startTagEnd, block.startTagEnd + offset), [
                         '',

package/lib/plugins/vue-style-css.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-style-css.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin = () => {
+    return {
+        version: 2.2,
+        compileSFCStyle(_lang, style) {
+            return {
+                imports: [...parseCssImports(style)],
+                bindings: [...parseCssBindings(style)],
+                classNames: [...parseCssClassNames(style)],
+            };
+        },
+    };
+};
+exports.default = plugin;
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+const cssBindingReg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([a-z_]\w*))\s*\)/gi;
+const cssClassNameReg = /(?=(\.[a-z_][-\w]*)[\s.,+~>:#)[{])/gi;
+const commentReg = /(?<=\/\*)[\s\S]*?(?=\*\/)|(?<=\/\/)[\s\S]*?(?=\n)/g;
+const fragmentReg = /(?<={)[^{]*(?=(?<!\\);)/g;
+function* parseCssImports(css) {
+    const matches = css.matchAll(cssImportReg);
+    for (const match of matches) {
+        let text = match[0];
+        let offset = match.index;
+        if (text.startsWith("'") || text.startsWith('"')) {
+            text = text.slice(1, -1);
+            offset += 1;
+        }
+        if (text) {
+            yield { text, offset };
+        }
+    }
+}
+function* parseCssBindings(css) {
+    css = fillBlank(css, commentReg);
+    const matchs = css.matchAll(cssBindingReg);
+    for (const match of matchs) {
+        const matchText = match.slice(1).find(t => t);
+        if (matchText) {
+            const offset = match.index + css.slice(match.index).indexOf(matchText);
+            yield { offset, text: matchText };
+        }
+    }
+}
+function* parseCssClassNames(css) {
+    css = fillBlank(css, commentReg, fragmentReg);
+    const matches = css.matchAll(cssClassNameReg);
+    for (const match of matches) {
+        const matchText = match[1];
+        if (matchText) {
+            yield { offset: match.index, text: matchText };
+        }
+    }
+}
+function fillBlank(css, ...regs) {
+    for (const reg of regs) {
+        css = css.replace(reg, match => ' '.repeat(match.length));
+    }
+    return css;
+}
+//# sourceMappingURL=vue-style-css.js.map

package/lib/plugins/vue-tsx.d.ts

@@ -1,5 +1,6 @@
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
+    getLang: () => string;
     getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
@@ -115,7 +116,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             name?: string;
         })[];
     } | undefined;
-    getLang: () => string;
+    getSetupSlotsAssignName: () => string | undefined;
     getGeneratedScript: () => {
         codes: Code[];
         generatedTemplate: boolean;
@@ -148,25 +149,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
                 offset: number;
             };
         };
-        codeFeatures: {
-            all: import("../types").VueCodeInformation;
-            verification: import("../types").VueCodeInformation;
-            completion: import("../types").VueCodeInformation;
-            additionalCompletion: import("../types").VueCodeInformation;
-            withoutCompletion: import("../types").VueCodeInformation;
-            navigation: import("../types").VueCodeInformation;
-            navigationWithoutRename: import("../types").VueCodeInformation;
-            navigationAndCompletion: import("../types").VueCodeInformation;
-            navigationAndAdditionalCompletion: import("../types").VueCodeInformation;
-            navigationAndVerification: import("../types").VueCodeInformation;
-            withoutNavigation: import("../types").VueCodeInformation;
-            semanticWithoutHighlight: import("../types").VueCodeInformation;
-            withoutHighlight: import("../types").VueCodeInformation;
-            withoutHighlightAndNavigation: import("../types").VueCodeInformation;
-            withoutHighlightAndCompletion: import("../types").VueCodeInformation;
-            withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
-            withoutSemantic: import("../types").VueCodeInformation;
-        };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
         inlineTsAsts: Map<string, import("typescript").SourceFile> | undefined;
         inVFor: boolean;

package/lib/plugins/vue-tsx.js

@@ -144,8 +144,7 @@ function createTsx(fileName, sfc, ctx) {
         if (getResolvedOptions().skipTemplateCodegen || !sfc.template) {
             return;
         }
-        const codes = [];
-        const codegen = (0, template_1.generateTemplate)({
+        const options = {
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
@@ -159,21 +158,23 @@ function createTsx(fileName, sfc, ctx) {
             propsAssignName: getSetupPropsAssignName(),
             inheritAttrs: getSetupInheritAttrs(),
             selfComponentName: getComponentSelfName(),
-        });
-        let current = codegen.next();
-        while (!current.done) {
-            const code = current.value;
+        };
+        const context = (0, template_1.createTemplateCodegenContext)(options, sfc.template.ast);
+        const codegen = (0, template_1.generateTemplate)(options, context);
+        const codes = [];
+        for (const code of codegen) {
+            if (typeof code === 'object') {
+                code[3] = context.resolveCodeFeatures(code[3]);
+            }
             codes.push(code);
-            current = codegen.next();
         }
         return {
-            ...current.value,
+            ...context,
             codes,
         };
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
-        const codes = [];
-        const codegen = (0, script_1.generateScript)({
+        const options = {
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
@@ -185,22 +186,19 @@ function createTsx(fileName, sfc, ctx) {
             templateCodegen: getGeneratedTemplate(),
             destructuredPropNames: getSetupDestructuredPropNames(),
             templateRefNames: getSetupTemplateRefNames(),
-        });
-        let current = codegen.next();
-        while (!current.done) {
-            const code = current.value;
-            codes.push(code);
-            current = codegen.next();
-        }
+        };
+        const context = (0, script_1.createScriptCodegenContext)(options);
+        const codegen = (0, script_1.generateScript)(options, context);
         return {
-            ...current.value,
-            codes,
+            ...context,
+            codes: [...codegen],
         };
     });
     return {
+        getLang,
         getScriptRanges,
         getScriptSetupRanges,
-        getLang,
+        getSetupSlotsAssignName,
         getGeneratedScript,
         getGeneratedTemplate,
     };

package/lib/types.d.ts

@@ -20,7 +20,7 @@ export type Code = Segment<VueCodeInformation>;
 export interface VueCompilerOptions {
     target: number;
     lib: string;
-    globalTypesPath: (fileName: string) => string | undefined;
+    globalTypesPath: (fileName: string) => string | void;
     extensions: string[];
     vitePressExtensions: string[];
     petiteVueExtensions: string[];

package/lib/utils/collectBindings.d.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+export declare function collectBindingNames(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string[];
+export declare function collectBindingRanges(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): import("../types").TextRange[];
+export declare function collectBindingIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[], isRest?: boolean, initializer?: ts.Expression | undefined): {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[];

package/lib/utils/collectBindings.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectBindingNames = collectBindingNames;
+exports.collectBindingRanges = collectBindingRanges;
+exports.collectBindingIdentifiers = collectBindingIdentifiers;
+const shared_1 = require("./shared");
+function collectBindingNames(ts, node, ast) {
+    return collectBindingIdentifiers(ts, node).map(({ id }) => (0, shared_1.getNodeText)(ts, id, ast));
+}
+function collectBindingRanges(ts, node, ast) {
+    return collectBindingIdentifiers(ts, node).map(({ id }) => (0, shared_1.getStartEnd)(ts, id, ast));
+}
+function collectBindingIdentifiers(ts, node, results = [], isRest = false, initializer = undefined) {
+    if (ts.isIdentifier(node)) {
+        results.push({ id: node, isRest, initializer });
+    }
+    else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            if (ts.isBindingElement(el)) {
+                collectBindingIdentifiers(ts, el.name, results, !!el.dotDotDotToken, el.initializer);
+            }
+        }
+    }
+    else {
+        ts.forEachChild(node, node => collectBindingIdentifiers(ts, node, results, false));
+    }
+    return results;
+}
+//# sourceMappingURL=collectBindings.js.map

package/lib/utils/ts.js

@@ -179,23 +179,25 @@ class CompilerOptionsResolver {
             // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
             experimentalModelPropName: Object.fromEntries(Object.entries(this.options.experimentalModelPropName ?? defaults.experimentalModelPropName).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
         };
-        if (this.fileExists && this.globalTypesPath === undefined) {
-            const fileDirToGlobalTypesPath = new Map();
-            resolvedOptions.globalTypesPath = fileName => {
-                const fileDir = path_browserify_1.posix.dirname(fileName);
-                if (fileDirToGlobalTypesPath.has(fileDir)) {
-                    return fileDirToGlobalTypesPath.get(fileDir);
-                }
-                const root = this.findNodeModulesRoot(fileDir, resolvedOptions.lib);
-                const result = root
-                    ? path_browserify_1.posix.join(root, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(resolvedOptions))
-                    : undefined;
-                fileDirToGlobalTypesPath.set(fileDir, result);
-                return result;
-            };
-        }
-        else {
-            resolvedOptions.globalTypesPath = () => this.globalTypesPath;
+        if (resolvedOptions.globalTypesPath === shared_1.NOOP) {
+            if (this.fileExists && this.globalTypesPath === undefined) {
+                const fileDirToGlobalTypesPath = new Map();
+                resolvedOptions.globalTypesPath = fileName => {
+                    const fileDir = path_browserify_1.posix.dirname(fileName);
+                    if (fileDirToGlobalTypesPath.has(fileDir)) {
+                        return fileDirToGlobalTypesPath.get(fileDir);
+                    }
+                    const root = this.findNodeModulesRoot(fileDir, resolvedOptions.lib);
+                    const result = root
+                        ? path_browserify_1.posix.join(root, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(resolvedOptions))
+                        : undefined;
+                    fileDirToGlobalTypesPath.set(fileDir, result);
+                    return result;
+                };
+            }
+            else {
+                resolvedOptions.globalTypesPath = () => this.globalTypesPath;
+            }
         }
         return resolvedOptions;
     }
@@ -239,7 +241,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
     return {
         target,
         lib,
-        globalTypesPath: () => undefined,
+        globalTypesPath: shared_1.NOOP,
         extensions: ['.vue'],
         vitePressExtensions: [],
         petiteVueExtensions: [],

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.3",
+	"version": "3.0.5",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,7 +13,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.4.20",
+		"@volar/language-core": "2.4.22",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/compiler-vue2": "^2.7.16",
 		"@vue/shared": "^3.5.0",
@@ -26,7 +26,7 @@
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1",
 		"@types/picomatch": "^4.0.0",
-		"@volar/typescript": "2.4.20",
+		"@volar/typescript": "2.4.22",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
 	"peerDependencies": {
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "129f30ff8d8d976abf0431063be5c6c4cf88f0fd"
+	"gitHead": "036b6b1882179d35586e16f2a5cba5150e5d18e6"
 }