byterover-cli 3.13.0 → 3.15.0

package/node_modules/refractor/lang/scss.d.ts

@@ -0,0 +1,7 @@
+/** @type {import('../core.js').Syntax} */
+declare function scss(Prism: any): void;
+declare namespace scss {
+    let displayName: string;
+    let aliases: any[];
+}
+export default scss;

package/node_modules/refractor/lang/scss.js

@@ -0,0 +1,90 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+import refractorCss from './css.js'
+scss.displayName = 'scss'
+scss.aliases = []
+
+/** @param {Refractor} Prism */
+export default function scss(Prism) {
+  Prism.register(refractorCss)
+  Prism.languages.scss = Prism.languages.extend('css', {
+    comment: {
+      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+      lookbehind: true
+    },
+    atrule: {
+      pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+      inside: {
+        rule: /@[\w-]+/
+        // See rest below
+      }
+    },
+    // url, compassified
+    url: /(?:[-a-z]+-)?url(?=\()/i,
+    // CSS selector regex is not appropriate for Sass
+    // since there can be lot more things (var, @ directive, nesting..)
+    // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+    // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+    // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+    // can "pass" as a selector- e.g: proper#{$erty})
+    // this one was hard to do, so please be careful if you edit this one :)
+    selector: {
+      // Initial look-ahead is used to prevent matching of blank selectors
+      pattern:
+        /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
+      inside: {
+        parent: {
+          pattern: /&/,
+          alias: 'important'
+        },
+        placeholder: /%[-\w]+/,
+        variable: /\$[-\w]+|#\{\$[-\w]+\}/
+      }
+    },
+    property: {
+      pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
+      inside: {
+        variable: /\$[-\w]+|#\{\$[-\w]+\}/
+      }
+    }
+  })
+  Prism.languages.insertBefore('scss', 'atrule', {
+    keyword: [
+      /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i,
+      {
+        pattern: /( )(?:from|through)(?= )/,
+        lookbehind: true
+      }
+    ]
+  })
+  Prism.languages.insertBefore('scss', 'important', {
+    // var and interpolated vars
+    variable: /\$[-\w]+|#\{\$[-\w]+\}/
+  })
+  Prism.languages.insertBefore('scss', 'function', {
+    'module-modifier': {
+      pattern: /\b(?:as|hide|show|with)\b/i,
+      alias: 'keyword'
+    },
+    placeholder: {
+      pattern: /%[-\w]+/,
+      alias: 'selector'
+    },
+    statement: {
+      pattern: /\B!(?:default|optional)\b/i,
+      alias: 'keyword'
+    },
+    boolean: /\b(?:false|true)\b/,
+    null: {
+      pattern: /\bnull\b/,
+      alias: 'keyword'
+    },
+    operator: {
+      pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
+      lookbehind: true
+    }
+  })
+  Prism.languages.scss['atrule'].inside.rest = Prism.languages.scss
+}

package/node_modules/refractor/lang/shell-session.d.ts

@@ -0,0 +1,7 @@
+/** @type {import('../core.js').Syntax} */
+declare function shellSession(Prism: any): void;
+declare namespace shellSession {
+    let displayName: string;
+    let aliases: string[];
+}
+export default shellSession;

package/node_modules/refractor/lang/shell-session.js

@@ -0,0 +1,82 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+import refractorBash from './bash.js'
+shellSession.displayName = 'shell-session'
+shellSession.aliases = ['sh-session', 'shellsession']
+
+/** @param {Refractor} Prism */
+export default function shellSession(Prism) {
+  Prism.register(refractorBash)
+  ;(function (Prism) {
+    // CAREFUL!
+    // The following patterns are concatenated, so the group referenced by a back reference is non-obvious!
+
+    var strings = [
+      // normal string
+      /"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/.source,
+      /'[^']*'/.source,
+      /\$'(?:[^'\\]|\\[\s\S])*'/.source,
+      // here doc
+      // 2 capturing groups
+      /<<-?\s*(["']?)(\w+)\1\s[\s\S]*?[\r\n]\2/.source
+    ].join('|')
+    Prism.languages['shell-session'] = {
+      command: {
+        pattern: RegExp(
+          // user info
+          /^/.source +
+            '(?:' +
+            // <user> ":" ( <path> )?
+            (/[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+(?::[^\0-\x1F$#%*?"<>:;|]+)?/
+              .source +
+              '|' +
+              // <path>
+              // Since the path pattern is quite general, we will require it to start with a special character to
+              // prevent false positives.
+              /[/~.][^\0-\x1F$#%*?"<>@:;|]*/.source) +
+            ')?' +
+            // shell symbol
+            /[$#%](?=\s)/.source +
+            // bash command
+            /(?:[^\\\r\n \t'"<$]|[ \t](?:(?!#)|#.*$)|\\(?:[^\r]|\r\n?)|\$(?!')|<(?!<)|<<str>>)+/.source.replace(
+              /<<str>>/g,
+              function () {
+                return strings
+              }
+            ),
+          'm'
+        ),
+        greedy: true,
+        inside: {
+          info: {
+            // foo@bar:~/files$ exit
+            // foo@bar$ exit
+            // ~/files$ exit
+            pattern: /^[^#$%]+/,
+            alias: 'punctuation',
+            inside: {
+              user: /^[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+/,
+              punctuation: /:/,
+              path: /[\s\S]+/
+            }
+          },
+          bash: {
+            pattern: /(^[$#%]\s*)\S[\s\S]*/,
+            lookbehind: true,
+            alias: 'language-bash',
+            inside: Prism.languages.bash
+          },
+          'shell-symbol': {
+            pattern: /^[$#%]/,
+            alias: 'important'
+          }
+        }
+      },
+      output: /.(?:.*(?:[\r\n]|.$))*/
+    }
+    Prism.languages['sh-session'] = Prism.languages['shellsession'] =
+      Prism.languages['shell-session']
+  })(Prism)
+}

package/node_modules/refractor/lang/smali.d.ts

@@ -0,0 +1,7 @@
+/** @type {import('../core.js').Syntax} */
+declare function smali(Prism: any): void;
+declare namespace smali {
+    let displayName: string;
+    let aliases: any[];
+}
+export default smali;

package/node_modules/refractor/lang/smali.js

@@ -0,0 +1,95 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+smali.displayName = 'smali'
+smali.aliases = []
+
+/** @param {Refractor} Prism */
+export default function smali(Prism) {
+  // Test files for the parser itself:
+  // https://github.com/JesusFreke/smali/tree/master/smali/src/test/resources/LexerTest
+
+  Prism.languages.smali = {
+    comment: /#.*/,
+    string: {
+      pattern: /"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\(?:.|u[\da-fA-F]{4}))'/,
+      greedy: true
+    },
+    'class-name': {
+      pattern:
+        /(^|[^L])L(?:(?:\w+|`[^`\r\n]*`)\/)*(?:[\w$]+|`[^`\r\n]*`)(?=\s*;)/,
+      lookbehind: true,
+      inside: {
+        'class-name': {
+          pattern: /(^L|\/)(?:[\w$]+|`[^`\r\n]*`)$/,
+          lookbehind: true
+        },
+        namespace: {
+          pattern: /^(L)(?:(?:\w+|`[^`\r\n]*`)\/)+/,
+          lookbehind: true,
+          inside: {
+            punctuation: /\//
+          }
+        },
+        builtin: /^L/
+      }
+    },
+    builtin: [
+      {
+        // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types
+        pattern: /([();\[])[BCDFIJSVZ]+/,
+        lookbehind: true
+      },
+      {
+        // e.g. .field mWifiOnUid:I
+        pattern: /([\w$>]:)[BCDFIJSVZ]/,
+        lookbehind: true
+      }
+    ],
+    keyword: [
+      {
+        pattern: /(\.end\s+)[\w-]+/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^\w.-])\.(?!\d)[\w-]+/,
+        lookbehind: true
+      },
+      {
+        pattern:
+          /(^|[^\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\w.-])/,
+        lookbehind: true
+      }
+    ],
+    function: {
+      pattern: /(^|[^\w.-])(?:\w+|<[\w$-]+>)(?=\()/,
+      lookbehind: true
+    },
+    field: {
+      pattern: /[\w$]+(?=:)/,
+      alias: 'variable'
+    },
+    register: {
+      pattern: /(^|[^\w.-])[vp]\d(?![\w.-])/,
+      lookbehind: true,
+      alias: 'variable'
+    },
+    boolean: {
+      pattern: /(^|[^\w.-])(?:false|true)(?![\w.-])/,
+      lookbehind: true
+    },
+    number: {
+      pattern:
+        /(^|[^/\w.-])-?(?:NAN|INFINITY|0x(?:[\dA-F]+(?:\.[\dA-F]*)?|\.[\dA-F]+)(?:p[+-]?[\dA-F]+)?|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)[dflst]?(?![\w.-])/i,
+      lookbehind: true
+    },
+    label: {
+      pattern: /(:)\w+/,
+      lookbehind: true,
+      alias: 'property'
+    },
+    operator: /->|\.\.|[\[=]/,
+    punctuation: /[{}(),;:]/
+  }
+}

package/node_modules/refractor/lang/smalltalk.d.ts

@@ -0,0 +1,7 @@
+/** @type {import('../core.js').Syntax} */
+declare function smalltalk(Prism: any): void;
+declare namespace smalltalk {
+    let displayName: string;
+    let aliases: any[];
+}
+export default smalltalk;

package/node_modules/refractor/lang/smalltalk.js

@@ -0,0 +1,48 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+smalltalk.displayName = 'smalltalk'
+smalltalk.aliases = []
+
+/** @param {Refractor} Prism */
+export default function smalltalk(Prism) {
+  Prism.languages.smalltalk = {
+    comment: {
+      pattern: /"(?:""|[^"])*"/,
+      greedy: true
+    },
+    char: {
+      pattern: /\$./,
+      greedy: true
+    },
+    string: {
+      pattern: /'(?:''|[^'])*'/,
+      greedy: true
+    },
+    symbol: /#[\da-z]+|#(?:-|([+\/\\*~<>=@%|&?!])\1?)|#(?=\()/i,
+    'block-arguments': {
+      pattern: /(\[\s*):[^\[|]*\|/,
+      lookbehind: true,
+      inside: {
+        variable: /:[\da-z]+/i,
+        punctuation: /\|/
+      }
+    },
+    'temporary-variables': {
+      pattern: /\|[^|]+\|/,
+      inside: {
+        variable: /[\da-z]+/i,
+        punctuation: /\|/
+      }
+    },
+    keyword: /\b(?:new|nil|self|super)\b/,
+    boolean: /\b(?:false|true)\b/,
+    number: [
+      /\d+r-?[\dA-Z]+(?:\.[\dA-Z]+)?(?:e-?\d+)?/,
+      /\b\d+(?:\.\d+)?(?:e-?\d+)?/
+    ],
+    operator: /[<=]=?|:=|~[~=]|\/\/?|\\\\|>[>=]?|[!^+\-*&|,@]/,
+    punctuation: /[.;:?\[\](){}]/
+  }
+}

package/node_modules/refractor/lang/smarty.d.ts

@@ -0,0 +1,7 @@
+/** @type {import('../core.js').Syntax} */
+declare function smarty(Prism: any): void;
+declare namespace smarty {
+    let displayName: string;
+    let aliases: any[];
+}
+export default smarty;

package/node_modules/refractor/lang/smarty.js

@@ -0,0 +1,147 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+import refractorMarkupTemplating from './markup-templating.js'
+smarty.displayName = 'smarty'
+smarty.aliases = []
+
+/** @param {Refractor} Prism */
+export default function smarty(Prism) {
+  Prism.register(refractorMarkupTemplating)
+  ;(function (Prism) {
+    Prism.languages.smarty = {
+      comment: {
+        pattern: /^\{\*[\s\S]*?\*\}/,
+        greedy: true
+      },
+      'embedded-php': {
+        pattern: /^\{php\}[\s\S]*?\{\/php\}/,
+        greedy: true,
+        inside: {
+          smarty: {
+            pattern: /^\{php\}|\{\/php\}$/,
+            inside: null // see below
+          },
+          php: {
+            pattern: /[\s\S]+/,
+            alias: 'language-php',
+            inside: Prism.languages.php
+          }
+        }
+      },
+      string: [
+        {
+          pattern: /"(?:\\.|[^"\\\r\n])*"/,
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: /\{[^{}]*\}|`[^`]*`/,
+              inside: {
+                'interpolation-punctuation': {
+                  pattern: /^[{`]|[`}]$/,
+                  alias: 'punctuation'
+                },
+                expression: {
+                  pattern: /[\s\S]+/,
+                  inside: null // see below
+                }
+              }
+            },
+            variable: /\$\w+/
+          }
+        },
+        {
+          pattern: /'(?:\\.|[^'\\\r\n])*'/,
+          greedy: true
+        }
+      ],
+      keyword: {
+        pattern: /(^\{\/?)[a-z_]\w*\b(?!\()/i,
+        lookbehind: true,
+        greedy: true
+      },
+      delimiter: {
+        pattern: /^\{\/?|\}$/,
+        greedy: true,
+        alias: 'punctuation'
+      },
+      number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+      variable: [
+        /\$(?!\d)\w+/,
+        /#(?!\d)\w+#/,
+        {
+          pattern: /(\.|->|\w\s*=)(?!\d)\w+\b(?!\()/,
+          lookbehind: true
+        },
+        {
+          pattern: /(\[)(?!\d)\w+(?=\])/,
+          lookbehind: true
+        }
+      ],
+      function: {
+        pattern: /(\|\s*)@?[a-z_]\w*|\b[a-z_]\w*(?=\()/i,
+        lookbehind: true
+      },
+      'attr-name': /\b[a-z_]\w*(?=\s*=)/i,
+      boolean: /\b(?:false|no|off|on|true|yes)\b/,
+      punctuation: /[\[\](){}.,:`]|->/,
+      operator: [
+        /[+\-*\/%]|==?=?|[!<>]=?|&&|\|\|?/,
+        /\bis\s+(?:not\s+)?(?:div|even|odd)(?:\s+by)?\b/,
+        /\b(?:and|eq|gt?e|gt|lt?e|lt|mod|neq?|not|or)\b/
+      ]
+    }
+    Prism.languages.smarty['embedded-php'].inside.smarty.inside =
+      Prism.languages.smarty
+    Prism.languages.smarty.string[0].inside.interpolation.inside.expression.inside =
+      Prism.languages.smarty
+    var string = /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/
+    var smartyPattern = RegExp(
+      // comments
+      /\{\*[\s\S]*?\*\}/.source +
+        '|' +
+        // php tags
+        /\{php\}[\s\S]*?\{\/php\}/.source +
+        '|' +
+        // smarty blocks
+        /\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>)*\})*\})*\}/.source.replace(
+          /<str>/g,
+          function () {
+            return string.source
+          }
+        ),
+      'g'
+    )
+
+    // Tokenize all inline Smarty expressions
+    Prism.hooks.add('before-tokenize', function (env) {
+      var smartyLiteralStart = '{literal}'
+      var smartyLiteralEnd = '{/literal}'
+      var smartyLiteralMode = false
+      Prism.languages['markup-templating'].buildPlaceholders(
+        env,
+        'smarty',
+        smartyPattern,
+        function (match) {
+          // Smarty tags inside {literal} block are ignored
+          if (match === smartyLiteralEnd) {
+            smartyLiteralMode = false
+          }
+          if (!smartyLiteralMode) {
+            if (match === smartyLiteralStart) {
+              smartyLiteralMode = true
+            }
+            return true
+          }
+          return false
+        }
+      )
+    })
+
+    // Re-insert the tokens after tokenizing
+    Prism.hooks.add('after-tokenize', function (env) {
+      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'smarty')
+    })
+  })(Prism)
+}

package/node_modules/refractor/lang/sml.d.ts

@@ -0,0 +1,7 @@
+/** @type {import('../core.js').Syntax} */
+declare function sml(Prism: any): void;
+declare namespace sml {
+    let displayName: string;
+    let aliases: string[];
+}
+export default sml;

package/node_modules/refractor/lang/sml.js

@@ -0,0 +1,79 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+sml.displayName = 'sml'
+sml.aliases = ['smlnj']
+
+/** @param {Refractor} Prism */
+export default function sml(Prism) {
+  // https://smlfamily.github.io/sml97-defn.pdf
+  // https://people.mpi-sws.org/~rossberg/sml.html
+  ;(function (Prism) {
+    var keywords =
+      /\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\b/i
+    Prism.languages.sml = {
+      // allow one level of nesting
+      comment:
+        /\(\*(?:[^*(]|\*(?!\))|\((?!\*)|\(\*(?:[^*(]|\*(?!\))|\((?!\*))*\*\))*\*\)/,
+      string: {
+        pattern: /#?"(?:[^"\\]|\\.)*"/,
+        greedy: true
+      },
+      'class-name': [
+        {
+          // This is only an approximation since the real grammar is context-free
+          //
+          // Why the main loop so complex?
+          // The main loop is approximately the same as /(?:\s*(?:[*,]|->)\s*<TERMINAL>)*/ which is, obviously, a lot
+          // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be
+          // followed by a long identifier.
+          pattern: RegExp(
+            /((?:^|[^:]):\s*)<TERMINAL>(?:\s*(?:(?:\*|->)\s*<TERMINAL>|,\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\s+<LONG-ID>)))*/.source
+              .replace(/<NOT-LAST>/g, function () {
+                return /\s*(?:[*,]|->)/.source
+              })
+              .replace(/<TERMINAL>/g, function () {
+                return /(?:'[\w']*|<LONG-ID>|\((?:[^()]|\([^()]*\))*\)|\{(?:[^{}]|\{[^{}]*\})*\})(?:\s+<LONG-ID>)*/
+                  .source
+              })
+              .replace(/<LONG-ID>/g, function () {
+                return /(?!<KEYWORD>)[a-z\d_][\w'.]*/.source
+              })
+              .replace(/<KEYWORD>/g, function () {
+                return keywords.source
+              }),
+            'i'
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: null // see below
+        },
+        {
+          pattern:
+            /((?:^|[^\w'])(?:datatype|exception|functor|signature|structure|type)\s+)[a-z_][\w'.]*/i,
+          lookbehind: true
+        }
+      ],
+      function: {
+        pattern: /((?:^|[^\w'])fun\s+)[a-z_][\w'.]*/i,
+        lookbehind: true
+      },
+      keyword: keywords,
+      variable: {
+        pattern: /(^|[^\w'])'[\w']*/,
+        lookbehind: true
+      },
+      number: /~?\b(?:\d+(?:\.\d+)?(?:e~?\d+)?|0x[\da-f]+)\b/i,
+      word: {
+        pattern: /\b0w(?:\d+|x[\da-f]+)\b/i,
+        alias: 'constant'
+      },
+      boolean: /\b(?:false|true)\b/i,
+      operator: /\.\.\.|:[>=:]|=>?|->|[<>]=?|[!+\-*/^#|@~]/,
+      punctuation: /[(){}\[\].:,;]/
+    }
+    Prism.languages.sml['class-name'][0].inside = Prism.languages.sml
+    Prism.languages.smlnj = Prism.languages.sml
+  })(Prism)
+}

package/node_modules/refractor/lang/solidity.d.ts

@@ -0,0 +1,7 @@
+/** @type {import('../core.js').Syntax} */
+declare function solidity(Prism: any): void;
+declare namespace solidity {
+    let displayName: string;
+    let aliases: string[];
+}
+export default solidity;

package/node_modules/refractor/lang/solidity.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+/**
+ * @import {Refractor} from '../lib/core.js'
+ */
+import refractorClike from './clike.js'
+solidity.displayName = 'solidity'
+solidity.aliases = ['sol']
+
+/** @param {Refractor} Prism */
+export default function solidity(Prism) {
+  Prism.register(refractorClike)
+  Prism.languages.solidity = Prism.languages.extend('clike', {
+    'class-name': {
+      pattern:
+        /(\b(?:contract|enum|interface|library|new|struct|using)\s+)(?!\d)[\w$]+/,
+      lookbehind: true
+    },
+    keyword:
+      /\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\b/,
+    operator: /=>|->|:=|=:|\*\*|\+\+|--|\|\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/
+  })
+  Prism.languages.insertBefore('solidity', 'keyword', {
+    builtin:
+      /\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/
+  })
+  Prism.languages.insertBefore('solidity', 'number', {
+    version: {
+      pattern: /([<>]=?|\^)\d+\.\d+\.\d+\b/,
+      lookbehind: true,
+      alias: 'number'
+    }
+  })
+  Prism.languages.sol = Prism.languages.solidity
+}

package/node_modules/refractor/lang/solution-file.d.ts

@@ -0,0 +1,7 @@
+/** @type {import('../core.js').Syntax} */
+declare function solutionFile(Prism: any): void;
+declare namespace solutionFile {
+    let displayName: string;
+    let aliases: string[];
+}
+export default solutionFile;