🎉 initiate project *astro_rewrite*

node_modules/vscode-html-languageservice/lib/umd/utils/arrays.js

@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.binarySearch = exports.findFirst = void 0;
+    /**
+     * Takes a sorted array and a function p. The array is sorted in such a way that all elements where p(x) is false
+     * are located before all elements where p(x) is true.
+     * @returns the least x for which p(x) is true or array.length if no element fullfills the given function.
+     */
+    function findFirst(array, p) {
+        let low = 0, high = array.length;
+        if (high === 0) {
+            return 0; // no children
+        }
+        while (low < high) {
+            let mid = Math.floor((low + high) / 2);
+            if (p(array[mid])) {
+                high = mid;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+    exports.findFirst = findFirst;
+    function binarySearch(array, key, comparator) {
+        let low = 0, high = array.length - 1;
+        while (low <= high) {
+            const mid = ((low + high) / 2) | 0;
+            const comp = comparator(array[mid], key);
+            if (comp < 0) {
+                low = mid + 1;
+            }
+            else if (comp > 0) {
+                high = mid - 1;
+            }
+            else {
+                return mid;
+            }
+        }
+        return -(low + 1);
+    }
+    exports.binarySearch = binarySearch;
+});

node_modules/vscode-html-languageservice/lib/umd/utils/markup.js

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.normalizeMarkupContent = void 0;
+    function normalizeMarkupContent(input) {
+        if (!input) {
+            return undefined;
+        }
+        if (typeof input === 'string') {
+            return {
+                kind: 'markdown',
+                value: input
+            };
+        }
+        return {
+            kind: 'markdown',
+            value: input.value
+        };
+    }
+    exports.normalizeMarkupContent = normalizeMarkupContent;
+});

node_modules/vscode-html-languageservice/lib/umd/utils/object.js

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isDefined = void 0;
+    function isDefined(obj) {
+        return typeof obj !== 'undefined';
+    }
+    exports.isDefined = isDefined;
+});

node_modules/vscode-html-languageservice/lib/umd/utils/paths.js

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.join = exports.extname = exports.basename = exports.dirname = void 0;
+    /**
+     * @returns the directory name of a path.
+     */
+    function dirname(path) {
+        const idx = ~path.lastIndexOf('/') || ~path.lastIndexOf('\\');
+        if (idx === 0) {
+            return '.';
+        }
+        else if (~idx === 0) {
+            return path[0];
+        }
+        else {
+            return path.substring(0, ~idx);
+        }
+    }
+    exports.dirname = dirname;
+    /**
+     * @returns the base name of a path.
+     */
+    function basename(path) {
+        const idx = ~path.lastIndexOf('/') || ~path.lastIndexOf('\\');
+        if (idx === 0) {
+            return path;
+        }
+        else if (~idx === path.length - 1) {
+            return basename(path.substring(0, path.length - 1));
+        }
+        else {
+            return path.substr(~idx + 1);
+        }
+    }
+    exports.basename = basename;
+    /**
+     * @returns {{.far}} from boo.far or the empty string.
+     */
+    function extname(path) {
+        path = basename(path);
+        const idx = ~path.lastIndexOf('.');
+        return idx ? path.substring(~idx) : '';
+    }
+    exports.extname = extname;
+    const join = function () {
+        // Not using a function with var-args because of how TS compiles
+        // them to JS - it would result in 2*n runtime cost instead
+        // of 1*n, where n is parts.length.
+        let value = '';
+        for (let i = 0; i < arguments.length; i++) {
+            const part = arguments[i];
+            if (i > 0) {
+                // add the separater between two parts unless
+                // there already is one
+                const last = value.charCodeAt(value.length - 1);
+                if (last !== 47 /* CharCode.Slash */ && last !== 92 /* CharCode.Backslash */) {
+                    const next = part.charCodeAt(0);
+                    if (next !== 47 /* CharCode.Slash */ && next !== 92 /* CharCode.Backslash */) {
+                        value += '/';
+                    }
+                }
+            }
+            value += part;
+        }
+        return value;
+    };
+    exports.join = join;
+});

node_modules/vscode-html-languageservice/lib/umd/utils/resources.js

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-uri"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.joinPath = exports.normalizePath = exports.resolvePath = exports.extname = exports.basename = exports.dirname = exports.isAbsolutePath = void 0;
+    const vscode_uri_1 = require("vscode-uri");
+    const Slash = '/'.charCodeAt(0);
+    const Dot = '.'.charCodeAt(0);
+    function isAbsolutePath(path) {
+        return path.charCodeAt(0) === Slash;
+    }
+    exports.isAbsolutePath = isAbsolutePath;
+    function dirname(uri) {
+        const lastIndexOfSlash = uri.lastIndexOf('/');
+        return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
+    }
+    exports.dirname = dirname;
+    function basename(uri) {
+        const lastIndexOfSlash = uri.lastIndexOf('/');
+        return uri.substr(lastIndexOfSlash + 1);
+    }
+    exports.basename = basename;
+    function extname(uri) {
+        for (let i = uri.length - 1; i >= 0; i--) {
+            const ch = uri.charCodeAt(i);
+            if (ch === Dot) {
+                if (i > 0 && uri.charCodeAt(i - 1) !== Slash) {
+                    return uri.substr(i);
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ch === Slash) {
+                break;
+            }
+        }
+        return '';
+    }
+    exports.extname = extname;
+    function resolvePath(uriString, path) {
+        if (isAbsolutePath(path)) {
+            const uri = vscode_uri_1.URI.parse(uriString);
+            const parts = path.split('/');
+            return uri.with({ path: normalizePath(parts) }).toString();
+        }
+        return joinPath(uriString, path);
+    }
+    exports.resolvePath = resolvePath;
+    function normalizePath(parts) {
+        const newParts = [];
+        for (const part of parts) {
+            if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
+                // ignore
+            }
+            else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
+                newParts.pop();
+            }
+            else {
+                newParts.push(part);
+            }
+        }
+        if (parts.length > 1 && parts[parts.length - 1].length === 0) {
+            newParts.push('');
+        }
+        let res = newParts.join('/');
+        if (parts[0].length === 0) {
+            res = '/' + res;
+        }
+        return res;
+    }
+    exports.normalizePath = normalizePath;
+    function joinPath(uriString, ...paths) {
+        const uri = vscode_uri_1.URI.parse(uriString);
+        const parts = uri.path.split('/');
+        for (let path of paths) {
+            parts.push(...path.split('/'));
+        }
+        return uri.with({ path: normalizePath(parts) }).toString();
+    }
+    exports.joinPath = joinPath;
+});

node_modules/vscode-html-languageservice/lib/umd/utils/strings.js

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isLetterOrDigit = exports.repeat = exports.commonPrefixLength = exports.endsWith = exports.startsWith = void 0;
+    function startsWith(haystack, needle) {
+        if (haystack.length < needle.length) {
+            return false;
+        }
+        for (let i = 0; i < needle.length; i++) {
+            if (haystack[i] !== needle[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    exports.startsWith = startsWith;
+    /**
+     * Determines if haystack ends with needle.
+     */
+    function endsWith(haystack, needle) {
+        const diff = haystack.length - needle.length;
+        if (diff > 0) {
+            return haystack.lastIndexOf(needle) === diff;
+        }
+        else if (diff === 0) {
+            return haystack === needle;
+        }
+        else {
+            return false;
+        }
+    }
+    exports.endsWith = endsWith;
+    /**
+     * @returns the length of the common prefix of the two strings.
+     */
+    function commonPrefixLength(a, b) {
+        let i;
+        const len = Math.min(a.length, b.length);
+        for (i = 0; i < len; i++) {
+            if (a.charCodeAt(i) !== b.charCodeAt(i)) {
+                return i;
+            }
+        }
+        return len;
+    }
+    exports.commonPrefixLength = commonPrefixLength;
+    function repeat(value, count) {
+        let s = '';
+        while (count > 0) {
+            if ((count & 1) === 1) {
+                s += value;
+            }
+            value += value;
+            count = count >>> 1;
+        }
+        return s;
+    }
+    exports.repeat = repeat;
+    const _a = 'a'.charCodeAt(0);
+    const _z = 'z'.charCodeAt(0);
+    const _A = 'A'.charCodeAt(0);
+    const _Z = 'Z'.charCodeAt(0);
+    const _0 = '0'.charCodeAt(0);
+    const _9 = '9'.charCodeAt(0);
+    function isLetterOrDigit(text, index) {
+        const c = text.charCodeAt(index);
+        return (_a <= c && c <= _z) || (_A <= c && c <= _Z) || (_0 <= c && c <= _9);
+    }
+    exports.isLetterOrDigit = isLetterOrDigit;
+});