@fecp/designer 5.6.6 → 5.6.8

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var armasm_1;
+var hasRequiredArmasm;
+function requireArmasm() {
+  if (hasRequiredArmasm) return armasm_1;
+  hasRequiredArmasm = 1;
+  function armasm(hljs) {
+    const COMMENT = { variants: [
+      hljs.COMMENT("^[ \\t]*(?=#)", "$", {
+        relevance: 0,
+        excludeBegin: true
+      }),
+      hljs.COMMENT("[;@]", "$", { relevance: 0 }),
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE
+    ] };
+    return {
+      name: "ARM Assembly",
+      case_insensitive: true,
+      aliases: ["arm"],
+      keywords: {
+        $pattern: "\\.?" + hljs.IDENT_RE,
+        meta: (
+          // GNU preprocs
+          ".2byte .4byte .align .ascii .asciz .balign .byte .code .data .else .end .endif .endm .endr .equ .err .exitm .extern .global .hword .if .ifdef .ifndef .include .irp .long .macro .rept .req .section .set .skip .space .text .word .arm .thumb .code16 .code32 .force_thumb .thumb_func .ltorg ALIAS ALIGN ARM AREA ASSERT ATTR CN CODE CODE16 CODE32 COMMON CP DATA DCB DCD DCDU DCDO DCFD DCFDU DCI DCQ DCQU DCW DCWU DN ELIF ELSE END ENDFUNC ENDIF ENDP ENTRY EQU EXPORT EXPORTAS EXTERN FIELD FILL FUNCTION GBLA GBLL GBLS GET GLOBAL IF IMPORT INCBIN INCLUDE INFO KEEP LCLA LCLL LCLS LTORG MACRO MAP MEND MEXIT NOFP OPT PRESERVE8 PROC QN READONLY RELOC REQUIRE REQUIRE8 RLIST FN ROUT SETA SETL SETS SN SPACE SUBT THUMB THUMBX TTL WHILE WEND "
+        ),
+        built_in: "r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 w0 w1 w2 w3 w4 w5 w6 w7 w8 w9 w10 w11 w12 w13 w14 w15 w16 w17 w18 w19 w20 w21 w22 w23 w24 w25 w26 w27 w28 w29 w30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 pc lr sp ip sl sb fp a1 a2 a3 a4 v1 v2 v3 v4 v5 v6 v7 v8 f0 f1 f2 f3 f4 f5 f6 f7 p0 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 q10 q11 q12 q13 q14 q15 cpsr_c cpsr_x cpsr_s cpsr_f cpsr_cx cpsr_cxs cpsr_xs cpsr_xsf cpsr_sf cpsr_cxsf spsr_c spsr_x spsr_s spsr_f spsr_cx spsr_cxs spsr_xs spsr_xsf spsr_sf spsr_cxsf s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 s12 s13 s14 s15 s16 s17 s18 s19 s20 s21 s22 s23 s24 s25 s26 s27 s28 s29 s30 s31 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d10 d11 d12 d13 d14 d15 d16 d17 d18 d19 d20 d21 d22 d23 d24 d25 d26 d27 d28 d29 d30 d31 {PC} {VAR} {TRUE} {FALSE} {OPT} {CONFIG} {ENDIAN} {CODESIZE} {CPU} {FPU} {ARCHITECTURE} {PCSTOREOFFSET} {ARMASM_VERSION} {INTER} {ROPI} {RWPI} {SWST} {NOSWST} . @"
+      },
+      contains: [
+        {
+          className: "keyword",
+          begin: "\\b(adc|(qd?|sh?|u[qh]?)?add(8|16)?|usada?8|(q|sh?|u[qh]?)?(as|sa)x|and|adrl?|sbc|rs[bc]|asr|b[lx]?|blx|bxj|cbn?z|tb[bh]|bic|bfc|bfi|[su]bfx|bkpt|cdp2?|clz|clrex|cmp|cmn|cpsi[ed]|cps|setend|dbg|dmb|dsb|eor|isb|it[te]{0,3}|lsl|lsr|ror|rrx|ldm(([id][ab])|f[ds])?|ldr((s|ex)?[bhd])?|movt?|mvn|mra|mar|mul|[us]mull|smul[bwt][bt]|smu[as]d|smmul|smmla|mla|umlaal|smlal?([wbt][bt]|d)|mls|smlsl?[ds]|smc|svc|sev|mia([bt]{2}|ph)?|mrr?c2?|mcrr2?|mrs|msr|orr|orn|pkh(tb|bt)|rbit|rev(16|sh)?|sel|[su]sat(16)?|nop|pop|push|rfe([id][ab])?|stm([id][ab])?|str(ex)?[bhd]?|(qd?)?sub|(sh?|q|u[qh]?)?sub(8|16)|[su]xt(a?h|a?b(16)?)|srs([id][ab])?|swpb?|swi|smi|tst|teq|wfe|wfi|yield)(eq|ne|cs|cc|mi|pl|vs|vc|hi|ls|ge|lt|gt|le|al|hs|lo)?[sptrx]?(?=\\s)"
+          // followed by space
+        },
+        COMMENT,
+        hljs.QUOTE_STRING_MODE,
+        {
+          className: "string",
+          begin: "'",
+          end: "[^\\\\]'",
+          relevance: 0
+        },
+        {
+          className: "title",
+          begin: "\\|",
+          end: "\\|",
+          illegal: "\\n",
+          relevance: 0
+        },
+        {
+          className: "number",
+          variants: [
+            {
+              // hex
+              begin: "[#$=]?0x[0-9a-f]+"
+            },
+            {
+              // bin
+              begin: "[#$=]?0b[01]+"
+            },
+            {
+              // literal
+              begin: "[#$=]\\d+"
+            },
+            {
+              // bare number
+              begin: "\\b\\d+"
+            }
+          ],
+          relevance: 0
+        },
+        {
+          className: "symbol",
+          variants: [
+            {
+              // GNU ARM syntax
+              begin: "^[ \\t]*[a-z_\\.\\$][a-z0-9_\\.\\$]+:"
+            },
+            {
+              // ARM syntax
+              begin: "^[a-z_\\.\\$][a-z0-9_\\.\\$]+"
+            },
+            {
+              // label reference
+              begin: "[=#]\\w+"
+            }
+          ],
+          relevance: 0
+        }
+      ]
+    };
+  }
+  armasm_1 = armasm;
+  return armasm_1;
+}
+exports.__require = requireArmasm;

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

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var asciidoc_1;
+var hasRequiredAsciidoc;
+function requireAsciidoc() {
+  if (hasRequiredAsciidoc) return asciidoc_1;
+  hasRequiredAsciidoc = 1;
+  function asciidoc(hljs) {
+    const regex = hljs.regex;
+    const HORIZONTAL_RULE = {
+      begin: "^'{3,}[ \\t]*$",
+      relevance: 10
+    };
+    const ESCAPED_FORMATTING = [
+      // escaped constrained formatting marks (i.e., \* \_ or \`)
+      { begin: /\\[*_`]/ },
+      // escaped unconstrained formatting marks (i.e., \\** \\__ or \\``)
+      // must ignore until the next formatting marks
+      // this rule might not be 100% compliant with Asciidoctor 2.0 but we are entering undefined behavior territory...
+      { begin: /\\\\\*{2}[^\n]*?\*{2}/ },
+      { begin: /\\\\_{2}[^\n]*_{2}/ },
+      { begin: /\\\\`{2}[^\n]*`{2}/ },
+      // guard: constrained formatting mark may not be preceded by ":", ";" or
+      // "}". match these so the constrained rule doesn't see them
+      { begin: /[:;}][*_`](?![*_`])/ }
+    ];
+    const STRONG = [
+      // inline unconstrained strong (single line)
+      {
+        className: "strong",
+        begin: /\*{2}([^\n]+?)\*{2}/
+      },
+      // inline unconstrained strong (multi-line)
+      {
+        className: "strong",
+        begin: regex.concat(
+          /\*\*/,
+          /((\*(?!\*)|\\[^\n]|[^*\n\\])+\n)+/,
+          /(\*(?!\*)|\\[^\n]|[^*\n\\])*/,
+          /\*\*/
+        ),
+        relevance: 0
+      },
+      // inline constrained strong (single line)
+      {
+        className: "strong",
+        // must not precede or follow a word character
+        begin: /\B\*(\S|\S[^\n]*?\S)\*(?!\w)/
+      },
+      // inline constrained strong (multi-line)
+      {
+        className: "strong",
+        // must not precede or follow a word character
+        begin: /\*[^\s]([^\n]+\n)+([^\n]+)\*/
+      }
+    ];
+    const EMPHASIS = [
+      // inline unconstrained emphasis (single line)
+      {
+        className: "emphasis",
+        begin: /_{2}([^\n]+?)_{2}/
+      },
+      // inline unconstrained emphasis (multi-line)
+      {
+        className: "emphasis",
+        begin: regex.concat(
+          /__/,
+          /((_(?!_)|\\[^\n]|[^_\n\\])+\n)+/,
+          /(_(?!_)|\\[^\n]|[^_\n\\])*/,
+          /__/
+        ),
+        relevance: 0
+      },
+      // inline constrained emphasis (single line)
+      {
+        className: "emphasis",
+        // must not precede or follow a word character
+        begin: /\b_(\S|\S[^\n]*?\S)_(?!\w)/
+      },
+      // inline constrained emphasis (multi-line)
+      {
+        className: "emphasis",
+        // must not precede or follow a word character
+        begin: /_[^\s]([^\n]+\n)+([^\n]+)_/
+      },
+      // inline constrained emphasis using single quote (legacy)
+      {
+        className: "emphasis",
+        // must not follow a word character or be followed by a single quote or space
+        begin: "\\B'(?!['\\s])",
+        end: "(\\n{2}|')",
+        // allow escaped single quote followed by word char
+        contains: [
+          {
+            begin: "\\\\'\\w",
+            relevance: 0
+          }
+        ],
+        relevance: 0
+      }
+    ];
+    const ADMONITION = {
+      className: "symbol",
+      begin: "^(NOTE|TIP|IMPORTANT|WARNING|CAUTION):\\s+",
+      relevance: 10
+    };
+    const BULLET_LIST = {
+      className: "bullet",
+      begin: "^(\\*+|-+|\\.+|[^\\n]+?::)\\s+"
+    };
+    return {
+      name: "AsciiDoc",
+      aliases: ["adoc"],
+      contains: [
+        // block comment
+        hljs.COMMENT(
+          "^/{4,}\\n",
+          "\\n/{4,}$",
+          // can also be done as...
+          // '^/{4,}$',
+          // '^/{4,}$',
+          { relevance: 10 }
+        ),
+        // line comment
+        hljs.COMMENT(
+          "^//",
+          "$",
+          { relevance: 0 }
+        ),
+        // title
+        {
+          className: "title",
+          begin: "^\\.\\w.*$"
+        },
+        // example, admonition & sidebar blocks
+        {
+          begin: "^[=\\*]{4,}\\n",
+          end: "\\n^[=\\*]{4,}$",
+          relevance: 10
+        },
+        // headings
+        {
+          className: "section",
+          relevance: 10,
+          variants: [
+            { begin: "^(={1,6})[ 	].+?([ 	]\\1)?$" },
+            { begin: "^[^\\[\\]\\n]+?\\n[=\\-~\\^\\+]{2,}$" }
+          ]
+        },
+        // document attributes
+        {
+          className: "meta",
+          begin: "^:.+?:",
+          end: "\\s",
+          excludeEnd: true,
+          relevance: 10
+        },
+        // block attributes
+        {
+          className: "meta",
+          begin: "^\\[.+?\\]$",
+          relevance: 0
+        },
+        // quoteblocks
+        {
+          className: "quote",
+          begin: "^_{4,}\\n",
+          end: "\\n_{4,}$",
+          relevance: 10
+        },
+        // listing and literal blocks
+        {
+          className: "code",
+          begin: "^[\\-\\.]{4,}\\n",
+          end: "\\n[\\-\\.]{4,}$",
+          relevance: 10
+        },
+        // passthrough blocks
+        {
+          begin: "^\\+{4,}\\n",
+          end: "\\n\\+{4,}$",
+          contains: [
+            {
+              begin: "<",
+              end: ">",
+              subLanguage: "xml",
+              relevance: 0
+            }
+          ],
+          relevance: 10
+        },
+        BULLET_LIST,
+        ADMONITION,
+        ...ESCAPED_FORMATTING,
+        ...STRONG,
+        ...EMPHASIS,
+        // inline smart quotes
+        {
+          className: "string",
+          variants: [
+            { begin: "``.+?''" },
+            { begin: "`.+?'" }
+          ]
+        },
+        // inline unconstrained emphasis
+        {
+          className: "code",
+          begin: /`{2}/,
+          end: /(\n{2}|`{2})/
+        },
+        // inline code snippets (TODO should get same treatment as strong and emphasis)
+        {
+          className: "code",
+          begin: "(`.+?`|\\+.+?\\+)",
+          relevance: 0
+        },
+        // indented literal block
+        {
+          className: "code",
+          begin: "^[ \\t]",
+          end: "$",
+          relevance: 0
+        },
+        HORIZONTAL_RULE,
+        // images and links
+        {
+          begin: "(link:)?(http|https|ftp|file|irc|image:?):\\S+?\\[[^[]*?\\]",
+          returnBegin: true,
+          contains: [
+            {
+              begin: "(link|image:?):",
+              relevance: 0
+            },
+            {
+              className: "link",
+              begin: "\\w",
+              end: "[^\\[]+",
+              relevance: 0
+            },
+            {
+              className: "string",
+              begin: "\\[",
+              end: "\\]",
+              excludeBegin: true,
+              excludeEnd: true,
+              relevance: 0
+            }
+          ],
+          relevance: 10
+        }
+      ]
+    };
+  }
+  asciidoc_1 = asciidoc;
+  return asciidoc_1;
+}
+exports.__require = requireAsciidoc;

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

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var aspectj_1;
+var hasRequiredAspectj;
+function requireAspectj() {
+  if (hasRequiredAspectj) return aspectj_1;
+  hasRequiredAspectj = 1;
+  function aspectj(hljs) {
+    const regex = hljs.regex;
+    const KEYWORDS = [
+      "false",
+      "synchronized",
+      "int",
+      "abstract",
+      "float",
+      "private",
+      "char",
+      "boolean",
+      "static",
+      "null",
+      "if",
+      "const",
+      "for",
+      "true",
+      "while",
+      "long",
+      "throw",
+      "strictfp",
+      "finally",
+      "protected",
+      "import",
+      "native",
+      "final",
+      "return",
+      "void",
+      "enum",
+      "else",
+      "extends",
+      "implements",
+      "break",
+      "transient",
+      "new",
+      "catch",
+      "instanceof",
+      "byte",
+      "super",
+      "volatile",
+      "case",
+      "assert",
+      "short",
+      "package",
+      "default",
+      "double",
+      "public",
+      "try",
+      "this",
+      "switch",
+      "continue",
+      "throws",
+      "privileged",
+      "aspectOf",
+      "adviceexecution",
+      "proceed",
+      "cflowbelow",
+      "cflow",
+      "initialization",
+      "preinitialization",
+      "staticinitialization",
+      "withincode",
+      "target",
+      "within",
+      "execution",
+      "getWithinTypeName",
+      "handler",
+      "thisJoinPoint",
+      "thisJoinPointStaticPart",
+      "thisEnclosingJoinPointStaticPart",
+      "declare",
+      "parents",
+      "warning",
+      "error",
+      "soft",
+      "precedence",
+      "thisAspectInstance"
+    ];
+    const SHORTKEYS = [
+      "get",
+      "set",
+      "args",
+      "call"
+    ];
+    return {
+      name: "AspectJ",
+      keywords: KEYWORDS,
+      illegal: /<\/|#/,
+      contains: [
+        hljs.COMMENT(
+          /\/\*\*/,
+          /\*\//,
+          {
+            relevance: 0,
+            contains: [
+              {
+                // eat up @'s in emails to prevent them to be recognized as doctags
+                begin: /\w+@/,
+                relevance: 0
+              },
+              {
+                className: "doctag",
+                begin: /@[A-Za-z]+/
+              }
+            ]
+          }
+        ),
+        hljs.C_LINE_COMMENT_MODE,
+        hljs.C_BLOCK_COMMENT_MODE,
+        hljs.APOS_STRING_MODE,
+        hljs.QUOTE_STRING_MODE,
+        {
+          className: "class",
+          beginKeywords: "aspect",
+          end: /[{;=]/,
+          excludeEnd: true,
+          illegal: /[:;"\[\]]/,
+          contains: [
+            { beginKeywords: "extends implements pertypewithin perthis pertarget percflowbelow percflow issingleton" },
+            hljs.UNDERSCORE_TITLE_MODE,
+            {
+              begin: /\([^\)]*/,
+              end: /[)]+/,
+              keywords: KEYWORDS.concat(SHORTKEYS),
+              excludeEnd: false
+            }
+          ]
+        },
+        {
+          className: "class",
+          beginKeywords: "class interface",
+          end: /[{;=]/,
+          excludeEnd: true,
+          relevance: 0,
+          keywords: "class interface",
+          illegal: /[:"\[\]]/,
+          contains: [
+            { beginKeywords: "extends implements" },
+            hljs.UNDERSCORE_TITLE_MODE
+          ]
+        },
+        {
+          // AspectJ Constructs
+          beginKeywords: "pointcut after before around throwing returning",
+          end: /[)]/,
+          excludeEnd: false,
+          illegal: /["\[\]]/,
+          contains: [
+            {
+              begin: regex.concat(hljs.UNDERSCORE_IDENT_RE, /\s*\(/),
+              returnBegin: true,
+              contains: [hljs.UNDERSCORE_TITLE_MODE]
+            }
+          ]
+        },
+        {
+          begin: /[:]/,
+          returnBegin: true,
+          end: /[{;]/,
+          relevance: 0,
+          excludeEnd: false,
+          keywords: KEYWORDS,
+          illegal: /["\[\]]/,
+          contains: [
+            {
+              begin: regex.concat(hljs.UNDERSCORE_IDENT_RE, /\s*\(/),
+              keywords: KEYWORDS.concat(SHORTKEYS),
+              relevance: 0
+            },
+            hljs.QUOTE_STRING_MODE
+          ]
+        },
+        {
+          // this prevents 'new Name(...), or throw ...' from being recognized as a function definition
+          beginKeywords: "new throw",
+          relevance: 0
+        },
+        {
+          // the function class is a bit different for AspectJ compared to the Java language
+          className: "function",
+          begin: /\w+ +\w+(\.\w+)?\s*\([^\)]*\)\s*((throws)[\w\s,]+)?[\{;]/,
+          returnBegin: true,
+          end: /[{;=]/,
+          keywords: KEYWORDS,
+          excludeEnd: true,
+          contains: [
+            {
+              begin: regex.concat(hljs.UNDERSCORE_IDENT_RE, /\s*\(/),
+              returnBegin: true,
+              relevance: 0,
+              contains: [hljs.UNDERSCORE_TITLE_MODE]
+            },
+            {
+              className: "params",
+              begin: /\(/,
+              end: /\)/,
+              relevance: 0,
+              keywords: KEYWORDS,
+              contains: [
+                hljs.APOS_STRING_MODE,
+                hljs.QUOTE_STRING_MODE,
+                hljs.C_NUMBER_MODE,
+                hljs.C_BLOCK_COMMENT_MODE
+              ]
+            },
+            hljs.C_LINE_COMMENT_MODE,
+            hljs.C_BLOCK_COMMENT_MODE
+          ]
+        },
+        hljs.C_NUMBER_MODE,
+        {
+          // annotation is also used in this language
+          className: "meta",
+          begin: /@[A-Za-z]+/
+        }
+      ]
+    };
+  }
+  aspectj_1 = aspectj;
+  return aspectj_1;
+}
+exports.__require = requireAspectj;

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var autohotkey_1;
+var hasRequiredAutohotkey;
+function requireAutohotkey() {
+  if (hasRequiredAutohotkey) return autohotkey_1;
+  hasRequiredAutohotkey = 1;
+  function autohotkey(hljs) {
+    const BACKTICK_ESCAPE = { begin: "`[\\s\\S]" };
+    return {
+      name: "AutoHotkey",
+      case_insensitive: true,
+      aliases: ["ahk"],
+      keywords: {
+        keyword: "Break Continue Critical Exit ExitApp Gosub Goto New OnExit Pause return SetBatchLines SetTimer Suspend Thread Throw Until ahk_id ahk_class ahk_pid ahk_exe ahk_group",
+        literal: "true false NOT AND OR",
+        built_in: "ComSpec Clipboard ClipboardAll ErrorLevel"
+      },
+      contains: [
+        BACKTICK_ESCAPE,
+        hljs.inherit(hljs.QUOTE_STRING_MODE, { contains: [BACKTICK_ESCAPE] }),
+        hljs.COMMENT(";", "$", { relevance: 0 }),
+        hljs.C_BLOCK_COMMENT_MODE,
+        {
+          className: "number",
+          begin: hljs.NUMBER_RE,
+          relevance: 0
+        },
+        {
+          // subst would be the most accurate however fails the point of
+          // highlighting. variable is comparably the most accurate that actually
+          // has some effect
+          className: "variable",
+          begin: "%[a-zA-Z0-9#_$@]+%"
+        },
+        {
+          className: "built_in",
+          begin: "^\\s*\\w+\\s*(,|%)"
+          // I don't really know if this is totally relevant
+        },
+        {
+          // symbol would be most accurate however is highlighted just like
+          // built_in and that makes up a lot of AutoHotkey code meaning that it
+          // would fail to highlight anything
+          className: "title",
+          variants: [
+            { begin: '^[^\\n";]+::(?!=)' },
+            {
+              begin: '^[^\\n";]+:(?!=)',
+              // zero relevance as it catches a lot of things
+              // followed by a single ':' in many languages
+              relevance: 0
+            }
+          ]
+        },
+        {
+          className: "meta",
+          begin: "^\\s*#\\w+",
+          end: "$",
+          relevance: 0
+        },
+        {
+          className: "built_in",
+          begin: "A_[a-zA-Z0-9]+"
+        },
+        {
+          // consecutive commas, not for highlighting but just for relevance
+          begin: ",\\s*,"
+        }
+      ]
+    };
+  }
+  autohotkey_1 = autohotkey;
+  return autohotkey_1;
+}
+exports.__require = requireAutohotkey;