tdsds.com/gitea
tdsds.com/gitea
1
1
Fork 0
mirror of https://github.com/go-gitea/gitea synced 2024-11-01 15:54:25 +00:00
Code Releases Activity
889bdf9196
gitea/public/vendor/plugins/codemirror/mode/livescript/index.html

460 lines
9.6 KiB
HTML
Raw Normal View History

Added coding style modes to SimpleMDE (#3286) * Added coding style modes to SimpleMDE * Moved the CodeMirror addon from simplemd to codemirror directory
2016-07-23 05:29:20 +00:00
<!doctype html>
<title>CodeMirror: LiveScript mode</title>
<meta charset="utf-8"/>
<link rel=stylesheet href="../../doc/docs.css">
<link rel="stylesheet" href="../../lib/codemirror.css">
<link rel="stylesheet" href="../../theme/solarized.css">
<script src="../../lib/codemirror.js"></script>
<script src="livescript.js"></script>
<style>.CodeMirror {font-size: 80%;border-top: 1px solid silver; border-bottom: 1px solid silver;}</style>
<div id=nav>
Update CodeMirror to version 5.49.0 (#8381) * Update CodeMirror to version 5.49.0 * Update CodeMirror versions in librejs and VERSIONS
2019-10-15 08:40:42 +00:00
<a href="https://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
Added coding style modes to SimpleMDE (#3286) * Added coding style modes to SimpleMDE * Moved the CodeMirror addon from simplemd to codemirror directory
2016-07-23 05:29:20 +00:00
<ul>
<li><a href="../../index.html">Home</a>
<li><a href="../../doc/manual.html">Manual</a>
<li><a href="https://github.com/codemirror/codemirror">Code</a>
</ul>
<ul>
<li><a href="../index.html">Language modes</a>
<li><a class=active href="#">LiveScript</a>
</ul>
</div>
<article>
<h2>LiveScript mode</h2>
<form><textarea id="code" name="code">
# LiveScript mode for CodeMirror
# The following script, prelude.ls, is used to
# demonstrate LiveScript mode for CodeMirror.
# https://github.com/gkz/prelude-ls
export objToFunc = objToFunc = (obj) ->
(key) -> obj[key]
export each = (f, xs) -->
if typeof! xs is \Object
for , x of xs then f x
else
for x in xs then f x
xs
export map = (f, xs) -->
f = objToFunc f if typeof! f isnt \Function
type = typeof! xs
if type is \Object
{[key, f x] for key, x of xs}
else
result = [f x for x in xs]
if type is \String then result * '' else result
export filter = (f, xs) -->
f = objToFunc f if typeof! f isnt \Function
type = typeof! xs
if type is \Object
{[key, x] for key, x of xs when f x}
else
result = [x for x in xs when f x]
if type is \String then result * '' else result
export reject = (f, xs) -->
f = objToFunc f if typeof! f isnt \Function
type = typeof! xs
if type is \Object
{[key, x] for key, x of xs when not f x}
else
result = [x for x in xs when not f x]
if type is \String then result * '' else result
export partition = (f, xs) -->
f = objToFunc f if typeof! f isnt \Function
type = typeof! xs
if type is \Object
passed = {}
failed = {}
for key, x of xs
(if f x then passed else failed)[key] = x
else
passed = []
failed = []
for x in xs
(if f x then passed else failed)push x
if type is \String
passed *= ''
failed *= ''
[passed, failed]
export find = (f, xs) -->
f = objToFunc f if typeof! f isnt \Function
if typeof! xs is \Object
for , x of xs when f x then return x
else
for x in xs when f x then return x
void
export head = export first = (xs) ->
return void if not xs.length
xs.0
export tail = (xs) ->
return void if not xs.length
xs.slice 1
export last = (xs) ->
return void if not xs.length
xs[*-1]
export initial = (xs) ->
return void if not xs.length
xs.slice 0 xs.length - 1
export empty = (xs) ->
if typeof! xs is \Object
for x of xs then return false
return yes
not xs.length
export values = (obj) ->
[x for , x of obj]
export keys = (obj) ->
[x for x of obj]
export len = (xs) ->
xs = values xs if typeof! xs is \Object
xs.length
export cons = (x, xs) -->
if typeof! xs is \String then x + xs else [x] ++ xs
export append = (xs, ys) -->
if typeof! ys is \String then xs + ys else xs ++ ys
export join = (sep, xs) -->
xs = values xs if typeof! xs is \Object
xs.join sep
export reverse = (xs) ->
if typeof! xs is \String
then (xs / '')reverse! * ''
else xs.slice!reverse!
export fold = export foldl = (f, memo, xs) -->
if typeof! xs is \Object
for , x of xs then memo = f memo, x
else
for x in xs then memo = f memo, x
memo
export fold1 = export foldl1 = (f, xs) --> fold f, xs.0, xs.slice 1
export foldr = (f, memo, xs) --> fold f, memo, xs.slice!reverse!
export foldr1 = (f, xs) -->
xs.=slice!reverse!
fold f, xs.0, xs.slice 1
export unfoldr = export unfold = (f, b) -->
if (f b)?
[that.0] ++ unfoldr f, that.1
else
[]
export andList = (xs) ->
for x in xs when not x
return false
true
export orList = (xs) ->
for x in xs when x
return true
false
export any = (f, xs) -->
f = objToFunc f if typeof! f isnt \Function
for x in xs when f x
return yes
no
export all = (f, xs) -->
f = objToFunc f if typeof! f isnt \Function
for x in xs when not f x
return no
yes
export unique = (xs) ->
result = []
if typeof! xs is \Object
for , x of xs when x not in result then result.push x
else
for x in xs when x not in result then result.push x
if typeof! xs is \String then result * '' else result
export sort = (xs) ->
xs.concat!sort (x, y) ->
| x > y => 1
| x < y => -1
| _ => 0
export sortBy = (f, xs) -->
return [] unless xs.length
xs.concat!sort f
export compare = (f, x, y) -->
| (f x) > (f y) => 1
| (f x) < (f y) => -1
| otherwise => 0
export sum = (xs) ->
result = 0
if typeof! xs is \Object
for , x of xs then result += x
else
for x in xs then result += x
result
export product = (xs) ->
result = 1
if typeof! xs is \Object
for , x of xs then result *= x
else
for x in xs then result *= x
result
export mean = export average = (xs) -> (sum xs) / len xs
export concat = (xss) -> fold append, [], xss
export concatMap = (f, xs) --> fold ((memo, x) -> append memo, f x), [], xs
export listToObj = (xs) ->
{[x.0, x.1] for x in xs}
export maximum = (xs) -> fold1 (>?), xs
export minimum = (xs) -> fold1 (<?), xs
export scan = export scanl = (f, memo, xs) -->
last = memo
if typeof! xs is \Object
then [memo] ++ [last = f last, x for , x of xs]
else [memo] ++ [last = f last, x for x in xs]
export scan1 = export scanl1 = (f, xs) --> scan f, xs.0, xs.slice 1
export scanr = (f, memo, xs) -->
xs.=slice!reverse!
scan f, memo, xs .reverse!
export scanr1 = (f, xs) -->
xs.=slice!reverse!
scan f, xs.0, xs.slice 1 .reverse!
export replicate = (n, x) -->
result = []
i = 0
while i < n, ++i then result.push x
result
export take = (n, xs) -->
| n <= 0
if typeof! xs is \String then '' else []
| not xs.length => xs
| otherwise => xs.slice 0, n
export drop = (n, xs) -->
| n <= 0 => xs
| not xs.length => xs
| otherwise => xs.slice n
export splitAt = (n, xs) --> [(take n, xs), (drop n, xs)]
export takeWhile = (p, xs) -->
return xs if not xs.length
p = objToFunc p if typeof! p isnt \Function
result = []
for x in xs
break if not p x
result.push x
if typeof! xs is \String then result * '' else result
export dropWhile = (p, xs) -->
return xs if not xs.length
p = objToFunc p if typeof! p isnt \Function
i = 0
for x in xs
break if not p x
++i
drop i, xs
export span = (p, xs) --> [(takeWhile p, xs), (dropWhile p, xs)]
export breakIt = (p, xs) --> span (not) << p, xs
export zip = (xs, ys) -->
result = []
for zs, i in [xs, ys]
for z, j in zs
result.push [] if i is 0
result[j]?push z
result
export zipWith = (f,xs, ys) -->
f = objToFunc f if typeof! f isnt \Function
if not xs.length or not ys.length
[]
else
[f.apply this, zs for zs in zip.call this, xs, ys]
export zipAll = (...xss) ->
result = []
for xs, i in xss
for x, j in xs
result.push [] if i is 0
result[j]?push x
result
export zipAllWith = (f, ...xss) ->
f = objToFunc f if typeof! f isnt \Function
if not xss.0.length or not xss.1.length
[]
else
[f.apply this, xs for xs in zipAll.apply this, xss]
export compose = (...funcs) ->
->
args = arguments
for f in funcs
args = [f.apply this, args]
args.0
export curry = (f) ->
curry$ f # using util method curry$ from livescript
export id = (x) -> x
export flip = (f, x, y) --> f y, x
export fix = (f) ->
( (g, x) -> -> f(g g) ...arguments ) do
(g, x) -> -> f(g g) ...arguments
export lines = (str) ->
return [] if not str.length
str / \\n
export unlines = (strs) -> strs * \\n
export words = (str) ->
return [] if not str.length
str / /[ ]+/
export unwords = (strs) -> strs * ' '
export max = (>?)
export min = (<?)
export negate = (x) -> -x
export abs = Math.abs
export signum = (x) ->
| x < 0 => -1
| x > 0 => 1
| otherwise => 0
export quot = (x, y) --> ~~(x / y)
export rem = (%)
export div = (x, y) --> Math.floor x / y
export mod = (%%)
export recip = (1 /)
export pi = Math.PI
export tau = pi * 2
export exp = Math.exp
export sqrt = Math.sqrt
# changed from log as log is a
# common function for logging things
export ln = Math.log
export pow = (^)
export sin = Math.sin
export tan = Math.tan
export cos = Math.cos
export asin = Math.asin
export acos = Math.acos
export atan = Math.atan
export atan2 = (x, y) --> Math.atan2 x, y
# sinh
# tanh
# cosh
# asinh
# atanh
# acosh
export truncate = (x) -> ~~x
export round = Math.round
export ceiling = Math.ceil
export floor = Math.floor
export isItNaN = (x) -> x isnt x
export even = (x) -> x % 2 == 0
export odd = (x) -> x % 2 != 0
export gcd = (x, y) -->
x = Math.abs x
y = Math.abs y
until y is 0
z = x % y
x = y
y = z
x
export lcm = (x, y) -->
Math.abs Math.floor (x / (gcd x, y) * y)
# meta
export installPrelude = !(target) ->
unless target.prelude?isInstalled
target <<< out$ # using out$ generated by livescript
target <<< target.prelude.isInstalled = true
export prelude = out$
</textarea></form>
<script>
var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
theme: "solarized light",
lineNumbers: true
});
</script>
<p><strong>MIME types defined:</strong> <code>text/x-livescript</code>.</p>
<p>The LiveScript mode was written by Kenneth Bentley.</p>
</article>
Copy Permalink