zydronium/neocities
1
0
Fork 0
mirror of https://github.com/neocities/neocities.git synced 2025-04-25 01:32:36 +02:00
Code Issues Projects Releases Packages Wiki Activity
neocities/public/monaco/dev/vs/basic-languages/postiats/postiats.js
Kyle Drake 8c7655ac6f fix monaco loading for text editor
2024-10-01 12:15:28 -05:00

941 lines
22 KiB
JavaScript
Raw Blame History

/*!-----------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Version: 0.52.0(f6dc0eb8fce67e57f6036f4769d92c1666cdf546)
* Released under the MIT license
* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
*-----------------------------------------------------------------------------*/
define("vs/basic-languages/postiats/postiats", ["require"],(require)=>{
"use strict";
var moduleExports = (() => {
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/basic-languages/postiats/postiats.ts
var postiats_exports = {};
__export(postiats_exports, {
conf: () => conf,
language: () => language
});
var conf = {
comments: {
lineComment: "//",
blockComment: ["(*", "*)"]
},
brackets: [
["{", "}"],
["[", "]"],
["(", ")"],
["<", ">"]
],
autoClosingPairs: [
{ open: '"', close: '"', notIn: ["string", "comment"] },
{ open: "{", close: "}", notIn: ["string", "comment"] },
{ open: "[", close: "]", notIn: ["string", "comment"] },
{ open: "(", close: ")", notIn: ["string", "comment"] }
]
};
var language = {
tokenPostfix: ".pats",
// TODO: staload and dynload are followed by a special kind of string literals
// with {$IDENTIFER} variables, and it also may make sense to highlight
// the punctuation (. and / and \) differently.
// Set defaultToken to invalid to see what you do not tokenize yet
defaultToken: "invalid",
// keyword reference: https://github.com/githwxi/ATS-Postiats/blob/master/src/pats_lexing_token.dats
keywords: [
//
"abstype",
// ABSTYPE
"abst0ype",
// ABST0YPE
"absprop",
// ABSPROP
"absview",
// ABSVIEW
"absvtype",
// ABSVIEWTYPE
"absviewtype",
// ABSVIEWTYPE
"absvt0ype",
// ABSVIEWT0YPE
"absviewt0ype",
// ABSVIEWT0YPE
//
"as",
// T_AS
//
"and",
// T_AND
//
"assume",
// T_ASSUME
//
"begin",
// T_BEGIN
//
/*
"case", // CASE
*/
//
"classdec",
// T_CLASSDEC
//
"datasort",
// T_DATASORT
//
"datatype",
// DATATYPE
"dataprop",
// DATAPROP
"dataview",
// DATAVIEW
"datavtype",
// DATAVIEWTYPE
"dataviewtype",
// DATAVIEWTYPE
//
"do",
// T_DO
//
"end",
// T_END
//
"extern",
// T_EXTERN
"extype",
// T_EXTYPE
"extvar",
// T_EXTVAR
//
"exception",
// T_EXCEPTION
//
"fn",
// FN // non-recursive
"fnx",
// FNX // mutual tail-rec.
"fun",
// FUN // general-recursive
//
"prfn",
// PRFN
"prfun",
// PRFUN
//
"praxi",
// PRAXI
"castfn",
// CASTFN
//
"if",
// T_IF
"then",
// T_THEN
"else",
// T_ELSE
//
"ifcase",
// T_IFCASE
//
"in",
// T_IN
//
"infix",
// INFIX
"infixl",
// INFIXL
"infixr",
// INFIXR
"prefix",
// PREFIX
"postfix",
// POSTFIX
//
"implmnt",
// IMPLMNT // 0
"implement",
// IMPLEMENT // 1
//
"primplmnt",
// PRIMPLMNT // ~1
"primplement",
// PRIMPLMNT // ~1
//
"import",
// T_IMPORT // for importing packages
//
/*
"lam", // LAM
"llam", // LLAM
"fix", // FIX
*/
//
"let",
// T_LET
//
"local",
// T_LOCAL
//
"macdef",
// MACDEF
"macrodef",
// MACRODEF
//
"nonfix",
// T_NONFIX
//
"symelim",
// T_SYMELIM
"symintr",
// T_SYMINTR
"overload",
// T_OVERLOAD
//
"of",
// T_OF
"op",
// T_OP
//
"rec",
// T_REC
//
"sif",
// T_SIF
"scase",
// T_SCASE
//
"sortdef",
// T_SORTDEF
/*
// HX: [sta] is now deprecated
*/
"sta",
// T_STACST
"stacst",
// T_STACST
"stadef",
// T_STADEF
"static",
// T_STATIC
/*
"stavar", // T_STAVAR
*/
//
"staload",
// T_STALOAD
"dynload",
// T_DYNLOAD
//
"try",
// T_TRY
//
"tkindef",
// T_TKINDEF // HX-2012-05-23
//
/*
"type", // TYPE
*/
"typedef",
// TYPEDEF
"propdef",
// PROPDEF
"viewdef",
// VIEWDEF
"vtypedef",
// VIEWTYPEDEF
"viewtypedef",
// VIEWTYPEDEF
//
/*
"val", // VAL
*/
"prval",
// PRVAL
//
"var",
// VAR
"prvar",
// PRVAR
//
"when",
// T_WHEN
"where",
// T_WHERE
//
/*
"for", // T_FOR
"while", // T_WHILE
*/
//
"with",
// T_WITH
//
"withtype",
// WITHTYPE
"withprop",
// WITHPROP
"withview",
// WITHVIEW
"withvtype",
// WITHVIEWTYPE
"withviewtype"
// WITHVIEWTYPE
//
],
keywords_dlr: [
"$delay",
// DLRDELAY
"$ldelay",
// DLRLDELAY
//
"$arrpsz",
// T_DLRARRPSZ
"$arrptrsize",
// T_DLRARRPSZ
//
"$d2ctype",
// T_DLRD2CTYPE
//
"$effmask",
// DLREFFMASK
"$effmask_ntm",
// DLREFFMASK_NTM
"$effmask_exn",
// DLREFFMASK_EXN
"$effmask_ref",
// DLREFFMASK_REF
"$effmask_wrt",
// DLREFFMASK_WRT
"$effmask_all",
// DLREFFMASK_ALL
//
"$extern",
// T_DLREXTERN
"$extkind",
// T_DLREXTKIND
"$extype",
// T_DLREXTYPE
"$extype_struct",
// T_DLREXTYPE_STRUCT
//
"$extval",
// T_DLREXTVAL
"$extfcall",
// T_DLREXTFCALL
"$extmcall",
// T_DLREXTMCALL
//
"$literal",
// T_DLRLITERAL
//
"$myfilename",
// T_DLRMYFILENAME
"$mylocation",
// T_DLRMYLOCATION
"$myfunction",
// T_DLRMYFUNCTION
//
"$lst",
// DLRLST
"$lst_t",
// DLRLST_T
"$lst_vt",
// DLRLST_VT
"$list",
// DLRLST
"$list_t",
// DLRLST_T
"$list_vt",
// DLRLST_VT
//
"$rec",
// DLRREC
"$rec_t",
// DLRREC_T
"$rec_vt",
// DLRREC_VT
"$record",
// DLRREC
"$record_t",
// DLRREC_T
"$record_vt",
// DLRREC_VT
//
"$tup",
// DLRTUP
"$tup_t",
// DLRTUP_T
"$tup_vt",
// DLRTUP_VT
"$tuple",
// DLRTUP
"$tuple_t",
// DLRTUP_T
"$tuple_vt",
// DLRTUP_VT
//
"$break",
// T_DLRBREAK
"$continue",
// T_DLRCONTINUE
//
"$raise",
// T_DLRRAISE
//
"$showtype",
// T_DLRSHOWTYPE
//
"$vcopyenv_v",
// DLRVCOPYENV_V
"$vcopyenv_vt",
// DLRVCOPYENV_VT
//
"$tempenver",
// T_DLRTEMPENVER
//
"$solver_assert",
// T_DLRSOLASSERT
"$solver_verify"
// T_DLRSOLVERIFY
],
keywords_srp: [
//
"#if",
// T_SRPIF
"#ifdef",
// T_SRPIFDEF
"#ifndef",
// T_SRPIFNDEF
//
"#then",
// T_SRPTHEN
//
"#elif",
// T_SRPELIF
"#elifdef",
// T_SRPELIFDEF
"#elifndef",
// T_SRPELIFNDEF
//
"#else",
// T_SRPELSE
"#endif",
// T_SRPENDIF
//
"#error",
// T_SRPERROR
//
"#prerr",
// T_SRPPRERR // outpui to stderr
"#print",
// T_SRPPRINT // output to stdout
//
"#assert",
// T_SRPASSERT
//
"#undef",
// T_SRPUNDEF
"#define",
// T_SRPDEFINE
//
"#include",
// T_SRPINCLUDE
"#require",
// T_SRPREQUIRE
//
"#pragma",
// T_SRPPRAGMA // HX: general pragma
"#codegen2",
// T_SRPCODEGEN2 // for level-2 codegen
"#codegen3"
// T_SRPCODEGEN3 // for level-3 codegen
//
// HX: end of special tokens
//
],
irregular_keyword_list: [
"val+",
"val-",
"val",
"case+",
"case-",
"case",
"addr@",
"addr",
"fold@",
"free@",
"fix@",
"fix",
"lam@",
"lam",
"llam@",
"llam",
"viewt@ype+",
"viewt@ype-",
"viewt@ype",
"viewtype+",
"viewtype-",
"viewtype",
"view+",
"view-",
"view@",
"view",
"type+",
"type-",
"type",
"vtype+",
"vtype-",
"vtype",
"vt@ype+",
"vt@ype-",
"vt@ype",
"viewt@ype+",
"viewt@ype-",
"viewt@ype",
"viewtype+",
"viewtype-",
"viewtype",
"prop+",
"prop-",
"prop",
"type+",
"type-",
"type",
"t@ype",
"t@ype+",
"t@ype-",
"abst@ype",
"abstype",
"absviewt@ype",
"absvt@ype",
"for*",
"for",
"while*",
"while"
],
keywords_types: [
"bool",
"double",
"byte",
"int",
"short",
"char",
"void",
"unit",
"long",
"float",
"string",
"strptr"
],
// TODO: reference for this?
keywords_effects: [
"0",
// no effects
"fun",
"clo",
"prf",
"funclo",
"cloptr",
"cloref",
"ref",
"ntm",
"1"
// all effects
],
operators: [
"@",
// T_AT
"!",
// T_BANG
"|",
// T_BAR
"`",
// T_BQUOTE
":",
// T_COLON
"$",
// T_DOLLAR
".",
// T_DOT
"=",
// T_EQ
"#",
// T_HASH
"~",
// T_TILDE
//
"..",
// T_DOTDOT
"...",
// T_DOTDOTDOT
//
"=>",
// T_EQGT
// "=<", // T_EQLT
"=<>",
// T_EQLTGT
"=/=>",
// T_EQSLASHEQGT
"=>>",
// T_EQGTGT
"=/=>>",
// T_EQSLASHEQGTGT
//
"<",
// T_LT // opening a tmparg
">",
// T_GT // closing a tmparg
//
"><",
// T_GTLT
//
".<",
// T_DOTLT
">.",
// T_GTDOT
//
".<>.",
// T_DOTLTGTDOT
//
"->",
// T_MINUSGT
//"-<", // T_MINUSLT
"-<>"
// T_MINUSLTGT
//
/*
":<", // T_COLONLT
*/
],
brackets: [
{ open: ",(", close: ")", token: "delimiter.parenthesis" },
// meta-programming syntax
{ open: "`(", close: ")", token: "delimiter.parenthesis" },
{ open: "%(", close: ")", token: "delimiter.parenthesis" },
{ open: "'(", close: ")", token: "delimiter.parenthesis" },
{ open: "'{", close: "}", token: "delimiter.parenthesis" },
{ open: "@(", close: ")", token: "delimiter.parenthesis" },
{ open: "@{", close: "}", token: "delimiter.brace" },
{ open: "@[", close: "]", token: "delimiter.square" },
{ open: "#[", close: "]", token: "delimiter.square" },
{ open: "{", close: "}", token: "delimiter.curly" },
{ open: "[", close: "]", token: "delimiter.square" },
{ open: "(", close: ")", token: "delimiter.parenthesis" },
{ open: "<", close: ">", token: "delimiter.angle" }
],
// we include these common regular expressions
symbols: /[=><!~?:&|+\-*\/\^%]+/,
IDENTFST: /[a-zA-Z_]/,
IDENTRST: /[a-zA-Z0-9_'$]/,
symbolic: /[%&+-./:=@~`^|*!$#?<>]/,
digit: /[0-9]/,
digitseq0: /@digit*/,
xdigit: /[0-9A-Za-z]/,
xdigitseq0: /@xdigit*/,
INTSP: /[lLuU]/,
FLOATSP: /[fFlL]/,
fexponent: /[eE][+-]?[0-9]+/,
fexponent_bin: /[pP][+-]?[0-9]+/,
deciexp: /\.[0-9]*@fexponent?/,
hexiexp: /\.[0-9a-zA-Z]*@fexponent_bin?/,
irregular_keywords: /val[+-]?|case[+-]?|addr\@?|fold\@|free\@|fix\@?|lam\@?|llam\@?|prop[+-]?|type[+-]?|view[+-@]?|viewt@?ype[+-]?|t@?ype[+-]?|v(iew)?t@?ype[+-]?|abst@?ype|absv(iew)?t@?ype|for\*?|while\*?/,
ESCHAR: /[ntvbrfa\\\?'"\(\[\{]/,
start: "root",
// The main tokenizer for ATS/Postiats
// reference: https://github.com/githwxi/ATS-Postiats/blob/master/src/pats_lexing.dats
tokenizer: {
root: [
// lexing_blankseq0
{ regex: /[ \t\r\n]+/, action: { token: "" } },
// NOTE: (*) is an invalid ML-like comment!
{ regex: /\(\*\)/, action: { token: "invalid" } },
{
regex: /\(\*/,
action: { token: "comment", next: "lexing_COMMENT_block_ml" }
},
{
regex: /\(/,
action: "@brackets"
/*{ token: 'delimiter.parenthesis' }*/
},
{
regex: /\)/,
action: "@brackets"
/*{ token: 'delimiter.parenthesis' }*/
},
{
regex: /\[/,
action: "@brackets"
/*{ token: 'delimiter.bracket' }*/
},
{
regex: /\]/,
action: "@brackets"
/*{ token: 'delimiter.bracket' }*/
},
{
regex: /\{/,
action: "@brackets"
/*{ token: 'delimiter.brace' }*/
},
{
regex: /\}/,
action: "@brackets"
/*{ token: 'delimiter.brace' }*/
},
// lexing_COMMA
{
regex: /,\(/,
action: "@brackets"
/*{ token: 'delimiter.parenthesis' }*/
},
// meta-programming syntax
{ regex: /,/, action: { token: "delimiter.comma" } },
{ regex: /;/, action: { token: "delimiter.semicolon" } },
// lexing_AT
{
regex: /@\(/,
action: "@brackets"
/* { token: 'delimiter.parenthesis' }*/
},
{
regex: /@\[/,
action: "@brackets"
/* { token: 'delimiter.bracket' }*/
},
{
regex: /@\{/,
action: "@brackets"
/*{ token: 'delimiter.brace' }*/
},
// lexing_COLON
{
regex: /:</,
action: { token: "keyword", next: "@lexing_EFFECT_commaseq0" }
},
// T_COLONLT
/*
lexing_DOT:
. // SYMBOLIC => lexing_IDENT_sym
. FLOATDOT => lexing_FLOAT_deciexp
. DIGIT => T_DOTINT
*/
{ regex: /\.@symbolic+/, action: { token: "identifier.sym" } },
// FLOATDOT case
{
regex: /\.@digit*@fexponent@FLOATSP*/,
action: { token: "number.float" }
},
{ regex: /\.@digit+/, action: { token: "number.float" } },
// T_DOTINT
// lexing_DOLLAR:
// '$' IDENTFST IDENTRST* => lexing_IDENT_dlr, _ => lexing_IDENT_sym
{
regex: /\$@IDENTFST@IDENTRST*/,
action: {
cases: {
"@keywords_dlr": { token: "keyword.dlr" },
"@default": { token: "namespace" }
// most likely a module qualifier
}
}
},
// lexing_SHARP:
// '#' IDENTFST IDENTRST* => lexing_ident_srp, _ => lexing_IDENT_sym
{
regex: /\#@IDENTFST@IDENTRST*/,
action: {
cases: {
"@keywords_srp": { token: "keyword.srp" },
"@default": { token: "identifier" }
}
}
},
// lexing_PERCENT:
{ regex: /%\(/, action: { token: "delimiter.parenthesis" } },
{
regex: /^%{(#|\^|\$)?/,
action: {
token: "keyword",
next: "@lexing_EXTCODE",
nextEmbedded: "text/javascript"
}
},
{ regex: /^%}/, action: { token: "keyword" } },
// lexing_QUOTE
{ regex: /'\(/, action: { token: "delimiter.parenthesis" } },
{ regex: /'\[/, action: { token: "delimiter.bracket" } },
{ regex: /'\{/, action: { token: "delimiter.brace" } },
[/(')(\\@ESCHAR|\\[xX]@xdigit+|\\@digit+)(')/, ["string", "string.escape", "string"]],
[/'[^\\']'/, "string"],
// lexing_DQUOTE
[/"/, "string.quote", "@lexing_DQUOTE"],
// lexing_BQUOTE
{
regex: /`\(/,
action: "@brackets"
/* { token: 'delimiter.parenthesis' }*/
},
// TODO: otherwise, try lexing_IDENT_sym
{ regex: /\\/, action: { token: "punctuation" } },
// just T_BACKSLASH
// lexing_IDENT_alp:
// NOTE: (?!regex) is syntax for "not-followed-by" regex
// to resolve ambiguity such as foreach$fwork being incorrectly lexed as [for] [each$fwork]!
{
regex: /@irregular_keywords(?!@IDENTRST)/,
action: { token: "keyword" }
},
{
regex: /@IDENTFST@IDENTRST*[<!\[]?/,
action: {
cases: {
// TODO: dynload and staload should be specially parsed
// dynload whitespace+ "special_string"
// this special string is really:
// '/' '\\' '.' => punctuation
// ({\$)([a-zA-Z_][a-zA-Z_0-9]*)(}) => punctuation,keyword,punctuation
// [^"] => identifier/literal
"@keywords": { token: "keyword" },
"@keywords_types": { token: "type" },
"@default": { token: "identifier" }
}
}
},
// lexing_IDENT_sym:
{
regex: /\/\/\/\//,
action: { token: "comment", next: "@lexing_COMMENT_rest" }
},
{ regex: /\/\/.*$/, action: { token: "comment" } },
{
regex: /\/\*/,
action: { token: "comment", next: "@lexing_COMMENT_block_c" }
},
// AS-20160627: specifically for effect annotations
{
regex: /-<|=</,
action: { token: "keyword", next: "@lexing_EFFECT_commaseq0" }
},
{
regex: /@symbolic+/,
action: {
cases: {
"@operators": "keyword",
"@default": "operator"
}
}
},
// lexing_ZERO:
// FIXME: this one is quite messy/unfinished yet
// TODO: lexing_INT_hex
// - testing_hexiexp => lexing_FLOAT_hexiexp
// - testing_fexponent_bin => lexing_FLOAT_hexiexp
// - testing_intspseq0 => T_INT_hex
// lexing_INT_hex:
{
regex: /0[xX]@xdigit+(@hexiexp|@fexponent_bin)@FLOATSP*/,
action: { token: "number.float" }
},
{ regex: /0[xX]@xdigit+@INTSP*/, action: { token: "number.hex" } },
{
regex: /0[0-7]+(?![0-9])@INTSP*/,
action: { token: "number.octal" }
},
// lexing_INT_oct
//{regex: /0/, action: { token: 'number' } }, // INTZERO
// lexing_INT_dec:
// - testing_deciexp => lexing_FLOAT_deciexp
// - testing_fexponent => lexing_FLOAT_deciexp
// - otherwise => intspseq0 ([0-9]*[lLuU]?)
{
regex: /@digit+(@fexponent|@deciexp)@FLOATSP*/,
action: { token: "number.float" }
},
{
regex: /@digit@digitseq0@INTSP*/,
action: { token: "number.decimal" }
},
// DIGIT, if followed by digitseq0, is lexing_INT_dec
{ regex: /@digit+@INTSP*/, action: { token: "number" } }
],
lexing_COMMENT_block_ml: [
[/[^\(\*]+/, "comment"],
[/\(\*/, "comment", "@push"],
[/\(\*/, "comment.invalid"],
[/\*\)/, "comment", "@pop"],
[/\*/, "comment"]
],
lexing_COMMENT_block_c: [
[/[^\/*]+/, "comment"],
// [/\/\*/, 'comment', '@push' ], // nested C-style block comments not allowed
// [/\/\*/, 'comment.invalid' ], // NOTE: this breaks block comments in the shape of /* //*/
[/\*\//, "comment", "@pop"],
[/[\/*]/, "comment"]
],
lexing_COMMENT_rest: [
[/$/, "comment", "@pop"],
// FIXME: does it match? docs say 'no'
[/.*/, "comment"]
],
// NOTE: added by AS, specifically for highlighting
lexing_EFFECT_commaseq0: [
{
regex: /@IDENTFST@IDENTRST+|@digit+/,
action: {
cases: {
"@keywords_effects": { token: "type.effect" },
"@default": { token: "identifier" }
}
}
},
{ regex: /,/, action: { token: "punctuation" } },
{ regex: />/, action: { token: "@rematch", next: "@pop" } }
],
lexing_EXTCODE: [
{
regex: /^%}/,
action: {
token: "@rematch",
next: "@pop",
nextEmbedded: "@pop"
}
},
{ regex: /[^%]+/, action: "" }
],
lexing_DQUOTE: [
{ regex: /"/, action: { token: "string.quote", next: "@pop" } },
// AS-20160628: additional hi-lighting for variables in staload/dynload strings
{
regex: /(\{\$)(@IDENTFST@IDENTRST*)(\})/,
action: [{ token: "string.escape" }, { token: "identifier" }, { token: "string.escape" }]
},
{ regex: /\\$/, action: { token: "string.escape" } },
{
regex: /\\(@ESCHAR|[xX]@xdigit+|@digit+)/,
action: { token: "string.escape" }
},
{ regex: /[^\\"]+/, action: { token: "string" } }
]
}
};
return __toCommonJS(postiats_exports);
})();
return moduleExports;
});
Reference in a new issue View git blame Copy permalink