# Deepwick Script

Deepwick Script is the language of Deepwick's charts and backtests. It is a
**subset of Pine Script v5/v6**: most `ta.*`, `math.*`, `str.*`, `array.*`, `map.*`,
`input.*`, `plot*` and `strategy.*` calls run exactly as in Pine. Deepwick is not
affiliated with TradingView; Pine Script is a trademark of TradingView, Inc.

A script runs once per bar, from the oldest bar to the newest, and every variable
keeps its history — the same series semantics as Pine.

## Rules that matter when generating code

- **Check the unsupported list before writing.** An unsupported call is the most expensive mistake here: most of them compile and silently return `na` instead of failing, so a script can look correct and plot nothing.
- **`request.security()` works for a higher timeframe of this chart's own symbol.** `request.security(syminfo.tickerid, "240", close)` gives the last *closed* 4h close, and the expression may be a `ta.*` call. Another **symbol** returns `na` — the engine only holds the chart's bars, so it will not fetch one.
- **No lookahead.** The backtest broker never fills an order using data from the future: market orders fill at the *next bar's* open.
- **Order costs are real.** Every fill pays commission and slippage as declared in `strategy()`. A profitable strategy at zero cost can be unprofitable with them.
- **Stop and limit fills follow the bar**, in the order open, nearer extreme, farther extreme, close. An order the price gapped through fills at the open.
- **Declare with `=`, reassign with `:=`.** Use `var` for state that must persist across bars.
- **Indentation is four spaces.** Pine has no braces; `if`/`for`/`while`/`switch` bodies are indented blocks.
- **Named arguments come last.** Once you write `name=`, every later argument must be named too: `plotshape(series=x, title="t", style=shape.circle)` is valid, `plotshape(x, "t", style=…)` is not. Mixing positional after named stops the script with a parse error.
- **An exit cannot trigger on the bar that issued it.** A market `strategy.entry` fills at the *next* bar's open, so a `strategy.exit` written on that bar can only fill from the following bar onward. A price that already dipped through your stop on the issuing bar is not filled against you.
- **A two-legged exit fires once.** When one leg of `strategy.exit(stop=…, limit=…)` fills, the other is cancelled with it — you get one trade, never two. If the bar reaches both levels, the one reached first along the bar's path wins.
- **Trailing stops:** `strategy.exit(trail_points=N, trail_offset=M)`. Both are in **ticks**, not price units. `trail_offset` is profit that must be cleared before the stop arms; `trail_points` is the distance kept from the best price reached. The stop only ratchets in your favour and moves on closed bars.

## Function reference

Signatures and what each one does. Arguments are in the order you write them.

### Language

Deepwick Script runs a subset of Pine Script, including enums, user-defined types, methods and maps; the //@version line is not enforced. A script runs once per bar, from the oldest bar to the newest, and every variable keeps its history.

- `x = expr / x := expr` — Declare a variable, then reassign it with :=. An optional type (int, float, bool, string, color, series, simple, const, line, label) may precede the name.
- `var / varip` — Initialise once on the first bar and keep the value across bars. varip behaves like var, since scripts run on closed bars.
- `x[n]` — History operator: the value of x n bars ago (na before the first bar).
- `if / else` — Conditional blocks, indented by four spaces. if can also be used as an expression.
- `cond ? a : b` — Ternary operator.
- `switch` — Multi-way branch, with or without a value to match.
- `for i = a to b [by step]` — Counted loop. break and continue are supported.
- `while cond` — Loop while a condition holds.
- `f(x, y) => expr` — User-defined function, on one line or as an indented block whose last expression is returned. Each call site keeps its own ta.* state, as in Pine.
- `[a, b] = f()` — Tuples: functions can return several values, and built-ins like ta.macd() and ta.bb() do.
- `and / or / not` — Logical operators. Arithmetic: + - * / %; comparison: == != < <= > >=.

### Declarations

- `indicator(title, shorttitle, overlay, precision)` (study) — Declares an indicator: it draws on the chart and has nothing to backtest. study() is accepted as an alias.
- `strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)` — Declares a strategy. Defaults: initial_capital 100000, 1 contract per order, commission 0, slippage 0 ticks, pyramiding 1. Other arguments, such as process_orders_on_close, are ignored.

### Inputs

Inputs appear next to the editor and in the indicator's settings, so you can change them without touching the code.

- `input.int(defval, title, minval, maxval, step)` — Whole number.
- `input.float(defval, title, minval, maxval, step)` — Decimal number.
- `input.bool(defval, title)` — Checkbox.
- `input.string(defval, title, options)` — Text, or a list of options.
- `input.session(defval, title)` — A trading session like "0930-1600", or days like "23456". Feed it to session.ismarket() and the other session.* predicates.
- `input.source(defval, title)` — A price source: open, high, low, close, hl2, hlc3, ohlc4 or hlcc4.
- `input.color(defval, title)` — Colour picker.
- `input(defval, title)` — Generic input; the type follows the default value.

### Bar data and time

Times are UTC milliseconds. hour() and the other time functions take an optional time; hour() also takes a time zone from a fixed list of offsets, without daylight saving.

- `open, high, low, close, volume` (open, high, low, close, volume) — Prices and volume of the current bar.
- `hl2, hlc3, ohlc4, hlcc4` (hl2, hlc3, ohlc4, hlcc4) — Common price averages.
- `bar_index, last_bar_index` (bar_index, last_bar_index) — Index of the current bar (0 is the oldest) and of the last bar.
- `time, time_close` (time, time_close) — Open and close time of the bar. As functions — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — the start (or end) of the higher-timeframe bar that holds this one, or na when the bar is outside the session. Sessions: "HHMM-HHMM", overnight ones too, comma-separated windows, optional days after a colon (1 = Sunday … 7 = Saturday), "24x7".
- `timeframe.change(timeframe)` — True on the first bar of each new period, e.g. timeframe.change("D") on the first bar of every day (weeks start on Monday).
- `timestamp(timezone?, year, month, day, hour, minute, second)` — A time in milliseconds from its parts, or from a date string: timestamp("2026-01-05T09:30:00Z").
- `dayofweek.sunday … dayofweek.saturday` (dayofweek.monday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday, dayofweek.saturday) — Day constants to compare with dayofweek (1 … 7).
- `session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket` (session.ismarket, session.isfirstbar, session.islastbar, session.ispremarket, session.ispostmarket) — Session state. Markets here trade around the clock, so every bar is in the market session; isfirstbar / islastbar mark the first and last bar of each UTC day.
- `year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second` (year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second) — Calendar parts of the bar's time; also callable with a time, e.g. hour(time, "America/New_York"). dayofweek: 1 = Sunday … 7 = Saturday.
- `barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime` (barstate.isfirst, barstate.islast, barstate.isnew, barstate.isconfirmed, barstate.ishistory, barstate.isrealtime) — Where the script is in the bar history.
- `timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly` (timeframe.period, timeframe.multiplier, timeframe.isintraday, timeframe.isdaily, timeframe.isweekly, timeframe.ismonthly) — The chart's timeframe.
- `syminfo.ticker, tickerid, mintick, pointvalue` (syminfo.ticker, syminfo.tickerid, syminfo.mintick, syminfo.pointvalue) — The chart's symbol, its price step and its point value.

### Technical analysis (ta.*)

Every call site keeps its own state, as in Pine: two ta.ema() calls on different lines are two independent averages. Results are na until enough bars exist.

- `ta.sma(source, length)` — Simple moving average.
- `ta.ema(source, length)` — Exponential moving average.
- `ta.rma(source, length)` — Wilder's moving average, used by RSI and ATR.
- `ta.wma(source, length)` — Weighted moving average.
- `ta.vwma(source, length)` — Volume-weighted moving average.
- `ta.hma(source, length)` — Hull moving average.
- `ta.linreg(source, length, offset)` — Linear regression line value.
- `ta.vwap(source)` — Volume-weighted average price, restarting at 00:00 UTC each day.
- `ta.rsi(source, length)` — Relative Strength Index, 0 to 100.
- `ta.macd(source, fastlen, slowlen, siglen)` — Returns [macd, signal, histogram].
- `ta.stoch(source, high, low, length)` — Stochastic %K, 0 to 100.
- `ta.cci(source, length)` — Commodity Channel Index.
- `ta.mfi(series, length)` — Money Flow Index.
- `ta.wpr(length)` — Williams %R, -100 to 0.
- `ta.dmi(diLength, adxSmoothing)` — Returns [+DI, -DI, ADX].
- `ta.supertrend(factor, atrPeriod)` — Returns [supertrend, direction]; direction is -1 in an uptrend and 1 in a downtrend.
- `ta.sar(start, inc, max)` — Parabolic SAR.
- `ta.mom(source, length)` — Momentum: source minus source length bars ago.
- `ta.roc(source, length)` — Rate of change, in percent.
- `ta.change(source, length)` — Difference from length bars ago (1 by default).
- `ta.tr / ta.tr(handle_na)` — True range.
- `ta.atr(length)` — Average true range (Wilder).
- `ta.bb(series, length, mult)` — Bollinger Bands: returns [middle, upper, lower].
- `ta.bbw(series, length, mult)` — Bollinger Band width: (upper - lower) / middle.
- `ta.kc(series, length, mult)` — Keltner Channels: returns [middle, upper, lower], with an EMA of the true range.
- `ta.stdev(source, length, biased)` — Standard deviation.
- `ta.variance(source, length, biased)` — Variance.
- `ta.dev(source, length)` — Mean absolute deviation.
- `ta.median(source, length)` — Median.
- `ta.highest(source, length) / ta.highest(length)` — Highest value over length bars (the high by default).
- `ta.lowest(source, length) / ta.lowest(length)` — Lowest value over length bars (the low by default).
- `ta.highestbars(source, length)` — Offset to the highest value: 0 or negative.
- `ta.lowestbars(source, length)` — Offset to the lowest value: 0 or negative.
- `ta.rising(source, length)` — True if source is above each of its previous length values.
- `ta.falling(source, length)` — True if source is below each of its previous length values.
- `ta.crossover(source1, source2)` — True on the bar where source1 crosses above source2.
- `ta.crossunder(source1, source2)` — True on the bar where source1 crosses below source2.
- `ta.cross(source1, source2)` — True on a cross in either direction.
- `ta.pivothigh(source, leftbars, rightbars)` — The pivot high price, known rightbars bars after the pivot; na otherwise. The source is optional (the high by default).
- `ta.pivotlow(source, leftbars, rightbars)` — The pivot low price, known rightbars bars after the pivot; na otherwise. The source is optional (the low by default).
- `ta.valuewhen(condition, source, occurrence)` — Value of source on the occurrence-th most recent bar where condition was true.
- `ta.barssince(condition)` — Bars since condition was last true.
- `ta.cum(source)` — Running total since the first bar.

### Strategies (strategy.*)

Market orders fill at the next bar's open. Stop and limit orders fill along the bar: open, then the extreme nearer the open, then the other extreme, then close. If price gaps through an order, it fills at the open. Commission is charged on every fill; slippage applies to market and stop fills.

- `strategy.entry(id, direction, qty, limit, stop, comment)` — Open or add to a position; market order unless limit or stop is given.
- `strategy.order(id, direction, qty, limit, stop, comment)` — Same arguments as strategy.entry().
- `strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)` — Take-profit, stop-loss and trailing stop for an entry: profit and loss in ticks, limit and stop as prices. trail_points is the distance in TICKS from the best price reached; trail_offset is the profit in ticks that must be cleared before the trailing stop arms. The stop only ever ratchets in your favour and moves on CLOSED bars, so a bar can never fill the stop that its own high set.
- `strategy.close(id, comment, qty_percent)` — Close an entry at market on the next bar.
- `strategy.close_all(comment)` — Close every open position.
- `strategy.cancel(id) / strategy.cancel_all()` (strategy.cancel_all) — Cancel pending orders.
- `strategy.position_size, position_avg_price` (strategy.position_size, strategy.position_avg_price) — Current position (positive long, negative short) and its average price.
- `strategy.opentrades.entry_bar_index(n), entry_price, entry_time, entry_id, size, profit, commission, max_runup, max_drawdown` (strategy.opentrades.entry_price, strategy.opentrades.entry_time, strategy.opentrades.entry_id, strategy.opentrades.size, strategy.opentrades.profit, strategy.opentrades.commission, strategy.opentrades.max_runup, strategy.opentrades.max_drawdown) — Details of open trade n (0 = oldest); na if there's no such trade. size is negative for shorts. E.g. exit after 10 bars: bar_index - strategy.opentrades.entry_bar_index(0) >= 10.
- `strategy.closedtrades.entry_bar_index(n), exit_bar_index, entry_price, exit_price, entry_time, exit_time, entry_id, size, profit, commission, max_runup, max_drawdown` (strategy.closedtrades.exit_bar_index, strategy.closedtrades.entry_price, strategy.closedtrades.exit_price, strategy.closedtrades.entry_time, strategy.closedtrades.exit_time, strategy.closedtrades.entry_id, strategy.closedtrades.size, strategy.closedtrades.profit, strategy.closedtrades.commission, strategy.closedtrades.max_runup, strategy.closedtrades.max_drawdown) — Details of closed trade n (0 = oldest; the last one is strategy.closedtrades - 1).
- `strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital` (strategy.equity, strategy.netprofit, strategy.openprofit, strategy.grossprofit, strategy.grossloss, strategy.initial_capital) — Account figures.
- `strategy.closedtrades, opentrades, wintrades, losstrades` (strategy.closedtrades, strategy.opentrades, strategy.wintrades, strategy.losstrades) — Trade counts.
- `strategy.long, strategy.short` (strategy.long, strategy.short) — Directions.
- `strategy.fixed, strategy.cash, strategy.percent_of_equity` (strategy.fixed, strategy.cash, strategy.percent_of_equity) — Values for default_qty_type.
- `strategy.commission.percent, cash_per_order, cash_per_contract` (strategy.commission.percent, strategy.commission.cash_per_order, strategy.commission.cash_per_contract) — Values for commission_type.

### Plots and alerts

- `plot(series, title, color, linewidth, style)` — Draw a series on the chart or in a pane.
- `plotshape(series, title, style, location, color, text)` — Draw a shape on bars where series is true.
- `plotchar(series, title, char, location, color)` — Draw a character on bars where series is true.
- `hline(price, title, color, linestyle)` — Horizontal line at a fixed level.
- `fill(plot1, plot2, color)` — Fill between two plots or two hlines.
- `bgcolor(color)` — Colour the background of the bar.
- `barcolor(color)` — Colour the bar itself.
- `alertcondition(condition, title, message)` — Declare a condition you can turn into an alert by email, Telegram, Discord or webhook.
- `plot.style_*` (plot.style_line, plot.style_linebr, plot.style_stepline, plot.style_histogram, plot.style_columns, plot.style_circles, plot.style_cross, plot.style_area) — line, linebr, stepline, histogram, columns, circles, cross, area.
- `hline.style_*` (hline.style_solid, hline.style_dashed, hline.style_dotted) — solid, dashed, dotted.
- `shape.*` (shape.triangleup, shape.triangledown, shape.arrowup, shape.arrowdown, shape.circle, shape.xcross, shape.cross, shape.diamond, shape.square, shape.flag, shape.labelup, shape.labeldown) — triangleup, triangledown, arrowup, arrowdown, circle, xcross, cross, diamond, square, flag, labelup, labeldown.
- `location.*` (location.abovebar, location.belowbar, location.top, location.bottom, location.absolute) — abovebar, belowbar, top, bottom, absolute.
- `size.*` (size.auto, size.tiny, size.small, size.normal, size.large, size.huge) — auto, tiny, small, normal, large, huge. Accepted, but shapes are drawn at one size.

### Lines and boxes

- `line.new(x1, y1, x2, y2, extend, color, style, width)` — Draw a line between two bar indexes and prices; returns its id.
- `line.set_x1, set_y1, set_x2, set_y2, set_xy1, set_xy2, set_color, set_style, set_width` (line.set_x1, line.set_y1, line.set_x2, line.set_y2, line.set_xy1, line.set_xy2, line.set_color, line.set_style, line.set_width) — Change a line.
- `line.delete(id)` — Remove a line.
- `box.new(left, top, right, bottom, border_color, bgcolor, extend)` — Draw a rectangle; returns its id.
- `box.set_left, set_top, set_right, set_bottom, set_bgcolor, set_border_color, set_extend` (box.set_left, box.set_top, box.set_right, box.set_bottom, box.set_bgcolor, box.set_border_color, box.set_extend) — Change a box.
- `box.delete(id)` — Remove a box.
- `line.style_*, box.style_*` (line.style_solid, line.style_dashed, line.style_dotted, box.style_solid, box.style_dashed, box.style_dotted) — solid, dashed, dotted.
- `extend.*` (extend.none, extend.left, extend.right, extend.both) — none, left, right, both.

### Math, strings and colours

- `math.abs, ceil, floor, round(number, precision), sign, sqrt, exp, log, log10, pow(base, exponent)` (math.abs, math.ceil, math.floor, math.round, math.sign, math.sqrt, math.exp, math.log, math.log10, math.pow) — Arithmetic.
- `math.max(...), math.min(...), math.avg(...)` (math.min, math.avg) — Of any number of values.
- `math.sum(source, length)` — Sum over the last length bars.
- `math.pi, math.e` (math.pi, math.e) — Constants.
- `na, na(x), nz(x, replacement), fixnan(x)` (na, nz, fixnan) — The missing value, a test for it, a replacement for it, and the last non-na value.
- `int(x), float(x), bool(x)` (float, bool) — Conversions.
- `str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)` (str.format, str.length, str.contains) — Strings. str.format replaces {0}, {1}… with the arguments.
- `color.new(color, transp), color.rgb(red, green, blue, transp)` (color.rgb) — Build a colour; transparency from 0 to 100.
- `color.*` (color.red, color.green, color.blue, color.orange, color.yellow, color.purple, color.aqua, color.lime, color.fuchsia, color.teal, color.maroon, color.navy, color.olive, color.gray, color.silver, color.white, color.black) — red, green, blue, orange, yellow, purple, aqua, lime, fuchsia, teal, maroon, navy, olive, gray, silver, white, black.

### Arrays (array.*)

- `array.new_float, new_int, new_bool, new_string, new_color, new_line, new_box, new_label, new_table(size)` (array.new_float, array.new_int, array.new_bool, array.new_string, array.new_color, array.new_line, array.new_box, array.new_label, array.new_table) — Create an array.
- `array.get, set, insert, push, pop, shift, unshift` (array.get, array.set, array.insert, array.push, array.pop, array.shift, array.unshift) — Read and change elements.
- `array.size, first, last, sum, avg, min, max, stdev` (array.size, array.first, array.last, array.sum, array.avg, array.min, array.max, array.stdev) — Size and statistics.

### Maps and user-defined types

User-defined types and the `map.<fn>` collection are supported. Both are top-level declarations; instance methods on a value use the `obj.method(args...)` syntax.

- `enum Name
    Member
    Member = N
    ...` — Top-level enum declaration. Members without a value auto-increment from 0; explicit values may be numbers or strings. Access as `Name.Member` in any expression position. Enum values are plain numbers (or strings), so they work with comparison operators and with `int()` without conversion.
- `type Name
    field1
    field2: int
    field3 = default` — Top-level user-defined type. Fields are listed one per line; the `: type` and `= default` parts are accepted for forward compatibility but not yet validated. Construct with `Type.new(arg1, arg2, ...)` and read fields with `instance.field`.
- `m = map.new<int, float>()` (map.new) — Create an empty map. Type-args `<K, V>` are accepted but ignored at runtime.
- `m = map.put(m, key, value)` (map.put) — Set a key. Returns the map so calls can chain or be reassigned.
- `v = map.get(m, key)` (map.get) — Read a value. Returns na if the key is missing.
- `n = map.size(m)` (map.size) — Number of entries.
- `keys = map.keys(m), values = map.values(m)` (map.keys, map.values) — Return the keys or values as a Pine array (insertion order).
- `map.contains(m, key), map.remove(m, key)` (map.remove) — Membership test and deletion. Both return the map.

## Not supported yet

A function the engine does not know stops the script with "Unknown function" and the line and column.

- `label.new(), table.new()`: Not available yet. Lines and boxes are.
- `import, matrix.*, array.new<type>()`: Libraries, matrices, and typed array constructors are not implemented yet.
- `strategy.risk.*`: The risk rules (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) are not supported. Trailing stops in strategy.exit() are: use trail_points and trail_offset.

## Runnable examples

Built-in scripts that compile against this engine:

**RSI Mean Reversion**

```pine
//@version=5
strategy("RSI Mean Reversion", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
len = input.int(14, "RSI length", minval=2)
oversold = input.float(30, "Oversold")
exitLevel = input.float(50, "Exit level")
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
r = ta.rsi(close, len)
if strategy.position_size == 0 and r < oversold
    strategy.entry("Long", strategy.long)
if strategy.position_size > 0 and r > exitLevel
    strategy.close("Long", comment="RSI exit")
plot(r, "RSI", color=color.purple)
hline(oversold, "Oversold", color=color.green)
hline(exitLevel, "Exit", color=color.gray)
```

**MACD Crossover**

```pine
//@version=5
strategy("MACD Crossover", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
fast = input.int(12, "Fast", minval=1)
slow = input.int(26, "Slow", minval=2)
sig = input.int(9, "Signal", minval=1)
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
[m, s, h] = ta.macd(close, fast, slow, sig)
if ta.crossover(m, s)
    strategy.entry("Long", strategy.long)
if ta.crossunder(m, s)
    strategy.close("Long", comment="MACD cross")
plot(h, "Histogram", color=h >= 0 ? color.new(color.green, 40) : color.new(color.red, 40), style=plot.style_columns)
plot(m, "MACD", color=color.orange)
plot(s, "Signal", color=color.blue)
```

**Bollinger Bounce**

```pine
//@version=5
strategy("Bollinger Bounce", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
len = input.int(20, "Length", minval=2)
mult = input.float(2, "StdDev", minval=0.5, step=0.1)
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
[basis, upper, lower] = ta.bb(close, len, mult)
if strategy.position_size == 0 and close <= lower
    strategy.entry("Long", strategy.long)
if strategy.position_size > 0 and close >= basis
    strategy.close("Long", comment="Back to mean")
u = plot(upper, "Upper", color=color.blue)
plot(basis, "Basis", color=color.gray)
l = plot(lower, "Lower", color=color.blue)
fill(u, l, color=color.new(color.blue, 92))
```

## Elsewhere

- Human reference: https://deepwick.com/docs/script (Spanish: https://deepwick.com/es/docs/script)
- Try a script with no signup: https://deepwick.com/try