@mavogel/cdk-vscode-server 0.0.2

package/node_modules/node-html-parser/dist/nodes/node.d.ts

@@ -0,0 +1,24 @@
+import NodeType from './type';
+import HTMLElement from './html';
+/**
+ * Node Class as base class for TextNode and HTMLElement.
+ */
+export default abstract class Node {
+    parentNode: HTMLElement;
+    abstract rawTagName: string;
+    abstract nodeType: NodeType;
+    childNodes: Node[];
+    range: readonly [number, number];
+    abstract text: string;
+    abstract rawText: string;
+    abstract toString(): string;
+    abstract clone(): Node;
+    constructor(parentNode?: HTMLElement, range?: [number, number]);
+    /**
+     * Remove current node
+     */
+    remove(): this;
+    get innerText(): string;
+    get textContent(): string;
+    set textContent(val: string);
+}

package/node_modules/node-html-parser/dist/nodes/node.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var he_1 = require("he");
+/**
+ * Node Class as base class for TextNode and HTMLElement.
+ */
+var Node = /** @class */ (function () {
+    function Node(parentNode, range) {
+        if (parentNode === void 0) { parentNode = null; }
+        this.parentNode = parentNode;
+        this.childNodes = [];
+        Object.defineProperty(this, 'range', {
+            enumerable: false,
+            writable: true,
+            configurable: true,
+            value: range !== null && range !== void 0 ? range : [-1, -1]
+        });
+    }
+    /**
+     * Remove current node
+     */
+    Node.prototype.remove = function () {
+        var _this = this;
+        if (this.parentNode) {
+            var children = this.parentNode.childNodes;
+            this.parentNode.childNodes = children.filter(function (child) {
+                return _this !== child;
+            });
+            this.parentNode = null;
+        }
+        return this;
+    };
+    Object.defineProperty(Node.prototype, "innerText", {
+        get: function () {
+            return this.rawText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "textContent", {
+        get: function () {
+            return (0, he_1.decode)(this.rawText);
+        },
+        set: function (val) {
+            this.rawText = (0, he_1.encode)(val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Node;
+}());
+exports.default = Node;

package/node_modules/node-html-parser/dist/nodes/text.d.ts

@@ -0,0 +1,44 @@
+import HTMLElement from './html';
+import Node from './node';
+import NodeType from './type';
+/**
+ * TextNode to contain a text element in DOM tree.
+ * @param {string} value [description]
+ */
+export default class TextNode extends Node {
+    clone(): TextNode;
+    constructor(rawText: string, parentNode?: HTMLElement, range?: [number, number]);
+    /**
+     * Node Type declaration.
+     * @type {Number}
+     */
+    nodeType: NodeType;
+    rawTagName: string;
+    private _rawText;
+    private _trimmedRawText?;
+    private _trimmedText?;
+    get rawText(): string;
+    /**
+     * Set rawText and invalidate trimmed caches
+     */
+    set rawText(text: string);
+    /**
+     * Returns raw text with all whitespace trimmed except single leading/trailing non-breaking space
+     */
+    get trimmedRawText(): string;
+    /**
+     * Returns text with all whitespace trimmed except single leading/trailing non-breaking space
+     */
+    get trimmedText(): string;
+    /**
+     * Get unescaped text value of current node and its children.
+     * @return {string} text content
+     */
+    get text(): string;
+    /**
+     * Detect if the node contains only white space.
+     * @return {boolean}
+     */
+    get isWhitespace(): boolean;
+    toString(): string;
+}

package/node_modules/node-html-parser/dist/nodes/text.js

@@ -0,0 +1,144 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var he_1 = require("he");
+var node_1 = __importDefault(require("./node"));
+var type_1 = __importDefault(require("./type"));
+/**
+ * TextNode to contain a text element in DOM tree.
+ * @param {string} value [description]
+ */
+var TextNode = /** @class */ (function (_super) {
+    __extends(TextNode, _super);
+    function TextNode(rawText, parentNode, range) {
+        if (parentNode === void 0) { parentNode = null; }
+        var _this = _super.call(this, parentNode, range) || this;
+        /**
+         * Node Type declaration.
+         * @type {Number}
+         */
+        _this.nodeType = type_1.default.TEXT_NODE;
+        _this.rawTagName = '';
+        _this._rawText = rawText;
+        return _this;
+    }
+    TextNode.prototype.clone = function () {
+        return new TextNode(this._rawText, null);
+    };
+    Object.defineProperty(TextNode.prototype, "rawText", {
+        get: function () {
+            return this._rawText;
+        },
+        /**
+         * Set rawText and invalidate trimmed caches
+         */
+        set: function (text) {
+            this._rawText = text;
+            this._trimmedRawText = void 0;
+            this._trimmedText = void 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextNode.prototype, "trimmedRawText", {
+        /**
+         * Returns raw text with all whitespace trimmed except single leading/trailing non-breaking space
+         */
+        get: function () {
+            if (this._trimmedRawText !== undefined)
+                return this._trimmedRawText;
+            this._trimmedRawText = trimText(this.rawText);
+            return this._trimmedRawText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextNode.prototype, "trimmedText", {
+        /**
+         * Returns text with all whitespace trimmed except single leading/trailing non-breaking space
+         */
+        get: function () {
+            if (this._trimmedText !== undefined)
+                return this._trimmedText;
+            this._trimmedText = trimText(this.text);
+            return this._trimmedText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextNode.prototype, "text", {
+        /**
+         * Get unescaped text value of current node and its children.
+         * @return {string} text content
+         */
+        get: function () {
+            return (0, he_1.decode)(this.rawText);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextNode.prototype, "isWhitespace", {
+        /**
+         * Detect if the node contains only white space.
+         * @return {boolean}
+         */
+        get: function () {
+            return /^(\s| )*$/.test(this.rawText);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextNode.prototype.toString = function () {
+        return this.rawText;
+    };
+    return TextNode;
+}(node_1.default));
+exports.default = TextNode;
+/**
+ * Trim whitespace except single leading/trailing non-breaking space
+ */
+function trimText(text) {
+    var i = 0;
+    var startPos;
+    var endPos;
+    while (i >= 0 && i < text.length) {
+        if (/\S/.test(text[i])) {
+            if (startPos === undefined) {
+                startPos = i;
+                i = text.length;
+            }
+            else {
+                endPos = i;
+                i = void 0;
+            }
+        }
+        if (startPos === undefined)
+            i++;
+        else
+            i--;
+    }
+    if (startPos === undefined)
+        startPos = 0;
+    if (endPos === undefined)
+        endPos = text.length - 1;
+    var hasLeadingSpace = startPos > 0 && /[^\S\r\n]/.test(text[startPos - 1]);
+    var hasTrailingSpace = endPos < (text.length - 1) && /[^\S\r\n]/.test(text[endPos + 1]);
+    return (hasLeadingSpace ? ' ' : '') + text.slice(startPos, endPos + 1) + (hasTrailingSpace ? ' ' : '');
+}

package/node_modules/node-html-parser/dist/nodes/type.d.ts

@@ -0,0 +1,6 @@
+declare enum NodeType {
+    ELEMENT_NODE = 1,
+    TEXT_NODE = 3,
+    COMMENT_NODE = 8
+}
+export default NodeType;

package/node_modules/node-html-parser/dist/nodes/type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var NodeType;
+(function (NodeType) {
+    NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+    NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
+    NodeType[NodeType["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+})(NodeType || (NodeType = {}));
+exports.default = NodeType;

package/node_modules/node-html-parser/dist/parse.d.ts

@@ -0,0 +1 @@
+export { parse as default } from './nodes/html';

package/node_modules/node-html-parser/dist/parse.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var html_1 = require("./nodes/html");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return html_1.parse; } });

package/node_modules/node-html-parser/dist/valid.d.ts

@@ -0,0 +1,6 @@
+import { Options } from './nodes/html';
+/**
+ * Parses HTML and returns a root element
+ * Parse a chuck of HTML source.
+ */
+export default function valid(data: string, options?: Partial<Options>): boolean;

package/node_modules/node-html-parser/dist/valid.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var html_1 = require("./nodes/html");
+/**
+ * Parses HTML and returns a root element
+ * Parse a chuck of HTML source.
+ */
+function valid(data, options) {
+    if (options === void 0) { options = {}; }
+    var stack = (0, html_1.base_parse)(data, options);
+    return Boolean(stack.length === 1);
+}
+exports.default = valid;

package/node_modules/node-html-parser/dist/void-tag.d.ts

@@ -0,0 +1,7 @@
+export default class VoidTag {
+    addClosingSlash: boolean;
+    private voidTags;
+    constructor(addClosingSlash?: boolean, tags?: string[]);
+    formatNode(tag: string, attrs: string, innerHTML: string): string;
+    isVoidElement(tag: string): boolean;
+}

package/node_modules/node-html-parser/dist/void-tag.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var VoidTag = /** @class */ (function () {
+    function VoidTag(addClosingSlash, tags) {
+        if (addClosingSlash === void 0) { addClosingSlash = false; }
+        this.addClosingSlash = addClosingSlash;
+        if (Array.isArray(tags)) {
+            this.voidTags = tags.reduce(function (set, tag) {
+                return set.add(tag.toLowerCase()).add(tag.toUpperCase()).add(tag);
+            }, new Set());
+        }
+        else {
+            this.voidTags = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'].reduce(function (set, tag) {
+                return set.add(tag.toLowerCase()).add(tag.toUpperCase()).add(tag);
+            }, new Set());
+        }
+    }
+    VoidTag.prototype.formatNode = function (tag, attrs, innerHTML) {
+        var addClosingSlash = this.addClosingSlash;
+        var closingSpace = (addClosingSlash && attrs && !attrs.endsWith(' ')) ? ' ' : '';
+        var closingSlash = addClosingSlash ? "".concat(closingSpace, "/") : '';
+        return this.isVoidElement(tag.toLowerCase()) ? "<".concat(tag).concat(attrs).concat(closingSlash, ">") : "<".concat(tag).concat(attrs, ">").concat(innerHTML, "</").concat(tag, ">");
+    };
+    VoidTag.prototype.isVoidElement = function (tag) {
+        return this.voidTags.has(tag);
+    };
+    return VoidTag;
+}());
+exports.default = VoidTag;

package/node_modules/node-html-parser/package.json

@@ -0,0 +1,114 @@
+{
+	"name": "node-html-parser",
+	"version": "6.1.13",
+	"description": "A very fast HTML parser, generating a simplified DOM, with basic element query support.",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"compile": "tsc",
+		"build": "npm run lint && npm run clean && npm run compile:cjs && npm run compile:amd",
+		"compile:cjs": "tsc -m commonjs",
+		"watch": "npx tsc -m commonjs --watch --preserveWatchOutput",
+		"compile:amd": "tsc -t es5 -m amd -d false --outFile ./dist/main.js",
+		"lint": "eslint ./src/*.ts ./src/**/*.ts",
+		"---------------": "",
+		"test": "yarn run test:target",
+		"test:src": "cross-env TEST_TARGET=src yarn run test",
+		"test:dist": "cross-env TEST_TARGET=dist yarn run test",
+		"benchmark": "node ./test/benchmark/compare.mjs",
+		"---------------  ": "",
+		"clean": "npx rimraf ./dist/",
+		"clean:global": "yarn run clean && npx rimraf yarn.lock test/yarn.lock test/node_modules node_modules",
+		"reset": "yarn run clean:global && yarn install && yarn build",
+		"--------------- ": "",
+		"test:target": "mocha --recursive \"./test/tests\"",
+		"test:ci": "cd test && yarn install && cd .. && cross-env TEST_TARGET=dist yarn run test:target",
+		"posttest": "yarn run benchmark",
+		"prepare": "npm run build",
+		"release": "standard-version && git push --follow-tags origin main"
+	},
+	"keywords": [
+		"html",
+		"parser",
+		"nodejs",
+		"typescript"
+	],
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md"
+	],
+	"author": "Xiaoyi Shi <ashi009@gmail.com>",
+	"contributors": [
+		"taoqf <tao_qiufeng@126.com>",
+		"Ron S. <ron@nonara.com>"
+	],
+	"license": "MIT",
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org"
+	},
+	"dependencies": {
+		"css-select": "^5.1.0",
+		"he": "1.2.0"
+	},
+	"devDependencies": {
+		"@types/entities": "latest",
+		"@types/he": "latest",
+		"@types/node": "latest",
+		"@typescript-eslint/eslint-plugin": "latest",
+		"@typescript-eslint/eslint-plugin-tslint": "latest",
+		"@typescript-eslint/parser": "latest",
+		"blanket": "latest",
+		"boolbase": "^1.0.0",
+		"cheerio": "^1.0.0-rc.12",
+		"cross-env": "^7.0.3",
+		"eslint": "^8.23.1",
+		"eslint-config-prettier": "latest",
+		"eslint-plugin-import": "latest",
+		"high5": "^1.0.0",
+		"html-dom-parser": "^3.1.2",
+		"html-parser": "^0.11.0",
+		"html5parser": "^2.0.2",
+		"htmljs-parser": "^5.1.4",
+		"htmlparser": "^1.7.7",
+		"htmlparser-benchmark": "^1.1.3",
+		"htmlparser2": "^8.0.1",
+		"mocha": "latest",
+		"mocha-each": "^2.0.1",
+		"neutron-html5parser": "^0.2.0",
+		"np": "latest",
+		"parse5": "^7.1.1",
+		"rimraf": "^3.0.2",
+		"saxes": "^6.0.0",
+		"should": "latest",
+		"spec": "latest",
+		"standard-version": "^9.5.0",
+		"travis-cov": "latest",
+		"ts-node": "^10.9.1",
+		"typescript": "latest"
+	},
+	"config": {
+		"blanket": {
+			"pattern": "./dist/index.js",
+			"data-cover-never": [
+				"node_modules"
+			]
+		},
+		"travis-cov": {
+			"threshold": 70
+		}
+	},
+	"directories": {
+		"test": "test"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/taoqf/node-fast-html-parser.git"
+	},
+	"bugs": {
+		"url": "https://github.com/taoqf/node-fast-html-parser/issues"
+	},
+	"homepage": "https://github.com/taoqf/node-fast-html-parser",
+	"sideEffects": false
+}

package/node_modules/nth-check/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/nth-check/README.md

@@ -0,0 +1,136 @@
+# nth-check [![Build Status](https://travis-ci.org/fb55/nth-check.svg)](https://travis-ci.org/fb55/nth-check)
+
+Parses and compiles CSS nth-checks to highly optimized functions.
+
+### About
+
+This module can be used to parse & compile nth-checks, as they are found in CSS 3's `nth-child()` and `nth-last-of-type()`. It can be used to check if a given index matches a given nth-rule, or to generate a sequence of indices matching a given nth-rule.
+
+`nth-check` focusses on speed, providing optimized functions for different kinds of nth-child formulas, while still following the [spec](http://www.w3.org/TR/css3-selectors/#nth-child-pseudo).
+
+### API
+
+```js
+import nthCheck, { parse, compile } from "nth-check";
+```
+
+##### `nthCheck(formula)`
+
+Parses and compiles a formula to a highly optimized function. Combination of `parse` and `compile`.
+
+If the formula doesn't match any elements, it returns [`boolbase`](https://github.com/fb55/boolbase)'s `falseFunc`. Otherwise, a function accepting an _index_ is returned, which returns whether or not the passed _index_ matches the formula.
+
+**Note**: The nth-rule starts counting at `1`, the returned function at `0`.
+
+**Example:**
+
+```js
+const check = nthCheck("2n+3");
+
+check(0); // `false`
+check(1); // `false`
+check(2); // `true`
+check(3); // `false`
+check(4); // `true`
+check(5); // `false`
+check(6); // `true`
+```
+
+##### `parse(formula)`
+
+Parses the expression, throws an `Error` if it fails. Otherwise, returns an array containing the integer step size and the integer offset of the nth rule.
+
+**Example:**
+
+```js
+parse("2n+3"); // [2, 3]
+```
+
+##### `compile([a, b])`
+
+Takes an array with two elements (as returned by `.parse`) and returns a highly optimized function.
+
+**Example:**
+
+```js
+const check = compile([2, 3]);
+
+check(0); // `false`
+check(1); // `false`
+check(2); // `true`
+check(3); // `false`
+check(4); // `true`
+check(5); // `false`
+check(6); // `true`
+```
+
+##### `generate([a, b])`
+
+Returns a function that produces a monotonously increasing sequence of indices.
+
+If the sequence has an end, the returned function will return `null` after the last index in the sequence.
+
+**Example:** An always increasing sequence
+
+```js
+const gen = nthCheck.generate([2, 3]);
+
+gen(); // `1`
+gen(); // `3`
+gen(); // `5`
+gen(); // `8`
+gen(); // `11`
+```
+
+**Example:** With an end value
+
+```js
+const gen = nthCheck.generate([-2, 5]);
+
+gen(); // 0
+gen(); // 2
+gen(); // 4
+gen(); // null
+```
+
+##### `sequence(formula)`
+
+Parses and compiles a formula to a generator that produces a sequence of indices. Combination of `parse` and `generate`.
+
+**Example:** An always increasing sequence
+
+```js
+const gen = nthCheck.sequence("2n+3");
+
+gen(); // `1`
+gen(); // `3`
+gen(); // `5`
+gen(); // `8`
+gen(); // `11`
+```
+
+**Example:** With an end value
+
+```js
+const gen = nthCheck.sequence("-2n+5");
+
+gen(); // 0
+gen(); // 2
+gen(); // 4
+gen(); // null
+```
+
+---
+
+License: BSD-2-Clause
+
+## Security contact information
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
+## `nth-check` for enterprise
+
+Available as part of the Tidelift Subscription
+
+The maintainers of `nth-check` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-nth-check?utm_source=npm-nth-check&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

package/node_modules/nth-check/lib/compile.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Returns a function that checks if an elements index matches the given rule
+ * highly optimized to return the fastest solution.
+ *
+ * @param parsed A tuple [a, b], as returned by `parse`.
+ * @returns A highly optimized function that returns whether an index matches the nth-check.
+ * @example
+ *
+ * ```js
+ * const check = nthCheck.compile([2, 3]);
+ *
+ * check(0); // `false`
+ * check(1); // `false`
+ * check(2); // `true`
+ * check(3); // `false`
+ * check(4); // `true`
+ * check(5); // `false`
+ * check(6); // `true`
+ * ```
+ */
+export declare function compile(parsed: [a: number, b: number]): (index: number) => boolean;
+/**
+ * Returns a function that produces a monotonously increasing sequence of indices.
+ *
+ * If the sequence has an end, the returned function will return `null` after
+ * the last index in the sequence.
+ *
+ * @param parsed A tuple [a, b], as returned by `parse`.
+ * @returns A function that produces a sequence of indices.
+ * @example <caption>Always increasing (2n+3)</caption>
+ *
+ * ```js
+ * const gen = nthCheck.generate([2, 3])
+ *
+ * gen() // `1`
+ * gen() // `3`
+ * gen() // `5`
+ * gen() // `8`
+ * gen() // `11`
+ * ```
+ *
+ * @example <caption>With end value (-2n+10)</caption>
+ *
+ * ```js
+ *
+ * const gen = nthCheck.generate([-2, 5]);
+ *
+ * gen() // 0
+ * gen() // 2
+ * gen() // 4
+ * gen() // null
+ * ```
+ */
+export declare function generate(parsed: [a: number, b: number]): () => number | null;
+//# sourceMappingURL=compile.d.ts.map

package/node_modules/nth-check/lib/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"https://raw.githubusercontent.com/fb55/nth-check/639fd2a4000b69f82350aad8c34cb43f77e483ba/src/","sources":["compile.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CACnB,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,GAC/B,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAgC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,MAAM,MAAM,GAAG,IAAI,CA+B5E"}