@codingame/monaco-editor-wrapper 1.7.0 → 1.8.0

package/dist/reason2.js

@@ -1,100 +0,0 @@
-var lambda = {
-	prefix: "fun",
-	body: [
-		"(${1:pattern}) => ${2:${1:pattern}}"
-	]
-};
-var module = {
-	prefix: "module",
-	body: [
-		"module ${1:M} = ${2:{}};$0"
-	]
-};
-var type = {
-	prefix: "type",
-	body: [
-		"type ${1:name} ${2:'${3:arg} }=",
-		"\t| ${4:Con${2: '${3:arg}}}",
-		"\t;"
-	]
-};
-var reason = {
-	"function": {
-	prefix: "let",
-	body: [
-		"let ${1:f} = (${2:pattern}) => ${3:${2:pattern}};$0"
-	]
-},
-	"function (block)": {
-	prefix: "let",
-	body: [
-		"let ${1:f} = (${2:pattern}) => {",
-		"\t${3:${2:pattern}}$0",
-		"};"
-	]
-},
-	lambda: lambda,
-	"lambda (switch)": {
-	prefix: "fun",
-	body: [
-		"fun",
-		"\t| ${1:pattern} => ${2:${1:pattern}}",
-		"\t;"
-	]
-},
-	"let": {
-	prefix: "let",
-	body: [
-		"let ${1:pattern} = ${2:()};$0"
-	]
-},
-	"let (block)": {
-	prefix: "let",
-	body: [
-		"let ${1:pattern} = {",
-		"\t$0",
-		"};"
-	]
-},
-	module: module,
-	"module (block)": {
-	prefix: "module",
-	body: [
-		"module ${1:M} = {",
-		"\t$0",
-		"};"
-	]
-},
-	"module function": {
-	prefix: "module",
-	body: [
-		"module ${1:M} = (${2:X}: $3{:{}}) => ${4:${2:X}};$0"
-	]
-},
-	"module function (block)": {
-	prefix: "module",
-	body: [
-		"module ${1:M} = (${2:X}: $3{:{}}) => {",
-		"\t${4:include ${2:X}}",
-		"\t$0",
-		"};"
-	]
-},
-	"switch": {
-	prefix: "switch",
-	body: [
-		"switch ${1:scrutinee} {",
-		"| ${2:pattern} => ${3:${2:pattern}}",
-		"};"
-	]
-},
-	"type (alias or abstract)": {
-	prefix: "type",
-	body: [
-		"type ${1:name} ${2:${3:'${4:arg} }= ${5:'${4:arg}}};$0"
-	]
-},
-	type: type
-};
-
-export { reason as default, lambda, module, type };

package/dist/services/functional.d.ts

@@ -1 +0,0 @@
-export declare function once<T extends Function>(this: unknown, fn: T): T;

package/dist/services/lyfecycle.d.ts

@@ -1,13 +0,0 @@
-import { IDisposable, IReference } from 'monaco-editor';
-export declare abstract class ReferenceCollection<T> {
-    private readonly references;
-    acquire(key: string, ...args: any[]): IReference<T>;
-    protected abstract createReferencedObject(key: string, ...args: any[]): T;
-    protected abstract destroyReferencedObject(key: string, object: T): void;
-}
-export declare class AsyncReferenceCollection<T> {
-    private referenceCollection;
-    constructor(referenceCollection: ReferenceCollection<Promise<T>>);
-    acquire(key: string, ...args: any[]): Promise<IReference<T>>;
-}
-export declare function toDisposable(fn: () => void): IDisposable;

package/dist/sql2.js

@@ -1,21 +0,0 @@
-var sql = {
-	"Create a new Database": {
-	prefix: "pgCreateDatabase",
-	body: [
-		"-- Create a new database called '${1:DatabaseName}'",
-		"CREATE DATABASE ${1:DatabaseName}"
-	],
-	description: "Create a new PostgreSQL Database"
-},
-	"List databases": {
-	prefix: "pgListDatabases",
-	body: [
-		"-- Get a list of databases",
-		"SELECT datname FROM pg_database",
-		"WHERE datistemplate = false"
-	],
-	description: "List PostgreSQL databases"
-}
-};
-
-export { sql as default };

package/dist/swift2.js

@@ -1,183 +0,0 @@
-var print = {
-	prefix: "print",
-	body: "print(\"$1\")\n$0",
-	description: "print(\"...\")"
-};
-var guard = {
-	prefix: "guard",
-	body: [
-		"guard ${1:condition} else {",
-		"\t$0",
-		"}"
-	],
-	description: "guard statement"
-};
-var func = {
-	prefix: "func",
-	body: [
-		"func ${1:name}(${2:parameters}) -> ${3:Type} {",
-		"\t$0",
-		"}"
-	],
-	description: "function declaration"
-};
-var struct = {
-	prefix: "struct",
-	body: [
-		"struct ${1:Name} {",
-		"",
-		"\t$0",
-		"}"
-	],
-	description: "struct declaration"
-};
-var protocol = {
-	prefix: "protocol",
-	body: [
-		"protocol ${1:Name} {",
-		"",
-		"\t$0",
-		"}"
-	],
-	description: "protocol declaration"
-};
-var extension = {
-	prefix: "extension",
-	body: [
-		"extension ${1:Type} {",
-		"",
-		"\t$0",
-		"}"
-	],
-	description: "extension declaration"
-};
-var swift = {
-	print: print,
-	"print value": {
-	prefix: "printv",
-	body: "print(\"\\($1)\")\n$0",
-	description: "print(\"\\(...)\")"
-},
-	"while": {
-	prefix: "while",
-	body: [
-		"while ${1:condition} {",
-		"\t$0",
-		"}"
-	],
-	description: "while statement"
-},
-	"repeat-while": {
-	prefix: "repeat",
-	body: [
-		"repeat {",
-		"\t$0",
-		"} while ${1:condition}"
-	],
-	description: "repeat-while statement"
-},
-	"for": {
-	prefix: "for",
-	body: [
-		"for ${1:item} in ${2:collection} {",
-		"\t$0",
-		"}"
-	],
-	description: "for-in statement"
-},
-	"if": {
-	prefix: "if",
-	body: [
-		"if ${1:condition} {",
-		"\t$0",
-		"}"
-	],
-	description: "if statement"
-},
-	"else if": {
-	prefix: "elif",
-	body: [
-		"else if ${1:condition} {",
-		"\t$0",
-		"}"
-	],
-	description: "else clause with a nested if statement"
-},
-	"else": {
-	prefix: "else",
-	body: [
-		"else {",
-		"\t$0",
-		"}"
-	],
-	description: "else clause"
-},
-	"if let": {
-	prefix: "iflet",
-	body: [
-		"if let ${1:value} = ${2:optional} {",
-		"\t$0",
-		"}"
-	],
-	description: "if statement with optional binding"
-},
-	guard: guard,
-	"guard let": {
-	prefix: "guardlet",
-	body: [
-		"guard let ${1:value} = ${2:optional} else {",
-		"\t$0",
-		"}"
-	],
-	description: "guard statement with optional binding"
-},
-	"switch": {
-	prefix: "switch",
-	body: [
-		"switch ${1:value} {",
-		"case ${2:pattern}:",
-		"\t$0",
-		"default:",
-		"\t",
-		"}"
-	],
-	description: "switch statement"
-},
-	"do": {
-	prefix: "do",
-	body: [
-		"do {",
-		"\t$0",
-		"} catch ${1:error} {",
-		"\t$2",
-		"}"
-	],
-	description: "do statement"
-},
-	func: func,
-	struct: struct,
-	"enum": {
-	prefix: "enum",
-	body: [
-		"enum ${1:Name} {",
-		"",
-		"\tcase $0",
-		"}"
-	],
-	description: "enum declaration"
-},
-	"class": {
-	prefix: "class",
-	body: [
-		"class ${1:Name} {",
-		"",
-		"\t$0",
-		"}"
-	],
-	description: "class declaration"
-},
-	protocol: protocol,
-	extension: extension
-};
-
-export { swift as default, extension, func, guard, print, protocol, struct };

package/dist/systemverilog2.js

@@ -1,208 +0,0 @@
-var bit = {
-	prefix: "bit",
-	body: "bit ${1:bit_name} = ${2:value};"
-};
-var int = {
-	prefix: "int",
-	body: "int ${1:int_name} = ${2:value};"
-};
-var shortint = {
-	prefix: "shortint",
-	body: "shortint ${1:name} = ${2:value};"
-};
-var longint = {
-	prefix: "longint",
-	body: "longint ${1:name} = ${2:value};"
-};
-var byte = {
-	prefix: "byte",
-	body: "byte ${1:byte:_name} = ${2:value};"
-};
-var logic = {
-	prefix: "logic",
-	body: "logic ${1:logic_name} = ${2:value};"
-};
-var packed = {
-	prefix: "packed",
-	body: "packed"
-};
-var task = {
-	prefix: "task",
-	body: [
-		"task ${1:automatic} ${2:taskName}(${3:arguments});",
-		"\t$0",
-		"endtask //$1"
-	],
-	description: "task name; ... endtask"
-};
-var modport = {
-	prefix: "modport",
-	body: [
-		"modport ${1:identifier} (",
-		"input ${2:input_ports},",
-		"output ${3:output_ports}",
-		");"
-	],
-	description: "modport name (input ports_in, output ports_out); "
-};
-var display = {
-	prefix: "display",
-	body: [
-		"\\$display(\"$1\"$2);$0"
-	],
-	description: "$display(\"...\", params...)"
-};
-var queue = {
-	prefix: "queue",
-	body: "${1:data_type} ${2:queue_name}[\\$];",
-	description: "insert queue."
-};
-var mailbox = {
-	prefix: "mailbox",
-	body: [
-		"mailbox mbx",
-		"${1:mbx = new();}"
-	],
-	description: "insert mailbox instance"
-};
-var assert = {
-	prefix: "assert",
-	body: [
-		"assert (${1:condition}) $2",
-		"else   ${3:error_process}"
-	],
-	description: "insert assert() ... else ..."
-};
-var systemverilog = {
-	"always_ff block": {
-	prefix: "always_ff",
-	body: [
-		"always_ff @( ${1:clock} ) begin : ${2:blockName}",
-		"\t$0",
-		"end"
-	],
-	description: "Insert an always_ff block"
-},
-	"always_comb block": {
-	prefix: "always_comb",
-	body: [
-		"always_comb begin : ${1:blockName}",
-		"\t$0",
-		"end"
-	],
-	description: "Insert an always_comb block"
-},
-	"always_latch block": {
-	prefix: "always_latch",
-	body: [
-		"always_latch begin : ${1:blockName}",
-		"\t$0",
-		"end"
-	],
-	description: "Insert an always_latch block"
-},
-	bit: bit,
-	int: int,
-	shortint: shortint,
-	longint: longint,
-	byte: byte,
-	logic: logic,
-	packed: packed,
-	"this": {
-	prefix: "this",
-	body: "this"
-},
-	"typedef struct packed": {
-	prefix: "typedef struct packed",
-	body: [
-		"typedef struct packed {",
-		"\t$0",
-		"} ${1:struct_name};"
-	],
-	description: "typedef struct packed { ... } name"
-},
-	"class": {
-	prefix: "class",
-	body: [
-		"class ${1:className};",
-		"\tfunction new();",
-		"\t\t$0",
-		"\tendfunction //new()",
-		"endclass //$1"
-	],
-	description: "class name; ... endclass"
-},
-	"class extends": {
-	prefix: "class extends",
-	body: [
-		"class ${1:className} extends ${2:superClass};",
-		"\tfunction new();",
-		"\t\t$0",
-		"\tendfunction //new()",
-		"endclass //$1 extends $2"
-	],
-	description: "class name extends super; ... endclass"
-},
-	task: task,
-	"package": {
-	prefix: "package",
-	body: [
-		"package ${1:package_name}",
-		"\t$2",
-		"endpackage"
-	],
-	description: "package name; ... endpackage"
-},
-	"import": {
-	prefix: "import",
-	body: "import ${1:name}::${2:scope};",
-	description: "import name::scope"
-},
-	"interface": {
-	prefix: "interface",
-	body: [
-		"interface ${1:interfacename};",
-		"\t$0",
-		"endinterface //$1"
-	],
-	description: "interface name; ... endinterface"
-},
-	modport: modport,
-	display: display,
-	"typedef enum": {
-	prefix: "typedef enum",
-	body: [
-		"typedef enum ${1:data_type} { $0 } ${2:name};"
-	],
-	description: "typedef enum (data_type) { ... } name"
-},
-	"enum": {
-	prefix: [
-		"en",
-		"enum"
-	],
-	body: [
-		"enum ${1:data_type} { $0 } ${2:name}"
-	],
-	description: "enum (data_type) { ... } name"
-},
-	queue: queue,
-	mailbox: mailbox,
-	"associative array": {
-	prefix: "AA",
-	body: "${1:data_type} ${2:name}[${3:index_type}];$0",
-	description: "insert Associative array(AA)."
-},
-	assert: assert,
-	"fork-join": {
-	prefix: "fork join",
-	body: [
-		"fork",
-		"\t$0",
-		"join"
-	],
-	description: "fork ... join"
-}
-};
-
-export { assert, bit, byte, systemverilog as default, display, int, logic, longint, mailbox, modport, packed, queue, shortint, task };

package/dist/tcl2.js

@@ -1,151 +0,0 @@
-var foreach = {
-	prefix: "foreach",
-	body: [
-		"foreach ${1:var} ${2:list} {",
-		"\t$0",
-		"}"
-	],
-	description: "Foreach Loop"
-};
-var elseif = {
-	prefix: "elseif",
-	body: [
-		"elseif {${1:var}} {",
-		"\t$0",
-		"}"
-	],
-	description: "ElseIf Condition"
-};
-var proc = {
-	prefix: "proc",
-	body: [
-		"proc ${1:name} {${2:args}} {",
-		"\t$0",
-		"}"
-	],
-	description: "Proc Block"
-};
-var tk_chooseDirectory = {
-	prefix: "tk_chooseDirectory",
-	body: [
-		"tk_chooseDirectory ${-initialdir dirname -mustexist boolean -title titleString}"
-	],
-	description: "Choose Directory"
-};
-var tk_getOpenFile = {
-	prefix: "tk_getOpenFile",
-	body: [
-		"tk_getOpenFile -filetypes {",
-		"\t\t{{Text Files}       {.txt}        }",
-		"\t\t{{All Files}        *             }",
-		"\t}"
-	],
-	description: "Open File Dialog"
-};
-var tk_getSaveFile = {
-	prefix: "tk_getSaveFile",
-	body: [
-		"tk_getSaveFile -filetypes {",
-		"\t\t{{Text Files}       {.txt}        }",
-		"\t\t{{All Files}        *             }",
-		"\t}"
-	],
-	description: "Save File Dialog"
-};
-var tk_messageBox = {
-	prefix: "tk_messageBox",
-	body: [
-		"tk_messageBox ${-message msg}"
-	],
-	description: "Message Box"
-};
-var tcl = {
-	"for": {
-	prefix: "for",
-	body: [
-		"for {set ${1:index} ${2:0}} {\\$${1:index} < ${3:length}} {incr ${1:index}} {",
-		"\t$0",
-		"}"
-	],
-	description: "For Loop"
-},
-	foreach: foreach,
-	"if": {
-	prefix: "if",
-	body: [
-		"if {${1:var}} {",
-		"\t$0",
-		"}"
-	],
-	description: "If Condition"
-},
-	elseif: elseif,
-	"else": {
-	prefix: "else",
-	body: [
-		"else {",
-		"\t$0",
-		"}"
-	],
-	description: "Else Block"
-},
-	proc: proc,
-	"while": {
-	prefix: "while",
-	body: [
-		"while {${1:var}} {",
-		"\t$0",
-		"}"
-	],
-	description: "While Loop"
-},
-	"catch": {
-	prefix: "catch",
-	body: [
-		"catch {${1:body}} ${2:var}"
-	],
-	description: "Catch Block"
-},
-	"try": {
-	prefix: "try",
-	body: [
-		"try {",
-		"\t$1",
-		"} finally {",
-		"\t$0",
-		"}"
-	],
-	description: "Try Block"
-},
-	"switch": {
-	prefix: "switch",
-	body: [
-		"switch ${1:var} {",
-		"\t${2:case} {$3}",
-		"\tdefault {$0}",
-		"}"
-	],
-	description: "Switch Block"
-},
-	"oo::class create": {
-	prefix: "oo::class create",
-	body: [
-		"oo::class create ${1:name} {",
-		"\t${2:superclass s}",
-		"\tconstructor {} {",
-		"\t\t$3",
-		"\t}",
-		"\tmethod ${4:m} {} {",
-		"\t\t$0",
-		"\t}",
-		"}"
-	],
-	description: "Class Create"
-},
-	tk_chooseDirectory: tk_chooseDirectory,
-	tk_getOpenFile: tk_getOpenFile,
-	tk_getSaveFile: tk_getSaveFile,
-	tk_messageBox: tk_messageBox
-};
-
-export { tcl as default, elseif, foreach, proc, tk_chooseDirectory, tk_getOpenFile, tk_getSaveFile, tk_messageBox };