volar-service-pug 0.0.0

package/out/baseParse.d.ts

@@ -0,0 +1,67 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function baseParse(pugCode: string): {
+    htmlCode: string;
+    mappings: import("@volar/source-map").Mapping<any>[];
+    pugTextDocument: TextDocument;
+    error: {
+        code: string;
+        msg: string;
+        line: number;
+        column: number;
+        filename: string;
+    } | undefined;
+    ast: Node | undefined;
+    emptyLineEnds: number[];
+};
+export type Node = BlockNode | MixinNode | TagNode | TextNode | CommentNode | BlockCommentNode;
+export interface BlockNode {
+    type: 'Block';
+    nodes: Node[];
+    line: number;
+}
+export interface TagNode {
+    type: 'Tag';
+    name: string;
+    selfClosing: boolean;
+    block: BlockNode;
+    attrs: {
+        name: string;
+        val: string | true;
+        line: number;
+        column: number;
+        mustEscape: boolean;
+    }[];
+    attributeBlocks: {}[];
+    isInline: boolean;
+    line: number;
+    column: number;
+}
+export interface TextNode {
+    type: 'Text';
+    val: string;
+    line: number;
+    column: number;
+}
+export interface CommentNode {
+    type: 'Comment';
+    val: string;
+    buffer: boolean;
+    line: number;
+    column: number;
+}
+export interface BlockCommentNode {
+    type: 'BlockComment';
+    block: BlockNode;
+    val: string;
+    buffer: boolean;
+    line: number;
+    column: number;
+}
+export interface MixinNode {
+    type: 'Mixin';
+    name: string;
+    args: null;
+    block: BlockNode | null;
+    line: number;
+    column: number;
+}

package/out/baseParse.js

@@ -0,0 +1,276 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseParse = void 0;
+const muggle_string_1 = require("muggle-string");
+const source_map_1 = require("@volar/source-map");
+const pug_lexer_1 = __importDefault(require("pug-lexer"));
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const pugParser = require('pug-parser');
+function baseParse(pugCode) {
+    const fileName = 'foo.pug';
+    const pugTextDocument = vscode_languageserver_textdocument_1.TextDocument.create('file:///a.pug', 'jade', 0, pugCode);
+    const codes = [];
+    let error;
+    let emptyLineEnds = [];
+    let attrsBlocks;
+    let ast;
+    try {
+        const tokens = (0, pug_lexer_1.default)(pugCode, { filename: fileName });
+        emptyLineEnds = collectEmptyLineEnds(tokens);
+        attrsBlocks = collectAttrsBlocks(tokens);
+        ast = pugParser(tokens, { filename: fileName, src: pugCode });
+        visitNode(ast, undefined, undefined);
+        codes.push([
+            '',
+            undefined,
+            pugCode.trimEnd().length,
+        ]);
+    }
+    catch (e) {
+        const _error = e;
+        error = {
+            ..._error,
+            line: _error.line - 1,
+            column: _error.column - 1,
+        };
+    }
+    ;
+    return {
+        htmlCode: (0, muggle_string_1.toString)(codes),
+        mappings: (0, source_map_1.buildMappings)(codes),
+        pugTextDocument,
+        error,
+        ast,
+        emptyLineEnds,
+    };
+    function visitNode(node, next, parent) {
+        if (node.type === 'Block') {
+            for (let i = 0; i < node.nodes.length; i++) {
+                visitNode(node.nodes[i], node.nodes[i + 1], node);
+            }
+        }
+        else if (node.type === 'Mixin') {
+            if (node.block) {
+                visitNode(node.block, undefined, node);
+            }
+        }
+        else if (node.type === 'Tag') {
+            const pugTagRange = getDocRange(node.line, node.column, node.name.length);
+            codes.push([
+                '',
+                undefined,
+                pugTagRange.start,
+            ]);
+            const selfClosing = node.block.nodes.length === 0;
+            addStartTag(node, selfClosing);
+            if (!selfClosing) {
+                visitNode(node.block, next, parent);
+                addEndTag(node, next, parent);
+            }
+            codes.push([
+                '',
+                undefined,
+                pugTagRange.start,
+            ]);
+        }
+        else if (node.type === 'Text') {
+            codes.push([
+                node.val,
+                undefined,
+                getDocOffset(node.line, node.column),
+            ]);
+        }
+    }
+    function addStartTag(node, selfClosing) {
+        codes.push([
+            '',
+            undefined,
+            getDocOffset(node.line, node.column),
+        ]);
+        codes.push('<');
+        const tagRange = getDocRange(node.line, node.column, node.name.length);
+        if (pugCode.substring(tagRange.start, tagRange.end) === node.name) {
+            codes.push([
+                node.name,
+                undefined,
+                tagRange.start,
+            ]);
+        }
+        else {
+            codes.push(node.name);
+        }
+        const noTitleAttrs = node.attrs.filter(attr => !attr.mustEscape && attr.name !== 'class');
+        const noTitleClassAttrs = node.attrs.filter(attr => !attr.mustEscape && attr.name === 'class');
+        const attrsBlock = attrsBlocks.get(getDocOffset(node.line, node.column)); // support attr auto-complete in spaces
+        const hasClassAttr = attrsBlock && attrsBlock.text.match(/\bclass\b\s*=/i);
+        if (!hasClassAttr) {
+            addClassesOrStyles(noTitleClassAttrs, 'class');
+        }
+        for (const attr of noTitleAttrs) {
+            codes.push(' ');
+            codes.push(attr.name);
+            if (typeof attr.val !== 'boolean') {
+                codes.push('=');
+                codes.push([
+                    attr.val,
+                    undefined,
+                    getDocOffset(attr.line, attr.column),
+                ]);
+            }
+        }
+        if (attrsBlock) {
+            codes.push(' ');
+            codes.push([
+                attrsBlock.text,
+                undefined,
+                attrsBlock.offset,
+            ]);
+        }
+        if (selfClosing) {
+            codes.push(' />');
+        }
+        else {
+            codes.push('>');
+        }
+    }
+    function addEndTag(node, next, parent) {
+        let nextStart;
+        if (next) {
+            if (next.type === 'Block') {
+                nextStart = getDocOffset(next.line, 1);
+            }
+            else {
+                nextStart = getDocOffset(next.line, next.column);
+            }
+        }
+        else if (!parent) {
+            nextStart = pugCode.length;
+        }
+        if (nextStart !== undefined) {
+            codes.push([
+                '',
+                undefined,
+                nextStart,
+            ]);
+        }
+        codes.push(`</${node.name}>`);
+    }
+    function addClassesOrStyles(attrs, attrName) {
+        if (!attrs.length)
+            return;
+        codes.push(' ');
+        codes.push(attrName);
+        codes.push('=');
+        codes.push('"');
+        for (const attr of attrs) {
+            if (typeof attr.val !== 'boolean') {
+                codes.push(' ');
+                codes.push([
+                    attr.val.slice(1, -1),
+                    undefined,
+                    getDocOffset(attr.line, attr.column + 1),
+                ]);
+            }
+        }
+        codes.push('"');
+    }
+    function collectEmptyLineEnds(tokens) {
+        const ends = [];
+        for (const token of tokens) {
+            if (token.type === 'newline' || token.type === 'outdent') {
+                let currentLine = token.loc.start.line - 2;
+                let prevLine = getLineText(pugTextDocument, currentLine);
+                while (prevLine.trim() === '') {
+                    ends.push(pugTextDocument.offsetAt({ line: currentLine + 1, character: 0 }) - 1);
+                    if (currentLine <= 0)
+                        break;
+                    currentLine--;
+                    prevLine = getLineText(pugTextDocument, currentLine);
+                }
+            }
+        }
+        return ends.sort((a, b) => a - b);
+    }
+    function collectAttrsBlocks(tokens) {
+        const blocks = new Map();
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token.type === 'start-attributes') {
+                let tagStart = token;
+                for (let j = i - 1; j >= 0; j--) {
+                    const prevToken = tokens[j];
+                    if (prevToken.type === 'newline'
+                        || prevToken.type === 'indent'
+                        || prevToken.type === 'outdent'
+                        || prevToken.type === ':')
+                        break;
+                    tagStart = prevToken;
+                    if (prevToken.type === 'tag')
+                        break;
+                }
+                let prevToken = token;
+                let text = '';
+                for (i++; i < tokens.length; i++) {
+                    const attrToken = tokens[i];
+                    addPrevSpace(attrToken);
+                    if (attrToken.type === 'attribute') {
+                        let attrText = pugCode.substring(getDocOffset(attrToken.loc.start.line, attrToken.loc.start.column), getDocOffset(attrToken.loc.end.line, attrToken.loc.end.column));
+                        if (typeof attrToken.val === 'string' && attrText.indexOf('=') >= 0) {
+                            let valText = attrToken.val;
+                            if (valText.startsWith('`') && valText.endsWith('`')) {
+                                if (valText.indexOf('"') === -1) {
+                                    valText = `"${valText.slice(1, -1)}"`;
+                                }
+                                else {
+                                    valText = `'${valText.slice(1, -1)}'`;
+                                }
+                            }
+                            valText = valText.replace(/ \\\n/g, '//\n');
+                            text += attrText.substring(0, attrText.lastIndexOf(attrToken.val)) + valText;
+                        }
+                        else {
+                            text += attrText;
+                        }
+                    }
+                    else if (attrToken.type === 'end-attributes') {
+                        blocks.set(getDocOffset(tagStart.loc.start.line, tagStart.loc.start.column), {
+                            offset: getDocOffset(token.loc.end.line, token.loc.end.column),
+                            text,
+                        });
+                        break;
+                    }
+                    prevToken = attrToken;
+                }
+                function addPrevSpace(currentToken) {
+                    text += pugCode.substring(getDocOffset(prevToken.loc.end.line, prevToken.loc.end.column), getDocOffset(currentToken.loc.start.line, currentToken.loc.start.column)).replace(/,/g, '\n');
+                }
+            }
+        }
+        return blocks;
+    }
+    function getDocOffset(pugLine, pugColumn) {
+        return pugTextDocument.offsetAt({ line: pugLine - 1, character: pugColumn - 1 });
+    }
+    function getDocRange(pugLine, pugColumn, length) {
+        const start = getDocOffset(pugLine, pugColumn);
+        const end = start + length;
+        return {
+            start,
+            end,
+        };
+    }
+}
+exports.baseParse = baseParse;
+function getLineText(document, line) {
+    const endOffset = document.offsetAt({ line: line + 1, character: 0 });
+    const end = document.positionAt(endOffset);
+    const text = document.getText({
+        start: { line: line, character: 0 },
+        end: end.line === line ? end : document.positionAt(endOffset - 1),
+    });
+    return text;
+}
+//# sourceMappingURL=baseParse.js.map

package/out/empty.d.ts

@@ -0,0 +1,3 @@
+import type { Service } from '@volar/language-service';
+declare const _default: () => Service;
+export default _default;

package/out/empty.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+console.warn('volar-service-pug: This plugin is not support on web yet.');
+exports.default = () => () => ({});
+//# sourceMappingURL=empty.js.map

package/out/index.d.ts

@@ -0,0 +1,12 @@
+import type { Service, ServiceContext } from '@volar/language-service';
+import type * as html from 'vscode-html-languageservice';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import * as pug from './languageService';
+export interface PluginInstance extends ReturnType<Service> {
+    getHtmlLs: () => html.LanguageService;
+    updateCustomData(extraData: html.IHTMLDataProvider[]): void;
+    getPugLs: () => pug.LanguageService;
+    getPugDocument: (document: TextDocument) => pug.PugDocument | undefined;
+}
+declare const _default: () => (context: ServiceContext | undefined) => PluginInstance;
+export default _default;

package/out/index.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const volar_service_html_1 = __importDefault(require("volar-service-html"));
+const language_service_1 = require("@volar/language-service");
+const pug = __importStar(require("./languageService"));
+exports.default = () => (context) => {
+    if (!context) {
+        return {};
+    }
+    const pugDocuments = new WeakMap();
+    const htmlPlugin = (0, volar_service_html_1.default)()(context);
+    const pugLs = pug.getLanguageService(htmlPlugin.getHtmlLs());
+    return {
+        ...htmlPlugin,
+        getPugLs: () => pugLs,
+        getPugDocument,
+        resolveRuleContext(context) {
+            worker(context.document, (pugDocument) => {
+                if (pugDocument.ast) {
+                    context.pug = {
+                        rootNode: pugDocument.ast,
+                        languageService: pugLs,
+                    };
+                }
+            });
+            return context;
+        },
+        provideCompletionItems(document, position, _) {
+            return worker(document, (pugDocument) => {
+                return pugLs.doComplete(pugDocument, position, context.env.documentContext);
+            });
+        },
+        provideDiagnostics(document) {
+            return worker(document, (pugDocument) => {
+                if (pugDocument.error) {
+                    return [{
+                            source: 'pug',
+                            code: pugDocument.error.code,
+                            message: pugDocument.error.msg,
+                            range: {
+                                start: { line: pugDocument.error.line, character: pugDocument.error.column },
+                                end: { line: pugDocument.error.line, character: pugDocument.error.column },
+                            },
+                        }];
+                }
+                return [];
+            });
+        },
+        provideHover(document, position) {
+            return worker(document, async (pugDocument) => {
+                const hoverSettings = await context.env.getConfiguration?.('html.hover');
+                return pugLs.doHover(pugDocument, position, hoverSettings);
+            });
+        },
+        provideDocumentHighlights(document, position) {
+            return worker(document, (pugDocument) => {
+                return pugLs.findDocumentHighlights(pugDocument, position);
+            });
+        },
+        provideDocumentLinks(document) {
+            return worker(document, (pugDocument) => {
+                if (context.env.documentContext) {
+                    return pugLs.findDocumentLinks(pugDocument, context.env.documentContext);
+                }
+            });
+        },
+        provideDocumentSymbols(document, token) {
+            return worker(document, async (pugDoc) => {
+                const htmlResult = await htmlPlugin.provideDocumentSymbols?.(pugDoc.map.virtualFileDocument, token) ?? [];
+                const pugResult = htmlResult.map(htmlSymbol => language_service_1.transformer.asDocumentSymbol(htmlSymbol, range => pugDoc.map.toSourceRange(range))).filter((symbol) => symbol !== undefined);
+                return pugResult;
+            });
+        },
+        provideFoldingRanges(document) {
+            return worker(document, (pugDocument) => {
+                return pugLs.getFoldingRanges(pugDocument);
+            });
+        },
+        provideSelectionRanges(document, positions) {
+            return worker(document, (pugDocument) => {
+                return pugLs.getSelectionRanges(pugDocument, positions);
+            });
+        },
+        async provideAutoInsertionEdit(document, position, insertContext) {
+            return worker(document, async (pugDocument) => {
+                const lastCharacter = insertContext.lastChange.text[insertContext.lastChange.text.length - 1];
+                if (insertContext.lastChange.rangeLength === 0 && lastCharacter === '=') {
+                    const enabled = (await context.env.getConfiguration?.('html.autoCreateQuotes')) ?? true;
+                    if (enabled) {
+                        const text = pugLs.doQuoteComplete(pugDocument, position, await context.env.getConfiguration?.('html.completion'));
+                        if (text) {
+                            return text;
+                        }
+                    }
+                }
+            });
+        },
+    };
+    function worker(document, callback) {
+        const pugDocument = getPugDocument(document);
+        if (!pugDocument)
+            return;
+        return callback(pugDocument);
+    }
+    function getPugDocument(document) {
+        if (document.languageId !== 'jade')
+            return;
+        const cache = pugDocuments.get(document);
+        if (cache) {
+            const [cacheVersion, cacheDoc] = cache;
+            if (cacheVersion === document.version) {
+                return cacheDoc;
+            }
+        }
+        const doc = pugLs.parsePugDocument(document.getText());
+        pugDocuments.set(document, [document.version, doc]);
+        return doc;
+    }
+};
+//# sourceMappingURL=index.js.map

package/out/languageService.d.ts

@@ -0,0 +1,32 @@
+import type * as html from 'vscode-html-languageservice';
+export { PugDocument } from './pugDocument';
+export * from './baseParse';
+export interface LanguageService extends ReturnType<typeof getLanguageService> {
+}
+export declare function getLanguageService(htmlLs: html.LanguageService): {
+    parsePugDocument: (pugCode: string) => {
+        htmlTextDocument: html.TextDocument;
+        htmlDocument: html.HTMLDocument;
+        map: import("@volar/language-service").SourceMapWithDocuments<any>;
+        htmlCode: string;
+        mappings: import("@volar/source-map").Mapping<any>[];
+        pugTextDocument: html.TextDocument;
+        error: {
+            code: string;
+            msg: string;
+            line: number;
+            column: number;
+            filename: string;
+        } | undefined;
+        ast: import("./baseParse").Node | undefined;
+        emptyLineEnds: number[];
+    };
+    doComplete: (pugDoc: import("./pugDocument").PugDocument, pos: html.Position, documentContext: html.DocumentContext | undefined, options?: html.CompletionConfiguration | undefined) => Promise<html.CompletionList | undefined>;
+    findDocumentHighlights: (pugDoc: import("./pugDocument").PugDocument, pos: html.Position) => html.DocumentHighlight[] | undefined;
+    findDocumentLinks: (pugDoc: import("./pugDocument").PugDocument, docContext: html.DocumentContext) => html.DocumentLink[];
+    doHover: (pugDoc: import("./pugDocument").PugDocument, pos: html.Position, options?: html.HoverSettings | undefined) => html.Hover | undefined;
+    createScanner: (pugDoc: import("./pugDocument").PugDocument, initialOffset?: number) => html.Scanner | undefined;
+    getSelectionRanges: (pugDoc: import("./pugDocument").PugDocument, posArr: html.Position[]) => html.SelectionRange[];
+    doQuoteComplete: (pugDoc: import("./pugDocument").PugDocument, pos: html.Position, options?: html.CompletionConfiguration | undefined) => string | null | undefined;
+    getFoldingRanges: (pugDoc: import("./pugDocument").PugDocument) => html.FoldingRange[];
+};

package/out/languageService.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLanguageService = void 0;
+const pugDocument_1 = require("./pugDocument");
+const completion_1 = require("./services/completion");
+const documentHighlight_1 = require("./services/documentHighlight");
+const documentLinks_1 = require("./services/documentLinks");
+const hover_1 = require("./services/hover");
+const scanner_1 = require("./services/scanner");
+const selectionRanges_1 = require("./services/selectionRanges");
+const foldingRanges_1 = require("./services/foldingRanges");
+const quoteComplete_1 = require("./services/quoteComplete");
+__exportStar(require("./baseParse"), exports);
+function getLanguageService(htmlLs) {
+    return {
+        parsePugDocument: (0, pugDocument_1.register)(htmlLs),
+        doComplete: (0, completion_1.register)(htmlLs),
+        findDocumentHighlights: (0, documentHighlight_1.register)(htmlLs),
+        findDocumentLinks: (0, documentLinks_1.register)(htmlLs),
+        doHover: (0, hover_1.register)(htmlLs),
+        createScanner: (0, scanner_1.register)(htmlLs),
+        getSelectionRanges: (0, selectionRanges_1.register)(htmlLs),
+        doQuoteComplete: (0, quoteComplete_1.register)(htmlLs),
+        getFoldingRanges: (0, foldingRanges_1.register)(),
+    };
+}
+exports.getLanguageService = getLanguageService;
+//# sourceMappingURL=languageService.js.map

package/out/pugDocument.d.ts

@@ -0,0 +1,22 @@
+import { SourceMapWithDocuments } from '@volar/language-service';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import type * as html from 'vscode-html-languageservice';
+export interface PugDocument extends ReturnType<ReturnType<typeof register>> {
+}
+export declare function register(htmlLs: html.LanguageService): (pugCode: string) => {
+    htmlTextDocument: TextDocument;
+    htmlDocument: html.HTMLDocument;
+    map: SourceMapWithDocuments<any>;
+    htmlCode: string;
+    mappings: import("@volar/source-map").Mapping<any>[];
+    pugTextDocument: TextDocument;
+    error: {
+        code: string;
+        msg: string;
+        line: number;
+        column: number;
+        filename: string;
+    } | undefined;
+    ast: import("./baseParse").Node | undefined;
+    emptyLineEnds: number[];
+};

package/out/pugDocument.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const language_service_1 = require("@volar/language-service");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const baseParse_1 = require("./baseParse");
+const source_map_1 = require("@volar/source-map");
+function register(htmlLs) {
+    return (pugCode) => {
+        const parsed = (0, baseParse_1.baseParse)(pugCode);
+        const htmlTextDocument = vscode_languageserver_textdocument_1.TextDocument.create('foo.html', 'html', 0, parsed.htmlCode);
+        const sourceMap = new language_service_1.SourceMapWithDocuments(parsed.pugTextDocument, htmlTextDocument, new source_map_1.SourceMap(parsed.mappings));
+        const htmlDocument = htmlLs.parseHTMLDocument(htmlTextDocument);
+        return {
+            ...parsed,
+            htmlTextDocument,
+            htmlDocument,
+            map: sourceMap,
+        };
+    };
+}
+exports.register = register;
+//# sourceMappingURL=pugDocument.js.map

package/out/services/completion.d.ts

@@ -0,0 +1,3 @@
+import type * as html from 'vscode-html-languageservice';
+import type { PugDocument } from '../pugDocument';
+export declare function register(htmlLs: html.LanguageService): (pugDoc: PugDocument, pos: html.Position, documentContext: html.DocumentContext | undefined, options?: html.CompletionConfiguration | undefined) => Promise<html.CompletionList | undefined>;

package/out/services/completion.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const language_service_1 = require("@volar/language-service");
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+function register(htmlLs) {
+    const docForEmptyLineCompletion = vscode_html_languageservice_1.TextDocument.create('file:///foo.html', 'html', 0, '< />');
+    const htmlDocForEmptyLineCompletion = htmlLs.parseHTMLDocument(docForEmptyLineCompletion);
+    const posForEmptyLine = docForEmptyLineCompletion.positionAt(1);
+    return async (pugDoc, pos, documentContext, options) => {
+        const offset = pugDoc.pugTextDocument.offsetAt(pos);
+        if (pugDoc.emptyLineEnds.includes(offset)) {
+            const htmlComplete = htmlLs.doComplete(docForEmptyLineCompletion, posForEmptyLine, htmlDocForEmptyLineCompletion, options);
+            for (const item of htmlComplete.items) {
+                item.textEdit = undefined;
+            }
+            return htmlComplete;
+        }
+        const htmlPos = pugDoc.map.toGeneratedPosition(pos);
+        if (!htmlPos)
+            return;
+        const htmlComplete = documentContext ? await htmlLs.doComplete2(pugDoc.htmlTextDocument, htmlPos, pugDoc.htmlDocument, documentContext, options) : htmlLs.doComplete(pugDoc.htmlTextDocument, htmlPos, pugDoc.htmlDocument, options);
+        return language_service_1.transformer.asCompletionList(htmlComplete, htmlRange => pugDoc.map.toSourceRange(htmlRange), pugDoc.map.virtualFileDocument);
+    };
+}
+exports.register = register;
+//# sourceMappingURL=completion.js.map

package/out/services/documentHighlight.d.ts

@@ -0,0 +1,3 @@
+import type * as html from 'vscode-html-languageservice';
+import type { PugDocument } from '../pugDocument';
+export declare function register(htmlLs: html.LanguageService): (pugDoc: PugDocument, pos: html.Position) => html.DocumentHighlight[] | undefined;

package/out/services/documentHighlight.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const language_service_1 = require("@volar/language-service");
+function register(htmlLs) {
+    return (pugDoc, pos) => {
+        const htmlPos = pugDoc.map.toGeneratedPosition(pos);
+        if (!htmlPos)
+            return;
+        const htmlResult = htmlLs.findDocumentHighlights(pugDoc.map.virtualFileDocument, htmlPos, pugDoc.htmlDocument);
+        return language_service_1.transformer.asLocations(htmlResult, htmlRange => pugDoc.map.toSourceRange(htmlRange));
+    };
+}
+exports.register = register;
+//# sourceMappingURL=documentHighlight.js.map

package/out/services/documentLinks.d.ts

@@ -0,0 +1,3 @@
+import type * as html from 'vscode-html-languageservice';
+import type { PugDocument } from '../pugDocument';
+export declare function register(htmlLs: html.LanguageService): (pugDoc: PugDocument, docContext: html.DocumentContext) => html.DocumentLink[];

package/out/services/documentLinks.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const language_service_1 = require("@volar/language-service");
+function register(htmlLs) {
+    return (pugDoc, docContext) => {
+        const htmlResult = htmlLs.findDocumentLinks(pugDoc.map.virtualFileDocument, docContext);
+        return language_service_1.transformer.asLocations(htmlResult, htmlRange => pugDoc.map.toSourceRange(htmlRange));
+    };
+}
+exports.register = register;
+//# sourceMappingURL=documentLinks.js.map

package/out/services/foldingRanges.d.ts

@@ -0,0 +1,3 @@
+import type * as html from 'vscode-html-languageservice';
+import type { PugDocument } from '../pugDocument';
+export declare function register(): (pugDoc: PugDocument) => html.FoldingRange[];

package/out/services/foldingRanges.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-types"));
+function register() {
+    return (pugDoc) => {
+        const result = [];
+        const docEndPos = pugDoc.pugTextDocument.positionAt(pugDoc.pugTextDocument.getText().length);
+        if (pugDoc.ast) {
+            visitNode(pugDoc.ast, findMinimalEndLine(docEndPos.line));
+        }
+        return result;
+        function visitNode(node, endLine) {
+            if (node.type === 'Block') {
+                for (let i = 0; i < node.nodes.length; i++) {
+                    const child = node.nodes[i];
+                    const next = i + 1 < node.nodes.length ? node.nodes[i + 1] : undefined;
+                    visitNode(child, next ? findMinimalEndLine(next.line - 2) : endLine);
+                }
+            }
+            else if (node.type === 'Tag' || node.type === 'BlockComment') {
+                const nodeLine = node.line - 1; // one base to zero base
+                if (nodeLine !== endLine) {
+                    result.push(vscode.FoldingRange.create(nodeLine, endLine, undefined, undefined, node.type === 'BlockComment' ? vscode.FoldingRangeKind.Comment : undefined));
+                }
+                visitNode(node.block, endLine);
+            }
+        }
+        function findMinimalEndLine(endLine) {
+            while (endLine > 0 && getLineText(endLine).trim() === '') {
+                endLine--;
+            }
+            return endLine;
+        }
+        function getLineText(line) {
+            if (line === docEndPos.line) {
+                return pugDoc.pugTextDocument.getText({
+                    start: { line: line, character: 0 },
+                    end: docEndPos,
+                });
+            }
+            const text = pugDoc.pugTextDocument.getText({
+                start: { line: line, character: 0 },
+                end: { line: line + 1, character: 0 },
+            });
+            return text.substring(0, text.length - 1);
+        }
+    };
+}
+exports.register = register;
+//# sourceMappingURL=foldingRanges.js.map

package/out/services/hover.d.ts

@@ -0,0 +1,3 @@
+import type * as html from 'vscode-html-languageservice';
+import type { PugDocument } from '../pugDocument';
+export declare function register(htmlLs: html.LanguageService): (pugDoc: PugDocument, pos: html.Position, options?: html.HoverSettings | undefined) => html.Hover | undefined;

package/out/services/hover.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const language_service_1 = require("@volar/language-service");
+function register(htmlLs) {
+    return (pugDoc, pos, options) => {
+        const htmlPos = pugDoc.map.toGeneratedPosition(pos);
+        if (!htmlPos)
+            return;
+        const htmlResult = htmlLs.doHover(pugDoc.map.virtualFileDocument, htmlPos, pugDoc.htmlDocument, options);
+        if (!htmlResult)
+            return;
+        return language_service_1.transformer.asHover(htmlResult, htmlRange => pugDoc.map.toSourceRange(htmlRange));
+    };
+}
+exports.register = register;
+//# sourceMappingURL=hover.js.map

package/out/services/quoteComplete.d.ts

@@ -0,0 +1,3 @@
+import type * as html from 'vscode-html-languageservice';
+import type { PugDocument } from '../pugDocument';
+export declare function register(htmlLs: html.LanguageService): (pugDoc: PugDocument, pos: html.Position, options?: html.CompletionConfiguration | undefined) => string | null | undefined;

package/out/services/quoteComplete.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+function register(htmlLs) {
+    return (pugDoc, pos, options) => {
+        const htmlStart = pugDoc.map.toGeneratedPosition(pos);
+        if (!htmlStart)
+            return;
+        const text = htmlLs.doQuoteComplete(pugDoc.htmlTextDocument, htmlStart, pugDoc.htmlDocument, options);
+        return text;
+    };
+}
+exports.register = register;
+//# sourceMappingURL=quoteComplete.js.map

package/out/services/scanner.d.ts

@@ -0,0 +1,3 @@
+import type * as html from 'vscode-html-languageservice';
+import type { PugDocument } from '../pugDocument';
+export declare function register(htmlLs: html.LanguageService): (pugDoc: PugDocument, initialOffset?: number) => html.Scanner | undefined;

package/out/services/scanner.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+function register(htmlLs) {
+    return (pugDoc, initialOffset = 0) => {
+        const htmlOffset = pugDoc.map.map.mappings
+            .filter(mapping => mapping.sourceRange[0] >= initialOffset)
+            .sort((a, b) => a.generatedRange[0] - b.generatedRange[0])[0]
+            ?.generatedRange[0];
+        if (htmlOffset === undefined)
+            return;
+        const htmlScanner = htmlLs.createScanner(pugDoc.htmlTextDocument.getText(), htmlOffset);
+        // @ts-expect-error
+        const scanner = {
+            scan: () => {
+                return htmlScanner.scan();
+            },
+            getTokenOffset: () => {
+                return pugDoc.map.map.toSourceOffset(htmlScanner.getTokenOffset())?.[0] ?? -1;
+            },
+            getTokenEnd: () => {
+                return pugDoc.map.map.toSourceOffset(htmlScanner.getTokenEnd())?.[0] ?? -1;
+            },
+            getTokenText: htmlScanner.getTokenText,
+            getTokenLength: htmlScanner.getTokenLength,
+            getTokenError: htmlScanner.getTokenError,
+            getScannerState: htmlScanner.getScannerState,
+        };
+        return scanner;
+    };
+}
+exports.register = register;
+//# sourceMappingURL=scanner.js.map

package/out/services/selectionRanges.d.ts

@@ -0,0 +1,3 @@
+import type * as html from 'vscode-html-languageservice';
+import type { PugDocument } from '../pugDocument';
+export declare function register(htmlLs: html.LanguageService): (pugDoc: PugDocument, posArr: html.Position[]) => html.SelectionRange[];

package/out/services/selectionRanges.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const language_service_1 = require("@volar/language-service");
+function register(htmlLs) {
+    return (pugDoc, posArr) => {
+        const htmlPosArr = posArr
+            .map(position => pugDoc.map.toGeneratedPosition(position))
+            .filter((v) => !!v);
+        const htmlResult = htmlLs.getSelectionRanges(pugDoc.map.virtualFileDocument, htmlPosArr);
+        return language_service_1.transformer.asLocations(htmlResult, htmlRange => pugDoc.map.toSourceRange(htmlRange));
+    };
+}
+exports.register = register;
+//# sourceMappingURL=selectionRanges.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "volar-service-pug",
+	"version": "0.0.0",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"rules.d.ts",
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/services.git",
+		"directory": "packages/pug"
+	},
+	"dependencies": {
+		"muggle-string": "^0.2.2",
+		"pug-lexer": "^5.0.1",
+		"pug-parser": "^6.0.0",
+		"volar-service-html": "0.0.0",
+		"vscode-html-languageservice": "^5.0.4",
+		"vscode-languageserver-textdocument": "^1.0.8",
+		"vscode-languageserver-types": "^3.17.2"
+	},
+	"peerDependencies": {
+		"@volar/language-service": "*",
+		"@volar/source-map": "*"
+	},
+	"browser": {
+		"./out/index.js": "./out/empty.js"
+	},
+	"gitHead": "1011561ac4bbf79c53c3b80c27692569bf861519"
+}

package/rules.d.ts

@@ -0,0 +1,10 @@
+import * as pug from 'volar-service-pug';
+
+declare module '@volar/language-service' {
+	interface RuleContext {
+		pug?: {
+			rootNode: pug.Node;
+			languageService: pug.LanguageService;
+		}
+	}
+}