@fecp/designer 5.6.6 → 5.6.9

package/lib/node_modules/highlight.js/lib/languages/haml.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var haml_1;
+var hasRequiredHaml;
+function requireHaml() {
+  if (hasRequiredHaml) return haml_1;
+  hasRequiredHaml = 1;
+  function haml(hljs) {
+    return {
+      name: "HAML",
+      case_insensitive: true,
+      contains: [
+        {
+          className: "meta",
+          begin: "^!!!( (5|1\\.1|Strict|Frameset|Basic|Mobile|RDFa|XML\\b.*))?$",
+          relevance: 10
+        },
+        // FIXME these comments should be allowed to span indented lines
+        hljs.COMMENT(
+          "^\\s*(!=#|=#|-#|/).*$",
+          null,
+          { relevance: 0 }
+        ),
+        {
+          begin: "^\\s*(-|=|!=)(?!#)",
+          end: /$/,
+          subLanguage: "ruby",
+          excludeBegin: true,
+          excludeEnd: true
+        },
+        {
+          className: "tag",
+          begin: "^\\s*%",
+          contains: [
+            {
+              className: "selector-tag",
+              begin: "\\w+"
+            },
+            {
+              className: "selector-id",
+              begin: "#[\\w-]+"
+            },
+            {
+              className: "selector-class",
+              begin: "\\.[\\w-]+"
+            },
+            {
+              begin: /\{\s*/,
+              end: /\s*\}/,
+              contains: [
+                {
+                  begin: ":\\w+\\s*=>",
+                  end: ",\\s+",
+                  returnBegin: true,
+                  endsWithParent: true,
+                  contains: [
+                    {
+                      className: "attr",
+                      begin: ":\\w+"
+                    },
+                    hljs.APOS_STRING_MODE,
+                    hljs.QUOTE_STRING_MODE,
+                    {
+                      begin: "\\w+",
+                      relevance: 0
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              begin: "\\(\\s*",
+              end: "\\s*\\)",
+              excludeEnd: true,
+              contains: [
+                {
+                  begin: "\\w+\\s*=",
+                  end: "\\s+",
+                  returnBegin: true,
+                  endsWithParent: true,
+                  contains: [
+                    {
+                      className: "attr",
+                      begin: "\\w+",
+                      relevance: 0
+                    },
+                    hljs.APOS_STRING_MODE,
+                    hljs.QUOTE_STRING_MODE,
+                    {
+                      begin: "\\w+",
+                      relevance: 0
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        { begin: "^\\s*[=~]\\s*" },
+        {
+          begin: /#\{/,
+          end: /\}/,
+          subLanguage: "ruby",
+          excludeBegin: true,
+          excludeEnd: true
+        }
+      ]
+    };
+  }
+  haml_1 = haml;
+  return haml_1;
+}
+exports.__require = requireHaml;

package/lib/node_modules/highlight.js/lib/languages/handlebars.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var handlebars_1;
+var hasRequiredHandlebars;
+function requireHandlebars() {
+  if (hasRequiredHandlebars) return handlebars_1;
+  hasRequiredHandlebars = 1;
+  function handlebars(hljs) {
+    const regex = hljs.regex;
+    const BUILT_INS = {
+      $pattern: /[\w.\/]+/,
+      built_in: [
+        "action",
+        "bindattr",
+        "collection",
+        "component",
+        "concat",
+        "debugger",
+        "each",
+        "each-in",
+        "get",
+        "hash",
+        "if",
+        "in",
+        "input",
+        "link-to",
+        "loc",
+        "log",
+        "lookup",
+        "mut",
+        "outlet",
+        "partial",
+        "query-params",
+        "render",
+        "template",
+        "textarea",
+        "unbound",
+        "unless",
+        "view",
+        "with",
+        "yield"
+      ]
+    };
+    const LITERALS = {
+      $pattern: /[\w.\/]+/,
+      literal: [
+        "true",
+        "false",
+        "undefined",
+        "null"
+      ]
+    };
+    const DOUBLE_QUOTED_ID_REGEX = /""|"[^"]+"/;
+    const SINGLE_QUOTED_ID_REGEX = /''|'[^']+'/;
+    const BRACKET_QUOTED_ID_REGEX = /\[\]|\[[^\]]+\]/;
+    const PLAIN_ID_REGEX = /[^\s!"#%&'()*+,.\/;<=>@\[\\\]^`{|}~]+/;
+    const PATH_DELIMITER_REGEX = /(\.|\/)/;
+    const ANY_ID = regex.either(
+      DOUBLE_QUOTED_ID_REGEX,
+      SINGLE_QUOTED_ID_REGEX,
+      BRACKET_QUOTED_ID_REGEX,
+      PLAIN_ID_REGEX
+    );
+    const IDENTIFIER_REGEX = regex.concat(
+      regex.optional(/\.|\.\/|\//),
+      // relative or absolute path
+      ANY_ID,
+      regex.anyNumberOfTimes(regex.concat(
+        PATH_DELIMITER_REGEX,
+        ANY_ID
+      ))
+    );
+    const HASH_PARAM_REGEX = regex.concat(
+      "(",
+      BRACKET_QUOTED_ID_REGEX,
+      "|",
+      PLAIN_ID_REGEX,
+      ")(?==)"
+    );
+    const HELPER_NAME_OR_PATH_EXPRESSION = { begin: IDENTIFIER_REGEX };
+    const HELPER_PARAMETER = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, { keywords: LITERALS });
+    const SUB_EXPRESSION = {
+      begin: /\(/,
+      end: /\)/
+      // the "contains" is added below when all necessary sub-modes are defined
+    };
+    const HASH = {
+      // fka "attribute-assignment", parameters of the form 'key=value'
+      className: "attr",
+      begin: HASH_PARAM_REGEX,
+      relevance: 0,
+      starts: {
+        begin: /=/,
+        end: /=/,
+        starts: { contains: [
+          hljs.NUMBER_MODE,
+          hljs.QUOTE_STRING_MODE,
+          hljs.APOS_STRING_MODE,
+          HELPER_PARAMETER,
+          SUB_EXPRESSION
+        ] }
+      }
+    };
+    const BLOCK_PARAMS = {
+      // parameters of the form '{{#with x as | y |}}...{{/with}}'
+      begin: /as\s+\|/,
+      keywords: { keyword: "as" },
+      end: /\|/,
+      contains: [
+        {
+          // define sub-mode in order to prevent highlighting of block-parameter named "as"
+          begin: /\w+/
+        }
+      ]
+    };
+    const HELPER_PARAMETERS = {
+      contains: [
+        hljs.NUMBER_MODE,
+        hljs.QUOTE_STRING_MODE,
+        hljs.APOS_STRING_MODE,
+        BLOCK_PARAMS,
+        HASH,
+        HELPER_PARAMETER,
+        SUB_EXPRESSION
+      ],
+      returnEnd: true
+      // the property "end" is defined through inheritance when the mode is used. If depends
+      // on the surrounding mode, but "endsWithParent" does not work here (i.e. it includes the
+      // end-token of the surrounding mode)
+    };
+    const SUB_EXPRESSION_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+      className: "name",
+      keywords: BUILT_INS,
+      starts: hljs.inherit(HELPER_PARAMETERS, { end: /\)/ })
+    });
+    SUB_EXPRESSION.contains = [SUB_EXPRESSION_CONTENTS];
+    const OPENING_BLOCK_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+      keywords: BUILT_INS,
+      className: "name",
+      starts: hljs.inherit(HELPER_PARAMETERS, { end: /\}\}/ })
+    });
+    const CLOSING_BLOCK_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+      keywords: BUILT_INS,
+      className: "name"
+    });
+    const BASIC_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+      className: "name",
+      keywords: BUILT_INS,
+      starts: hljs.inherit(HELPER_PARAMETERS, { end: /\}\}/ })
+    });
+    const ESCAPE_MUSTACHE_WITH_PRECEEDING_BACKSLASH = {
+      begin: /\\\{\{/,
+      skip: true
+    };
+    const PREVENT_ESCAPE_WITH_ANOTHER_PRECEEDING_BACKSLASH = {
+      begin: /\\\\(?=\{\{)/,
+      skip: true
+    };
+    return {
+      name: "Handlebars",
+      aliases: [
+        "hbs",
+        "html.hbs",
+        "html.handlebars",
+        "htmlbars"
+      ],
+      case_insensitive: true,
+      subLanguage: "xml",
+      contains: [
+        ESCAPE_MUSTACHE_WITH_PRECEEDING_BACKSLASH,
+        PREVENT_ESCAPE_WITH_ANOTHER_PRECEEDING_BACKSLASH,
+        hljs.COMMENT(/\{\{!--/, /--\}\}/),
+        hljs.COMMENT(/\{\{!/, /\}\}/),
+        {
+          // open raw block "{{{{raw}}}} content not evaluated {{{{/raw}}}}"
+          className: "template-tag",
+          begin: /\{\{\{\{(?!\/)/,
+          end: /\}\}\}\}/,
+          contains: [OPENING_BLOCK_MUSTACHE_CONTENTS],
+          starts: {
+            end: /\{\{\{\{\//,
+            returnEnd: true,
+            subLanguage: "xml"
+          }
+        },
+        {
+          // close raw block
+          className: "template-tag",
+          begin: /\{\{\{\{\//,
+          end: /\}\}\}\}/,
+          contains: [CLOSING_BLOCK_MUSTACHE_CONTENTS]
+        },
+        {
+          // open block statement
+          className: "template-tag",
+          begin: /\{\{#/,
+          end: /\}\}/,
+          contains: [OPENING_BLOCK_MUSTACHE_CONTENTS]
+        },
+        {
+          className: "template-tag",
+          begin: /\{\{(?=else\}\})/,
+          end: /\}\}/,
+          keywords: "else"
+        },
+        {
+          className: "template-tag",
+          begin: /\{\{(?=else if)/,
+          end: /\}\}/,
+          keywords: "else if"
+        },
+        {
+          // closing block statement
+          className: "template-tag",
+          begin: /\{\{\//,
+          end: /\}\}/,
+          contains: [CLOSING_BLOCK_MUSTACHE_CONTENTS]
+        },
+        {
+          // template variable or helper-call that is NOT html-escaped
+          className: "template-variable",
+          begin: /\{\{\{/,
+          end: /\}\}\}/,
+          contains: [BASIC_MUSTACHE_CONTENTS]
+        },
+        {
+          // template variable or helper-call that is html-escaped
+          className: "template-variable",
+          begin: /\{\{/,
+          end: /\}\}/,
+          contains: [BASIC_MUSTACHE_CONTENTS]
+        }
+      ]
+    };
+  }
+  handlebars_1 = handlebars;
+  return handlebars_1;
+}
+exports.__require = requireHandlebars;

package/lib/node_modules/highlight.js/lib/languages/haskell.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var haskell_1;
+var hasRequiredHaskell;
+function requireHaskell() {
+  if (hasRequiredHaskell) return haskell_1;
+  hasRequiredHaskell = 1;
+  function haskell(hljs) {
+    const decimalDigits = "([0-9]_*)+";
+    const hexDigits = "([0-9a-fA-F]_*)+";
+    const binaryDigits = "([01]_*)+";
+    const octalDigits = "([0-7]_*)+";
+    const ascSymbol = "[!#$%&*+.\\/<=>?@\\\\^~-]";
+    const uniSymbol = "(\\p{S}|\\p{P})";
+    const special = "[(),;\\[\\]`|{}]";
+    const symbol = `(${ascSymbol}|(?!(${special}|[_:"']))${uniSymbol})`;
+    const COMMENT = { variants: [
+      // Double dash forms a valid comment only if it's not part of legal lexeme.
+      // See: Haskell 98 report: https://www.haskell.org/onlinereport/lexemes.html
+      //
+      // The commented code does the job, but we can't use negative lookbehind,
+      // due to poor support by Safari browser.
+      // > hljs.COMMENT(`(?<!${symbol})--+(?!${symbol})`, '$'),
+      // So instead, we'll add a no-markup rule before the COMMENT rule in the rules list
+      // to match the problematic infix operators that contain double dash.
+      hljs.COMMENT("--+", "$"),
+      hljs.COMMENT(
+        /\{-/,
+        /-\}/,
+        { contains: ["self"] }
+      )
+    ] };
+    const PRAGMA = {
+      className: "meta",
+      begin: /\{-#/,
+      end: /#-\}/
+    };
+    const PREPROCESSOR = {
+      className: "meta",
+      begin: "^#",
+      end: "$"
+    };
+    const CONSTRUCTOR = {
+      className: "type",
+      begin: "\\b[A-Z][\\w']*",
+      // TODO: other constructors (build-in, infix).
+      relevance: 0
+    };
+    const LIST = {
+      begin: "\\(",
+      end: "\\)",
+      illegal: '"',
+      contains: [
+        PRAGMA,
+        PREPROCESSOR,
+        {
+          className: "type",
+          begin: "\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"
+        },
+        hljs.inherit(hljs.TITLE_MODE, { begin: "[_a-z][\\w']*" }),
+        COMMENT
+      ]
+    };
+    const RECORD = {
+      begin: /\{/,
+      end: /\}/,
+      contains: LIST.contains
+    };
+    const NUMBER = {
+      className: "number",
+      relevance: 0,
+      variants: [
+        // decimal floating-point-literal (subsumes decimal-literal)
+        { match: `\\b(${decimalDigits})(\\.(${decimalDigits}))?([eE][+-]?(${decimalDigits}))?\\b` },
+        // hexadecimal floating-point-literal (subsumes hexadecimal-literal)
+        { match: `\\b0[xX]_*(${hexDigits})(\\.(${hexDigits}))?([pP][+-]?(${decimalDigits}))?\\b` },
+        // octal-literal
+        { match: `\\b0[oO](${octalDigits})\\b` },
+        // binary-literal
+        { match: `\\b0[bB](${binaryDigits})\\b` }
+      ]
+    };
+    return {
+      name: "Haskell",
+      aliases: ["hs"],
+      keywords: "let in if then else case of where do module import hiding qualified type data newtype deriving class instance as default infix infixl infixr foreign export ccall stdcall cplusplus jvm dotnet safe unsafe family forall mdo proc rec",
+      unicodeRegex: true,
+      contains: [
+        // Top-level constructions.
+        {
+          beginKeywords: "module",
+          end: "where",
+          keywords: "module where",
+          contains: [
+            LIST,
+            COMMENT
+          ],
+          illegal: "\\W\\.|;"
+        },
+        {
+          begin: "\\bimport\\b",
+          end: "$",
+          keywords: "import qualified as hiding",
+          contains: [
+            LIST,
+            COMMENT
+          ],
+          illegal: "\\W\\.|;"
+        },
+        {
+          className: "class",
+          begin: "^(\\s*)?(class|instance)\\b",
+          end: "where",
+          keywords: "class family instance where",
+          contains: [
+            CONSTRUCTOR,
+            LIST,
+            COMMENT
+          ]
+        },
+        {
+          className: "class",
+          begin: "\\b(data|(new)?type)\\b",
+          end: "$",
+          keywords: "data family type newtype deriving",
+          contains: [
+            PRAGMA,
+            CONSTRUCTOR,
+            LIST,
+            RECORD,
+            COMMENT
+          ]
+        },
+        {
+          beginKeywords: "default",
+          end: "$",
+          contains: [
+            CONSTRUCTOR,
+            LIST,
+            COMMENT
+          ]
+        },
+        {
+          beginKeywords: "infix infixl infixr",
+          end: "$",
+          contains: [
+            hljs.C_NUMBER_MODE,
+            COMMENT
+          ]
+        },
+        {
+          begin: "\\bforeign\\b",
+          end: "$",
+          keywords: "foreign import export ccall stdcall cplusplus jvm dotnet safe unsafe",
+          contains: [
+            CONSTRUCTOR,
+            hljs.QUOTE_STRING_MODE,
+            COMMENT
+          ]
+        },
+        {
+          className: "meta",
+          begin: "#!\\/usr\\/bin\\/env runhaskell",
+          end: "$"
+        },
+        // "Whitespaces".
+        PRAGMA,
+        PREPROCESSOR,
+        // Literals and names.
+        // Single characters.
+        {
+          scope: "string",
+          begin: /'(?=\\?.')/,
+          end: /'/,
+          contains: [
+            {
+              scope: "char.escape",
+              match: /\\./
+            }
+          ]
+        },
+        hljs.QUOTE_STRING_MODE,
+        NUMBER,
+        CONSTRUCTOR,
+        hljs.inherit(hljs.TITLE_MODE, { begin: "^[_a-z][\\w']*" }),
+        // No markup, prevents infix operators from being recognized as comments.
+        { begin: `(?!-)${symbol}--+|--+(?!-)${symbol}` },
+        COMMENT,
+        {
+          // No markup, relevance booster
+          begin: "->|<-"
+        }
+      ]
+    };
+  }
+  haskell_1 = haskell;
+  return haskell_1;
+}
+exports.__require = requireHaskell;