added vscode extensions

.vscode/extensions/pranaygp.vscode-css-peek-4.2.0/server/out/core/findDefinition.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDefinition = exports.findSymbols = exports.getLanguageService = exports.isLanguageServiceSupported = void 0;
+const path = require("path");
+const vscode_css_languageservice_1 = require("vscode-css-languageservice");
+const logger_1 = require("./../logger");
+const languageServices = {
+    css: vscode_css_languageservice_1.getCSSLanguageService(),
+    scss: vscode_css_languageservice_1.getSCSSLanguageService(),
+    less: vscode_css_languageservice_1.getLESSLanguageService(),
+};
+function isLanguageServiceSupported(serviceId) {
+    return !!languageServices[serviceId];
+}
+exports.isLanguageServiceSupported = isLanguageServiceSupported;
+function getLanguageService(document) {
+    let service = languageServices[document.languageId];
+    if (!service) {
+        logger_1.console.log("Document type is " + document.languageId + ", using css instead.");
+        service = languageServices["css"];
+    }
+    return service;
+}
+exports.getLanguageService = getLanguageService;
+function getSelection(selector) {
+    switch (selector.attribute) {
+        case "id":
+            return "#" + selector.value;
+        case "class":
+            return "." + selector.value;
+        default:
+            return selector.value;
+    }
+}
+function resolveSymbolName(symbols, i) {
+    const name = symbols[i].name;
+    if (name.startsWith("&")) {
+        return resolveSymbolName(symbols, i - 1) + name.slice(1);
+    }
+    return name;
+}
+function findSymbols(selector, stylesheetMap) {
+    const foundSymbols = [];
+    // Construct RegExp of selector to test against the symbols
+    let selection = getSelection(selector);
+    const classOrIdSelector = selector.attribute === "class" || selector.attribute === "id";
+    if (selection[0] === ".") {
+        selection = "\\" + selection;
+    }
+    if (!classOrIdSelector) {
+        // Tag selectors must have nothing, whitespace, or a combinator before it.
+        selection = "(^|[\\s>+~])" + selection;
+    }
+    const re = new RegExp(selection + "(\\[[^\\]]*\\]|:{1,2}[\\w-()]+|\\.[\\w-]+|#[\\w-]+)*\\s*$", classOrIdSelector ? "" : "i");
+    // Test all the symbols against the RegExp
+    Object.keys(stylesheetMap).forEach((uri) => {
+        const { symbols } = stylesheetMap[uri];
+        try {
+            logger_1.console.log(`${path.basename(uri)} has ${symbols.length} symbols`);
+            symbols.forEach((symbol, i) => {
+                let name = resolveSymbolName(symbols, i);
+                logger_1.console.log(`  ${symbol.location.range.start.line}:${symbol.location.range.start.character} ${symbol.deprecated ? "[deprecated] " : " "}${symbol.containerName ? `[container:${symbol.containerName}] ` : " "} [${symbol.kind}] ${name}`);
+                if (name.search(re) !== -1) {
+                    foundSymbols.push(symbol);
+                }
+                else if (!classOrIdSelector) {
+                    // Special case for tag selectors - match "*" as the rightmost character
+                    if (/\*\s*$/.test(name)) {
+                        foundSymbols.push(symbol);
+                    }
+                }
+            });
+        }
+        catch (e) {
+            logger_1.console.log(e.stack);
+        }
+    });
+    return foundSymbols;
+}
+exports.findSymbols = findSymbols;
+function findDefinition(selector, stylesheetMap) {
+    return findSymbols(selector, stylesheetMap).map(({ location }) => location);
+}
+exports.findDefinition = findDefinition;
+//# sourceMappingURL=findDefinition.js.map

.vscode/extensions/pranaygp.vscode-css-peek-4.2.0/server/out/core/findSelector.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+const logger_1 = require("./../logger");
+/**
+ * Find the selector given the document and the current cursor position.
+ * This is found by iterating forwards and backwards from the position to find a valid CSS class/id
+ *
+ * @param {vscode.TextDocument} document - The Document to check
+ * @param {vscode.Position} position - The current cursor position
+ * @returns {{attribute: string, value: string}} The valid CSS selector
+ *
+ * @memberOf PeekFileDefinitionProvider
+ */
+function findSelector(document, position, settings) {
+    const text = document.getText();
+    const offset = document.offsetAt(position);
+    let start = offset;
+    let end = offset;
+    // expand selection to this word specifically
+    while (start > 0 &&
+        text.charAt(start - 1) !== " " &&
+        text.charAt(start - 1) !== "'" &&
+        text.charAt(start - 1) !== '"' &&
+        text.charAt(start - 1) !== "\n" &&
+        text.charAt(start - 1) !== "/" &&
+        text.charAt(start - 1) !== "<")
+        start -= 1;
+    while (end < text.length &&
+        text.charAt(end) !== " " &&
+        text.charAt(end) !== "'" &&
+        text.charAt(end) !== '"' &&
+        text.charAt(end) !== "\n" &&
+        text.charAt(end) !== ">")
+        end += 1;
+    const selectorWord = text.slice(start, end);
+    let selector = null;
+    const htmlScanner = vscode_html_languageservice_1.getLanguageService().createScanner(text);
+    let attribute = null;
+    logger_1.console.log(`${selectorWord} ${start}`);
+    let tokenType = htmlScanner.scan();
+    while (tokenType !== vscode_html_languageservice_1.TokenType.EOS) {
+        switch (tokenType) {
+            case vscode_html_languageservice_1.TokenType.StartTag:
+            case vscode_html_languageservice_1.TokenType.EndTag:
+                attribute = null;
+                if (!settings.supportTags) {
+                    break;
+                }
+                // FOR DEBUGGING
+                logger_1.console.log(`  ${htmlScanner.getTokenText()} ${htmlScanner.getTokenOffset()} ${htmlScanner.getTokenEnd()}`);
+                const tokenOffset = htmlScanner.getTokenOffset();
+                if ([
+                    "javascript",
+                    "typescript",
+                    "javascriptreact",
+                    "typescriptreact",
+                ].includes(document.languageId)) {
+                    if (selectorWord[0].toUpperCase() === selectorWord[0]) {
+                        // if the first letter is uppercase, this is a JSX component
+                        break;
+                    }
+                }
+                if (start === tokenOffset)
+                    selector = { attribute: null, value: selectorWord };
+                break;
+            case vscode_html_languageservice_1.TokenType.AttributeName:
+                attribute = htmlScanner.getTokenText().toLowerCase();
+                // Convert the attribute to a standard class attribute
+                if (attribute === "classname") {
+                    attribute = "class";
+                }
+                break;
+            case vscode_html_languageservice_1.TokenType.AttributeValue:
+                // FOR DEBUGGING
+                // console.log(
+                //   `${htmlScanner.getTokenText()} ${htmlScanner.getTokenOffset()} ${htmlScanner.getTokenEnd()}`
+                // );
+                if (attribute === "class" || attribute === "id") {
+                    const values = htmlScanner.getTokenText().slice(1, -1).split(" ");
+                    // calculate startOffsets for each class/id in this attribute
+                    // +1 because we sliced earlier, so the first offset is the offset + 1
+                    let startOffset = htmlScanner.getTokenOffset() + 1;
+                    const offsets = values.map((v) => {
+                        const o = startOffset;
+                        startOffset += v.length + 1; // add 1 for the space
+                        return o;
+                    });
+                    values.forEach((value, i) => {
+                        const startOffset = offsets[i];
+                        // FOR DEBUGGING
+                        // console.log(`  ${value} ${startOffset}`);
+                        if (start === startOffset) {
+                            selector = { attribute, value };
+                        }
+                    });
+                }
+                break;
+        }
+        if (selector) {
+            break;
+        }
+        tokenType = htmlScanner.scan();
+    }
+    if (selector) {
+        logger_1.console.log(`${selector.value} is a "${selector.attribute || "html tag"}"`);
+    }
+    else {
+        logger_1.console.log("Invalid Selector");
+    }
+    return selector;
+}
+exports.default = findSelector;
+//# sourceMappingURL=findSelector.js.map

.vscode/extensions/pranaygp.vscode-css-peek-4.2.0/server/out/logger/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = exports.console = void 0;
+exports.console = null;
+function create(nConsole) {
+    exports.console = nConsole;
+}
+exports.create = create;
+//# sourceMappingURL=index.js.map

.vscode/extensions/pranaygp.vscode-css-peek-4.2.0/server/out/server.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const minimatch = require("minimatch");
+const path = require("path");
+const vscode_languageserver_1 = require("vscode-languageserver");
+const findSelector_1 = require("./core/findSelector");
+const findDefinition_1 = require("./core/findDefinition");
+const logger_1 = require("./logger");
+// Creates the LSP connection
+const connection = vscode_languageserver_1.createConnection(vscode_languageserver_1.ProposedFeatures.all);
+// Create a manager for open text documents
+const documents = new vscode_languageserver_1.TextDocuments();
+// Create a map of styleSheet URIs to the stylesheet text content
+const styleSheets = {};
+// The workspace folder this server is operating on
+let workspaceFolder;
+let hasConfigurationCapability = false;
+let hasWorkspaceFolderCapability = false;
+async function documentShouldBeIgnored(document) {
+    const settings = await getDocumentSettings(document.uri);
+    if (!settings.peekFromLanguages.includes(document.languageId) ||
+        settings.peekToExclude.find((glob) => minimatch(document.uri, glob))) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/* Handle Document Updates */
+documents.onDidOpen(async (event) => {
+    if (await documentShouldBeIgnored(event.document)) {
+        return;
+    }
+    connection.console.log(`[Server(${process.pid}) ${path.basename(workspaceFolder)}/] Document opened: ${path.basename(event.document.uri)}`);
+    if (findDefinition_1.isLanguageServiceSupported(event.document.languageId)) {
+        const languageService = findDefinition_1.getLanguageService(event.document);
+        const stylesheet = languageService.parseStylesheet(event.document);
+        const symbols = languageService.findDocumentSymbols(event.document, stylesheet);
+        styleSheets[event.document.uri] = {
+            document: event.document,
+            symbols,
+        };
+    }
+});
+documents.onDidChangeContent(async (event) => {
+    if (await documentShouldBeIgnored(event.document)) {
+        return;
+    }
+    connection.console.log(`[Server(${process.pid}) ${path.basename(workspaceFolder)}/] Document changed: ${path.basename(event.document.uri)}`);
+    if (findDefinition_1.isLanguageServiceSupported(event.document.languageId)) {
+        const languageService = findDefinition_1.getLanguageService(event.document);
+        const stylesheet = languageService.parseStylesheet(event.document);
+        const symbols = languageService.findDocumentSymbols(event.document, stylesheet);
+        styleSheets[event.document.uri] = {
+            document: event.document,
+            symbols,
+        };
+    }
+});
+documents.listen(connection);
+/* Server Initialization */
+connection.onInitialize((params) => {
+    logger_1.create(connection.console);
+    const capabilities = params.capabilities;
+    workspaceFolder = params.rootUri;
+    // Does the client support the `workspace/configuration` request?
+    // If not, we will fall back using global settings
+    hasConfigurationCapability =
+        capabilities.workspace && !!capabilities.workspace.configuration;
+    hasWorkspaceFolderCapability =
+        capabilities.workspace && !!capabilities.workspace.workspaceFolders;
+    connection.console.log(`[Server(${process.pid}) ${path.basename(workspaceFolder)}/] onInitialize`);
+    setupInitialStyleMap(params);
+    connection.console.log(`[Server(${process.pid}) ${path.basename(workspaceFolder)}/] setupInitialStylemap`);
+    return {
+        capabilities: {
+            textDocumentSync: {
+                openClose: true,
+                change: vscode_languageserver_1.TextDocumentSyncKind.Full,
+            },
+            definitionProvider: true,
+            workspaceSymbolProvider: true,
+        },
+    };
+});
+connection.onInitialized(() => {
+    if (hasConfigurationCapability) {
+        // Register for all configuration changes.
+        connection.client.register(vscode_languageserver_1.DidChangeConfigurationNotification.type, undefined);
+    }
+    if (hasWorkspaceFolderCapability) {
+        connection.workspace.onDidChangeWorkspaceFolders((_event) => {
+            connection.console.log("Workspace folder change event received.");
+        });
+    }
+});
+// The global settings, used when the `workspace/configuration` request is not supported by the client.
+const defaultSettings = {
+    supportTags: true,
+    peekFromLanguages: ["html"],
+    peekToExclude: ["**/node_modules/**", "**/bower_components/**"],
+};
+let globalSettings = defaultSettings;
+// Cache the settings of all open documents
+let documentSettings = new Map();
+connection.onDidChangeConfiguration((change) => {
+    if (hasConfigurationCapability) {
+        // Reset all cached document settings
+        documentSettings.clear();
+    }
+    else {
+        globalSettings = (change.settings.cssPeek || defaultSettings);
+    }
+});
+function getDocumentSettings(resource) {
+    if (!hasConfigurationCapability) {
+        return Promise.resolve(globalSettings);
+    }
+    let result = documentSettings.get(resource);
+    if (!result) {
+        result = connection.workspace.getConfiguration({
+            scopeUri: resource,
+            section: "cssPeek",
+        });
+        documentSettings.set(resource, result);
+    }
+    return result;
+}
+// Only keep settings for open documents
+documents.onDidClose((e) => {
+    documentSettings.delete(e.document.uri);
+});
+function setupInitialStyleMap(params) {
+    const styleFiles = params.initializationOptions.stylesheets;
+    styleFiles.forEach((fileUri) => {
+        const languageId = fileUri.fsPath.split(".").slice(-1)[0];
+        const text = fs.readFileSync(fileUri.fsPath, "utf8");
+        const document = vscode_languageserver_1.TextDocument.create(fileUri.uri, languageId, 1, text);
+        const languageService = findDefinition_1.getLanguageService(document);
+        const stylesheet = languageService.parseStylesheet(document);
+        const symbols = languageService.findDocumentSymbols(document, stylesheet);
+        styleSheets[fileUri.uri] = {
+            document,
+            symbols,
+        };
+    });
+}
+connection.onDefinition(async (textDocumentPositon) => {
+    const documentIdentifier = textDocumentPositon.textDocument;
+    const position = textDocumentPositon.position;
+    const document = documents.get(documentIdentifier.uri);
+    if (await documentShouldBeIgnored(document)) {
+        return null;
+    }
+    const settings = await getDocumentSettings(document.uri);
+    const selector = findSelector_1.default(document, position, settings);
+    if (!selector) {
+        return null;
+    }
+    return findDefinition_1.findDefinition(selector, styleSheets);
+});
+connection.onWorkspaceSymbol(({ query }) => {
+    const selectors = [
+        {
+            attribute: "class",
+            value: query,
+        },
+        {
+            attribute: "id",
+            value: query,
+        },
+    ];
+    return selectors.reduce((p, selector) => [...p, ...findDefinition_1.findSymbols(selector, styleSheets)], []);
+});
+connection.listen();
+//# sourceMappingURL=server.js.map

.vscode/extensions/pranaygp.vscode-css-peek-4.2.0/server/out/utils/selectorToString.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function default_1(selector) {
+    switch (selector.attribute) {
+        case "id":
+            return "#" + selector.value;
+        case "class":
+            return "." + selector.value;
+        default:
+            return selector.value;
+    }
+}
+exports.default = default_1;
+//# sourceMappingURL=selectorToString.js.map