@markuplint/parser-utils 3.4.0 → 3.5.0

package/lib/const.d.ts

@@ -1,7 +1,10 @@
-export declare const MASK_CHAR = '\uE000';
+export declare const MASK_CHAR = "\uE000";
 /**
  * SVG Element list
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Element
  */
 export declare const svgElementList: string[];
+export declare const reTag: RegExp;
+export declare const reTagName: RegExp;
+export declare const reSplitterTag: RegExp;

package/lib/const.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.svgElementList = exports.MASK_CHAR = void 0;
+exports.reSplitterTag = exports.reTagName = exports.reTag = exports.svgElementList = exports.MASK_CHAR = void 0;
 exports.MASK_CHAR = '\uE000';
 /**
  * SVG Element list
@@ -97,3 +97,7 @@ exports.svgElementList = [
     'tref',
     'vkern',
 ];
+exports.reTag = /^<((?:.|\s|\n)+)>\s*$/;
+// eslint-disable-next-line no-control-regex
+exports.reTagName = /^(?:[a-z][^\u0000\u0009\u000A\u000C\u0020/>]*)/i;
+exports.reSplitterTag = /<[^>]+>/g;

package/lib/create-token.d.ts

@@ -1,9 +1,4 @@
 import type { MLToken } from '@markuplint/ml-ast';
-export declare function tokenizer(
-	raw: string | null,
-	startLine: number,
-	startCol: number,
-	startOffset: number,
-): MLToken;
+export declare function tokenizer(raw: string | null, startLine: number, startCol: number, startOffset: number): MLToken;
 export declare function createTokenFromRawCode(raw: string | null, startOffset: number, rawCode: string): MLToken;
 export declare function uuid(): string;

package/lib/debugger.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.attributesToDebugMaps = exports.nodeListToDebugMaps = void 0;
-function nodeListToDebugMaps(nodeList, withAttr = false) {
+function nodeListToDebugMaps(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeList, withAttr = false) {
     return nodeList
         .map(n => {
         const r = [];
@@ -19,7 +21,9 @@ function nodeListToDebugMaps(nodeList, withAttr = false) {
         .flat();
 }
 exports.nodeListToDebugMaps = nodeListToDebugMaps;
-function attributesToDebugMaps(attributes) {
+function attributesToDebugMaps(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+attributes) {
     return attributes.map(n => {
         const r = [
             tokenDebug({

package/lib/detect-element-type.d.ts

@@ -1,6 +1,2 @@
 import type { ElementType, ParserAuthoredElementNameDistinguishing } from '@markuplint/ml-ast';
-export declare function detectElementType(
-	name: string,
-	option?: ParserAuthoredElementNameDistinguishing,
-	defaultPattern?: ParserAuthoredElementNameDistinguishing,
-): ElementType;
+export declare function detectElementType(name: string, option?: ParserAuthoredElementNameDistinguishing, defaultPattern?: ParserAuthoredElementNameDistinguishing): ElementType;

package/lib/flatten-nodes.d.ts

@@ -0,0 +1,2 @@
+import type { MLASTNode } from '@markuplint/ml-ast';
+export declare function flattenNodes(nodeTree: MLASTNode[], rawHtml: string, createLastText?: boolean): MLASTNode[];

package/lib/flatten-nodes.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenNodes = void 0;
+const tslib_1 = require("tslib");
+const remove_deprecated_node_1 = require("./remove-deprecated-node");
+const tag_splitter_1 = tslib_1.__importDefault(require("./tag-splitter"));
+const parser_utils_1 = require("@markuplint/parser-utils");
+function flattenNodes(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeTree, rawHtml, createLastText = true) {
+    const nodeOrders = arrayize(nodeTree, rawHtml);
+    {
+        /**
+         * Correction prev/next/parent
+         */
+        let prevToken = null;
+        for (const node of nodeOrders) {
+            if (!prevToken) {
+                prevToken = node;
+                continue;
+            }
+            if (node.type !== 'endtag') {
+                prevToken = node;
+                continue;
+            }
+            const endTag = node;
+            if (endTag.nodeName.toLowerCase() === 'body' && prevToken.type === 'text') {
+                const prevWreckagesText = prevToken;
+                if (prevWreckagesText) {
+                    const wreckages = (0, tag_splitter_1.default)(prevWreckagesText.raw, prevWreckagesText.startLine, prevWreckagesText.startCol);
+                    if (wreckages.length && wreckages[0]) {
+                        // console.log('wreckages\n', wreckages);
+                        const lastText = wreckages[0];
+                        const raw = lastText.raw;
+                        const startLine = lastText.line;
+                        const startCol = lastText.col;
+                        prevWreckagesText.raw = raw;
+                        prevWreckagesText.endOffset = prevWreckagesText.startOffset + raw.length;
+                        prevWreckagesText.startLine = startLine;
+                        prevWreckagesText.endLine = (0, parser_utils_1.getEndLine)(raw, startLine);
+                        prevWreckagesText.startCol = startCol;
+                        prevWreckagesText.endCol = (0, parser_utils_1.getEndCol)(raw, startCol);
+                    }
+                }
+            }
+        }
+    }
+    (0, remove_deprecated_node_1.removeDeprecatedNode)(nodeOrders);
+    {
+        /**
+         * getting last node
+         */
+        let lastNode = null;
+        for (const node of nodeOrders) {
+            if (node.isGhost) {
+                continue;
+            }
+            lastNode = node;
+        }
+        if (lastNode) {
+            if (lastNode.type === 'text') {
+                // Correction for Parse5 AST
+                // prev node: ? -> html
+                lastNode.prevNode = lastNode.parentNode && lastNode.parentNode.parentNode;
+                if (lastNode.prevNode) {
+                    lastNode.prevNode.nextNode = lastNode;
+                }
+                // parent node: body -> null
+                lastNode.parentNode = null;
+                // next node: ? -> null
+                lastNode.nextNode = null;
+            }
+            else if (createLastText) {
+                /**
+                 * create Last spaces
+                 */
+                let lastOffset = 0;
+                nodeOrders.forEach((node, i) => {
+                    lastOffset = Math.max(node.endOffset, lastOffset);
+                });
+                // console.log(lastOffset);
+                const lastTextContent = rawHtml.slice(lastOffset);
+                // console.log(`"${lastTextContent}"`);
+                if (lastTextContent) {
+                    const line = lastNode ? lastNode.endLine : 0;
+                    const col = lastNode ? lastNode.endCol : 0;
+                    const lastTextNode = {
+                        uuid: (0, parser_utils_1.uuid)(),
+                        raw: lastTextContent,
+                        startOffset: lastOffset,
+                        endOffset: lastOffset + lastTextContent.length,
+                        startLine: line,
+                        endLine: (0, parser_utils_1.getEndLine)(lastTextContent, line),
+                        startCol: col,
+                        endCol: (0, parser_utils_1.getEndCol)(lastTextContent, col),
+                        nodeName: '#text',
+                        type: 'text',
+                        parentNode: null,
+                        prevNode: lastNode,
+                        nextNode: null,
+                        isFragment: false,
+                        isGhost: false,
+                    };
+                    if (lastNode) {
+                        lastNode.nextNode = lastTextNode;
+                        if ((lastNode.type === 'starttag' || lastNode.type === 'endtag') && lastNode.pearNode) {
+                            lastNode.pearNode.nextNode = lastTextNode;
+                        }
+                    }
+                    nodeOrders.push(lastTextNode);
+                }
+            }
+        }
+    }
+    /**
+     * concat text nodes
+     */
+    const result = [];
+    nodeOrders.forEach(node => {
+        const prevNode = result[result.length - 1] || null;
+        if (node.type === 'text' && prevNode && prevNode.type === 'text') {
+            prevNode.raw = prevNode.raw + node.raw;
+            prevNode.endOffset = node.endOffset;
+            prevNode.endLine = node.endLine;
+            prevNode.endCol = node.endCol;
+            prevNode.nextNode = node.nextNode;
+            if (prevNode.parentNode && prevNode.parentNode.childNodes) {
+                prevNode.parentNode.childNodes = prevNode.parentNode.childNodes.filter(n => n.uuid !== node.uuid);
+            }
+            if (node.nextNode) {
+                node.nextNode.prevNode = prevNode;
+            }
+            return;
+        }
+        result.push(node);
+    });
+    {
+        /**
+         * Correction prev/next/parent
+         */
+        let prevToken = null;
+        for (const node of result) {
+            if (!prevToken) {
+                prevToken = node;
+                continue;
+            }
+            if (((prevToken.type === 'endtag' && prevToken.nodeName.toLowerCase() === 'body') ||
+                prevToken.type === 'doctype') &&
+                node.type === 'text') {
+                const nextNode = prevToken.nextNode;
+                prevToken.nextNode = node;
+                if (prevToken.type === 'endtag' && prevToken.pearNode) {
+                    prevToken.pearNode.nextNode = node;
+                }
+                node.prevNode = prevToken;
+                node.nextNode = nextNode;
+                node.parentNode = prevToken.parentNode;
+            }
+            // EndTag
+            if (node.type === 'starttag' && node.pearNode) {
+                const endTag = node.pearNode;
+                endTag.pearNode = node;
+                endTag.prevNode = node.prevNode;
+                endTag.nextNode = node.nextNode;
+            }
+            // Children
+            if (node.type === 'text') {
+                const parent = node.parentNode;
+                if (parent && parent.type === 'starttag' && parent.nodeName.toLowerCase() === 'html') {
+                    if (parent.childNodes && !parent.childNodes.some(n => n.uuid === node.uuid)) {
+                        parent.childNodes.push(node);
+                    }
+                }
+            }
+            prevToken = node;
+        }
+    }
+    // console.log(nodeOrders.map((n, i) => `${i}: ${n.raw.trim()}`));
+    return result;
+}
+exports.flattenNodes = flattenNodes;
+function arrayize(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeTree, rawHtml) {
+    const nodeOrders = [];
+    let prevLine = 1;
+    let prevCol = 1;
+    let currentEndOffset = 0;
+    /**
+     * pushing list
+     */
+    (0, parser_utils_1.walk)(nodeTree, node => {
+        const diff = node.startOffset - currentEndOffset;
+        if (diff > 0) {
+            const html = rawHtml.slice(currentEndOffset, node.startOffset);
+            /**
+             * first white spaces
+             */
+            if (/^\s+$/.test(html)) {
+                const spaces = html;
+                const textNode = {
+                    uuid: (0, parser_utils_1.uuid)(),
+                    raw: spaces,
+                    startOffset: currentEndOffset,
+                    endOffset: currentEndOffset + spaces.length,
+                    startLine: prevLine,
+                    endLine: (0, parser_utils_1.getEndLine)(spaces, prevLine),
+                    startCol: prevCol,
+                    endCol: (0, parser_utils_1.getEndCol)(spaces, prevCol),
+                    nodeName: '#text',
+                    type: 'text',
+                    parentNode: node.parentNode,
+                    prevNode: node.prevNode,
+                    nextNode: node,
+                    isFragment: false,
+                    isGhost: false,
+                };
+                node.prevNode = textNode;
+                if (node.parentNode && node.parentNode.childNodes) {
+                    const newChildNodes = [...node.parentNode.childNodes];
+                    if (newChildNodes.some(child => {
+                        return (
+                        // Out of start offset
+                        textNode.endOffset < child.startOffset ||
+                            // Out of end offset
+                            child.endOffset < textNode.startOffset);
+                    })) {
+                        newChildNodes.push(textNode);
+                    }
+                    newChildNodes.sort((a, b) => a.startOffset - b.startOffset);
+                    node.parentNode.childNodes = newChildNodes;
+                }
+                nodeOrders.push(textNode);
+            }
+        }
+        currentEndOffset = node.startOffset + node.raw.length;
+        prevLine = node.endLine;
+        prevCol = node.endCol;
+        // for ghost nodes
+        node.startOffset = node.startOffset || node.startOffset;
+        node.endOffset = node.endOffset || currentEndOffset;
+        nodeOrders.push(node);
+    });
+    return nodeOrders.slice();
+}

package/lib/get-location.d.ts

@@ -2,16 +2,12 @@ export declare function getLine(html: string, startOffset: number): number;
 export declare function getCol(html: string, startOffset: number): number;
 export declare function getEndLine(html: string, line: number): number;
 export declare function getEndCol(html: string, col: number): number;
-export declare function sliceFragment(
-	rawHtml: string,
-	start: number,
-	end: number,
-): {
-	startOffset: number;
-	endOffset: number;
-	startLine: number;
-	endLine: number;
-	startCol: number;
-	endCol: number;
-	raw: string;
+export declare function sliceFragment(rawHtml: string, start: number, end: number): {
+    startOffset: number;
+    endOffset: number;
+    startLine: number;
+    endLine: number;
+    startCol: number;
+    endCol: number;
+    raw: string;
 };

package/lib/idl-attributes.d.ts

@@ -1,4 +1,4 @@
 export declare function searchIDLAttribute(name: string): {
-	idlPropName: string | undefined;
-	contentAttrName: string | undefined;
+    idlPropName: string | undefined;
+    contentAttrName: string | undefined;
 };

package/lib/ignore-block.d.ts

@@ -1,4 +1,4 @@
 import type { IgnoreBlock, IgnoreTag } from './types';
 import type { MLASTNode } from '@markuplint/ml-ast';
-export declare function ignoreBlock(source: string, tags: IgnoreTag[], maskChar?: string): IgnoreBlock;
+export declare function ignoreBlock(source: string, tags: readonly IgnoreTag[], maskChar?: string): IgnoreBlock;
 export declare function restoreNode(nodeList: MLASTNode[], ignoreBlock: IgnoreBlock): MLASTNode[];

package/lib/ignore-block.js

@@ -64,7 +64,9 @@ function maskText(start, end, replaced, masking) {
         stack,
     };
 }
-function restoreNode(nodeList, ignoreBlock) {
+function restoreNode(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeList, ignoreBlock) {
     var _a, _b, _c, _d;
     nodeList = nodeList.slice();
     const { source, stack, maskChar } = ignoreBlock;

package/lib/index.d.ts

@@ -1,10 +1,14 @@
+export * from './const';
+export * from './create-token';
+export * from './debugger';
 export * from './decision';
+export * from './detect-element-type';
+export * from './flatten-nodes';
 export * from './get-location';
-export * from './create-token';
 export * from './idl-attributes';
-export * from './walker';
 export * from './ignore-block';
 export * from './ignore-front-matter';
-export * from './debugger';
 export * from './parser-error';
-export * from './detect-element-type';
+export * from './remove-deprecated-node';
+export * from './tag-splitter';
+export * from './walker';

package/lib/index.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./const"), exports);
+tslib_1.__exportStar(require("./create-token"), exports);
+tslib_1.__exportStar(require("./debugger"), exports);
 tslib_1.__exportStar(require("./decision"), exports);
+tslib_1.__exportStar(require("./detect-element-type"), exports);
+tslib_1.__exportStar(require("./flatten-nodes"), exports);
 tslib_1.__exportStar(require("./get-location"), exports);
-tslib_1.__exportStar(require("./create-token"), exports);
 tslib_1.__exportStar(require("./idl-attributes"), exports);
-tslib_1.__exportStar(require("./walker"), exports);
 tslib_1.__exportStar(require("./ignore-block"), exports);
 tslib_1.__exportStar(require("./ignore-front-matter"), exports);
-tslib_1.__exportStar(require("./debugger"), exports);
 tslib_1.__exportStar(require("./parser-error"), exports);
-tslib_1.__exportStar(require("./detect-element-type"), exports);
+tslib_1.__exportStar(require("./remove-deprecated-node"), exports);
+tslib_1.__exportStar(require("./tag-splitter"), exports);
+tslib_1.__exportStar(require("./walker"), exports);

package/lib/parser-error.d.ts

@@ -1,21 +1,13 @@
 export declare class ParserError extends Error {
-	readonly col: number;
-	readonly line: number;
-	name: string;
-	readonly nodeName: string | null;
-	readonly raw: string;
-	constructor(
-		message: string,
-		{
-			line,
-			col,
-			raw,
-			nodeName,
-		}: {
-			line?: number;
-			col?: number;
-			raw?: string;
-			nodeName?: string | null;
-		},
-	);
+    readonly col: number;
+    readonly line: number;
+    name: string;
+    readonly nodeName: string | null;
+    readonly raw: string;
+    constructor(message: string, { line, col, raw, nodeName, }: {
+        readonly line?: number;
+        readonly col?: number;
+        readonly raw?: string;
+        readonly nodeName?: string | null;
+    });
 }

package/lib/remove-deprecated-node.d.ts

@@ -0,0 +1,7 @@
+import type { MLASTNode } from '@markuplint/ml-ast';
+/**
+ *
+ * @disruptive
+ * @param nodeOrders [Disruptive change]
+ */
+export declare function removeDeprecatedNode(nodeOrders: MLASTNode[]): void;

package/lib/remove-deprecated-node.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDeprecatedNode = void 0;
+/**
+ *
+ * @disruptive
+ * @param nodeOrders [Disruptive change]
+ */
+function removeDeprecatedNode(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeOrders) {
+    /**
+     * sorting
+     */
+    nodeOrders.sort((a, b) => {
+        if (a.isGhost || b.isGhost) {
+            return 0;
+        }
+        return a.startOffset - b.startOffset;
+    });
+    /**
+     * remove duplicated node
+     */
+    const stack = {};
+    const removeIndexes = [];
+    nodeOrders.forEach((node, i) => {
+        if (node.isGhost) {
+            return;
+        }
+        const id = `${node.startLine}:${node.startCol}:${node.endLine}:${node.endCol}`;
+        if (stack[id] != null) {
+            removeIndexes.push(i);
+        }
+        stack[id] = i;
+    });
+    let r = nodeOrders.length;
+    while (r--) {
+        if (removeIndexes.includes(r)) {
+            nodeOrders.splice(r, 1);
+        }
+    }
+}
+exports.removeDeprecatedNode = removeDeprecatedNode;

package/lib/siblings-correction.js

@@ -8,7 +8,9 @@ exports.siblingsCorrection = void 0;
  * @affects nodeList[].prevNode
  * @affects nodeList[].nextNode
  */
-function siblingsCorrection(nodeList) {
+function siblingsCorrection(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeList) {
     for (let i = 0; i < nodeList.length; i++) {
         const prevNode = nodeList[i - 1] || null;
         const node = nodeList[i];

package/lib/tag-splitter.d.ts

@@ -0,0 +1,7 @@
+export interface N {
+    type: 'text' | 'starttag' | 'endtag' | 'comment' | 'boguscomment';
+    raw: string;
+    line: number;
+    col: number;
+}
+export default function tagSplitter(raw: string, line: number, col: number): N[];

package/lib/tag-splitter.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const const_1 = require("./const");
+const parser_utils_1 = require("@markuplint/parser-utils");
+function tagSplitter(raw, line, col) {
+    return withLocation(tagSplitterAsString(raw), line, col);
+}
+exports.default = tagSplitter;
+function tagSplitterAsString(raw) {
+    const tagMatches = raw.match(const_1.reSplitterTag);
+    if (!tagMatches) {
+        return [raw];
+    }
+    const tokens = Array.from(tagMatches);
+    tokens.unshift(); // remove all match
+    const nodes = [];
+    let rest = raw;
+    for (const token of tokens) {
+        const index = rest.indexOf(token);
+        let length = token.length;
+        if (index > 0) {
+            const text = rest.slice(0, index);
+            nodes.push(text);
+            length += text.length;
+        }
+        nodes.push(token);
+        rest = rest.slice(length);
+    }
+    if (rest) {
+        nodes.push(rest);
+    }
+    return nodes;
+}
+function withLocation(nodes, line, col) {
+    const result = [];
+    for (const node of nodes) {
+        if (node[0] !== '<') {
+            result.push({
+                type: 'text',
+                raw: node,
+                line,
+                col,
+            });
+        }
+        else {
+            const label = node.slice(1).slice(0, -1);
+            if (const_1.reTagName.test(label)) {
+                result.push({
+                    type: 'starttag',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '/') {
+                result.push({
+                    type: 'endtag',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '!') {
+                result.push({
+                    type: 'comment',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '?') {
+                result.push({
+                    type: 'boguscomment',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else {
+                result.push({
+                    type: 'text',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+        }
+        line = (0, parser_utils_1.getEndLine)(node, line);
+        col = (0, parser_utils_1.getEndCol)(node, col);
+    }
+    return result;
+}

package/lib/types.d.ts

@@ -1,18 +1,18 @@
 export type Code = {
-	type: string;
-	index: number;
-	startTag: string;
-	taggedCode: string;
-	endTag: string | null;
+    readonly type: string;
+    readonly index: number;
+    readonly startTag: string;
+    readonly taggedCode: string;
+    readonly endTag: string | null;
 };
 export type IgnoreTag = {
-	type: string;
-	start: RegExp;
-	end: RegExp;
+    readonly type: string;
+    readonly start: Readonly<RegExp>;
+    readonly end: Readonly<RegExp>;
 };
 export type IgnoreBlock = {
-	source: string;
-	replaced: string;
-	stack: Code[];
-	maskChar: string;
+    readonly source: string;
+    readonly replaced: string;
+    readonly stack: readonly Code[];
+    readonly maskChar: string;
 };

package/lib/walker.d.ts

@@ -1,2 +1,2 @@
 import type { MLASTNode, Walker } from '@markuplint/ml-ast';
-export declare function walk(nodeList: MLASTNode[], walker: Walker, depth?: number): void;
+export declare function walk(nodeList: readonly MLASTNode[], walker: Walker, depth?: number): void;

package/lib/walker.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.walk = void 0;
-function walk(nodeList, walker, depth = 0) {
+function walk(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeList, walker, depth = 0) {
     for (const node of nodeList) {
         walker(node, depth);
         if ('childNodes' in node) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/parser-utils",
-	"version": "3.4.0",
+	"version": "3.5.0",
 	"description": "Utility module for markuplint parser plugin",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -19,16 +19,17 @@
 		"clean": "tsc --build --clean"
 	},
 	"devDependencies": {
-		"@types/uuid": "^9.0.0"
+		"@types/uuid": "^9.0.0",
+		"type-fest": "^3.7.0"
 	},
 	"dependencies": {
-		"@markuplint/ml-ast": "3.0.0",
-		"@markuplint/types": "3.3.0",
+		"@markuplint/ml-ast": "3.1.0",
+		"@markuplint/types": "3.4.0",
 		"tslib": "^2.4.1",
 		"uuid": "^9.0.0"
 	},
 	"peerDependencies": {
 		"@markuplint/ml-core": "3.x"
 	},
-	"gitHead": "a83e0f5f214a9bbcc0286b9e269074ddca6189e7"
+	"gitHead": "0c47b2c2722f6823a17f36edbab98486275f8ab4"
 }