pygpt-net 2.4.47__py3-none-any.whl

pygpt_net/data/js/highlight/es/languages/fsharp.js

@@ -0,0 +1,635 @@
+/*! `fsharp` grammar compiled for Highlight.js 11.10.0 */
+var hljsGrammar = (function () {
+  'use strict';
+
+  /**
+   * @param {string} value
+   * @returns {RegExp}
+   * */
+  function escape(value) {
+    return new RegExp(value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&'), 'm');
+  }
+
+  /**
+   * @param {RegExp | string } re
+   * @returns {string}
+   */
+  function source(re) {
+    if (!re) return null;
+    if (typeof re === "string") return re;
+
+    return re.source;
+  }
+
+  /**
+   * @param {RegExp | string } re
+   * @returns {string}
+   */
+  function lookahead(re) {
+    return concat('(?=', re, ')');
+  }
+
+  /**
+   * @param {...(RegExp | string) } args
+   * @returns {string}
+   */
+  function concat(...args) {
+    const joined = args.map((x) => source(x)).join("");
+    return joined;
+  }
+
+  /**
+   * @param { Array<string | RegExp | Object> } args
+   * @returns {object}
+   */
+  function stripOptionsFromArgs(args) {
+    const opts = args[args.length - 1];
+
+    if (typeof opts === 'object' && opts.constructor === Object) {
+      args.splice(args.length - 1, 1);
+      return opts;
+    } else {
+      return {};
+    }
+  }
+
+  /** @typedef { {capture?: boolean} } RegexEitherOptions */
+
+  /**
+   * Any of the passed expresssions may match
+   *
+   * Creates a huge this | this | that | that match
+   * @param {(RegExp | string)[] | [...(RegExp | string)[], RegexEitherOptions]} args
+   * @returns {string}
+   */
+  function either(...args) {
+    /** @type { object & {capture?: boolean} }  */
+    const opts = stripOptionsFromArgs(args);
+    const joined = '('
+      + (opts.capture ? "" : "?:")
+      + args.map((x) => source(x)).join("|") + ")";
+    return joined;
+  }
+
+  /*
+  Language: F#
+  Author: Jonas Follesø <jonas@follesoe.no>
+  Contributors: Troy Kershaw <hello@troykershaw.com>, Henrik Feldt <henrik@haf.se>, Melvyn Laïly <melvyn.laily@gmail.com>
+  Website: https://docs.microsoft.com/en-us/dotnet/fsharp/
+  Category: functional
+  */
+
+
+  /** @type LanguageFn */
+  function fsharp(hljs) {
+    const KEYWORDS = [
+      "abstract",
+      "and",
+      "as",
+      "assert",
+      "base",
+      "begin",
+      "class",
+      "default",
+      "delegate",
+      "do",
+      "done",
+      "downcast",
+      "downto",
+      "elif",
+      "else",
+      "end",
+      "exception",
+      "extern",
+      // "false", // literal
+      "finally",
+      "fixed",
+      "for",
+      "fun",
+      "function",
+      "global",
+      "if",
+      "in",
+      "inherit",
+      "inline",
+      "interface",
+      "internal",
+      "lazy",
+      "let",
+      "match",
+      "member",
+      "module",
+      "mutable",
+      "namespace",
+      "new",
+      // "not", // built_in
+      // "null", // literal
+      "of",
+      "open",
+      "or",
+      "override",
+      "private",
+      "public",
+      "rec",
+      "return",
+      "static",
+      "struct",
+      "then",
+      "to",
+      // "true", // literal
+      "try",
+      "type",
+      "upcast",
+      "use",
+      "val",
+      "void",
+      "when",
+      "while",
+      "with",
+      "yield"
+    ];
+
+    const BANG_KEYWORD_MODE = {
+      // monad builder keywords (matches before non-bang keywords)
+      scope: 'keyword',
+      match: /\b(yield|return|let|do|match|use)!/
+    };
+
+    const PREPROCESSOR_KEYWORDS = [
+      "if",
+      "else",
+      "endif",
+      "line",
+      "nowarn",
+      "light",
+      "r",
+      "i",
+      "I",
+      "load",
+      "time",
+      "help",
+      "quit"
+    ];
+
+    const LITERALS = [
+      "true",
+      "false",
+      "null",
+      "Some",
+      "None",
+      "Ok",
+      "Error",
+      "infinity",
+      "infinityf",
+      "nan",
+      "nanf"
+    ];
+
+    const SPECIAL_IDENTIFIERS = [
+      "__LINE__",
+      "__SOURCE_DIRECTORY__",
+      "__SOURCE_FILE__"
+    ];
+
+    // Since it's possible to re-bind/shadow names (e.g. let char = 'c'),
+    // these builtin types should only be matched when a type name is expected.
+    const KNOWN_TYPES = [
+      // basic types
+      "bool",
+      "byte",
+      "sbyte",
+      "int8",
+      "int16",
+      "int32",
+      "uint8",
+      "uint16",
+      "uint32",
+      "int",
+      "uint",
+      "int64",
+      "uint64",
+      "nativeint",
+      "unativeint",
+      "decimal",
+      "float",
+      "double",
+      "float32",
+      "single",
+      "char",
+      "string",
+      "unit",
+      "bigint",
+      // other native types or lowercase aliases
+      "option",
+      "voption",
+      "list",
+      "array",
+      "seq",
+      "byref",
+      "exn",
+      "inref",
+      "nativeptr",
+      "obj",
+      "outref",
+      "voidptr",
+      // other important FSharp types
+      "Result"
+    ];
+
+    const BUILTINS = [
+      // Somewhat arbitrary list of builtin functions and values.
+      // Most of them are declared in Microsoft.FSharp.Core
+      // I tried to stay relevant by adding only the most idiomatic
+      // and most used symbols that are not already declared as types.
+      "not",
+      "ref",
+      "raise",
+      "reraise",
+      "dict",
+      "readOnlyDict",
+      "set",
+      "get",
+      "enum",
+      "sizeof",
+      "typeof",
+      "typedefof",
+      "nameof",
+      "nullArg",
+      "invalidArg",
+      "invalidOp",
+      "id",
+      "fst",
+      "snd",
+      "ignore",
+      "lock",
+      "using",
+      "box",
+      "unbox",
+      "tryUnbox",
+      "printf",
+      "printfn",
+      "sprintf",
+      "eprintf",
+      "eprintfn",
+      "fprintf",
+      "fprintfn",
+      "failwith",
+      "failwithf"
+    ];
+
+    const ALL_KEYWORDS = {
+      keyword: KEYWORDS,
+      literal: LITERALS,
+      built_in: BUILTINS,
+      'variable.constant': SPECIAL_IDENTIFIERS
+    };
+
+    // (* potentially multi-line Meta Language style comment *)
+    const ML_COMMENT =
+      hljs.COMMENT(/\(\*(?!\))/, /\*\)/, {
+        contains: ["self"]
+      });
+    // Either a multi-line (* Meta Language style comment *) or a single line // C style comment.
+    const COMMENT = {
+      variants: [
+        ML_COMMENT,
+        hljs.C_LINE_COMMENT_MODE,
+      ]
+    };
+
+    // Most identifiers can contain apostrophes
+    const IDENTIFIER_RE = /[a-zA-Z_](\w|')*/;
+
+    const QUOTED_IDENTIFIER = {
+      scope: 'variable',
+      begin: /``/,
+      end: /``/
+    };
+
+    // 'a or ^a where a can be a ``quoted identifier``
+    const BEGIN_GENERIC_TYPE_SYMBOL_RE = /\B('|\^)/;
+    const GENERIC_TYPE_SYMBOL = {
+      scope: 'symbol',
+      variants: [
+        // the type name is a quoted identifier:
+        { match: concat(BEGIN_GENERIC_TYPE_SYMBOL_RE, /``.*?``/) },
+        // the type name is a normal identifier (we don't use IDENTIFIER_RE because there cannot be another apostrophe here):
+        { match: concat(BEGIN_GENERIC_TYPE_SYMBOL_RE, hljs.UNDERSCORE_IDENT_RE) }
+      ],
+      relevance: 0
+    };
+
+    const makeOperatorMode = function({ includeEqual }) {
+      // List or symbolic operator characters from the FSharp Spec 4.1, minus the dot, and with `?` added, used for nullable operators.
+      let allOperatorChars;
+      if (includeEqual)
+        allOperatorChars = "!%&*+-/<=>@^|~?";
+      else
+        allOperatorChars = "!%&*+-/<>@^|~?";
+      const OPERATOR_CHARS = Array.from(allOperatorChars);
+      const OPERATOR_CHAR_RE = concat('[', ...OPERATOR_CHARS.map(escape), ']');
+      // The lone dot operator is special. It cannot be redefined, and we don't want to highlight it. It can be used as part of a multi-chars operator though.
+      const OPERATOR_CHAR_OR_DOT_RE = either(OPERATOR_CHAR_RE, /\./);
+      // When a dot is present, it must be followed by another operator char:
+      const OPERATOR_FIRST_CHAR_OF_MULTIPLE_RE = concat(OPERATOR_CHAR_OR_DOT_RE, lookahead(OPERATOR_CHAR_OR_DOT_RE));
+      const SYMBOLIC_OPERATOR_RE = either(
+        concat(OPERATOR_FIRST_CHAR_OF_MULTIPLE_RE, OPERATOR_CHAR_OR_DOT_RE, '*'), // Matches at least 2 chars operators
+        concat(OPERATOR_CHAR_RE, '+'), // Matches at least one char operators
+      );
+      return {
+        scope: 'operator',
+        match: either(
+          // symbolic operators:
+          SYMBOLIC_OPERATOR_RE,
+          // other symbolic keywords:
+          // Type casting and conversion operators:
+          /:\?>/,
+          /:\?/,
+          /:>/,
+          /:=/, // Reference cell assignment
+          /::?/, // : or ::
+          /\$/), // A single $ can be used as an operator
+        relevance: 0
+      };
+    };
+
+    const OPERATOR = makeOperatorMode({ includeEqual: true });
+    // This variant is used when matching '=' should end a parent mode:
+    const OPERATOR_WITHOUT_EQUAL = makeOperatorMode({ includeEqual: false });
+
+    const makeTypeAnnotationMode = function(prefix, prefixScope) {
+      return {
+        begin: concat( // a type annotation is a
+          prefix,            // should be a colon or the 'of' keyword
+          lookahead(   // that has to be followed by
+            concat(
+              /\s*/,         // optional space
+              either(  // then either of:
+                /\w/,        // word
+                /'/,         // generic type name
+                /\^/,        // generic type name
+                /#/,         // flexible type name
+                /``/,        // quoted type name
+                /\(/,        // parens type expression
+                /{\|/,       // anonymous type annotation
+        )))),
+        beginScope: prefixScope,
+        // BUG: because ending with \n is necessary for some cases, multi-line type annotations are not properly supported.
+        // Examples where \n is required at the end:
+        // - abstract member definitions in classes: abstract Property : int * string
+        // - return type annotations: let f f' = f' () : returnTypeAnnotation
+        // - record fields definitions: { A : int \n B : string }
+        end: lookahead(
+          either(
+            /\n/,
+            /=/)),
+        relevance: 0,
+        // we need the known types, and we need the type constraint keywords and literals. e.g.: when 'a : null
+        keywords: hljs.inherit(ALL_KEYWORDS, { type: KNOWN_TYPES }),
+        contains: [
+          COMMENT,
+          GENERIC_TYPE_SYMBOL,
+          hljs.inherit(QUOTED_IDENTIFIER, { scope: null }), // match to avoid strange patterns inside that may break the parsing
+          OPERATOR_WITHOUT_EQUAL
+        ]
+      };
+    };
+
+    const TYPE_ANNOTATION = makeTypeAnnotationMode(/:/, 'operator');
+    const DISCRIMINATED_UNION_TYPE_ANNOTATION = makeTypeAnnotationMode(/\bof\b/, 'keyword');
+
+    // type MyType<'a> = ...
+    const TYPE_DECLARATION = {
+      begin: [
+        /(^|\s+)/, // prevents matching the following: `match s.stype with`
+        /type/,
+        /\s+/,
+        IDENTIFIER_RE
+      ],
+      beginScope: {
+        2: 'keyword',
+        4: 'title.class'
+      },
+      end: lookahead(/\(|=|$/),
+      keywords: ALL_KEYWORDS, // match keywords in type constraints. e.g.: when 'a : null
+      contains: [
+        COMMENT,
+        hljs.inherit(QUOTED_IDENTIFIER, { scope: null }), // match to avoid strange patterns inside that may break the parsing
+        GENERIC_TYPE_SYMBOL,
+        {
+          // For visual consistency, highlight type brackets as operators.
+          scope: 'operator',
+          match: /<|>/
+        },
+        TYPE_ANNOTATION // generic types can have constraints, which are type annotations. e.g. type MyType<'T when 'T : delegate<obj * string>> =
+      ]
+    };
+
+    const COMPUTATION_EXPRESSION = {
+      // computation expressions:
+      scope: 'computation-expression',
+      // BUG: might conflict with record deconstruction. e.g. let f { Name = name } = name // will highlight f
+      match: /\b[_a-z]\w*(?=\s*\{)/
+    };
+
+    const PREPROCESSOR = {
+      // preprocessor directives and fsi commands:
+      begin: [
+        /^\s*/,
+        concat(/#/, either(...PREPROCESSOR_KEYWORDS)),
+        /\b/
+      ],
+      beginScope: { 2: 'meta' },
+      end: lookahead(/\s|$/)
+    };
+
+    // TODO: this definition is missing support for type suffixes and octal notation.
+    // BUG: range operator without any space is wrongly interpreted as a single number (e.g. 1..10 )
+    const NUMBER = {
+      variants: [
+        hljs.BINARY_NUMBER_MODE,
+        hljs.C_NUMBER_MODE
+      ]
+    };
+
+    // All the following string definitions are potentially multi-line.
+    // BUG: these definitions are missing support for byte strings (suffixed with B)
+
+    // "..."
+    const QUOTED_STRING = {
+      scope: 'string',
+      begin: /"/,
+      end: /"/,
+      contains: [
+        hljs.BACKSLASH_ESCAPE
+      ]
+    };
+    // @"..."
+    const VERBATIM_STRING = {
+      scope: 'string',
+      begin: /@"/,
+      end: /"/,
+      contains: [
+        {
+          match: /""/ // escaped "
+        },
+        hljs.BACKSLASH_ESCAPE
+      ]
+    };
+    // """..."""
+    const TRIPLE_QUOTED_STRING = {
+      scope: 'string',
+      begin: /"""/,
+      end: /"""/,
+      relevance: 2
+    };
+    const SUBST = {
+      scope: 'subst',
+      begin: /\{/,
+      end: /\}/,
+      keywords: ALL_KEYWORDS
+    };
+    // $"...{1+1}..."
+    const INTERPOLATED_STRING = {
+      scope: 'string',
+      begin: /\$"/,
+      end: /"/,
+      contains: [
+        {
+          match: /\{\{/ // escaped {
+        },
+        {
+          match: /\}\}/ // escaped }
+        },
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
+      ]
+    };
+    // $@"...{1+1}..."
+    const INTERPOLATED_VERBATIM_STRING = {
+      scope: 'string',
+      begin: /(\$@|@\$)"/,
+      end: /"/,
+      contains: [
+        {
+          match: /\{\{/ // escaped {
+        },
+        {
+          match: /\}\}/ // escaped }
+        },
+        {
+          match: /""/
+        },
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
+      ]
+    };
+    // $"""...{1+1}..."""
+    const INTERPOLATED_TRIPLE_QUOTED_STRING = {
+      scope: 'string',
+      begin: /\$"""/,
+      end: /"""/,
+      contains: [
+        {
+          match: /\{\{/ // escaped {
+        },
+        {
+          match: /\}\}/ // escaped }
+        },
+        SUBST
+      ],
+      relevance: 2
+    };
+    // '.'
+    const CHAR_LITERAL = {
+      scope: 'string',
+      match: concat(
+        /'/,
+        either(
+          /[^\\']/, // either a single non escaped char...
+          /\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8})/ // ...or an escape sequence
+        ),
+        /'/
+      )
+    };
+    // F# allows a lot of things inside string placeholders.
+    // Things that don't currently seem allowed by the compiler: types definition, attributes usage.
+    // (Strictly speaking, some of the followings are only allowed inside triple quoted interpolated strings...)
+    SUBST.contains = [
+      INTERPOLATED_VERBATIM_STRING,
+      INTERPOLATED_STRING,
+      VERBATIM_STRING,
+      QUOTED_STRING,
+      CHAR_LITERAL,
+      BANG_KEYWORD_MODE,
+      COMMENT,
+      QUOTED_IDENTIFIER,
+      TYPE_ANNOTATION,
+      COMPUTATION_EXPRESSION,
+      PREPROCESSOR,
+      NUMBER,
+      GENERIC_TYPE_SYMBOL,
+      OPERATOR
+    ];
+    const STRING = {
+      variants: [
+        INTERPOLATED_TRIPLE_QUOTED_STRING,
+        INTERPOLATED_VERBATIM_STRING,
+        INTERPOLATED_STRING,
+        TRIPLE_QUOTED_STRING,
+        VERBATIM_STRING,
+        QUOTED_STRING,
+        CHAR_LITERAL
+      ]
+    };
+
+    return {
+      name: 'F#',
+      aliases: [
+        'fs',
+        'f#'
+      ],
+      keywords: ALL_KEYWORDS,
+      illegal: /\/\*/,
+      classNameAliases: {
+        'computation-expression': 'keyword'
+      },
+      contains: [
+        BANG_KEYWORD_MODE,
+        STRING,
+        COMMENT,
+        QUOTED_IDENTIFIER,
+        TYPE_DECLARATION,
+        {
+          // e.g. [<Attributes("")>] or [<``module``: MyCustomAttributeThatWorksOnModules>]
+          // or [<Sealed; NoEquality; NoComparison; CompiledName("FSharpAsync`1")>]
+          scope: 'meta',
+          begin: /\[</,
+          end: />\]/,
+          relevance: 2,
+          contains: [
+            QUOTED_IDENTIFIER,
+            // can contain any constant value
+            TRIPLE_QUOTED_STRING,
+            VERBATIM_STRING,
+            QUOTED_STRING,
+            CHAR_LITERAL,
+            NUMBER
+          ]
+        },
+        DISCRIMINATED_UNION_TYPE_ANNOTATION,
+        TYPE_ANNOTATION,
+        COMPUTATION_EXPRESSION,
+        PREPROCESSOR,
+        NUMBER,
+        GENERIC_TYPE_SYMBOL,
+        OPERATOR
+      ]
+    };
+  }
+
+  return fsharp;
+
+})();
+;
+export default hljsGrammar;

pygpt_net/data/js/highlight/es/languages/fsharp.min.js

@@ -0,0 +1,47 @@
+/*! `fsharp` grammar compiled for Highlight.js 11.10.0 */
+var hljsGrammar=(()=>{"use strict";function e(e){
+return RegExp(e.replace(/[-/\\^$*+?.()|[\]{}]/g,"\\$&"),"m")}function n(e){
+return e?"string"==typeof e?e:e.source:null}function t(e){return i("(?=",e,")")}
+function i(...e){return e.map((e=>n(e))).join("")}function a(...e){const t=(e=>{
+const n=e[e.length-1]
+;return"object"==typeof n&&n.constructor===Object?(e.splice(e.length-1,1),n):{}
+})(e);return"("+(t.capture?"":"?:")+e.map((e=>n(e))).join("|")+")"}return n=>{
+const r={scope:"keyword",match:/\b(yield|return|let|do|match|use)!/
+},o=["bool","byte","sbyte","int8","int16","int32","uint8","uint16","uint32","int","uint","int64","uint64","nativeint","unativeint","decimal","float","double","float32","single","char","string","unit","bigint","option","voption","list","array","seq","byref","exn","inref","nativeptr","obj","outref","voidptr","Result"],s={
+keyword:["abstract","and","as","assert","base","begin","class","default","delegate","do","done","downcast","downto","elif","else","end","exception","extern","finally","fixed","for","fun","function","global","if","in","inherit","inline","interface","internal","lazy","let","match","member","module","mutable","namespace","new","of","open","or","override","private","public","rec","return","static","struct","then","to","try","type","upcast","use","val","void","when","while","with","yield"],
+literal:["true","false","null","Some","None","Ok","Error","infinity","infinityf","nan","nanf"],
+built_in:["not","ref","raise","reraise","dict","readOnlyDict","set","get","enum","sizeof","typeof","typedefof","nameof","nullArg","invalidArg","invalidOp","id","fst","snd","ignore","lock","using","box","unbox","tryUnbox","printf","printfn","sprintf","eprintf","eprintfn","fprintf","fprintfn","failwith","failwithf"],
+"variable.constant":["__LINE__","__SOURCE_DIRECTORY__","__SOURCE_FILE__"]},c={
+variants:[n.COMMENT(/\(\*(?!\))/,/\*\)/,{contains:["self"]
+}),n.C_LINE_COMMENT_MODE]},l={scope:"variable",begin:/``/,end:/``/
+},u=/\B('|\^)/,p={scope:"symbol",variants:[{match:i(u,/``.*?``/)},{
+match:i(u,n.UNDERSCORE_IDENT_RE)}],relevance:0},f=({includeEqual:n})=>{let r
+;r=n?"!%&*+-/<=>@^|~?":"!%&*+-/<>@^|~?"
+;const o=i("[",...Array.from(r).map(e),"]"),s=a(o,/\./),c=i(s,t(s)),l=a(i(c,s,"*"),i(o,"+"))
+;return{scope:"operator",match:a(l,/:\?>/,/:\?/,/:>/,/:=/,/::?/,/\$/),
+relevance:0}},d=f({includeEqual:!0}),b=f({includeEqual:!1}),m=(e,r)=>({
+begin:i(e,t(i(/\s*/,a(/\w/,/'/,/\^/,/#/,/``/,/\(/,/{\|/)))),beginScope:r,
+end:t(a(/\n/,/=/)),relevance:0,keywords:n.inherit(s,{type:o}),
+contains:[c,p,n.inherit(l,{scope:null}),b]
+}),g=m(/:/,"operator"),h=m(/\bof\b/,"keyword"),y={
+begin:[/(^|\s+)/,/type/,/\s+/,/[a-zA-Z_](\w|')*/],beginScope:{2:"keyword",
+4:"title.class"},end:t(/\(|=|$/),keywords:s,contains:[c,n.inherit(l,{scope:null
+}),p,{scope:"operator",match:/<|>/},g]},E={scope:"computation-expression",
+match:/\b[_a-z]\w*(?=\s*\{)/},_={
+begin:[/^\s*/,i(/#/,a("if","else","endif","line","nowarn","light","r","i","I","load","time","help","quit")),/\b/],
+beginScope:{2:"meta"},end:t(/\s|$/)},v={
+variants:[n.BINARY_NUMBER_MODE,n.C_NUMBER_MODE]},w={scope:"string",begin:/"/,
+end:/"/,contains:[n.BACKSLASH_ESCAPE]},A={scope:"string",begin:/@"/,end:/"/,
+contains:[{match:/""/},n.BACKSLASH_ESCAPE]},S={scope:"string",begin:/"""/,
+end:/"""/,relevance:2},C={scope:"subst",begin:/\{/,end:/\}/,keywords:s},O={
+scope:"string",begin:/\$"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/
+},n.BACKSLASH_ESCAPE,C]},x={scope:"string",begin:/(\$@|@\$)"/,end:/"/,
+contains:[{match:/\{\{/},{match:/\}\}/},{match:/""/},n.BACKSLASH_ESCAPE,C]},R={
+scope:"string",begin:/\$"""/,end:/"""/,contains:[{match:/\{\{/},{match:/\}\}/
+},C],relevance:2},k={scope:"string",
+match:i(/'/,a(/[^\\']/,/\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8})/),/'/)
+};return C.contains=[x,O,A,w,k,r,c,l,g,E,_,v,p,d],{name:"F#",
+aliases:["fs","f#"],keywords:s,illegal:/\/\*/,classNameAliases:{
+"computation-expression":"keyword"},contains:[r,{variants:[R,x,O,S,A,w,k]
+},c,l,y,{scope:"meta",begin:/\[</,end:/>\]/,relevance:2,contains:[l,S,A,w,k,v]
+},h,g,E,_,v,p,d]}}})();export default hljsGrammar;