@pb33f/cowboy-components 0.0.13 → 0.1.0

package/dist/scss-C4l7ZIRR.js

@@ -0,0 +1,268 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.46.0(21007360cad28648bdf46282a2592cb47c3a7a6f)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+var e = {
+  wordPattern: /(#?-?\d*\.\d\w*%?)|([@$#!.:]?[\w-?]+%?)|[@#!.]/g,
+  comments: {
+    blockComment: ["/*", "*/"],
+    lineComment: "//"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}", notIn: ["string", "comment"] },
+    { open: "[", close: "]", notIn: ["string", "comment"] },
+    { open: "(", close: ")", notIn: ["string", "comment"] },
+    { open: '"', close: '"', notIn: ["string", "comment"] },
+    { open: "'", close: "'", notIn: ["string", "comment"] }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),
+      end: new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")
+    }
+  }
+}, t = {
+  defaultToken: "",
+  tokenPostfix: ".scss",
+  ws: `[ 	
+\r\f]*`,
+  // whitespaces (referenced in several rules)
+  identifier: "-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.bracket" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" },
+    { open: "<", close: ">", token: "delimiter.angle" }
+  ],
+  tokenizer: {
+    root: [{ include: "@selector" }],
+    selector: [
+      { include: "@comments" },
+      { include: "@import" },
+      { include: "@variabledeclaration" },
+      { include: "@warndebug" },
+      // sass: log statements
+      ["[@](include)", { token: "keyword", next: "@includedeclaration" }],
+      // sass: include statement
+      [
+        "[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)",
+        { token: "keyword", next: "@keyframedeclaration" }
+      ],
+      ["[@](page|content|font-face|-moz-document)", { token: "keyword" }],
+      // sass: placeholder for includes
+      ["[@](charset|namespace)", { token: "keyword", next: "@declarationbody" }],
+      ["[@](function)", { token: "keyword", next: "@functiondeclaration" }],
+      ["[@](mixin)", { token: "keyword", next: "@mixindeclaration" }],
+      ["url(\\-prefix)?\\(", { token: "meta", next: "@urldeclaration" }],
+      { include: "@controlstatement" },
+      // sass control statements
+      { include: "@selectorname" },
+      ["[&\\*]", "tag"],
+      // selector symbols
+      ["[>\\+,]", "delimiter"],
+      // selector operators
+      ["\\[", { token: "delimiter.bracket", next: "@selectorattribute" }],
+      ["{", { token: "delimiter.curly", next: "@selectorbody" }]
+    ],
+    selectorbody: [
+      ["[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))", "attribute.name", "@rulevalue"],
+      // rule definition: to distinguish from a nested selector check for whitespace, number or a semicolon
+      { include: "@selector" },
+      // sass: nested selectors
+      ["[@](extend)", { token: "keyword", next: "@extendbody" }],
+      // sass: extend other selectors
+      ["[@](return)", { token: "keyword", next: "@declarationbody" }],
+      ["}", { token: "delimiter.curly", next: "@pop" }]
+    ],
+    selectorname: [
+      ["#{", { token: "meta", next: "@variableinterpolation" }],
+      // sass: interpolation
+      ["(\\.|#(?=[^{])|%|(@identifier)|:)+", "tag"]
+      // selector (.foo, div, ...)
+    ],
+    selectorattribute: [{ include: "@term" }, ["]", { token: "delimiter.bracket", next: "@pop" }]],
+    term: [
+      { include: "@comments" },
+      ["url(\\-prefix)?\\(", { token: "meta", next: "@urldeclaration" }],
+      { include: "@functioninvocation" },
+      { include: "@numbers" },
+      { include: "@strings" },
+      { include: "@variablereference" },
+      ["(and\\b|or\\b|not\\b)", "operator"],
+      { include: "@name" },
+      ["([<>=\\+\\-\\*\\/\\^\\|\\~,])", "operator"],
+      [",", "delimiter"],
+      ["!default", "literal"],
+      ["\\(", { token: "delimiter.parenthesis", next: "@parenthizedterm" }]
+    ],
+    rulevalue: [
+      { include: "@term" },
+      ["!important", "literal"],
+      [";", "delimiter", "@pop"],
+      ["{", { token: "delimiter.curly", switchTo: "@nestedproperty" }],
+      // sass: nested properties
+      ["(?=})", { token: "", next: "@pop" }]
+      // missing semicolon
+    ],
+    nestedproperty: [
+      ["[*_]?@identifier@ws:", "attribute.name", "@rulevalue"],
+      { include: "@comments" },
+      ["}", { token: "delimiter.curly", next: "@pop" }]
+    ],
+    warndebug: [["[@](warn|debug)", { token: "keyword", next: "@declarationbody" }]],
+    import: [["[@](import)", { token: "keyword", next: "@declarationbody" }]],
+    variabledeclaration: [
+      // sass variables
+      ["\\$@identifier@ws:", "variable.decl", "@declarationbody"]
+    ],
+    urldeclaration: [
+      { include: "@strings" },
+      [`[^)\r
+]+`, "string"],
+      ["\\)", { token: "meta", next: "@pop" }]
+    ],
+    parenthizedterm: [
+      { include: "@term" },
+      ["\\)", { token: "delimiter.parenthesis", next: "@pop" }]
+    ],
+    declarationbody: [
+      { include: "@term" },
+      [";", "delimiter", "@pop"],
+      ["(?=})", { token: "", next: "@pop" }]
+      // missing semicolon
+    ],
+    extendbody: [
+      { include: "@selectorname" },
+      ["!optional", "literal"],
+      [";", "delimiter", "@pop"],
+      ["(?=})", { token: "", next: "@pop" }]
+      // missing semicolon
+    ],
+    variablereference: [
+      // sass variable reference
+      ["\\$@identifier", "variable.ref"],
+      ["\\.\\.\\.", "operator"],
+      // var args in reference
+      ["#{", { token: "meta", next: "@variableinterpolation" }]
+      // sass var resolve
+    ],
+    variableinterpolation: [
+      { include: "@variablereference" },
+      ["}", { token: "meta", next: "@pop" }]
+    ],
+    comments: [
+      ["\\/\\*", "comment", "@comment"],
+      ["\\/\\/+.*", "comment"]
+    ],
+    comment: [
+      ["\\*\\/", "comment", "@pop"],
+      [".", "comment"]
+    ],
+    name: [["@identifier", "attribute.value"]],
+    numbers: [
+      ["(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?", { token: "number", next: "@units" }],
+      ["#[0-9a-fA-F_]+(?!\\w)", "number.hex"]
+    ],
+    units: [
+      [
+        "(em|ex|ch|rem|fr|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?",
+        "number",
+        "@pop"
+      ]
+    ],
+    functiondeclaration: [
+      ["@identifier@ws\\(", { token: "meta", next: "@parameterdeclaration" }],
+      ["{", { token: "delimiter.curly", switchTo: "@functionbody" }]
+    ],
+    mixindeclaration: [
+      // mixin with parameters
+      ["@identifier@ws\\(", { token: "meta", next: "@parameterdeclaration" }],
+      // mixin without parameters
+      ["@identifier", "meta"],
+      ["{", { token: "delimiter.curly", switchTo: "@selectorbody" }]
+    ],
+    parameterdeclaration: [
+      ["\\$@identifier@ws:", "variable.decl"],
+      ["\\.\\.\\.", "operator"],
+      // var args in declaration
+      [",", "delimiter"],
+      { include: "@term" },
+      ["\\)", { token: "meta", next: "@pop" }]
+    ],
+    includedeclaration: [
+      { include: "@functioninvocation" },
+      ["@identifier", "meta"],
+      [";", "delimiter", "@pop"],
+      ["(?=})", { token: "", next: "@pop" }],
+      // missing semicolon
+      ["{", { token: "delimiter.curly", switchTo: "@selectorbody" }]
+    ],
+    keyframedeclaration: [
+      ["@identifier", "meta"],
+      ["{", { token: "delimiter.curly", switchTo: "@keyframebody" }]
+    ],
+    keyframebody: [
+      { include: "@term" },
+      ["{", { token: "delimiter.curly", next: "@selectorbody" }],
+      ["}", { token: "delimiter.curly", next: "@pop" }]
+    ],
+    controlstatement: [
+      [
+        "[@](if|else|for|while|each|media)",
+        { token: "keyword.flow", next: "@controlstatementdeclaration" }
+      ]
+    ],
+    controlstatementdeclaration: [
+      ["(in|from|through|if|to)\\b", { token: "keyword.flow" }],
+      { include: "@term" },
+      ["{", { token: "delimiter.curly", switchTo: "@selectorbody" }]
+    ],
+    functionbody: [
+      ["[@](return)", { token: "keyword" }],
+      { include: "@variabledeclaration" },
+      { include: "@term" },
+      { include: "@controlstatement" },
+      [";", "delimiter"],
+      ["}", { token: "delimiter.curly", next: "@pop" }]
+    ],
+    functioninvocation: [["@identifier\\(", { token: "meta", next: "@functionarguments" }]],
+    functionarguments: [
+      ["\\$@identifier@ws:", "attribute.name"],
+      ["[,]", "delimiter"],
+      { include: "@term" },
+      ["\\)", { token: "meta", next: "@pop" }]
+    ],
+    strings: [
+      ['~?"', { token: "string.delimiter", next: "@stringenddoublequote" }],
+      ["~?'", { token: "string.delimiter", next: "@stringendquote" }]
+    ],
+    stringenddoublequote: [
+      ["\\\\.", "string"],
+      ['"', { token: "string.delimiter", next: "@pop" }],
+      [".", "string"]
+    ],
+    stringendquote: [
+      ["\\\\.", "string"],
+      ["'", { token: "string.delimiter", next: "@pop" }],
+      [".", "string"]
+    ]
+  }
+};
+export {
+  e as conf,
+  t as language
+};

package/dist/services/linting-service.d.ts

@@ -0,0 +1,12 @@
+import { Problem } from "@/model/problem";
+import { HowToFix } from "@/model/how_to_fix";
+import { DrDiagnostics } from "@/model/document-statistics";
+import { Session } from "@/model/session";
+export declare class LintingService {
+    static doctorEndpoint: string;
+    static compareProblems(a: Problem, b: Problem): number;
+    static lintFile(file: string, OWASP?: boolean): Promise<Problem[]>;
+    static fetchAllHowToFix(): Promise<HowToFix[]>;
+    static fetchStatistics(): Promise<DrDiagnostics>;
+    static startSession(): Promise<Session>;
+}

package/dist/services/linting-service.js

@@ -0,0 +1,121 @@
+import { Problem } from "@/model/problem";
+export class LintingService {
+    static compareProblems(a, b) {
+        if (a.startLineNumber < b.startLineNumber) {
+            return -1;
+        }
+        if (a.startLineNumber > b.startLineNumber) {
+            return 1;
+        }
+        if (a.startColumn < b.startColumn) {
+            return -1;
+        }
+        if (a.startColumn > b.startColumn) {
+            return 1;
+        }
+        if (a.jsonPath < b.jsonPath) {
+            return -1;
+        }
+        return 0;
+    }
+    static async lintFile(file, OWASP = false) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let query = '';
+                if (OWASP) {
+                    query = '?owasp=true';
+                }
+                const lintResults = await fetch(LintingService.doctorEndpoint + '/lint-lsp' + query, {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: file
+                });
+                const apiResult = await lintResults.json();
+                if (!apiResult) {
+                    reject([]);
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                const lintData = apiResult;
+                const constructedProblems = [];
+                if (lintData && Array.isArray(lintData)) {
+                    for (let i = 0; i < lintData.length; i++) {
+                        const problem = lintData[i];
+                        constructedProblems.push(new Problem(problem.category, problem.jsonPath, problem.endColumn, problem.endLineNumber, problem.message, problem.severity, problem.startColumn, problem.startLineNumber, problem.source, problem.id));
+                    }
+                }
+                if (lintData && !Array.isArray(lintData)) {
+                    const problem = lintData;
+                    constructedProblems.push(new Problem(problem.category, problem.jsonPath, problem.endColumn, problem.endLineNumber, problem.message, problem.severity, problem.startColumn, problem.startLineNumber, problem.source, problem.id));
+                }
+                constructedProblems.sort(LintingService.compareProblems);
+                resolve(constructedProblems);
+            }
+            catch (e) {
+                reject({ detail: "the pb33f platform is unresponsive" });
+            }
+        });
+    }
+    static async fetchAllHowToFix() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const howToFixJSON = await fetch(LintingService.doctorEndpoint + '/rules/howtofix', {
+                    method: 'GET',
+                    credentials: 'include',
+                });
+                const howToFix = await howToFixJSON.json();
+                if (howToFix.title && howToFix.status && howToFix.error) {
+                    reject(howToFix);
+                }
+                resolve(howToFix);
+            }
+            catch (e) {
+                reject({ tile: "platform error", detail: "the pb33f platform is unresponsive, " +
+                        "please try again later." });
+            }
+        });
+    }
+    static async fetchStatistics() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const lintStatsJSON = await fetch(LintingService.doctorEndpoint + '/lint-statistics', {
+                    method: 'GET',
+                    credentials: 'include',
+                });
+                const lintStats = await lintStatsJSON.json();
+                if (lintStats.type && lintStats.title && lintStats.status) {
+                    reject(lintStats);
+                }
+                resolve(lintStats);
+            }
+            catch (e) {
+                reject({ detail: "the pb33f platform is unresponsive" });
+            }
+        });
+    }
+    static async startSession() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const sessionJSON = await fetch(LintingService.doctorEndpoint + '/start-session', {
+                    method: 'GET',
+                    credentials: 'include',
+                });
+                const session = await sessionJSON.json();
+                if (session.type && session.title && session.status) {
+                    reject(session);
+                }
+                resolve(session);
+            }
+            catch (e) {
+                reject({ detail: "the pb33f platform is unresponsive" });
+            }
+        });
+    }
+}
+LintingService.doctorEndpoint = 'https://doctor.pb33f.io';

package/dist/shell-ikLk_l24.js

@@ -0,0 +1,227 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.46.0(21007360cad28648bdf46282a2592cb47c3a7a6f)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+var e = {
+  comments: {
+    lineComment: "#"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" },
+    { open: "`", close: "`" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" },
+    { open: "`", close: "`" }
+  ]
+}, r = {
+  defaultToken: "",
+  ignoreCase: !0,
+  tokenPostfix: ".shell",
+  brackets: [
+    { token: "delimiter.bracket", open: "{", close: "}" },
+    { token: "delimiter.parenthesis", open: "(", close: ")" },
+    { token: "delimiter.square", open: "[", close: "]" }
+  ],
+  keywords: [
+    "if",
+    "then",
+    "do",
+    "else",
+    "elif",
+    "while",
+    "until",
+    "for",
+    "in",
+    "esac",
+    "fi",
+    "fin",
+    "fil",
+    "done",
+    "exit",
+    "set",
+    "unset",
+    "export",
+    "function"
+  ],
+  builtins: [
+    "ab",
+    "awk",
+    "bash",
+    "beep",
+    "cat",
+    "cc",
+    "cd",
+    "chown",
+    "chmod",
+    "chroot",
+    "clear",
+    "cp",
+    "curl",
+    "cut",
+    "diff",
+    "echo",
+    "find",
+    "gawk",
+    "gcc",
+    "get",
+    "git",
+    "grep",
+    "hg",
+    "kill",
+    "killall",
+    "ln",
+    "ls",
+    "make",
+    "mkdir",
+    "openssl",
+    "mv",
+    "nc",
+    "node",
+    "npm",
+    "ping",
+    "ps",
+    "restart",
+    "rm",
+    "rmdir",
+    "sed",
+    "service",
+    "sh",
+    "shopt",
+    "shred",
+    "source",
+    "sort",
+    "sleep",
+    "ssh",
+    "start",
+    "stop",
+    "su",
+    "sudo",
+    "svn",
+    "tee",
+    "telnet",
+    "top",
+    "touch",
+    "vi",
+    "vim",
+    "wall",
+    "wc",
+    "wget",
+    "who",
+    "write",
+    "yes",
+    "zsh"
+  ],
+  startingWithDash: /\-+\w+/,
+  identifiersWithDashes: /[a-zA-Z]\w+(?:@startingWithDash)+/,
+  // we include these common regular expressions
+  symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      [/@identifiersWithDashes/, ""],
+      [/(\s)((?:@startingWithDash)+)/, ["white", "attribute.name"]],
+      [
+        /[a-zA-Z]\w*/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@builtins": "type.identifier",
+            "@default": ""
+          }
+        }
+      ],
+      { include: "@whitespace" },
+      { include: "@strings" },
+      { include: "@parameters" },
+      { include: "@heredoc" },
+      [/[{}\[\]()]/, "@brackets"],
+      [/@symbols/, "delimiter"],
+      { include: "@numbers" },
+      [/[,;]/, "delimiter"]
+    ],
+    whitespace: [
+      [/\s+/, "white"],
+      [/(^#!.*$)/, "metatag"],
+      [/(^#.*$)/, "comment"]
+    ],
+    numbers: [
+      [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, "number.hex"],
+      [/\d+/, "number"]
+    ],
+    // Recognize strings, including those broken across lines
+    strings: [
+      [/'/, "string", "@stringBody"],
+      [/"/, "string", "@dblStringBody"]
+    ],
+    stringBody: [
+      [/'/, "string", "@popall"],
+      [/./, "string"]
+    ],
+    dblStringBody: [
+      [/"/, "string", "@popall"],
+      [/./, "string"]
+    ],
+    heredoc: [
+      [
+        /(<<[-<]?)(\s*)(['"`]?)([\w\-]+)(['"`]?)/,
+        [
+          "constants",
+          "white",
+          "string.heredoc.delimiter",
+          "string.heredoc",
+          "string.heredoc.delimiter"
+        ]
+      ]
+    ],
+    parameters: [
+      [/\$\d+/, "variable.predefined"],
+      [/\$\w+/, "variable"],
+      [/\$[*@#?\-$!0_]/, "variable"],
+      [/\$'/, "variable", "@parameterBodyQuote"],
+      [/\$"/, "variable", "@parameterBodyDoubleQuote"],
+      [/\$\(/, "variable", "@parameterBodyParen"],
+      [/\$\{/, "variable", "@parameterBodyCurlyBrace"]
+    ],
+    parameterBodyQuote: [
+      [/[^#:%*@\-!_']+/, "variable"],
+      [/[#:%*@\-!_]/, "delimiter"],
+      [/[']/, "variable", "@pop"]
+    ],
+    parameterBodyDoubleQuote: [
+      [/[^#:%*@\-!_"]+/, "variable"],
+      [/[#:%*@\-!_]/, "delimiter"],
+      [/["]/, "variable", "@pop"]
+    ],
+    parameterBodyParen: [
+      [/[^#:%*@\-!_)]+/, "variable"],
+      [/[#:%*@\-!_]/, "delimiter"],
+      [/[)]/, "variable", "@pop"]
+    ],
+    parameterBodyCurlyBrace: [
+      [/[^#:%*@\-!_}]+/, "variable"],
+      [/[#:%*@\-!_]/, "delimiter"],
+      [/[}]/, "variable", "@pop"]
+    ]
+  }
+};
+export {
+  e as conf,
+  r as language
+};