//@version=6
indicator("Price Action Toolkit (structure, zones, MTF liquidity)", shorttitle = "PA Toolkit", overlay = true, max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500, max_bars_back = 2000)

// ============================================================================
// PRICE ACTION TOOLKIT
//
// Original code. Every module has its own switch in the settings:
//   1. Market structure   internal + swing: BOS, BOS+, CHoCH, CHoCH+,
//                         HH/HL/LH/LL at every swing point, level lines at
//                         the open swing high and low, strong / weak high and
//                         low, candles coloured by structure (partly after a
//                         CHoCH, fully after a BOS)
//   2. Order blocks       with breaker blocks (show or hide)
//   3. Fair value gaps    with inverse gaps (IFVG): a gap that price closes
//                         through flips colour and stays as support or
//                         resistance until price closes back through it
//   4. Liquidity zones    wick-to-body zones at swing highs and lows (green),
//                         merged when highs or lows are nearly equal,
//                         a box around the wick of a sweep candle,
//                         equal highs / lows
//   5. Higher timeframes  the same liquidity zones from up to four other
//                         timeframes, each tagged with its timeframe;
//                         overlapping zones are combined into one
//      Zone odds          counted on this chart: after a zone was taken, how
//                         often price went up or down first
//   6. Premium / discount with equilibrium, in its own column right of the
//                         zones, so it never covers them
//   7. Previous day / week / month highs and lows, and the day / week /
//      month open, as a tag with a short line (close levels share one tag)
//      Sessions           high and low of the Asia, London and New York session,
//                         drawn as lines over the session itself. Asia starts
//                         when the trading day opens (18:00 New York time) or at
//                         the Tokyo open; London and New York start at their
//                         opens; New York runs to 17:00 New York time
//      Opening range      the New York opening range (ORB), which side broke
//                         first, and how past days went on this chart
//      Session opens      a vertical line at the Tokyo, London and New York
//                         open (Asia / London / New York), each in its own local time
//      Engulfing candles  a triangle below a bullish and above a bearish
//                         engulfing candle
//      Liquidity grabs    a wick through the previous day's or a session's high
//                         or low (and optionally a recent swing), with the close
//                         back inside. Each level counts once: only the first
//                         candle that trades through it. Marked in orange with
//                         a dashed box around the wick
//      Day range          how much of an average day is already used, the two
//                         levels of a normal-sized day, round numbers, the
//                         daily and 4-hour trend
//
// Clean by design: order blocks, gaps and liquidity zones are drawn short and
// only where at least two things meet (confluence): an order block, a gap, a
// liquidity zone from any timeframe, or a key level (PDH / PDL, PWH / PWL,
// PMH / PML, a session high or low, equilibrium, the open swing high or low).
// Confluence zones get a thick border. Premium / discount runs long, across
// the whole swing range, as a light background with an equilibrium line.
// Busy extras (internal swing labels, internal BOS / CHoCH lines, equal highs /
// lows, engulfing marks, round numbers, ADR levels, opens, opening range)
// start switched off. Built for the 1D, 1H and 15m charts.
// Focus on price (on by default): the chart moves with price. Only the zones
// and level tags nearest to price are drawn; what is far away is hidden until
// price comes near it again. Only liquidity zones and premium / discount are
// drawn long; everything else stays short.
//
// Candle colours: after a CHoCH the bodies are only lightly coloured in the new
// direction; the full colour comes only with a BOS in that direction.
//
// Higher-timeframe values come from closed bars only, so they do not repaint.
// Swing points are confirmed some bars late by nature. Zones and labels are
// descriptions of what price did, not signals.
// ============================================================================

// ---------------------------------------------------------------- inputs ----
// The settings page: the everyday switches first, section by section; all
// fine-tuning sits in the last section.
G_TRD = "━━ 𝟭  𝗧𝗥𝗔𝗗𝗘 𝗦𝗘𝗧𝗨𝗣 ━━  buy / sell zone, entry, SL, TP"
G_FIL = "━━ 𝟮  𝗙𝗜𝗟𝗧𝗘𝗥 ━━  show only what matters"
G_MS  = "━━ 𝟯  𝗠𝗔𝗥𝗞𝗘𝗧 𝗦𝗧𝗥𝗨𝗖𝗧𝗨𝗥𝗘 ━━"
G_LIQ = "━━ 𝟰  𝗟𝗜𝗤𝗨𝗜𝗗𝗜𝗧𝗬 ━━"
G_FVG = "━━ 𝟱  𝗙𝗔𝗜𝗥 𝗩𝗔𝗟𝗨𝗘 𝗚𝗔𝗣𝗦 ━━"
G_OB  = "━━ 𝟲  𝗢𝗥𝗗𝗘𝗥 𝗕𝗟𝗢𝗖𝗞𝗦 ━━"
G_PD  = "━━ 𝟳  𝗣𝗥𝗘𝗠𝗜𝗨𝗠 / 𝗗𝗜𝗦𝗖𝗢𝗨𝗡𝗧 ━━"
G_LV  = "━━ 𝟴  𝗟𝗘𝗩𝗘𝗟𝗦 ━━  day, week, month"
G_SES = "━━ 𝟵  𝗦𝗘𝗦𝗦𝗜𝗢𝗡𝗦 𝗔𝗡𝗗 𝗢𝗣𝗘𝗡𝗜𝗡𝗚 𝗥𝗔𝗡𝗚𝗘 ━━"
G_EMA = "━━ 𝟭𝟬  𝗘𝗠𝗔 ━━"
G_ENG = "━━ 𝟭𝟭  𝗘𝗡𝗚𝗨𝗟𝗙𝗜𝗡𝗚 𝗖𝗔𝗡𝗗𝗟𝗘𝗦 ━━"
G_ALR = "━━ 𝟭𝟮  𝗔𝗟𝗘𝗥𝗧𝗦 ━━  one alert covers everything ticked"
G_UI  = "━━ 𝟭𝟯  𝗗𝗜𝗦𝗣𝗟𝗔𝗬 ━━"
G_COL = "━━ 𝟭𝟰  𝗖𝗢𝗟𝗢𝗨𝗥𝗦 ━━"
G_ADV = "━━ 𝟭𝟱  𝗙𝗜𝗡𝗘-𝗧𝗨𝗡𝗜𝗡𝗚 ━━  only if needed"

showBS    = input.bool(true, "Buy zone and sell zone", group = G_TRD, tooltip = "BUY ZONE = the strongest support below price, SELL ZONE = the strongest resistance above. The % in the box says how likely it is to hold (confluence, how often such zones held on this chart, size of the liquidity, minus retests). When no zone is strong, the nearest one is used and marked weak, so both are always on the chart. A zone stays until price closes through it or it is taken.")
bsTfIn    = input.string("Any", "Buy / sell zone: only on charts of at least", options = ["Any", "15m", "1H", "4H", "D"], group = G_TRD, tooltip = "On small timeframes the zones are not strong enough to trade from, so the buy / sell zone, its entry, stop and target are only drawn on this timeframe and above.")
entryIn   = input.string("Middle of the zone", "Entry at", options = ["Middle of the zone", "Near edge of the zone"], group = G_TRD, tooltip = "Middle = a limit order at 50% of the zone: a smaller stop, a better reward to risk, but it fills less often. Near edge = fills more often, but the stop covers the whole zone.")
slMult    = input.float(1.5, "Stop loss: zone heights past the zone (1.5 = 1.5 x the zone)", minval = 0.0, maxval = 5.0, step = 0.1, group = G_TRD, tooltip = "The stop sits this many zone heights past the far side of the zone: below a buy zone, above a sell zone. Example: a zone 4 dollars high and 1.5 = the stop 6 dollars past the zone.")
tpMode    = input.string("Fixed R:R", "Take profit", options = ["Fixed R:R", "Nearest target"], group = G_TRD, tooltip = "Fixed R:R = one TP per side: the stop distance times the reward to risk below, measured from the zone edge (3 = three times the stop distance). Nearest target = the nearest real target (zone, liquidity, day / week / month or session high / low) that pays at least that reward to risk.")
minRR     = input.float(3.0, "Take profit: reward to risk (3 = 1:3)", minval = 1.0, maxval = 10.0, step = 0.5, group = G_TRD, tooltip = "3 = the TP is three times as far as the stop. With Nearest target: when no real target pays this much, no TP is drawn and the zone says so.")
rndOn     = input.bool(true, "SL and TP on round numbers", group = G_TRD, tooltip = "The stop moves out to the next round number past it (further from the zone, never closer). The take profit (fixed R:R) goes to the round number nearest to its spot, and the label shows the reward to risk that results.")
rndStep   = input.float(0.0, "Round number step (0 = automatic)", minval = 0, step = 1, group = G_TRD, tooltip = "Automatic = the roundest number (100, 50, 10, 5, 1) that moves the stop by at most a quarter of the risk, so the stop does not grow much. Or set a step by hand, e.g. 5 or 10.")
showTp    = input.bool(true, "Take profit line", group = G_TRD, tooltip = "One TP per side, as set above. The text shows the price and the reward to risk. A guide only, not advice.")

focusOn   = input.bool(true, "Focus on price: show only what is near price now", group = G_FIL, tooltip = "Moves with price. Only the nearest order blocks and gaps above and below price are drawn, the nearest liquidity zone above and below, and any zone price is inside. Of the level tags (PDH, PWH, sessions, swing levels and so on) only the nearest ones above and below. Everything further away is hidden until price comes near it again. Premium / discount and the session lines always stay.")
minImp    = input.int(3, "Hide weak zones: strength below (1-5)", minval = 1, maxval = 5, group = G_FIL, tooltip = "Every zone gets a strength from 1 to 5: how many things meet there (order block, gap, liquidity, key level, more timeframes) and, for liquidity, its size in $. Zones weaker than this are not drawn. 1 = show all, 3 = only solid zones, 4-5 = only the very strongest.")
combZn    = input.bool(true, "Zones on the same price become one box", group = G_FIL, tooltip = "Order blocks, gaps and liquidity zones that overlap are drawn as one box with one combined text, so nothing is drawn on top of each other. The strongest zone gives the colour; each extra zone makes the box a step brighter.")
liqMinUsd = input.int(2, "Liquidity: always show zones of at least ($)", minval = 1, maxval = 5, group = G_FIL, tooltip = "Liquidity zones of this size are drawn even without other confluence. $ = this chart's own, $$ = 1H / 4H or a zone hit twice, $$$ = daily, $$$$ = weekly; each extra timeframe on the same price adds one. 1 = every liquidity zone.")
fvgSig    = input.float(0.6, "Significant gap: at least (x ATR)", minval = 0.0, maxval = 5.0, step = 0.1, group = G_FIL, tooltip = "A gap (or inverse gap) at least this tall is always drawn near price. Smaller ones are drawn only when they meet other confluence. 0 = every gap counts as significant.")
focusZn   = input.int(2, "Focus: order blocks and gaps kept above and below price", minval = 1, maxval = 10, group = G_FIL)
focusLq   = input.int(1, "Focus: liquidity zones kept above and below price", minval = 1, maxval = 10, group = G_FIL, tooltip = "The nearest liquidity above and below price: where price is likely to reach for next.")
focusLv   = input.int(2, "Focus: level tags kept above and below price", minval = 1, maxval = 20, group = G_FIL)

showSw    = input.bool(true, "Swing structure", group = G_MS)
intMode   = input.string("All", "Internal BOS / CHoCH lines", options = ["All", "Only with confluence", "Off"], group = G_MS, tooltip = "All = every internal BOS, BOS+, CHoCH and CHoCH+ gets its dashed line and its name. Only with confluence = only the breaks where price came from a support / resistance zone (order block, gap, liquidity) or swept liquidity in the last 10 candles, or the breaking candle left a gap or was a strong candle. Swing breaks (solid line, bold name) are always drawn. The last 30 of each are kept.")
showInt   = input.bool(true, "Internal structure", group = G_MS, tooltip = "The small swings inside the big ones (thin labels). Its BOS / CHoCH lines are the switch above: only the ones with confluence.")
showPts   = input.bool(true, "Swing point labels: swing (HH, HL, LH, LL, in bold)", group = G_MS)
intPtsIn  = input.string("Labels", "Swing points: internal (thin, smaller)", options = ["Labels", "Triangles", "Off"], group = G_MS, tooltip = "Swing points (the big structure) are written in bold. Internal points (the small structure) are written thin, smaller and a little faded, so the two are easy to tell apart. Triangles only marks the internal points (the name is in the tooltip of each triangle).")
showPlus  = input.bool(true, "Mark strong breaks as BOS+", group = G_MS, tooltip = "CHoCH+ = a change of character that was already hinted at by a failed swing: a lower high before a break down, or a higher low before a break up. BOS+ = a break of structure made by a strong candle. Both are labels of this script, not proof of a stronger signal.")
showLvSw  = input.bool(true, "Level lines at the open swing high and low", group = G_MS, tooltip = "Draws the last unbroken swing high and swing low as a level, labelled HH, LH, HL or LL. In brackets: what a break of that level would be (BOS, CHoCH or CHoCH+).")
showSW    = input.bool(true, "Strong / weak high and low", group = G_MS)
showEQ    = input.bool(true, "Equal highs and lows", group = G_MS)
storyOn   = input.bool(true, "Story line: joins the swing points", group = G_MS, tooltip = "Read the chart like a path: a line from swing point to swing point, up legs in the bullish colour and down legs in the bearish colour. The last part, dashed, runs from the last swing point to the current price.")
storyTgt  = input.bool(true, "Next target: arrow to the nearest liquidity in the trend direction", group = G_MS, tooltip = "In a bullish swing trend the nearest liquidity zone above price gets a bright, thick border and an arrow points to it; in a bearish trend the nearest one below. It shows where price is likely to reach for next, not a promise. A zone price is inside right now is drawn brighter too.")
colorBars = input.bool(true, "Colour candles by the last break", group = G_MS, tooltip = "The candles take the colour of the last BOS / CHoCH drawn on the chart (swing or internal): BOS+ full colour, BOS strong, CHoCH+ medium, CHoCH pale. Bullish colour after a break up, bearish after a break down.")

showLiq   = input.bool(true, "Liquidity zones at swing highs and lows", group = G_LIQ)
tf1On  = input.bool(false, "", inline = "t1", group = G_LIQ)
tf1    = input.timeframe("60", "Timeframe 1", inline = "t1", group = G_LIQ)
tf1C   = input.color(#7DFF66, "", inline = "t1", group = G_LIQ)
tf2On  = input.bool(true, "", inline = "t2", group = G_LIQ)
tf2    = input.timeframe("240", "Timeframe 2", inline = "t2", group = G_LIQ)
tf2C   = input.color(#5CFF4A, "", inline = "t2", group = G_LIQ)
tf3On  = input.bool(true, "", inline = "t3", group = G_LIQ)
tf3    = input.timeframe("D", "Timeframe 3", inline = "t3", group = G_LIQ)
tf3C   = input.color(#39FF14, "", inline = "t3", group = G_LIQ)
tf4On  = input.bool(true, "", inline = "t4", group = G_LIQ)
tf4    = input.timeframe("W", "Timeframe 4", inline = "t4", group = G_LIQ)
tf4C   = input.color(#2BF000, "", inline = "t4", group = G_LIQ)
liqUsd    = input.bool(true, "Liquidity size in dollars ($ to $$$$$)", group = G_LIQ, tooltip = "More dollars = more liquidity resting there. One point for the timeframe (this chart $, 1H / 4H $$, daily $$$, weekly $$$$, monthly $$$$$), plus one for each extra touch at the same price (equal highs or lows, up to two), plus one for each other timeframe that has liquidity in the same place. At most $$$$$.")
showSweep = input.bool(true, "Box around the wick of a sweep or liquidity grab candle", group = G_LIQ, tooltip = "A sweep is a candle whose wick goes through a liquidity zone and whose close is back inside (outlined in orange, plus a small dashed zone to the right). A liquidity grab is the same at a session or previous-day level (outlined in the grab colour). Master switch for both.")
grabSess  = input.bool(true, "Liquidity grabs at the session highs and lows", group = G_LIQ, tooltip = "Asia, London and New York high and low, once the session is over. Each level counts only once: the first candle that trades through it. If that candle closes back inside, it is a grab; if not, the level is simply broken and no later candle can grab it. Intraday charts up to 1 hour.")
grabPd    = input.bool(true, "Liquidity grabs at the previous day's high and low", group = G_LIQ, tooltip = "Same rule: only the first candle that trades through the level counts. Intraday charts only.")
showGrab  = input.bool(false, "Liquidity grabs at recent swing highs and lows", group = G_LIQ, tooltip = "Also marks a grab of small recent swings. Off by default: these happen on many wicks.")
grabTxt   = input.bool(true, "Grabs and sweeps: write 'Liquidity swept' (and the level) above / below", group = G_LIQ, tooltip = "PDH, PDL, Asia H, Asia L, Lon H, Lon L, NY H, NY L (Swing H / Swing L for the swing grabs).")

showFVG   = input.bool(true, "Fair value gaps", group = G_FVG)
showIFVG  = input.bool(true, "Inverse gaps (IFVG)", group = G_FVG, tooltip = "A gap that price closes through flips into an inverse gap: it takes the colour of the other side, gets a dashed border and the text IFVG, and stays as support or resistance until price closes back through it. With 'Full fill' or 'Half fill' below, a gap that is filled before any close through it is removed and does not flip.")
gapDedupe = input.bool(true, "Broken gap on the same prices: show only the IFVG", group = G_FVG, tooltip = "When a gap is broken it turns into an inverse gap (IFVG). If a normal gap that works the same way (both resistance or both support) lies on the same prices, only the IFVG is drawn, so one area = one box.")
fvgAll    = input.bool(false, "Show every gap (FVG and IFVG)", group = G_FVG, tooltip = "Every fair value gap and inverse gap is drawn, also without confluence and also away from price (up to 'Gaps kept'). Off = gaps are filtered by strength and focus like the other zones.")
gapLen    = input.int(0, "Gap boxes: length (candles, 0 = to the common right edge)", minval = 0, maxval = 500, group = G_FVG, tooltip = "0 = every gap starts at the candles that formed it and ends on the same line as the order blocks and liquidity zones, so all boxes end in one line. A number = the gap runs only that many candles (an inverse gap: from its candles to the candle that broke it, then that many more), never past that line.")

showOB    = input.bool(true, "Order blocks", group = G_OB)
showBrk   = input.bool(true, "Breaker blocks", group = G_OB, tooltip = "When an order block is broken it stays on the chart as a breaker until price closes back through it. Turn off to delete broken order blocks.")
obTfIn    = input.string("1H", "Order blocks: only on charts of at least", options = ["Any", "15m", "1H", "4H", "D"], group = G_OB, tooltip = "Order blocks on small timeframes are mostly noise, so they are only looked for on this timeframe and above.")
obStrong  = input.bool(true, "Only strong blocks (where institutions likely stepped in)", group = G_OB, tooltip = "A block is kept only when the move away from it was real: it broke structure (always), it travelled far (size below), it left a fair value gap behind (displacement), and, if switched on, it came on above-average volume or the block first ran a previous high / low. Off = every block that broke structure.")

showPD  = input.bool(true, "Premium, equilibrium and discount zones", group = G_PD)
pdStyle = input.string("Full halves", "Zone size", options = ["Full halves", "Thin bands"], group = G_PD, tooltip = "Full halves = the upper half of the range is premium, the lower half discount, with an equilibrium band in the middle. Thin bands = only a band at the top, the middle and the bottom.")

showD  = input.bool(true, "Previous day high and low", group = G_LV)
showW  = input.bool(true, "Previous week high and low", group = G_LV)
showM  = input.bool(true, "Previous month high and low", group = G_LV)
showOpen = input.bool(false, "Open of the day, week and month", group = G_LV)
adrTags   = input.bool(false, "Levels of a normal-sized day (ADR High, ADR Low)", group = G_LV, tooltip = "ADR High = today's low plus the average day. ADR Low = today's high minus the average day. Price beyond them means today is already larger than an average day.")
showRound = input.bool(false, "Round numbers (nearest above and below)", group = G_LV)

showSess = input.bool(true, "Session highs and lows (Asia, London, New York)", group = G_SES, tooltip = "The high and low of each session, drawn as a line over the session with its name just above the high and just below the low. During a session its lines follow the running high and low.")
sessDrawIn = input.string("Over the session + tag", "Session highs and lows are drawn", options = ["Over the session + tag", "Over the session", "Tag at the right edge"], group = G_SES, tooltip = "Over the session = a line above and a line below the session, from its first to its last candle, with the name on the line. Tag = a label at the right edge of the chart, like the other levels.")
showOrb  = input.bool(false, "Opening range (ORB)", group = G_SES, tooltip = "The high and low of the opening range, a mark on the first candle that closes outside it, and which side broke first. The two times below are always New York time.")
orbMark  = input.bool(true, "Arrow on the candle that breaks the opening range", group = G_SES, tooltip = "The direction is always written on the opening range box.")
showOpn  = input.bool(true, "Session open lines", group = G_SES, tooltip = "A vertical line at the Tokyo, London and New York open. Each open is set in its own local time, so daylight-saving changes are handled automatically. The line is put on the candle that starts nearest to the open (for example 09:02 for a 09:00 open). The labels stay at the height of the highest candle on screen.")
tyoOn    = input.bool(true, "Open line: Asia (Tokyo)", group = G_SES)
lonOn    = input.bool(true, "Open line: London", group = G_SES)
nycOn    = input.bool(true, "Open line: New York", group = G_SES)

emaOn     = input.bool(false, "EMA 1", inline = "e1", group = G_EMA)
ema1Len   = input.int(50, "", minval = 1, maxval = 1000, inline = "e1", group = G_EMA)
ema1C     = input.color(#FFB000, "", inline = "e1", group = G_EMA)
ema2On    = input.bool(false, "EMA 2", inline = "e2", group = G_EMA)
ema2Len   = input.int(200, "", minval = 1, maxval = 1000, inline = "e2", group = G_EMA)
ema2C     = input.color(#2E9BFF, "", inline = "e2", group = G_EMA)
emaW      = input.int(2, "EMA line width", minval = 1, maxval = 4, group = G_EMA)

showEng  = input.bool(true, "Engulfing candles", group = G_ENG, tooltip = "A triangle below a bullish engulfing candle and above a bearish one, in the bullish and bearish colour. Only the latest few are kept (setting below).")
engMax   = input.int(3, "Show the last ... engulfing candles", minval = 1, maxval = 50, group = G_ENG, tooltip = "Only the latest engulfing candles keep their mark (3 = the last three); older marks are removed.")
engMode  = input.string("Body engulfs body", "An engulfing candle is", options = ["Body engulfs body", "Close beyond the previous wick"], group = G_ENG, tooltip = "Body engulfs body = the candle turns against the previous candle and its body covers the whole previous body. Close beyond the previous wick = the same, and it also closes above the previous high (bullish) or below the previous low (bearish).")
engSzIn  = input.string("Normal", "Mark size", options = ["Tiny", "Small", "Normal", "Large"], group = G_ENG)

alertsOn = input.bool(true, "Alerts on  (how to set: see the ⓘ)", group = G_ALR, tooltip = "1) Tick below what you want to be told about.  2) On the chart click Alert (the clock with +) or press Alt + A.  3) Condition: Price Action Toolkit, then 'Any alert() function call'.  4) Expiration: open-ended, then Create.  That one alert covers everything ticked here, on this symbol and timeframe. TradingView saves the settings with the alert: after you change a tick here, delete the alert and create it again. Every message starts with symbol and timeframe, e.g. 'XAUUSD 15m · ...'.")
alZone    = input.bool(true, "Price reaches the buy or sell zone", group = G_ALR, tooltip = "Once when price first touches the zone, with the zone, its strength, SL and TP in the message.")
alNear    = input.bool(true, "Heads-up: price comes close to the buy or sell zone", group = G_ALR, tooltip = "Once when price comes within 1 ATR (one average candle) of the zone, so you have time to get ready. It can tell you again after price has moved away by 2 ATR.")
alTpSl    = input.bool(true, "Take profit or stop loss reached", group = G_ALR, tooltip = "After price has touched the buy or sell zone: once when it reaches that zone's TP or its SL.")
alSweep   = input.bool(true, "Liquidity sweep or grab", group = G_ALR)
alStruct  = input.bool(true, "Swing BOS / CHoCH", group = G_ALR)
alInt     = input.bool(false, "Internal BOS / CHoCH", group = G_ALR)
alGap     = input.bool(false, "A gap flips into an IFVG", group = G_ALR)
alOb      = input.bool(false, "Order block broken", group = G_ALR)
alOrb     = input.bool(true, "Opening range broken", group = G_ALR)
opnAlert = input.bool(false, "Session opens (Asia, London, New York)", group = G_ALR)
engAlert = input.bool(false, "Engulfing candles", group = G_ALR)

txtIn    = input.string("Small", "Text size", options = ["Tiny", "Small", "Normal"], group = G_UI)
lnFade   = input.int(80, "Lines: transparency (0 = solid, 95 = almost invisible)", minval = 0, maxval = 95, group = G_UI, tooltip = "For the guide lines: session opens, level tags, premium / discount. BOS / CHoCH, equal highs / lows, session highs and lows, entry, stop loss and take profit keep their full colour.")

cBull   = input.color(#FFF44F, "Bullish", group = G_COL)
cBear   = input.color(#ffffff, "Bearish", group = G_COL)
cFvgUp  = input.color(#FFF44F, "Fair value gap up", group = G_COL)
cFvgDn  = input.color(#ababab, "Fair value gap down", group = G_COL)
cLiq    = input.color(#8CFF6B, "Liquidity zones (this chart)", group = G_COL)
cPrem   = input.color(#ababab, "Premium", group = G_COL)
cEq     = input.color(#5b6f88, "Equilibrium", group = G_COL)
cDisc   = input.color(#969549, "Discount", group = G_COL)
cLevel  = input.color(#5AB8FF, "Previous highs and lows", group = G_COL)
cAsia   = input.color(color.new(color.white, 25), "Asia session", group = G_COL)
cLon    = input.color(#5AB8FF, "London session", group = G_COL)
cNy     = input.color(#FFF44F, "New York session", group = G_COL)
cGrab   = input.color(#FF3D3D, "Liquidity sweeps and grabs", group = G_COL)
cGrey   = input.color(#8a8a8a, "Taken zones and small text", group = G_COL)
cBuy    = input.color(#FFF44F, "Buy zone", group = G_COL)
cSell   = input.color(#FFFFFF, "Sell zone", group = G_COL)
cStop   = input.color(#FF3B5C, "Stop loss line", group = G_COL)
cTp     = input.color(#85BB65, "Take profit line", group = G_COL)


confMode  = input.string("Only confluence", "Trade / filter · Order blocks, gaps and liquidity zones", options = ["Only confluence", "Highlight confluence", "All"], group = G_ADV, tooltip = "Only confluence = a zone is drawn only where at least the number of things below meet. Highlight confluence = every zone is drawn, the ones without confluence very faint. All = every zone, as before. Confluence zones always get a thick border.")
confMin   = input.int(2, "Trade / filter · Confluence: things that must meet", minval = 2, maxval = 4, group = G_ADV, tooltip = "Counted kinds: order block (or breaker), gap (FVG or IFVG), liquidity zone (any timeframe), key level. A liquidity zone made of two or more timeframes counts one extra.")
confLv    = input.bool(true, "Trade / filter · Key levels count as confluence", group = G_ADV, tooltip = "Previous day, week and month high and low, the latest Asia, London and New York high and low, equilibrium, and the open swing high and low.")
innerIn   = input.string("Off", "Trade / filter · Combined box: show each zone inside it", options = ["Gaps only", "All", "Off"], group = G_ADV, tooltip = "Inside a combined box each zone keeps its own band at its exact prices, with its short name (FVG, IFVG, OB, BRK, 1H, 4H, D, W, Liq) at its left end. Gaps only = only for fair value gaps and inverse gaps.")
bsWeak    = input.bool(true, "Trade / filter · No strong zone on a side: use the nearest liquidity (marked 'weak')", group = G_ADV, tooltip = "Without this, a side with no strong zone simply has no buy / sell zone.")
bsHtf     = input.bool(true, "Trade / filter · Buy / sell zone: only higher-timeframe zones", group = G_ADV, tooltip = "Only a zone that is a higher-timeframe liquidity zone (1H, 4H, D, W ...), or that lies on one, can become the buy or sell zone. A zone made only on the chart timeframe does not qualify.")
bsAtr     = input.float(15.0, "Trade / filter · Buy / sell zone: look this far from price (x ATR)", minval = 1.0, maxval = 100.0, step = 1.0, group = G_ADV)
tpBuf     = input.float(0.2, "Trade / filter · Take profit: this far in front of the target (x ATR)", minval = 0.0, maxval = 5.0, step = 0.1, group = G_ADV)
swLen     = input.int(50, "Structure · Swing length", minval = 10, maxval = 500, group = G_ADV)
intLen    = input.int(3, "Structure · Internal length", minval = 2, maxval = 50, group = G_ADV, tooltip = "How many candles on each side make an internal swing point. 3 = many internal CHoCH / BOS (the default). 5 = fewer, bigger ones. 2 = very many tiny ones (each line only 2-3 candles long).")
msMode    = input.string("CHoCH and BOS", "Structure · Show", options = ["CHoCH and BOS", "CHoCH only", "BOS only"], group = G_ADV)
breakBy   = input.string("Close", "Structure · A level is broken by", options = ["Close", "Wick"], group = G_ADV)
ptsMax    = 6
ptsInMax  = 10
showLvInt = input.bool(false, "Structure · Level lines at the open internal high and low", group = G_ADV)
plusAtr   = input.float(1.5, "Structure · BOS+ : the breaking candle is at least (x ATR)", minval = 0.5, step = 0.1, group = G_ADV)
msMax     = 30
storyLen  = 10
storyMax  = 6
storyTr   = 35
obLen     = input.int(4, "Order blocks · Swing length used to find order blocks", minval = 2, maxval = 50, group = G_ADV, tooltip = "Order blocks have their own swing length, separate from the internal and swing structure.")
obMit     = input.string("Close", "Order blocks · Order block is broken by", options = ["Close", "Wick", "Close past the middle"], group = G_ADV)
obBody    = input.bool(false, "Order blocks · Use candle body only", group = G_ADV)
obMid     = false
obOverlap = true
obMax     = input.int(3, "Order blocks · Blocks kept", minval = 1, maxval = 30, group = G_ADV)
obDispAtr = input.float(2.0, "Order blocks · Strong: the move away from the block is at least (x ATR)", minval = 0.5, maxval = 10.0, step = 0.25, group = G_ADV)
obNeedGap = input.bool(true, "Order blocks · Strong: the move left a fair value gap (displacement)", group = G_ADV)
obNeedVol = false
obNeedSwp = false
ifvgAlways = input.bool(false, "Gaps · Always show inverse gaps (IFVG)", group = G_ADV, tooltip = "An inverse gap is shown even without other confluence, and the focus keeps the nearest one above and below price on top of the other gaps and order blocks. Off = inverse gaps are filtered like every other zone.")
fvgThr    = input.float(0.25, "Gaps · Minimum size (x ATR)", minval = 0.0, step = 0.05, group = G_ADV)
fvgMit    = input.string("Close through", "Gaps · Gap is removed on", options = ["Full fill", "Half fill", "Close through"], group = G_ADV)
fvgMax    = input.int(4, "Gaps · Gaps kept", minval = 1, maxval = 30, group = G_ADV)
fvgExt    = 0
liqLen    = input.int(20, "Liquidity · Swing length", minval = 3, maxval = 200, group = G_ADV)
liqTol    = input.float(0.15, "Liquidity · Merge highs or lows closer than (x ATR)", minval = 0.0, step = 0.05, group = G_ADV)
liqMax    = input.int(3, "Liquidity · Zones kept", minval = 2, maxval = 40, group = G_ADV)
zoneThick = input.float(1.0, "Liquidity · Zone thickness at most (x ATR of its timeframe)", minval = 0.1, step = 0.1, group = G_ADV, tooltip = "A zone runs from the wick to the candle body, but never thicker than this. Also used for the higher-timeframe zones.")
liqKeep   = input.string("Delete", "Liquidity · When a zone is taken", options = ["Grey out", "Delete"], group = G_ADV)
grabLen   = 5
grabBox   = false
grabExt   = 3
grabMax   = 6
wickPad   = 0.04
grabGap   = 0.3
sweepBox  = false
sweepExt  = 4
liqFull   = true
liqBack   = 0
mergeZn   = true
eqLen     = 3
eqTol     = 0.2
mtfLen = input.int(5, "HTF liquidity · Swing length (bars of that timeframe)", minval = 2, maxval = 20, group = G_ADV)
mtfTol = input.float(0.25, "HTF liquidity · Merge highs or lows closer than (x ATR of that timeframe)", minval = 0.0, step = 0.05, group = G_ADV)
mtfMax = input.int(2, "HTF liquidity · Zones kept per timeframe", minval = 2, maxval = 20, group = G_ADV)
showOdds = input.bool(false, "Odds · Show up / down odds on the zone labels", group = G_ADV, tooltip = "Counted on the bars loaded on this chart. Each time a liquidity zone was taken, the script checks which came first: price moving the distance below back away from the zone edge, or the same distance further through it. The zone label shows how often price went up first and how often down first. These are past frequencies on a small sample, not win probabilities.")
oddsAtr  = 1.0
oddsBars = 48
oddsMin  = 10
pdPct   = input.float(10.0, "Premium / discount · Equilibrium band (thin bands: every band) in % of the range", minval = 1.0, maxval = 50.0, step = 1.0, group = G_ADV)
pdW     = 8
pdBars  = 0
pdDim   = 60
pdDimC  = 90
tagIn  = input.string("Soft", "Levels · Level labels", options = ["Soft", "Filled", "Plain text"], group = G_ADV, tooltip = "Soft = a lightly tinted label with coloured text. Filled = a solid label. Plain text = text only. Applies to all level tags at the right edge.")
lvMergeAtr = input.float(0.5, "Levels · Levels closer than this share one label (x ATR)", minval = 0.0, step = 0.05, group = G_ADV)
tagPad = 18
sessW    = 2
sessGap  = 0.5
sessKeep = 1
asStartIn = input.string("Tokyo open", "Sessions · Asia session starts at", options = ["Trading day open (18:00 New York)", "Tokyo open"], group = G_ADV, tooltip = "Trading day open = Asia starts when gold reopens after the daily break, 18:00 New York time (00:00 in Zurich), so the first hours of the day count. Tokyo open = Asia starts at the Tokyo open set further down (Session opens) (02:00 in Zurich in summer).")
nyEndH   = input.int(17, "Sessions · New York session ends at: hour (New York time)", minval = 10, maxval = 23, group = G_ADV, tooltip = "17:00 New York time is the end of the trading day for gold (23:00 in Zurich). The stock market closes at 16:00.")
nyEndM   = input.int(0, "Sessions · New York session ends at: minute", minval = 0, maxval = 59, group = G_ADV)
orbS     = input.session("0930-0945", "Sessions · Opening range (New York time)", group = G_ADV)
orbDayS  = input.session("0930-1600", "Sessions · Breaks are tracked during (New York time)", group = G_ADV)
opnMaxTf = 60
opnCol   = color.new(color.white, 40)
opnStyIn = "Dashed"
opnWidth = 1
opnTxtC  = color.white
opnSide  = "Right"
opnSzIn  = "Small"
opnKeep  = 6
tyoTxt   = "Asia"
tyoH     = 9
tyoM     = 0
lonTxt   = "London"
lonH     = 8
lonM     = 0
nycTxt   = "New York"
nycH     = 9
nycM     = 30
engMin   = input.float(0.0, "Engulfing · Body at least (x ATR, 0 = any size)", minval = 0.0, step = 0.1, group = G_ADV)
engGap   = 0.3
adrLen    = input.int(14, "Day · Average day: number of days", minval = 3, maxval = 60, group = G_ADV)
roundStep = input.float(50.0, "Day · Round numbers: step (price)", minval = 0.0001, group = G_ADV)
lbGap    = 4
txtGap   = 0.25
padBars  = input.int(0, "Display · Boxes end, and the buy / sell column starts, this many candles past the last candle", minval = 0, maxval = 100, group = G_ADV, tooltip = "Smaller = everything on the right (box ends, BUY / SELL ZONE, SL, TP, level tags, premium / discount) sits closer to the candles, so more of the chart shows price. Bigger = more room between the candles and the right side.")
leftBars = input.int(0, "Display · Zones are drawn back at most (bars, 0 = from their origin)", minval = 0, maxval = 5000, group = G_ADV, tooltip = "0 = every zone starts at the candle where it formed. A number keeps zones shorter. Premium / discount is not limited by this.")
drawBack = input.int(3000, "Speed · Marks are drawn on the last (candles)", minval = 300, maxval = 20000, step = 500, group = G_ADV, tooltip = "Swing names, BOS / CHoCH lines, engulfing arrows, sweep labels, EQH / EQL, the story line and session lines are only drawn on this many recent candles. Older ones would be deleted anyway (only the latest few are kept), so this saves calculation time without changing what you see. Zones, liquidity, structure and the % are still worked out on every candle. Raise it only if a mark you expect is missing.")
nearAtr  = input.float(10.0, "Display · Hide liquidity zones further from price than (x ATR, 0 = show all)", minval = 0.0, step = 1.0, group = G_ADV)

// ----------------------------------------------------------- shared values ---
float  atr14  = ta.atr(14)
// marks are only drawn on recent candles (saves time; older marks would be deleted anyway)
bool   drawNow = last_bar_index - bar_index <= drawBack
bool   intConf = intMode == "Only with confluence"
// confluence for a break: [0] = last candle that swept a low or traded in a support zone,
// [1] = the same for a high / resistance zone. A break up within 10 candles of [0] (or
// with a gap or a strong candle) has confluence; the same for a break down with [1].
var array<int> znHit = array.new<int>(2, -100000)
bool   cfUp = false
bool   cfDn = false
float  atr200 = ta.atr(200)
float  atrBig = na(atr200) ? atr14 : atr200
float  volAvg = ta.sma(volume, 20)
float  tGap   = txtGap * nz(atr14)
float  sGap   = sessGap * nz(atr14)
float  gGap   = grabGap * nz(atr14)
string szTxt  = txtIn == "Tiny" ? size.tiny : (txtIn == "Small" ? size.small : size.normal)
bool   wantBos   = msMode != "CHoCH only"
bool   wantChoch = msMode != "BOS only"
bool   byClose   = breakBy == "Close"
float  barRng    = high - low
bool   strongUp  = showPlus and barRng >= plusAtr * atr14 and close > open and close >= low + barRng * 0.6
int    tfMs      = timeframe.in_seconds() * 1000
bool   strongDn  = showPlus and barRng >= plusAtr * atr14 and close < open and close <= high - barRng * 0.6
bool   sessOver  = sessDrawIn != "Tag at the right edge"
bool   sessTag   = sessDrawIn != "Over the session"
bool   pdFull    = pdStyle == "Full halves"
// layout right of the last candle: zones up to padBars, then the premium /
// discount column, then the level tags
int    bsW       = 7
int    pdColL    = padBars + bsW + 1
int    pdColR    = pdColL + pdW
int    tagBars   = showPD ? math.max(tagPad, pdColR + 2) : tagPad
string opnLnSty  = opnStyIn == "Dotted" ? line.style_dotted : (opnStyIn == "Dashed" ? line.style_dashed : line.style_solid)
string opnSz     = opnSzIn == "Tiny" ? size.tiny : (opnSzIn == "Normal" ? size.normal : size.small)
// "label_right" puts the text on the left of the line, "label_left" on the right
string opnLbSty  = opnSide == "Left" ? label.style_label_right : label.style_label_left
// engulfing candles: the candle turns against the previous one and its body covers the previous body
float  engBody   = math.abs(close - open)
float  engSlack  = nz(atr14) * 0.05
bool   engBig    = engMin <= 0 or engBody >= engMin * nz(atr14)
bool   engWick   = engMode == "Close beyond the previous wick"
bool   engUp     = showEng and close > open and close[1] < open[1] and close > open[1] and open <= close[1] + engSlack and (not engWick or close > high[1]) and engBig
bool   engDn     = showEng and close < open and close[1] > open[1] and close < open[1] and open >= close[1] - engSlack and (not engWick or close < low[1]) and engBig

// ------------------------------------------------------------------ types ---
// state: 0 active, 1 flipped (breaker or inverse gap), 2 taken and greyed
type Zone
    box    bx
    float  top
    float  bot
    int    dir
    int    state
    int    hits
    string tag
    line   ml
    color  col
    string t1
    string t2
    int    t0
    bool   off = false
    int    tfs = 1
    int    pts = 0
    string txt = ""
    int    imp = 0
    int    knd = 0
    int    gid = -1
    int    fb  = na

// a liquidity zone that was just taken and is waiting for its outcome
type Pend
    float edge
    int   dir
    float dist
    int   bar0
    int   grp

var array<Zone>  obs       = array.new<Zone>()
var array<Zone>  fvgs      = array.new<Zone>()
var array<Zone>  liq       = array.new<Zone>()
var array<Zone>  mtf1      = array.new<Zone>()
var array<Zone>  mtf2      = array.new<Zone>()
var array<Zone>  mtf3      = array.new<Zone>()
var array<Zone>  mtf4      = array.new<Zone>()
var array<line>  swLines   = array.new<line>()
var array<label> swLabels  = array.new<label>()
var array<label> swPoints  = array.new<label>()
var array<line>  intLines  = array.new<line>()
var array<label> intLabels = array.new<label>()
var array<label> intPoints = array.new<label>()
var array<line>  obNoLines = array.new<line>()
var array<label> obNoLbs   = array.new<label>()
var array<line>  eqLines   = array.new<line>()
var array<label> eqLabels  = array.new<label>()
var array<label> orbLbs    = array.new<label>()
var array<line>  opnLines  = array.new<line>()
var array<box>   opnLbs    = array.new<box>()
var array<float> grabHiLv  = array.new<float>()
var array<float> grabLoLv  = array.new<float>()
var array<box>   grabBoxes = array.new<box>()
var array<label> grabLbs   = array.new<label>()
var array<label> engLbs    = array.new<label>()
var array<line>  grabLns   = array.new<line>()
var array<line>  lastLines = array.new<line>()
var array<label> lastLbs   = array.new<label>()
var array<box>   lastBoxes = array.new<box>()
var array<float> lvPx      = array.new<float>()
var array<label> lvLb      = array.new<label>()
var array<color> lvC       = array.new<color>()
// the times of the chart's candles, to turn a higher-timeframe time into a candle number
var array<int> barTimes = array.new<int>()
// premium / equilibrium / discount: made once, so they stay beneath every zone drawn later.
// Each zone has a part over the last candles (Bk) and its own column right of the zones (Bx).
var box pdPremBk = box.new(bar_index, high, bar_index, low, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_center, text_valign = text.align_center)
var box pdEqBk   = box.new(bar_index, high, bar_index, low, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_center, text_valign = text.align_center)
var box pdDiscBk = box.new(bar_index, high, bar_index, low, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_center, text_valign = text.align_center)
var box pdPremBx = box.new(bar_index, high, bar_index, low, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_center, text_valign = text.align_center, text_formatting = text.format_bold)
var box pdEqBx   = box.new(bar_index, high, bar_index, low, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_center, text_valign = text.align_center, text_formatting = text.format_bold)
var box pdDiscBx = box.new(bar_index, high, bar_index, low, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_center, text_valign = text.align_center, text_formatting = text.format_bold)
var line pdHiLn  = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), width = 1)
var line pdLoLn  = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), width = 1)
var line pdEqLn  = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dotted, width = 1)
// zone odds: index = group * 2 + side (group 0 this chart, 1 higher timeframes; side 0 highs, 1 lows)
var array<Pend>  pend      = array.new<Pend>()
var array<int>   stTot     = array.new<int>(4, 0)
var array<int>   stRev     = array.new<int>(4, 0)
var array<int>   stCont    = array.new<int>(4, 0)

// ---------------------------------------------------------------- helpers ---
f_keep_line(array<line> a, line ln, int maxN) =>
    array.push(a, ln)
    if array.size(a) > maxN
        line.delete(array.shift(a))
    true

f_keep_label(array<label> a, label lb, int maxN) =>
    array.push(a, lb)
    if array.size(a) > maxN
        label.delete(array.shift(a))
    true

// structure breaks: when the oldest line goes, its BOS / CHoCH name goes with it,
// so a name is never left on the chart without its line
f_keep_ms(array<line> lns, array<label> lbs, line ln, int maxN) =>
    array.push(lns, ln)
    if array.size(lns) > maxN
        line old = array.shift(lns)
        int xm = int((line.get_x1(old) + line.get_x2(old)) / 2)
        float ly = line.get_y1(old)
        if array.size(lbs) > 0
            for i = array.size(lbs) - 1 to 0
                label q = array.get(lbs, i)
                if label.get_x(q) == xm and math.abs(label.get_y(q) - ly) <= 3.0 * nz(atr14)
                    label.delete(q)
                    array.remove(lbs, i)
        line.delete(old)
    true

f_keep_box(array<box> a, box b, int maxN) =>
    array.push(a, b)
    if array.size(a) > maxN
        box.delete(array.shift(a))
    true

// Drawings are placed by candle number, not by time: a time in the future that
// falls on a weekend or the daily break has no candle, so everything placed
// there would be squeezed together. Candle numbers never squeeze.
// the candle number of the candle that contains time t
f_bar_of(int t) =>
    int n = array.size(barTimes)
    int r = bar_index
    if n > 0 and not na(t)
        int k = array.binary_search_leftmost(barTimes, t)
        k := math.max(0, math.min(k, n - 1))
        r := bar_index - (n - 1 - k)
    r

// a candle number that drawings can use (not more than 9900 candles back)
f_bx(int b) =>
    int r = na(b) ? bar_index : math.max(b, bar_index - 9900)
    r

// deletes the marks of a list that sit on one candle at one price, and takes
// them out of the list, so the list never holds deleted labels
f_drop_at(array<label> a, int bar, float px) =>
    if array.size(a) > 0
        for i = array.size(a) - 1 to 0
            label q = array.get(a, i)
            if label.get_x(q) == bar and label.get_y(q) == px
                label.delete(q)
                array.remove(a, i)
    true

// label room: a new label needs a free spot. Priorities: 5 swing HH / HL / LH / LL,
// 4 swing BOS / CHoCH, 3 grab names, 2 internal BOS / CHoCH, 1 internal points.
// A label of the same or a higher priority close by blocks the new one; labels
// of a lower priority in the way are removed.
f_lb_near(label q, int x, float y, int dx, float dy) =>
    bool r = math.abs(label.get_x(q) - x) <= dx and math.abs(label.get_y(q) - y) <= dy
    r

f_lb_busy(array<label> a, int x, float y, int dx, float dy) =>
    bool r = false
    if array.size(a) > 0
        for q in a
            if not r and f_lb_near(q, x, y, dx, dy)
                r := true
    r

f_lb_clear(array<label> a, int x, float y, int dx, float dy) =>
    if array.size(a) > 0
        for i = array.size(a) - 1 to 0
            label q = array.get(a, i)
            if f_lb_near(q, x, y, dx, dy)
                label.delete(q)
                array.remove(a, i)
    true

// removes grab texts in the way, together with their thin line
f_grab_clear(int x, float y, int dx, float dy) =>
    if array.size(grabLbs) > 0
        for i = array.size(grabLbs) - 1 to 0
            label q = array.get(grabLbs, i)
            if f_lb_near(q, x, y, dx, dy)
                if array.size(grabLns) > 0
                    for j = array.size(grabLns) - 1 to 0
                        line g = array.get(grabLns, j)
                        if line.get_x2(g) == label.get_x(q) and line.get_y2(g) == label.get_y(q)
                            line.delete(g)
                            array.remove(grabLns, j)
                label.delete(q)
                array.remove(grabLbs, i)
    true

f_room(int prio, int x, float y) =>
    bool ok = true
    if lbGap > 0
        int   dx = lbGap
        float dy = nz(atr14) * 1.2
        // the lists in order of importance: swing points (5), swing BOS / CHoCH (4), grab
        // names and internal BOS / CHoCH with confluence (both 3), internal points (1). A label
        // is only written when nothing of the same or higher importance is in the way ...
        for k = 0 to 4
            if ok and prio <= (k == 3 ? 3 : 5 - k)
                array<label> a = k == 0 ? swPoints : (k == 1 ? swLabels : (k == 2 ? grabLbs : (k == 3 ? intLabels : intPoints)))
                if f_lb_busy(a, x, y, dx, dy)
                    ok := false
        // ... and then it removes the less important ones in its way
        if ok
            for k = 1 to 4
                if prio > (k == 3 ? 3 : 5 - k)
                    if k == 2
                        f_grab_clear(x, y, dx, dy)
                    else
                        f_lb_clear(k == 1 ? swLabels : (k == 3 ? intLabels : intPoints), x, y, dx, dy)
    ok

// a zone price is inside right now: drawn brighter
f_inside_glow(array<Zone> a) =>
    if array.size(a) > 0
        for z in a
            if not z.off and z.state != 2
                float tp = box.get_top(z.bx)
                float bt = box.get_bottom(z.bx)
                if close <= tp and close >= bt
                    // brighter than even the strongest zone (70): this is where price is now
                    // (an inverse gap stays an outline only)
                    box.set_bgcolor(z.bx, color.new(z.col, z.tag == "IFVG" ? 100 : 66))
                    box.set_border_color(z.bx, color.new(z.col, 0))
    true

f_kill(Zone z) =>
    box.delete(z.bx)
    if not na(z.ml)
        line.delete(z.ml)
    true

// keeps at most maxN zones: taken (grey) zones go first, then the oldest
f_trim(array<Zone> a, int maxN) =>
    while array.size(a) > maxN and array.size(a) > 0
        int k = 0
        for i = 0 to array.size(a) - 1
            Zone q = array.get(a, i)
            if q.state == 2
                k := i
                break
        Zone gone = array.remove(a, k)
        f_kill(gone)
    array.size(a)

// active zones run to the right edge and start at most leftBars back
f_extend(array<Zone> a, int rt, int lt) =>
    if array.size(a) > 0
        for z in a
            if z.state != 2
                box.set_right(z.bx, rt)
                box.set_left(z.bx, f_bx(math.max(z.t0, lt)))
                if not na(z.ml)
                    line.set_x2(z.ml, rt)
                    line.set_x1(z.ml, f_bx(math.max(z.t0, lt)))
    true

// gaps start at their own candles and keep a fixed length, never past the right edge rt
f_gap_len(array<Zone> a, int n, int rt) =>
    if array.size(a) > 0
        for z in a
            if z.state != 2
                int l = f_bx(z.t0)
                // an inverse gap runs from its own candles to the candle that broke it, then
                // the same length again
                int e = n == 0 ? rt : (z.state == 1 and not na(z.fb) ? math.max(l + n, z.fb + n) : l + n)
                box.set_left(z.bx, l)
                box.set_right(z.bx, math.max(math.min(e, rt), l + 1))
    true

// hides liquidity zones far from price. Only liquidity zones: gaps and order
// blocks are styled by their own code, so they are skipped here even if passed in.
f_hide_far(array<Zone> a, float maxDist) =>
    if array.size(a) > 0 and maxDist > 0
        for z in a
            bool isLiq = z.tag != "FVG" and z.tag != "IFVG" and z.tag != "OB"
            if isLiq and z.state == 0
                float d = close > z.top ? close - z.top : (close < z.bot ? z.bot - close : 0.0)
                if d > maxDist
                    z.off := true
                    box.set_bgcolor(z.bx, color.new(z.col, 100))
                    box.set_border_color(z.bx, color.new(z.col, 100))
                    box.set_text(z.bx, "")
    true

// order blocks and breakers: look, and hidden when far from price (0 = never hidden)
f_style_obs(array<Zone> a, float maxDist) =>
    if array.size(a) > 0
        for z in a
            float d = close > z.top ? close - z.top : (close < z.bot ? z.bot - close : 0.0)
            bool far = maxDist > 0 and d > maxDist
            z.off := far
            box.set_text(z.bx, z.state == 1 ? "Breaker" : "OB")
            box.set_border_width(z.bx, 1)
            box.set_bgcolor(z.bx, color.new(z.col, far ? 100 : (z.state == 1 ? 88 : 92)))
            box.set_border_color(z.bx, color.new(z.col, far ? 100 : 45))
            box.set_text_color(z.bx, color.new(z.col, far ? 100 : 0))
            if not na(z.ml)
                line.set_color(z.ml, color.new(z.col, far ? 100 : 55))
    true

// gaps and inverse gaps: their look, set again on every update
f_style_fvgs(array<Zone> a) =>
    if array.size(a) > 0
        for z in a
            z.off := false
            box.set_border_width(z.bx, 1)
            box.set_bgcolor(z.bx, color.new(z.col, z.state == 1 ? 100 : 85))
            box.set_border_color(z.bx, color.new(z.col, 35))
            box.set_text(z.bx, z.state == 1 ? (z.dir == 1 ? "IFVG ▼ Resistance" : "IFVG ▲ Support") : (z.dir == 1 ? "FVG ▲ Support" : "FVG ▼ Resistance"))
            box.set_border_style(z.bx, z.state == 1 ? line.style_dashed : line.style_solid)
            box.set_text_color(z.bx, z.col)
            box.set_text_valign(z.bx, text.align_center)
    true

// true when the wick of this candle went through one of the levels and the close is
// back inside. Levels that were reached are removed. dir 1 = highs, -1 = lows.
f_grab(array<float> a, int dir) =>
    bool hit = false
    if array.size(a) > 0
        for i = array.size(a) - 1 to 0
            float lv = array.get(a, i)
            bool through = dir == 1 ? high > lv : low < lv
            if through
                bool back = dir == 1 ? close < lv : close > lv
                if back
                    hit := true
                array.remove(a, i)
    hit

// a fixed level (session or previous-day high / low) counts only once: the first
// candle that trades through it decides. If that candle opened and closed on the
// near side, only its wick went through: a grab. Either way the level is used up
// until it changes (a new day or a new session). na = no level right now.
f_once(float lv, int dir) =>
    var float last = na
    var bool  used = false
    if na(lv) or na(last) or lv != last
        last := lv
        used := false
    bool hit = false
    if not na(lv) and not used
        bool through = dir == 1 ? high > lv : low < lv
        if through
            used := true
            hit  := dir == 1 ? (close < lv and open < lv) : (close > lv and open > lv)
    hit

// 1 up, -1 down, 0 mixed or not enough data
f_trend(float px, float fast, float slow) =>
    int r = (na(px) or na(fast) or na(slow)) ? 0 : ((px > fast and fast > slow) ? 1 : ((px < fast and fast < slow) ? -1 : 0))
    r

// joins two pieces of text with " · ", leaving out empty ones
f_join(string a, string b) =>
    string r = b == "" ? a : (a == "" ? b : a + " · " + b)
    r

// adds a level name to a list of names when on is true
f_add_name(string s, bool on, string n) =>
    string r = on ? f_join(s, n) : s
    r

// text colour that stays readable on a filled label of colour c
f_ink(color c) =>
    float lum = 0.299 * color.r(c) + 0.587 * color.g(c) + 0.114 * color.b(c)
    color r = lum > 190 ? #1a1a1a : color.white
    r

// text colour that stays readable on a zone of colour c drawn with transparency tr on the chart background
f_ink_on(color c, int tr) =>
    float a  = (100 - tr) / 100.0
    color b  = chart.bg_color
    float rr = color.r(b) + a * (color.r(c) - color.r(b))
    float gg = color.g(b) + a * (color.g(c) - color.g(b))
    float bb = color.b(b) + a * (color.b(c) - color.b(b))
    float lum = 0.299 * rr + 0.587 * gg + 0.114 * bb
    color r = lum > 125 ? #1a1a1a : color.white
    r

// places one premium / equilibrium / discount box
f_pd_box(box b, int lt, float top, int rt, float bot, color c, int tr, string txt) =>
    box.set_lefttop(b, lt, top)
    box.set_rightbottom(b, rt, bot)
    box.set_bgcolor(b, color.new(c, tr))
    // a border only on the column, not on the long background part
    box.set_border_color(b, color.new(c, tr <= 85 ? math.max(tr - 30, 0) : 100))
    box.set_text(b, txt)
    box.set_text_color(b, f_ink_on(c, tr))
    true

f_pd_hide(box b) =>
    box.set_bgcolor(b, color.new(color.gray, 100))
    box.set_border_color(b, color.new(color.gray, 100))
    box.set_text(b, "")
    true

// high, low and start time of the latest session of one kind. The high and low
// are also drawn as two lines over the session itself, with the name in plain
// text just above the high and just below the low.
// inS = this candle is in the session, fresh = it is the first candle of a new one.
f_session(bool inS, bool fresh, string name, color sc) =>
    var float hi = na
    var float lo = na
    var int   t0 = na
    var line  hiLn = na
    var line  loLn = na
    var label hiLb = na
    var label loLb = na
    // a small arrow on the candle that made the session high and the one that made its low
    var int   hiAt = na
    var int   loAt = na
    var label hiAr = na
    var label loAr = na
    var array<line>  lns = array.new<line>()
    var array<label> lbs = array.new<label>()
    bool draw  = showSess and sessOver and drawNow
    if fresh
        hi   := high
        lo   := low
        t0   := time
        hiAt := time
        loAt := time
    else if inS
        if high > hi
            hiAt := time
        if low < lo
            loAt := time
        hi := math.max(hi, high)
        lo := math.min(lo, low)
    if fresh and draw
        hiLn := line.new(time, high, time + tfMs, high, xloc = xloc.bar_time, color = sc, style = line.style_solid, width = sessW)
        loLn := line.new(time, low, time + tfMs, low, xloc = xloc.bar_time, color = sc, style = line.style_solid, width = sessW)
        f_keep_line(lns, hiLn, sessKeep * 2)
        f_keep_line(lns, loLn, sessKeep * 2)
        hiAr := label.new(time, high, "▼", xloc = xloc.bar_time, yloc = yloc.price, style = label.style_label_down, color = color.new(sc, 100), textcolor = sc, size = size.tiny)
        loAr := label.new(time, low, "▲", xloc = xloc.bar_time, yloc = yloc.price, style = label.style_label_up, color = color.new(sc, 100), textcolor = sc, size = size.tiny)
        f_keep_label(lbs, hiAr, sessKeep * (sessTag ? 2 : 4))
        f_keep_label(lbs, loAr, sessKeep * (sessTag ? 2 : 4))
        // the name over the session only when it is not already written at the right edge
        if not sessTag
            hiLb := label.new(time, high + sGap, name + " High", xloc = xloc.bar_time, yloc = yloc.price, style = label.style_label_down, color = color.new(sc, 100), textcolor = sc, size = szTxt, text_formatting = text.format_bold)
            loLb := label.new(time, low - sGap, name + " Low", xloc = xloc.bar_time, yloc = yloc.price, style = label.style_label_up, color = color.new(sc, 100), textcolor = sc, size = szTxt, text_formatting = text.format_bold)
            f_keep_label(lbs, hiLb, sessKeep * (sessTag ? 2 : 4))
            f_keep_label(lbs, loLb, sessKeep * (sessTag ? 2 : 4))
    if inS and draw and not na(hiLn)
        // the lines run from the first candle of the session: Asia and London up to the next
        // session's line (one candle on), New York to its last candle (the end of the day)
        int endT = name == "NY" ? time : time + tfMs
        int midT = t0 + int((time + tfMs - t0) / (2 * tfMs)) * tfMs
        line.set_xy1(hiLn, t0, hi)
        line.set_xy2(hiLn, endT, hi)
        line.set_xy1(loLn, t0, lo)
        line.set_xy2(loLn, endT, lo)
        // the arrows move to the candle that holds the high / low so far
        label.set_xy(hiAr, hiAt, hi)
        label.set_xy(loAr, loAt, lo)
        if not sessTag
            label.set_xy(hiLb, midT, hi + sGap)
            label.set_xy(loLb, midT, lo - sGap)
    [hi, lo, t0]

// true on the candle whose start is nearest to a session open. Some feeds start
// candles at :02, :17, :32, :47, so no candle starts exactly on the open; this
// picks the closest one (09:02 for a 09:00 open) instead of the candle before.
f_near_open(int h, int m, string tz) =>
    int half = timeframe.in_seconds() * 500
    int tA = time - half
    int tB = time + half
    int oA = timestamp(tz, year(tA, tz), month(tA, tz), dayofmonth(tA, tz), h, m, 0)
    int oB = timestamp(tz, year(tB, tz), month(tB, tz), dayofmonth(tB, tz), h, m, 0)
    bool r = (oA > tA and oA <= tB) or (oB > tA and oB <= tB)
    r

// where the next session line will be for a session whose line is at t0: Asia ends at the
// London line, London at the New York line, New York at the end of the day (17:00 New York)
f_sess_end(int t0, int k) =>
    string tz = k == 1 ? "Europe/London" : "America/New_York"
    int    h  = k == 1 ? lonH : (k == 2 ? nycH : nyEndH)
    int    m  = k == 1 ? lonM : (k == 2 ? nycM : nyEndM)
    int    e  = timestamp(tz, year(t0, tz), month(t0, tz), dayofmonth(t0, tz), h, m, 0)
    e := e <= t0 ? e + 86400000 : e
    t0 + int(math.ceil((e - t0 - tfMs / 2.0) / tfMs)) * tfMs

// a session line, and the session name written in an invisible box that runs exactly from
// this line to the next one, so the name is always in the middle of its session (also
// when the session has an odd number of candles). Asia white, London blue, New York gold.
f_open_mark(string txt, int kind) =>
    f_keep_line(opnLines, line.new(time, close, time, close + syminfo.mintick, xloc = xloc.bar_time, extend = extend.both, color = color.new(opnCol, math.max(color.t(opnCol), lnFade)), style = opnLnSty, width = opnWidth), opnKeep)
    color tc = kind == 1 ? cAsia : (kind == 2 ? cLon : cNy)
    f_keep_box(opnLbs, box.new(time, high + nz(atr14) * 0.5, f_sess_end(time, kind), high, xloc = xloc.bar_time, border_color = color.new(color.black, 100), bgcolor = color.new(color.black, 100), text = txt, text_size = opnSz, text_color = tc, text_halign = text.align_center, text_valign = text.align_center), opnKeep)
    true

f_zone_box(int t0, float top, float bot, color c, int fillT, string txt) =>
    box.new(f_bx(t0), top, bar_index, bot, xloc = xloc.bar_index, border_color = color.new(c, 35), border_width = 1, bgcolor = color.new(c, fillT), text = txt, text_size = szTxt, text_color = color.new(c, 0), text_halign = text.align_right, text_valign = text.align_center)

// remembers the candle when price traded in a zone of the list: in a support zone
// (bullish block or gap, flipped bearish one, liquidity below) in znHit[0], in a
// resistance zone in znHit[1]
f_zn_hit(array<Zone> a, bool isLiq) =>
    for z in a
        if z.state != 2 and low <= z.top and high >= z.bot
            array.set(znHit, (isLiq or z.state == 1 ? -z.dir : z.dir) == 1 ? 0 : 1, bar_index)
    true

f_tf_name(simple string tf) =>
    int s = timeframe.in_seconds(tf)
    string r = s >= 2419200 ? "M" : (s >= 604800 ? "W" : (s >= 86400 ? "D" : (s >= 3600 ? str.tostring(s / 3600) + "H" : str.tostring(s / 60) + "m")))
    r

// event codes: 1 BOS, 2 CHoCH, 3 CHoCH+, 4 BOS+ (negative = bearish)
f_ev_name(int e) =>
    int a = math.abs(e)
    string r = a == 1 ? "BOS" : (a == 2 ? "CHoCH" : (a == 3 ? "CHoCH+" : "BOS+"))
    r

// ------------------------------------------------------- market structure ---
// One call per level (swing, internal, order blocks). Each call keeps its own
// state. pts: 0 no swing point marks, 1 labels (HH, HL, LH, LL), 2 triangles.
// Returns: trend, event (1 BOS, 2 CHoCH, 3 CHoCH+, 4 BOS+, negative = bearish),
// an order block candidate (top, bottom, time), the last swing high and low,
// whether a new swing high or low was confirmed on this bar, and for the last
// swing high and low: its time, whether it is already broken, its name
// (HH, LH, HL, LL) and what a break of it would be called.
// dup: swing point marks of the other level; a mark of that list on the same
// candle is removed, so two names never sit on top of each other.
// bold: swing point names in bold (swing level) or thin and faded (internal).
// keepN: how many swing point marks are kept.
f_structure(int len, bool draw, int pts, float avoidHi, float avoidLo, string lnStyle, string lbSize, array<line> lns, array<label> lbs, array<label> ptl, array<label> dup, bool bold, int keepN) =>
    var int   trend  = 0
    var int   leg    = 0
    var float hiP    = na
    var float hiPrev = na
    var int   hiBar  = na
    var bool  hiDone = true
    var int   hiT    = na
    var string hiName = ""
    var float loP    = na
    var float loPrev = na
    var int   loBar  = na
    var bool  loDone = true
    var int   loT    = na
    var string loName = ""
    float hiAfter = ta.highest(high, len)
    float loAfter = ta.lowest(low, len)
    int   prevLeg = leg
    if high[len] > hiAfter
        leg := -1
    else if low[len] < loAfter
        leg := 1
    bool newHi = leg == -1 and prevLeg != -1
    bool newLo = leg == 1 and prevLeg != 1
    if newHi
        hiPrev := hiP
        hiP    := high[len]
        hiBar  := bar_index - len
        hiT    := time[len]
        hiDone := false
        bool higher = na(hiPrev) or hiP > hiPrev
        hiName := higher ? "HH" : "LH"
        if pts > 0
            f_drop_at(dup, hiBar, hiP)
        if pts == 1 and f_room(bold ? 5 : 1, hiBar, hiP)
            // an engulfing mark sits above this candle: the name moves one line up
            string hiTxt = hiName + (engDn[len] ? "\n" : "")
            color  hiCol = color.new(higher ? cBull : cBear, bold ? 0 : 45)
            if bold
                f_keep_label(ptl, label.new(hiBar, hiP, hiTxt, xloc = xloc.bar_index, style = label.style_label_down, color = color.new(cGrey, 100), textcolor = hiCol, size = lbSize, text_formatting = text.format_bold), keepN)
            else
                f_keep_label(ptl, label.new(hiBar, hiP, hiTxt, xloc = xloc.bar_index, style = label.style_label_down, color = color.new(cGrey, 100), textcolor = hiCol, size = lbSize), keepN)
        if pts == 2
            f_keep_label(ptl, label.new(hiBar, hiP, "", xloc = xloc.bar_index, yloc = yloc.abovebar, style = label.style_triangledown, color = higher ? cBull : cBear, size = size.tiny, tooltip = higher ? "HH" : "LH"), keepN)
    if newLo
        loPrev := loP
        loP    := low[len]
        loBar  := bar_index - len
        loT    := time[len]
        loDone := false
        bool lower = na(loPrev) or loP < loPrev
        loName := lower ? "LL" : "HL"
        if pts > 0
            f_drop_at(dup, loBar, loP)
        if pts == 1 and f_room(bold ? 5 : 1, loBar, loP)
            // an engulfing mark sits below this candle: the name moves one line down
            string loTxt = (engUp[len] ? "\n" : "") + loName
            color  loCol = color.new(lower ? cBear : cBull, bold ? 0 : 45)
            if bold
                f_keep_label(ptl, label.new(loBar, loP, loTxt, xloc = xloc.bar_index, style = label.style_label_up, color = color.new(cGrey, 100), textcolor = loCol, size = lbSize, text_formatting = text.format_bold), keepN)
            else
                f_keep_label(ptl, label.new(loBar, loP, loTxt, xloc = xloc.bar_index, style = label.style_label_up, color = color.new(cGrey, 100), textcolor = loCol, size = lbSize), keepN)
        if pts == 2
            f_keep_label(ptl, label.new(loBar, loP, "", xloc = xloc.bar_index, yloc = yloc.belowbar, style = label.style_triangleup, color = lower ? cBear : cBull, size = size.tiny, tooltip = lower ? "LL" : "HL"), keepN)
    int   ev    = 0
    float obTop = na
    float obBot = na
    int   obT   = na
    float upSrc = byClose ? close : high
    float dnSrc = byClose ? close : low
    if not na(hiP) and not hiDone and upSrc > hiP
        hiDone := true
        bool chochUp = trend == -1
        bool plusUp  = chochUp and not na(loPrev) and loP > loPrev
        ev    := chochUp ? (plusUp ? 3 : 2) : (strongUp ? 4 : 1)
        trend := 1
        bool wantUp = chochUp ? wantChoch : wantBos
        if draw and wantUp and (bold or not intConf or cfUp) and (na(avoidHi) or hiP != avoidHi)
            int x1u = math.max(hiBar, bar_index - 4500)
            f_keep_ms(lns, lbs, line.new(x1u, hiP, bar_index, hiP, xloc = xloc.bar_index, color = cBull, style = lnStyle, width = bold and chochUp ? 2 : 1), msMax)
            int xmu = int((x1u + bar_index) / 2)
            if true
                if bold
                    f_keep_label(lbs, label.new(xmu, hiP + tGap, chochUp ? (plusUp ? "CHoCH+" : "CHoCH") : (strongUp ? "BOS+" : "BOS"), xloc = xloc.bar_index, style = label.style_label_down, color = color.new(cGrey, 100), textcolor = cBull, size = lbSize, text_formatting = text.format_bold), msMax * 2)
                else
                    f_keep_label(lbs, label.new(xmu, hiP + tGap, chochUp ? (plusUp ? "CHoCH+" : "CHoCH") : (strongUp ? "BOS+" : "BOS"), xloc = xloc.bar_index, style = label.style_label_down, color = color.new(cGrey, 100), textcolor = cBull, size = size.small), msMax * 2)
        // order block candidate: the candle with the lowest low since the broken high
        int nUp = math.min(bar_index - hiBar, 1000)
        if nUp >= 1
            float bestLo = na
            int   idxLo  = na
            for i = 1 to nUp
                if (high[i] - low[i]) <= 2.0 * atrBig
                    if na(bestLo) or low[i] < bestLo
                        bestLo := low[i]
                        idxLo  := i
            if not na(idxLo)
                obBot := obBody ? math.min(open[idxLo], close[idxLo]) : low[idxLo]
                obTop := obBody ? math.max(open[idxLo], close[idxLo]) : high[idxLo]
                obT   := bar_index - idxLo
    if not na(loP) and not loDone and dnSrc < loP
        loDone := true
        bool chochDn = trend == 1
        bool plusDn  = chochDn and not na(hiPrev) and hiP < hiPrev
        ev    := chochDn ? (plusDn ? -3 : -2) : (strongDn ? -4 : -1)
        trend := -1
        bool wantDn = chochDn ? wantChoch : wantBos
        if draw and wantDn and (bold or not intConf or cfDn) and (na(avoidLo) or loP != avoidLo)
            int x1d = math.max(loBar, bar_index - 4500)
            f_keep_ms(lns, lbs, line.new(x1d, loP, bar_index, loP, xloc = xloc.bar_index, color = cBear, style = lnStyle, width = bold and chochDn ? 2 : 1), msMax)
            int xmd = int((x1d + bar_index) / 2)
            if true
                if bold
                    f_keep_label(lbs, label.new(xmd, loP - tGap, chochDn ? (plusDn ? "CHoCH+" : "CHoCH") : (strongDn ? "BOS+" : "BOS"), xloc = xloc.bar_index, style = label.style_label_up, color = color.new(cGrey, 100), textcolor = cBear, size = lbSize, text_formatting = text.format_bold), msMax * 2)
                else
                    f_keep_label(lbs, label.new(xmd, loP - tGap, chochDn ? (plusDn ? "CHoCH+" : "CHoCH") : (strongDn ? "BOS+" : "BOS"), xloc = xloc.bar_index, style = label.style_label_up, color = color.new(cGrey, 100), textcolor = cBear, size = size.small), msMax * 2)
        // order block candidate: the candle with the highest high since the broken low
        int nDn = math.min(bar_index - loBar, 1000)
        if nDn >= 1
            float bestHi = na
            int   idxHi  = na
            for i = 1 to nDn
                if (high[i] - low[i]) <= 2.0 * atrBig
                    if na(bestHi) or high[i] > bestHi
                        bestHi := high[i]
                        idxHi  := i
            if not na(idxHi)
                obBot := obBody ? math.min(open[idxHi], close[idxHi]) : low[idxHi]
                obTop := obBody ? math.max(open[idxHi], close[idxHi]) : high[idxHi]
                obT   := bar_index - idxHi
    // what a break of the open high or low would be called
    string upName = trend == -1 ? ((not na(loPrev) and loP > loPrev) ? "CHoCH+" : "CHoCH") : "BOS"
    string dnName = trend == 1 ? ((not na(hiPrev) and hiP < hiPrev) ? "CHoCH+" : "CHoCH") : "BOS"
    [trend, ev, obTop, obBot, obT, hiP, loP, newHi, newLo, hiT, hiDone, hiName, upName, loT, loDone, loName, dnName]

// ---------------------------------------------------------- order blocks ----
// true when the move from a block to the break was strong enough to count.
// obBar = candle number of the block, dir = 1 bullish, -1 bearish.
f_ob_strong(float top, float bot, int obBar, int dir) =>
    int k = math.min(bar_index - obBar, 300)
    // 1. size: from the block to the close that broke structure
    float move = dir == 1 ? close - bot : top - close
    bool ok = move >= obDispAtr * nz(atr14)
    // 2. displacement: a fair value gap between the block and now
    if ok and obNeedGap
        bool gap = false
        if k >= 2
            for i = 0 to k - 2
                if not gap
                    gap := dir == 1 ? low[i] > high[i + 2] : high[i] < low[i + 2]
        ok := gap
    // 3. volume: one candle of the move traded well above the average
    if ok and obNeedVol
        bool loud = false
        if k >= 1
            for i = 0 to k - 1
                if not loud
                    loud := volume[i] > 1.5 * nz(volAvg[i])
        ok := loud
    // 4. liquidity: the block ran the extreme of the 20 candles before it
    if ok and obNeedSwp
        float ext = na
        for j = k + 1 to k + 20
            ext := dir == 1 ? (na(ext) ? low[j] : math.min(ext, low[j])) : (na(ext) ? high[j] : math.max(ext, high[j]))
        ok := not na(ext) and (dir == 1 ? low[k] < ext : high[k] > ext)
    ok

f_add_ob(float top, float bot, int t0, int dir, string tag) =>
    if obOverlap and array.size(obs) > 0
        for i = array.size(obs) - 1 to 0
            Zone z = array.get(obs, i)
            if z.state == 0 and z.top >= bot and z.bot <= top
                f_kill(z)
                array.remove(obs, i)
    color c = dir == 1 ? cBull : cBear
    float m = (top + bot) / 2.0
    line  midLn = obMid ? line.new(f_bx(t0), m, bar_index, m, xloc = xloc.bar_index, color = color.new(c, 45), style = line.style_dashed, width = 1) : na
    array.push(obs, Zone.new(f_zone_box(t0, top, bot, c, 88, tag), top, bot, dir, 0, 1, tag, midLn, c, "", "", t0))
    f_trim(obs, obMax)
    true

f_update_obs() =>
    int broke = 0
    if array.size(obs) > 0
        for i = array.size(obs) - 1 to 0
            Zone z = array.get(obs, i)
            float mid = (z.top + z.bot) / 2.0
            if z.state == 0
                bool hitUp = obMit == "Close" ? close > z.top : (obMit == "Wick" ? high > z.top : close > mid)
                bool hitDn = obMit == "Close" ? close < z.bot : (obMit == "Wick" ? low < z.bot : close < mid)
                bool hit   = z.dir == 1 ? hitDn : hitUp
                if hit
                    broke := z.dir
                    if showBrk
                        z.state := 1
                        box.set_bgcolor(z.bx, color.new(z.dir == 1 ? cBull : cBear, 85))
                        box.set_text(z.bx, "Breaker")
                    else
                        f_kill(z)
                        array.remove(obs, i)
            else
                // a breaker is removed once price closes back through its far side
                bool dead = z.dir == 1 ? close > z.top : close < z.bot
                if dead
                    f_kill(z)
                    array.remove(obs, i)
    broke

// -------------------------------------------------------- fair value gaps ---
// Returns 1 when a bearish gap flipped into a bullish inverse gap (support) on
// this candle, -1 when a bullish gap flipped into a bearish one (resistance).
// z.dir keeps the side of the original gap, so the far side stays known.
f_update_fvgs() =>
    int flipped = 0
    if array.size(fvgs) > 0
        for i = array.size(fvgs) - 1 to 0
            Zone z = array.get(fvgs, i)
            float mid = (z.top + z.bot) / 2.0
            if z.state == 0
                bool through = z.dir == 1 ? close < z.bot : close > z.top
                bool filled  = z.dir == 1 ? low <= z.bot : high >= z.top
                bool half    = z.dir == 1 ? low <= mid : high >= mid
                bool gone    = fvgMit == "Close through" ? through : (fvgMit == "Half fill" ? half : filled)
                if through and showIFVG
                    // the gap flips: it takes the colour of the other side
                    color ic = z.dir == 1 ? cFvgDn : cFvgUp
                    z.state := 1
                    z.tag   := "IFVG"
                    z.fb    := bar_index
                    z.col   := ic
                    box.set_bgcolor(z.bx, color.new(ic, 88))
                    box.set_border_color(z.bx, color.new(ic, 35))
                    box.set_border_style(z.bx, line.style_dashed)
                    box.set_text(z.bx, z.dir == 1 ? "IFVG ▼ Resistance" : "IFVG ▲ Support")
                    box.set_text_color(z.bx, ic)
                    // without the right-edge option the box restarts its length from the flip
                    if fvgExt > 0
                        box.set_right(z.bx, bar_index + fvgExt)
                    flipped := z.dir == 1 ? -1 : 1
                else if gone
                    f_kill(z)
                    array.remove(fvgs, i)
            else
                // an inverse gap is removed once price closes back through it
                bool dead = z.dir == 1 ? close > z.top : close < z.bot
                if dead
                    f_kill(z)
                    array.remove(fvgs, i)
    flipped

// -------------------------------------------------------- liquidity zones ---
// dir 1 = zone at a swing high, dir -1 = zone at a swing low
f_add_liq(array<Zone> a, float px, float body, int t0, int dir, float tol, color c, string tag, int maxN) =>
    bool merged = false
    if array.size(a) > 0
        for i = array.size(a) - 1 to 0
            Zone z = array.get(a, i)
            if not merged and z.state == 0 and z.dir == dir
                float edge = dir == 1 ? z.top : z.bot
                if math.abs(px - edge) <= tol
                    merged := true
                    if dir == 1
                        z.top := math.max(z.top, px)
                    else
                        z.bot := math.min(z.bot, px)
                    z.hits := z.hits + 1
                    box.set_top(z.bx, z.top)
                    box.set_bottom(z.bx, z.bot)
                    box.set_text(z.bx, tag + " x" + str.tostring(z.hits))
    if not merged
        float top = dir == 1 ? px : body
        float bot = dir == 1 ? body : px
        array.push(a, Zone.new(f_zone_box(t0, top, bot, c, 90, tag), top, bot, dir, 0, 1, tag, na, c, tag, "", t0))
        f_trim(a, maxN)
    merged

// a zone is taken when price trades through its outer edge; if the candle
// closes back inside, that is a sweep. Returns 0 none, 1 a high was swept,
// 2 a low was swept, 3 both. grp: 0 this chart, 1 higher timeframes.
f_update_liq(array<Zone> a, int grp) =>
    int swept = 0
    if array.size(a) > 0
        for i = array.size(a) - 1 to 0
            Zone z = array.get(a, i)
            if z.state == 0
                bool pierced = z.dir == 1 ? high > z.top : low < z.bot
                if pierced
                    bool back = z.dir == 1 ? close <= z.top : close >= z.bot
                    if back
                        swept := z.dir == 1 ? (swept >= 2 ? 3 : 1) : ((swept == 1 or swept == 3) ? 3 : 2)
                    // remember it, to count later what price did next
                    array.push(pend, Pend.new(z.dir == 1 ? z.top : z.bot, z.dir, oddsAtr * atr14, bar_index, grp))
                    if array.size(pend) > 60
                        array.shift(pend)
                    if liqKeep == "Grey out"
                        z.state := 2
                        box.set_top(z.bx, z.top)
                        box.set_bottom(z.bx, z.bot)
                        box.set_right(z.bx, bar_index)
                        box.set_text(z.bx, z.tag)
                        box.set_bgcolor(z.bx, color.new(cGrey, 93))
                        box.set_border_color(z.bx, color.new(cGrey, 55))
                        box.set_border_style(z.bx, line.style_dotted)
                        box.set_text_color(z.bx, color.new(cGrey, 30))
                    else
                        f_kill(z)
                        array.remove(a, i)
    swept

// counts what price did after a zone was taken: went on through it, or came back
f_resolve() =>
    if array.size(pend) > 0
        for i = array.size(pend) - 1 to 0
            Pend q = array.get(pend, i)
            if bar_index > q.bar0 and not na(q.dist)
                bool cont = q.dir == 1 ? high >= q.edge + q.dist : low <= q.edge - q.dist
                bool rev  = q.dir == 1 ? low <= q.edge - q.dist : high >= q.edge + q.dist
                bool old  = (bar_index - q.bar0) >= oddsBars
                if cont or rev or old
                    int k = q.grp * 2 + (q.dir == 1 ? 0 : 1)
                    array.set(stTot, k, array.get(stTot, k) + 1)
                    if rev and not cont
                        array.set(stRev, k, array.get(stRev, k) + 1)
                    if cont and not rev
                        array.set(stCont, k, array.get(stCont, k) + 1)
                    array.remove(pend, i)
    true

// share of past cases in which price went up first / down first, for one bucket
f_up_pct(int k) =>
    int n = array.get(stTot, k)
    int up = k % 2 == 0 ? array.get(stCont, k) : array.get(stRev, k)
    int r = n > 0 ? math.round(100.0 * up / n) : 0
    r

f_dn_pct(int k) =>
    int n = array.get(stTot, k)
    int dn = k % 2 == 0 ? array.get(stRev, k) : array.get(stCont, k)
    int r = n > 0 ? math.round(100.0 * dn / n) : 0
    r

// liquidity size: one point for the timeframe of the zone
f_tf_weight(string tag) =>
    int r = tag == "Liq" ? 1 : (tag == "M" ? 5 : (tag == "W" ? 4 : (tag == "D" ? 3 : 2)))
    r

// puts every active zone back to its own size, colour and label
f_reset(array<Zone> a, int grp) =>
    if array.size(a) > 0
        for z in a
            if z.state == 0
                int k = grp * 2 + (z.dir == 1 ? 0 : 1)
                z.off := false
                z.tfs := 1
                box.set_border_width(z.bx, 1)
                box.set_text_color(z.bx, z.col)
                z.t1 := z.tag + (z.hits > 1 ? " x" + str.tostring(z.hits) : "")
                z.t2 := (showOdds and array.get(stTot, k) >= oddsMin) ? "  ▲" + str.tostring(f_up_pct(k)) + "% ▼" + str.tostring(f_dn_pct(k)) + "%" : ""
                box.set_top(z.bx, z.top)
                box.set_bottom(z.bx, z.bot)
                box.set_bgcolor(z.bx, color.new(z.col, 92))
                box.set_border_color(z.bx, color.new(z.col, 40))
                z.pts := f_tf_weight(z.tag) + math.min(z.hits - 1, 2)
                z.txt := z.t1 + z.t2
                box.set_text(z.bx, z.txt)
    true

f_collect(array<Zone> all, array<Zone> a) =>
    if array.size(a) > 0
        for z in a
            if z.state == 0
                array.push(all, z)
    true

// zones on the same side that overlap in price are drawn as one. The list is
// in order of importance: the first zone of a group keeps its colour.
f_merge(array<Zone> all) =>
    int n = array.size(all)
    if n > 1
        array<bool> hid = array.new<bool>(n, false)
        for i = 0 to n - 2
            if not array.get(hid, i)
                Zone zi = array.get(all, i)
                float tp = zi.top
                float bt = zi.bot
                string names = ""
                int    best  = zi.pts
                int    extra = 0
                for turn = 1 to 2
                    for j = i + 1 to n - 1
                        if not array.get(hid, j)
                            Zone zj = array.get(all, j)
                            if zj.dir == zi.dir and zj.top >= bt and zj.bot <= tp
                                tp := math.max(tp, zj.top)
                                bt := math.min(bt, zj.bot)
                                names := names + " + " + zj.t1
                                array.set(hid, j, true)
                                zj.off := true
                                zi.tfs := zi.tfs + 1
                                best  := math.max(best, zj.pts)
                                extra += 1
                                box.set_bgcolor(zj.bx, color.new(zj.col, 100))
                                box.set_border_color(zj.bx, color.new(zj.col, 100))
                                box.set_text(zj.bx, "")
                if names != ""
                    box.set_top(zi.bx, tp)
                    box.set_bottom(zi.bx, bt)
                    box.set_bgcolor(zi.bx, color.new(zi.col, 88))
                    zi.pts := best + extra
                    zi.txt := zi.t1 + names + zi.t2
                    box.set_text(zi.bx, zi.txt)
    true

// writes the size in dollars in front of the zone's own text
f_dollars(array<Zone> a) =>
    if liqUsd and array.size(a) > 0
        for z in a
            if z.state == 0 and not z.off
                int n = math.max(1, math.min(z.pts, 5))
                box.set_text(z.bx, str.repeat("$", n) + "  " + (z.dir == 1 ? "BSL · " : "SSL · ") + z.txt)
    true

// ------------------------------------------------------------- confluence ---
// true when a shown zone of the list overlaps the price range bt..tp
f_hit(array<Zone> a, float tp, float bt, float tol) =>
    bool r = false
    if array.size(a) > 0
        for q in a
            if not r and not q.off and q.state != 2
                float qt = box.get_top(q.bx)
                float qb = box.get_bottom(q.bx)
                if qt >= bt - tol and qb <= tp + tol
                    r := true
    r

// true when a key level lies inside the price range bt..tp
f_lv_hit(array<float> lv, float tp, float bt, float tol) =>
    bool r = false
    if array.size(lv) > 0
        for p in lv
            if not r and not na(p) and p <= tp + tol and p >= bt - tol
                r := true
    r

// how many different kinds of thing meet in one zone. kind: 0 order block,
// 1 gap, 2 liquidity zone. The zone counts itself; a liquidity zone made of
// several timeframes counts one extra.
f_score(int kind, float tp, float bt, int tfs, float tol, array<float> lv) =>
    int s = 1
    if kind != 0 and f_hit(obs, tp, bt, tol)
        s += 1
    if kind != 1 and f_hit(fvgs, tp, bt, tol)
        s += 1
    if kind != 2 and (f_hit(liq, tp, bt, tol) or f_hit(mtf1, tp, bt, tol) or f_hit(mtf2, tp, bt, tol) or f_hit(mtf3, tp, bt, tol) or f_hit(mtf4, tp, bt, tol))
        s += 1
    if confLv and f_lv_hit(lv, tp, bt, tol)
        s += 1
    if tfs > 1
        s += 1
    s

// the scores of every zone of a list (all scores first, so hiding one zone
// never changes the score of another)
f_scores(array<Zone> a, int kind, float tol, array<float> lv) =>
    array<int> sc = array.new<int>()
    if array.size(a) > 0
        for z in a
            array.push(sc, f_score(kind, box.get_top(z.bx), box.get_bottom(z.bx), z.tfs, tol, lv))
    sc

// importance 1 (least) to 5 (most): the more important, the stronger the
// fill, the border and the text
f_imp_style(Zone z, int imp) =>
    int i = math.max(1, math.min(imp, 5))
    // importance 1 to 5: fill 90 → 70 transparent, border 64 → 0
    box.set_bgcolor(z.bx, color.new(z.col, 95 - i * 5))
    box.set_border_color(z.bx, color.new(z.col, math.max(80 - i * 16, 0)))
    box.set_border_width(z.bx, i >= 5 ? 2 : 1)
    box.set_text_color(z.bx, color.new(z.col, i >= 3 ? 0 : 35))
    // an inverse gap is drawn as a dashed outline only, so where it overlaps a normal
    // (filled) gap you still see both
    if z.tag == "IFVG"
        box.set_bgcolor(z.bx, color.new(z.col, 100))
        box.set_border_color(z.bx, color.new(z.col, 15))
    else if z.tag == "FVG"
        box.set_bgcolor(z.bx, color.new(z.col, 90 - i * 6))
    true

// zones are drawn by importance: for order blocks and gaps that is the
// confluence count, for liquidity the larger of the confluence count and its
// size in dollars. Zones without enough confluence are hidden or faint.
f_conf_apply(array<Zone> a, array<int> sc, bool isLiq) =>
    if array.size(a) > 0 and array.size(sc) == array.size(a)
        for i = 0 to array.size(a) - 1
            Zone z = array.get(a, i)
            if not z.off and z.state != 2
                int s   = array.get(sc, i)
                bool inv = not isLiq and z.tag == "IFVG" and ifvgAlways
                // every gap is shown when asked for, whatever its confluence
                bool isGap = not isLiq and (z.tag == "FVG" or z.tag == "IFVG")
                bool gap = isGap and (fvgAll or (z.top - z.bot) >= fvgSig * nz(atr14))
                int imp = isLiq ? math.max(s, math.max(1, math.min(z.pts, 5))) : (inv ? math.max(s, 3) : s)
                // a liquidity zone of real size ($$ and more: higher timeframe, several hits or
                // several timeframes) is shown even without other confluence
                bool big = isLiq and z.pts >= liqMinUsd
                z.imp := imp
                if gap or big or ((s >= confMin or confMode == "All" or inv) and imp >= minImp)
                    f_imp_style(z, imp)
                else if confMode == "Only confluence" or (imp < minImp and not gap and not big)
                    z.off := true
                    box.set_bgcolor(z.bx, color.new(z.col, 100))
                    box.set_border_color(z.bx, color.new(z.col, 100))
                    box.set_text(z.bx, "")
                    if not na(z.ml)
                        line.set_color(z.ml, color.new(z.col, 100))
                else if confMode == "Highlight confluence"
                    box.set_bgcolor(z.bx, color.new(z.col, 96))
                    box.set_border_color(z.bx, color.new(z.col, 85))
                    box.set_text_color(z.bx, color.new(z.col, 70))
    true

// ------------------------------------------------------- buy / sell zone ---
// adds the active zones of one list, with their strength and kind (0 order
// block, 1 gap, 2 liquidity), to one combined list
// true when an active higher-timeframe liquidity zone overlaps the range tp..bt
f_htf_in(array<Zone> a, float tp, float bt) =>
    bool r = false
    if array.size(a) > 0
        for q in a
            if not r and q.state == 0 and q.top >= bt and q.bot <= tp
                r := true
    r

f_bs_add(array<Zone> zs, array<int> ss, array<int> ks, array<bool> hs, array<Zone> a, array<int> sc, int kind) =>
    if array.size(a) > 0 and array.size(sc) == array.size(a)
        for i = 0 to array.size(a) - 1
            Zone z = array.get(a, i)
            if z.state != 2
                int s = array.get(sc, i)
                array.push(zs, z)
                array.push(ss, kind == 2 ? math.max(s, math.max(1, math.min(z.pts, 5))) : (z.tag == "IFVG" ? math.max(s, 3) : s))
                array.push(ks, kind)
                // a higher-timeframe zone, or one lies on it
                array.push(hs, (kind == 2 and z.tag != "Liq") or f_htf_in(mtf1, z.top, z.bot) or f_htf_in(mtf2, z.top, z.bot) or f_htf_in(mtf3, z.top, z.bot) or f_htf_in(mtf4, z.top, z.bot))
    true

// the buy zone (side 1, support below price) or the sell zone (side -1, resistance above),
// in three steps: 1) the strongest strong zone (higher timeframe only, if set), 2) if none:
// the best liquidity zone of any timeframe, marked weak, 3) if still none: the nearest zone
// of any kind at any distance, marked weak, so a side is never empty. Returns [zone, weak].
f_bs_pick(array<Zone> zs, array<int> ss, array<int> ks, array<bool> hs, int side, float eq, float lim) =>
    Zone best = na
    int  pass = 0
    for p = 0 to 2
        if na(best) and (p == 0 or bsWeak) and array.size(zs) > 0
            int   bSc = -1
            float bD  = na
            for i = 0 to array.size(zs) - 1
                Zone  z  = array.get(zs, i)
                int   k  = array.get(ks, i)
                float tp = box.get_top(z.bx)
                float bt = box.get_bottom(z.bx)
                // which way the zone works: blocks and gaps by their side (flipped once
                // broken), liquidity by where it lies
                int   works  = k == 2 ? (bt < close ? 1 : -1) : (z.state == 1 ? -z.dir : z.dir)
                bool  onSide = side == 1 ? close >= bt : close <= tp
                float d      = side == 1 ? math.max(close - tp, 0.0) : math.max(bt - close, 0.0)
                bool  okKind = p == 0 ? (array.get(hs, i) or not bsHtf) : (p == 1 ? k == 2 : true)
                if okKind and works == side and onSide and d <= (p == 2 ? 1e12 : lim)
                    int sc = array.get(ss, i) + (not na(eq) and (side == 1 ? tp <= eq : bt >= eq) ? 1 : 0)
                    bool better = p == 2 ? (na(bD) or d < bD) : (sc > bSc or (sc == bSc and d < bD))
                    if sc >= (p == 0 ? minImp : (p == 1 ? 1 : -1)) and better
                        best := z
                        bSc  := sc
                        bD   := d
            if not na(best)
                pass := p
    [best, pass > 0]

// draws (or hides) one framed zone with its stop loss line
// candle number of the last candle (before this one) that traded inside hi..lo,
// at most 5 candles back from now, so a line never starts further back than needed
f_touch(float hi, float lo) =>
    int r = bar_index - 5
    if not na(hi) and not na(lo)
        for i = 1 to math.min(1500, bar_index)
            if high[i] >= lo and low[i] <= hi
                r := math.min(bar_index - i, bar_index - 5)
                break
    r

// entry of a zone: its middle, or its near edge (top of a buy zone, bottom of a sell zone)
f_entry(float tp, float bt, int side) =>
    float r = entryIn == "Middle of the zone" ? (tp + bt) / 2.0 : (side == 1 ? tp : bt)
    r

// stop loss: slMult x the zone height past the zone's far edge (below a buy zone,
// above a sell zone)
f_sl_raw(float tp, float bt, int side) =>
    float r = (side == 1 ? bt : tp) - side * slMult * (tp - bt)
    r

// the round number step for one zone: set by hand, or automatic = the roundest number
// (100, 50, 10, 5, 1 ...) that moves the stop out by no more than a quarter of the risk
// (risk = zone edge to stop), so the stop sits on a round number without growing much
f_rstep(float tp, float bt, int side) =>
    float r = rndStep
    if r <= 0
        float h    = math.max(tp - bt, syminfo.mintick)
        float risk = (1.0 + slMult) * h
        float raw  = f_sl_raw(tp, bt, side)
        float top  = math.pow(10, math.floor(math.log10(risk)))
        r := syminfo.mintick
        bool found = false
        for k = 0 to 12
            if not found
                float st = k % 2 == 0 ? top / math.pow(10, k / 2) : top / (2.0 * math.pow(10, (k - 1) / 2))
                if st >= syminfo.mintick
                    float slr = side == 1 ? math.floor(raw / st + 1e-9) * st : math.ceil(raw / st - 1e-9) * st
                    if math.abs(slr - raw) <= 0.25 * risk
                        r := st
                        found := true
    math.max(r, syminfo.mintick)

// the trade of one zone, worked out once: [stop loss, fixed take profit, its reward to risk].
// Stop: slMult x the zone height past the far edge, moved out to the next round number.
// Fixed TP: minRR x the stop distance (far edge to stop) past the near edge, on the
// nearest round number. Reward to risk counted the same way, from the zone edges.
f_trade(float tp, float bt, int side) =>
    float sl  = na
    float tg  = na
    float rr  = na
    if not na(tp) and not na(bt)
        float far = side == 1 ? bt : tp
        float nr  = side == 1 ? tp : bt
        float st  = rndOn ? f_rstep(tp, bt, side) : 0.0
        sl := f_sl_raw(tp, bt, side)
        if rndOn
            sl := side == 1 ? math.floor(sl / st + 1e-9) * st : math.ceil(sl / st - 1e-9) * st
        tg := nr + side * minRR * math.abs(far - sl)
        if rndOn
            tg := math.round(tg / st) * st
        rr := math.abs(tg - nr) / math.max(math.abs(far - sl), syminfo.mintick)
    [sl, tg, rr]

// a price as text: whole numbers without decimals
f_px(float p) =>
    string r = p == math.round(p) ? str.tostring(p, "#") : str.tostring(p, format.mintick)
    r

// the stop loss line and its text, as wide as the column, the text in its middle
f_sl_draw(line ln, label lb, float sl, int x1, int x2, string sd) =>
    if na(sl)
        line.set_color(ln, color.new(cStop, 100))
        label.set_text(lb, "")
        label.set_textcolor(lb, color.new(cStop, 100))
    else
        line.set_xy1(ln, x1, sl)
        line.set_xy2(ln, x2, sl)
        line.set_color(ln, color.new(cStop, 10))
        label.set_xy(lb, int((x1 + x2) / 2), sl)
        label.set_style(lb, label.style_label_center)
        label.set_color(lb, color.new(cStop, 100))
        label.set_text(lb, "SL " + f_px(sl) + " (" + sd + ")")
        label.set_textcolor(lb, cStop)
    true

f_bs_show(box b, line ln, label lb, float tp, float bt, int side, int x1, int x2, string txt) =>
    color c = side == 1 ? cBuy : cSell
    if na(tp) or na(bt)
        box.set_bgcolor(b, color.new(c, 100))
        box.set_border_color(b, color.new(c, 100))
        box.set_text(b, "")
    else
        box.set_lefttop(b, x1, tp)
        box.set_rightbottom(b, x2, bt)
        box.set_bgcolor(b, color.new(c, 72))
        box.set_border_color(b, color.new(c, 0))
        box.set_border_width(b, 2)
        box.set_text(b, txt)
        box.set_text_color(b, c)
        box.set_text_halign(b, text.align_center)
        box.set_text_valign(b, text.align_center)
    true

// ------------------------------------------------------------------ focus ---
// hides one zone (box, text and middle line)
f_zone_hide(Zone z) =>
    z.off := true
    box.set_bgcolor(z.bx, color.new(z.col, 100))
    box.set_border_color(z.bx, color.new(z.col, 100))
    box.set_text(z.bx, "")
    if not na(z.ml)
        line.set_color(z.ml, color.new(z.col, 100))
    true

// adds the zones of a list that are drawn right now
f_collect_shown(array<Zone> all, array<Zone> a) =>
    if array.size(a) > 0
        for z in a
            if not z.off and z.state != 2
                array.push(all, z)
    true

// the same, split by kind: inv = true takes only inverse gaps, false skips them
f_collect_inv(array<Zone> all, array<Zone> a, bool inv) =>
    if array.size(a) > 0
        for z in a
            if not z.off and z.state != 2 and (z.tag == "IFVG") == inv
                array.push(all, z)
    true

// keeps the n nearest zones of one side, hides the rest
f_focus_side(array<Zone> zs, array<float> ds, int n) =>
    if array.size(zs) > n
        array<int> ord = array.sort_indices(ds, order.ascending)
        for k = n to array.size(ord) - 1
            f_zone_hide(array.get(zs, array.get(ord, k)))
    true

// of the zones drawn right now: the ones price is inside stay, plus the n
// nearest above and the n nearest below price
f_focus_zones(array<Zone> all, int n) =>
    array<Zone>  zUp = array.new<Zone>()
    array<float> dUp = array.new<float>()
    array<Zone>  zDn = array.new<Zone>()
    array<float> dDn = array.new<float>()
    if array.size(all) > 0
        for z in all
            float tp = box.get_top(z.bx)
            float bt = box.get_bottom(z.bx)
            if bt > close
                array.push(zUp, z)
                array.push(dUp, bt - close)
            else if tp < close
                array.push(zDn, z)
                array.push(dDn, close - tp)
    f_focus_side(zUp, dUp, n)
    f_focus_side(zDn, dDn, n)
    true

// --------------------------------------------- zones on one price = one box ---
// the text a zone shows
f_zname(Zone z) =>
    string r = ""
    if z.knd == 0
        r := z.state == 1 ? "Breaker" : "OB"
    else if z.knd == 1
        r := z.state == 1 ? (z.dir == 1 ? "IFVG ▼\nRes." : "IFVG ▲\nSup.") : (z.dir == 1 ? "FVG ▲\nSup." : "FVG ▼\nRes.")
    else
        r := (liqUsd ? str.repeat("$", math.max(1, math.min(z.pts, 5))) + "  " : "") + (z.dir == 1 ? "BSL · " : "SSL · ") + z.txt
    r

// remembers the kind of every zone of a list and adds the ones drawn now
f_mcollect(array<Zone> all, array<Zone> a, int kind) =>
    if array.size(a) > 0
        for z in a
            z.knd := kind
            z.gid := -1
            if not z.off and z.state != 2
                array.push(all, z)
    true

// zones drawn now that overlap (in price and in time) become one box with one
// text: "$$$ 4H + Liq  +  OB  +  FVG ▲ Support". The strongest zone gives the
// colour, every extra zone makes the box one step brighter.
// short name of a zone for its outline inside a combined box
f_zshort(Zone z) =>
    string r = z.knd == 0 ? (z.state == 1 ? "BRK" : "OB") : (z.knd == 1 ? (z.state == 1 ? "IFVG" : "FVG") : z.tag)
    r

// the text of a combined box: liquidity of one side is written once ("$$$$$ SSL · W + Liq"
// instead of "$$$$$ SSL · W + Liq" and "$ SSL · Liq" on two rows), with the biggest $ and
// every timeframe once; blocks and gaps follow, each name once
f_comb_names(array<Zone> mem) =>
    array<string> parts = array.new<string>()
    for sd in array.from(1, -1)
        int mx = 0
        array<string> tk = array.new<string>()
        for m in mem
            if m.knd == 2 and m.dir == sd
                mx := math.max(mx, math.max(1, math.min(m.pts, 5)))
                for t in str.split(m.txt, " + ")
                    string tt = str.trim(t)
                    if tt != "" and not array.includes(tk, tt)
                        array.push(tk, tt)
        if mx > 0
            // this chart's own liquidity goes last
            int li = array.indexof(tk, "Liq")
            if li >= 0 and array.size(tk) > 1
                array.remove(tk, li)
                array.push(tk, "Liq")
            array.push(parts, (liqUsd ? str.repeat("$", mx) + "  " : "") + (sd == 1 ? "BSL · " : "SSL · ") + array.join(tk, " + "))
    for m in mem
        if m.knd != 2
            string nm = f_zname(m)
            if not array.includes(parts, nm)
                array.push(parts, nm)
    array.join(parts, "\n")

f_combine(array<Zone> mZ, array<float> gTop, array<float> gBot, array<int> gLf, array<box> gBox, array<string> gTxt, int rEdge) =>
    int n = array.size(mZ)
    if n > 1
        array<float> key = array.new<float>()
        for z in mZ
            array.push(key, -z.imp)
        array<int>  ord  = array.sort_indices(key, order.ascending)
        array<bool> used = array.new<bool>(n, false)
        for oi = 0 to n - 1
            int i = array.get(ord, oi)
            if not array.get(used, i)
                array.set(used, i, true)
                Zone   zi    = array.get(mZ, i)
                float  tp    = box.get_top(zi.bx)
                float  bt    = box.get_bottom(zi.bx)
                int    lf    = box.get_left(zi.bx)
                int    rt    = box.get_right(zi.bx)
                array<string> parts = array.new<string>()
                array.push(parts, f_zname(zi))
                array<Zone> mem = array.new<Zone>()
                array.push(mem, zi)
                for turn = 1 to 2
                    for oj = 0 to n - 1
                        int j = array.get(ord, oj)
                        if not array.get(used, j)
                            Zone  zj = array.get(mZ, j)
                            float tj = box.get_top(zj.bx)
                            float bj = box.get_bottom(zj.bx)
                            if tj >= bt and bj <= tp and box.get_left(zj.bx) <= rt and box.get_right(zj.bx) >= lf
                                tp := math.max(tp, tj)
                                bt := math.min(bt, bj)
                                lf := math.min(lf, box.get_left(zj.bx))
                                rt := math.max(rt, box.get_right(zj.bx))
                                array.push(parts, f_zname(zj))
                                array.set(used, j, true)
                                array.push(mem, zj)
                // one name per row: the text stacks at the right end, centred, instead of running left
                string names = array.size(mem) > 1 ? f_comb_names(mem) : array.join(parts, "\n")
                if array.size(mem) > 1
                    // a combined zone runs to the common right edge, in line with all other boxes
                    rt := math.max(rt, rEdge)
                    int  g      = array.size(gTop)
                    int  imp    = math.max(1, math.min(zi.imp + array.size(mem) - 1, 5))
                    bool inside = close <= tp and close >= bt
                    box  b      = box.new(lf, tp, rt, bt, xloc = xloc.bar_index, border_color = color.new(zi.col, inside ? 0 : math.max(80 - imp * 16, 0)), border_width = imp >= 5 ? 2 : 1, bgcolor = color.new(zi.col, inside ? 66 : 95 - imp * 5), text = names, text_size = szTxt, text_color = zi.col, text_halign = text.align_right, text_valign = text.align_center)
                    array.push(lastBoxes, b)
                    array.push(gTop, tp)
                    array.push(gBot, bt)
                    array.push(gLf, lf)
                    array.push(gBox, b)
                    array.push(gTxt, names)
                    for m in mem
                        m.gid := g
                        // where each zone lies inside the combined box: a thin outline with its short name
                        if innerIn == "All" or (innerIn == "Gaps only" and m.knd == 1)
                            // its own band: a light fill and a thin border at its exact prices (where two
                            // overlap the fill is darker), its short name at the left end
                            array.push(lastBoxes, box.new(box.get_left(m.bx), box.get_top(m.bx), rt, box.get_bottom(m.bx), xloc = xloc.bar_index, border_color = color.new(m.col, 40), border_width = 1, border_style = m.state == 1 ? line.style_dashed : line.style_solid, bgcolor = color.new(m.col, 90), text = f_zshort(m), text_size = size.tiny, text_color = color.new(m.col, 0), text_halign = text.align_left, text_valign = text.align_center))
                        f_zone_hide(m)
    true

// every gap keeps its own name in its own box. Where two names would sit on top of
// each other (middles closer than 0.8 ATR), the higher gap writes its name at the top
// of its box and the lower one at the bottom of its box, so each stays readable
// a gap that was broken became an IFVG; where a normal gap working the same way
// (both support or both resistance) lies on the same prices, only the IFVG is drawn
f_gap_dedupe(array<Zone> gz) =>
    int n = array.size(gz)
    if n > 1
        for i = 0 to n - 1
            Zone zi = array.get(gz, i)
            if zi.state == 1 and not zi.off
                int wi = -zi.dir
                for j = 0 to n - 1
                    Zone zj = array.get(gz, j)
                    if j != i and zj.state == 0 and not zj.off and zj.dir == wi and zj.top >= zi.bot and zj.bot <= zi.top
                        f_zone_hide(zj)
    true

f_gap_texts(array<Zone> gz, int colX) =>
    int n = array.size(gz)
    if n > 0
        // where each name goes: 0 middle of its box, 1 top, -1 bottom (when names would touch)
        array<int>   pos  = array.new<int>(n, 0)
        array<float> mids = array.new<float>()
        for z in gz
            array.push(mids, (box.get_top(z.bx) + box.get_bottom(z.bx)) / 2.0)
        if n > 1
            array<int> ord = array.sort_indices(mids, order.ascending)
            int c0 = 0
            for k = 1 to n
                bool brk = k == n
                if not brk
                    brk := array.get(mids, array.get(ord, k)) - array.get(mids, array.get(ord, k - 1)) >= 0.8 * nz(atr14)
                if brk
                    if k - c0 >= 2
                        array.set(pos, array.get(ord, c0), -1)
                        array.set(pos, array.get(ord, k - 1), 1)
                    c0 := k
        // every name inside its own box, at its right end
        for i = 0 to n - 1
            Zone z = array.get(gz, i)
            int  p = array.get(pos, i)
            // always short, on two rows: "FVG ▼" over "Res."
            box.set_text(z.bx, f_zname(z))
            box.set_text_halign(z.bx, text.align_right)
            box.set_text_valign(z.bx, p == 1 ? text.align_top : (p == -1 ? text.align_bottom : text.align_center))
    true

// when no liquidity zone is drawn on one side of price, the nearest one there is
// shown anyway, so there is always liquidity above and below
f_liq_side(int side, array<Zone> l0, array<Zone> l1, array<Zone> l2, array<Zone> l3, array<Zone> l4) =>
    array<Zone> all = array.new<Zone>()
    for z in l0
        array.push(all, z)
    for z in l1
        array.push(all, z)
    for z in l2
        array.push(all, z)
    for z in l3
        array.push(all, z)
    for z in l4
        array.push(all, z)
    bool have = false
    Zone best = na
    float bd = na
    for z in all
        if z.state == 0
            bool onSide = side == 1 ? z.bot > close : z.top < close
            if onSide
                if not z.off
                    have := true
                float d = side == 1 ? z.bot - close : close - z.top
                if na(bd) or d < bd
                    bd := d
                    best := z
    if not have and not na(best)
        best.off := false
        best.knd := 2
        f_imp_style(best, math.max(best.imp, 2))
        box.set_text(best.bx, f_zname(best))
    true

// the zone of list a that is drawn on the chart and overlaps zone z the most (or cur).
// Used when the buy / sell zone itself is not drawn (hidden by focus or merged into
// another box): the frame then takes the size of the box you actually see.
f_cover(array<Zone> a, Zone z, Zone cur) =>
    Zone  r  = cur
    float zt = box.get_top(z.bx)
    float zb = box.get_bottom(z.bx)
    float rb = na(cur) ? 0.0 : math.min(box.get_top(cur.bx), zt) - math.max(box.get_bottom(cur.bx), zb)
    for q in a
        if (not q.off or q.gid >= 0) and q.state != 2
            float ov = math.min(box.get_top(q.bx), zt) - math.max(box.get_bottom(q.bx), zb)
            if ov > rb
                r  := q
                rb := ov
    r

// the buy / sell zone as drawn: the zone itself when it is on the chart, otherwise the
// drawn box that overlaps it most
f_shown(Zone z) =>
    Zone r = z
    if not na(z) and z.off and z.gid < 0
        Zone c = na
        c := f_cover(liq, z, c)
        c := f_cover(mtf1, z, c)
        c := f_cover(mtf2, z, c)
        c := f_cover(mtf3, z, c)
        c := f_cover(mtf4, z, c)
        c := f_cover(obs, z, c)
        c := f_cover(fvgs, z, c)
        if not na(c)
            r := c
    r

// the buy / sell frame around its zone (or around the combined box it is in),
// with BUY ZONE / SELL ZONE written in front of that box's own text
f_bs_frame(box b, line ln, label lb, Zone z, int side, array<float> gTop, array<float> gBot, array<int> gLf, array<box> gBox, array<string> gTxt, int rt) =>
    float rTop = na
    float rBot = na
    int   rLf  = bar_index - 2
    string rNm = ""
    box    rBx = na
    bool   rVis = false
    if na(z)
        f_bs_show(b, ln, lb, float(na), float(na), side, bar_index, bar_index, "")
    else
        string tag = side == 1 ? "BUY ZONE" : "SELL ZONE"
        float  tp  = box.get_top(z.bx)
        float  bt  = box.get_bottom(z.bx)
        string nm  = f_zname(z)
        box   zb  = z.bx
        bool  vis = not z.off and z.knd != 1
        if z.gid >= 0
            tp  := array.get(gTop, z.gid)
            bt  := array.get(gBot, z.gid)
            nm  := array.get(gTxt, z.gid)
            zb  := array.get(gBox, z.gid)
            vis := true
        // the frame is the zone you trade: from the last candle that traded in it to the right edge,
        // with its name and what it is made of written once, at its right end
        // only the last part, like the premium / discount column: from just after the last
        // candle to the right edge
        int fx = rt
        f_bs_show(b, ln, lb, tp, bt, side, fx, rt + bsW, "")
        rTop := tp
        rBot := bt
        rLf  := fx
        rNm  := nm
        rBx  := zb
        rVis := vis
    [rTop, rBot, rLf, rNm, rBx, rVis]

// the take profit line of one side, with the reward to risk from the zone edge
// (entry = near edge of the zone, risk = entry to the SL line)
f_bs_tp(line ln, label lb, float tgt, float entry, float sl, int x1, int x2, string sd, float rrFix = na) =>
    if not na(tgt) and not na(entry)
        float rr = not na(rrFix) ? rrFix : math.abs(tgt - entry) / math.max(math.abs(entry - sl), syminfo.mintick)
        line.set_xy1(ln, x1, tgt)
        line.set_xy2(ln, x2, tgt)
        line.set_color(ln, color.new(cTp, 10))
        label.set_xy(lb, int((x1 + x2) / 2), tgt)
        label.set_style(lb, label.style_label_center)
        label.set_color(lb, color.new(cTp, 100))
        label.set_text(lb, "TP " + f_px(tgt) + " · 1:" + str.tostring(rr, "#.#") + " (" + sd + ")")
        label.set_textcolor(lb, cTp)
    else
        line.set_color(ln, color.new(cTp, 100))
        label.set_text(lb, "")
        label.set_textcolor(lb, color.new(cTp, 100))
    true

// the entry line of one side, in the colour of its frame. noTp = no target pays minRR
f_bs_entry(line ln, label lb, box fr, box zb, bool zvis, string nm, float px, float tp, float bt, int side, int x1, int x2, bool noTp, bool weak = false, string swTxt = "", string evid = "", int pct = 50) =>
    color c = side == 1 ? cBuy : cSell
    if showBS and not na(px)
        line.set_xy1(ln, f_touch(px, px), px)
        line.set_xy2(ln, x1, px)
        // no entry line (it ran through the zones): the zone and its column say enough
        line.set_color(ln, color.new(c, 100))
        string entTxt = (side == 1 ? "Buy " : "Sell ") + str.tostring(px, format.mintick)
        // the zone keeps only what it is made of
        if zvis and not na(zb)
            box.set_text(zb, nm)
        // the column: its top price, which side, its bottom price
        box.set_text(fr, (side == 1 ? "BUY ZONE" : "SELL ZONE") + (evid != "" ? "\n" + evid : ""))
        // stronger zone = stronger colour, weaker zone = paler colour
        box.set_bgcolor(fr, color.new(c, int(92 - pct * 0.4)))
        box.set_border_color(fr, color.new(c, int(60 - pct * 0.6)))
        // its top and bottom, led to the price scale by two faint dashed lines
        array.push(lastLines, line.new(x2, tp, x2 + 1, tp, xloc = xloc.bar_index, extend = extend.right, color = color.new(c, 80), style = line.style_dashed, width = 1))
        array.push(lastLines, line.new(x2, bt, x2 + 1, bt, xloc = xloc.bar_index, extend = extend.right, color = color.new(c, 80), style = line.style_dashed, width = 1))
        // no separate entry / range text: the column shows the zone's prices
        label.set_xy(lb, int((x1 + x2) / 2), side == 1 ? bt : tp)
        label.set_style(lb, side == 1 ? label.style_label_up : label.style_label_down)
        label.set_color(lb, color.new(c, 100))
        label.set_text(lb, noTp ? "no 1:" + str.tostring(minRR, "#.#") + " target" : "")
        label.set_textcolor(lb, c)
    else
        line.set_color(ln, color.new(c, 100))
        label.set_text(lb, "")
        label.set_textcolor(lb, color.new(c, 100))
    true

// two labels at the right edge that sit too close: the second one's text joins the first
// two labels on (almost) the same price: one label with two rows (the higher price on top),
// placed half way between their two lines
f_lb_pair(label a, label b) =>
    string ta = label.get_text(a)
    string tb = label.get_text(b)
    float  ya = label.get_y(a)
    float  yb = label.get_y(b)
    if ta != "" and tb != "" and math.abs(ya - yb) < 1.0 * nz(atr14)
        label.set_text(a, ya >= yb ? ta + "\n" + tb : tb + "\n" + ta)
        label.set_y(a, (ya + yb) / 2.0)
        label.set_text(b, "")
    true

// target prices on one side: the near edge of every drawn liquidity zone
f_tg_add(array<float> c, array<Zone> a, int side) =>
    if array.size(a) > 0
        for z in a
            if not z.off and z.state == 0
                array.push(c, side == 1 ? z.bot : z.top)
    true

f_tg_push(array<float> c, float p) =>
    if not na(p)
        array.push(c, p)
    true

// the nearest target that pays at least minRR (moved tpBuf in front of it)
// wall = the near edge of the opposite strong zone: a target beyond it does not count
f_pick_tp(array<float> c, float entry, float sl, int side, float wall) =>
    float best = na
    if not na(entry) and not na(sl) and array.size(c) > 0
        float risk = math.max(math.abs(entry - sl), syminfo.mintick)
        float lim  = na(wall) ? na : wall - side * tpBuf * nz(atr14)
        for p in c
            float t = p - side * tpBuf * nz(atr14)
            bool  blocked = not na(lim) and (side == 1 ? t > lim : t < lim)
            if (side == 1 ? t > entry : t < entry) and not blocked
                if math.abs(t - entry) / risk >= minRR and (na(best) or math.abs(t - entry) < math.abs(best - entry))
                    best := t
    best

// a level tag waiting to be drawn
type Lvl
    float  px
    string name
    int    t0
    string st
    color  c
    bool   pin = false

f_lv(array<Lvl> a, float px, string name, int t0, string st, color c) =>
    if not na(px)
        array.push(a, Lvl.new(px, name, t0, st, c))
    true

// a key level: drawn always while price has not traded through it (swept = false),
// and not drawn at all once it is swept
f_lvk(array<Lvl> a, float px, string name, int t0, string st, color c, bool swept) =>
    if not na(px) and not swept
        array.push(a, Lvl.new(px, name, t0, st, c, true))
    true

// marks the n nearest levels of one side to keep
f_keep_near(array<bool> keep, array<int> ii, array<float> dd, int n) =>
    if array.size(ii) > n
        array<int> ord = array.sort_indices(dd, order.ascending)
        for k = n to array.size(ord) - 1
            array.set(keep, array.get(ii, array.get(ord, k)), false)
    true

// which level tags to draw: all of them, or with focus only the n nearest
// above and the n nearest below price
f_focus_levels(array<Lvl> a, bool on, int n) =>
    array<bool> keep = array.new<bool>(array.size(a), true)
    if on and array.size(a) > 0
        array<int>   iUp = array.new<int>()
        array<float> dUp = array.new<float>()
        array<int>   iDn = array.new<int>()
        array<float> dDn = array.new<float>()
        for i = 0 to array.size(a) - 1
            Lvl l = array.get(a, i)
            if l.pin
                continue
            if l.px >= close
                array.push(iUp, i)
                array.push(dUp, l.px - close)
            else
                array.push(iDn, i)
                array.push(dDn, close - l.px)
        f_keep_near(keep, iUp, dUp, n)
        f_keep_near(keep, iDn, dDn, n)
    keep

// zones from another timeframe: confirmed swing points of closed bars only
// A higher-timeframe zone made precise on this chart: of the candles of this chart
// inside that higher-timeframe candle (t0b = its first, n = how many), the one with
// the extreme wick is found, and the zone ends at the first body there (its own
// and its two neighbours'). fb = the edge to use when the candles are too far back.
f_refine(float px, int t0b, int dir, int n, float fb) =>
    float r  = fb
    int   s0 = bar_index - t0b
    if s0 >= 1 and s0 <= 1900
        int   e0 = math.max(s0 - n + 1, 1)
        int   kb = -1
        float ex = na
        for k = s0 to e0
            float v = dir == 1 ? high[k] : low[k]
            if na(ex) or (dir == 1 ? v > ex : v < ex)
                ex := v
                kb := k
        if kb >= 1
            float b0 = dir == 1 ? math.max(open[kb], close[kb]) : math.min(open[kb], close[kb])
            float b1 = dir == 1 ? math.max(open[kb + 1], close[kb + 1]) : math.min(open[kb + 1], close[kb + 1])
            float b2 = dir == 1 ? math.max(open[kb - 1], close[kb - 1]) : math.min(open[kb - 1], close[kb - 1])
            float bb = dir == 1 ? math.max(b0, b1, b2) : math.min(b0, b1, b2)
            if dir == 1 ? bb < px : bb > px
                r := bb
    r

f_mtf(bool on, simple string tf, color c, array<Zone> a) =>
    [ph, pb, pl, lb, pt, ha] = request.security(syminfo.tickerid, tf, [ta.pivothigh(high, mtfLen, mtfLen)[1], math.max(math.max(open, close)[mtfLen], math.max(open, close)[mtfLen + 1], math.max(open, close)[mtfLen + 2]), ta.pivotlow(low, mtfLen, mtfLen)[1], math.min(math.min(open, close)[mtfLen], math.min(open, close)[mtfLen + 1], math.min(open, close)[mtfLen + 2]), time[mtfLen + 1], ta.atr(14)[1]], lookahead = barmerge.lookahead_on)
    var int lastHiT = na
    var int lastLoT = na
    string tag = f_tf_name(tf)
    bool ok = on and timeframe.in_seconds(tf) > timeframe.in_seconds()
    int swept = 0
    if ok
        swept := f_update_liq(a, 1)
        float thin = nz(ha) * 0.05
        if not na(ph) and not na(pt) and (na(lastHiT) or pt != lastHiT)
            lastHiT := pt
            int   nB  = int(timeframe.in_seconds(tf) / timeframe.in_seconds()) + 1
            float fbH = math.max(math.min(pb, ph - thin), ph - zoneThick * nz(ha))
            float bdH = f_refine(ph, f_bar_of(pt), 1, nB, fbH)
            f_add_liq(a, ph, math.min(bdH, ph - 0.5 * nz(atr14)), f_bar_of(pt), 1, mtfTol * nz(ha), c, tag, mtfMax)
        if not na(pl) and not na(pt) and (na(lastLoT) or pt != lastLoT)
            lastLoT := pt
            int   nB  = int(timeframe.in_seconds(tf) / timeframe.in_seconds()) + 1
            float fbL = math.min(math.max(lb, pl + thin), pl + zoneThick * nz(ha))
            float bdL = f_refine(pl, f_bar_of(pt), -1, nB, fbL)
            f_add_liq(a, pl, math.max(bdL, pl + 0.5 * nz(atr14)), f_bar_of(pt), -1, mtfTol * nz(ha), c, tag, mtfMax)
    swept

// ------------------------------------------------------------ level lines ----
// one line per level with a tag at the right edge; levels that are close to
// each other share one tag. The line starts lvBars candles before its tag.
f_level(float px, string name, int t0, string st, int rt, float tol, color c) =>
    if not na(px)
        int found = -1
        if array.size(lvPx) > 0
            for i = 0 to array.size(lvPx) - 1
                if math.abs(array.get(lvPx, i) - px) <= tol
                    found := i
                    break
        // a dashed line across the buy / sell column, under its text; a level that shares a
        // tag gets its own line too, at its exact price
        int hw = int(bsW / 2)
        array.push(lastLines, line.new(rt - hw, px, rt + hw, px, xloc = xloc.bar_index, color = color.new(c, 10), style = line.style_dashed, width = 1))
        if found >= 0
            label old = array.get(lvLb, found)
            // short names on one row, a long list on two
            string ot = label.get_text(old)
            label.set_text(old, ot + (str.length(ot) + str.length(name) > 14 ? "\n" : " · ") + name)
            // the shared tag sits half way between the levels
            label.set_y(old, (label.get_y(old) + px) / 2.0)
        else
            // strong / weak and the weekly and monthly levels are the key ones: bold
            bool key = str.contains(name, "Strong") or str.contains(name, "Weak") or str.startswith(name, "PW") or str.startswith(name, "PM")
            label fresh = na
            // the text on the centre line, on its line (its background is set to the colour behind it later)
            if key
                fresh := label.new(rt, px, name, xloc = xloc.bar_index, style = label.style_label_center, color = color.new(c, 100), textcolor = c, size = szTxt, text_formatting = text.format_bold)
            else
                fresh := label.new(rt, px, name, xloc = xloc.bar_index, style = label.style_label_center, color = color.new(c, 100), textcolor = c, size = szTxt)
            array.push(lastLbs, fresh)
            array.push(lvPx, px)
            array.push(lvLb, fresh)
            array.push(lvC, c)
    true

// =============================================================== per bar ====
// 0. remember this candle's time (to place higher-timeframe zones by candle number)
array.push(barTimes, time)
if array.size(barTimes) > 60000
    array.shift(barTimes)

// 1. existing zones react to this candle first
f_resolve()
int obBroke = f_update_obs()
int fvgFlip = f_update_fvgs()
int liqSwept = showLiq ? f_update_liq(liq, 0) : 0

// 2. market structure
cfUp := bar_index - array.get(znHit, 0) <= 10 or low > high[2] or strongUp
cfDn := bar_index - array.get(znHit, 1) <= 10 or high < low[2] or strongDn
[swTrend, swEv, swObTop, swObBot, swObT, swHi, swLo, swNewHi, swNewLo, swHiT, swHiDone, swHiName, swUpName, swLoT, swLoDone, swLoName, swDnName] = f_structure(swLen, showSw and drawNow, drawNow and showPts ? 1 : 0, na, na, line.style_solid, size.small, swLines, swLabels, swPoints, intPoints, true, ptsMax)
[inTrend, inEv, inObTop, inObBot, inObT, inHi, inLo, inNewHi, inNewLo, inHiT, inHiDone, inHiName, inUpName, inLoT, inLoDone, inLoName, inDnName] = f_structure(intLen, showInt and intMode != "Off" and drawNow, not drawNow ? 0 : (intPtsIn == "Labels" ? 1 : (intPtsIn == "Triangles" ? 2 : 0)), swHi, swLo, line.style_dashed, size.tiny, intLines, intLabels, intPoints, obNoLbs, false, ptsInMax)
// a third pass with its own length, used only to find order blocks (draws nothing)
[obTrend, obEv, obTopC, obBotC, obTimeC, obU1, obU2, obU3, obU4, obU5, obU6, obU7, obU8, obU9, obU10, obU11, obU12] = f_structure(obLen, false, 0, na, na, line.style_solid, size.tiny, obNoLines, obNoLbs, obNoLbs, obNoLbs, false, 2)

// story line: a path through the swing points, up legs bullish, down legs bearish
float zph = ta.pivothigh(high, storyLen, storyLen)
float zpl = ta.pivotlow(low, storyLen, storyLen)
var int   zDir  = 0
var float zPx   = na
var int   zBar  = na
var line  zLast = na
var array<line> zLines = array.new<line>()
if storyOn and not na(zph)
    int zbH = bar_index - storyLen
    if zDir == 1
        // two highs in a row: the leg goes on to the higher one
        if zph > zPx
            zPx  := zph
            zBar := zbH
            if not na(zLast)
                line.set_xy2(zLast, zbH, zph)
    else
        if not na(zPx)
            zLast := drawNow ? line.new(zBar, zPx, zbH, zph, xloc = xloc.bar_index, color = color.new(cBull, storyTr), width = 2) : na
            if drawNow
                f_keep_line(zLines, zLast, storyMax)
        zDir := 1
        zPx  := zph
        zBar := zbH
if storyOn and not na(zpl)
    int zbL = bar_index - storyLen
    if zDir == -1
        // two lows in a row: the leg goes on to the lower one
        if zpl < zPx
            zPx  := zpl
            zBar := zbL
            if not na(zLast)
                line.set_xy2(zLast, zbL, zpl)
    else
        if not na(zPx)
            zLast := drawNow ? line.new(zBar, zPx, zbL, zpl, xloc = xloc.bar_index, color = color.new(cBear, storyTr), width = 2) : na
            if drawNow
                f_keep_line(zLines, zLast, storyMax)
        zDir := -1
        zPx  := zpl
        zBar := zbL

// 3. new order blocks
int  obSec  = obTfIn == "15m" ? 900 : (obTfIn == "1H" ? 3600 : (obTfIn == "4H" ? 14400 : (obTfIn == "D" ? 86400 : 0)))
bool obTfOk = timeframe.in_seconds() >= obSec
if showOB and obTfOk and obEv != 0 and not na(obTopC) and (not obStrong or f_ob_strong(obTopC, obBotC, obTimeC, obEv > 0 ? 1 : -1))
    f_add_ob(obTopC, obBotC, obTimeC, obEv > 0 ? 1 : -1, "OB")

// 4. new fair value gaps
bool fvgUp = low > high[2] and close[1] > high[2] and (low - high[2]) >= fvgThr * atr14
bool fvgDn = high < low[2] and close[1] < low[2] and (low[2] - high) >= fvgThr * atr14
if showFVG and fvgUp
    Zone gUp = Zone.new(f_zone_box(bar_index - 1, low, high[2], cFvgUp, 85, "FVG ▲ Support"), low, high[2], 1, 0, 1, "FVG", na, cFvgUp, "", "", bar_index - 1)
    if fvgExt > 0
        box.set_right(gUp.bx, bar_index + fvgExt)
    array.push(fvgs, gUp)
    f_trim(fvgs, fvgMax)
if showFVG and fvgDn
    Zone gDn = Zone.new(f_zone_box(bar_index - 1, low[2], high, cFvgDn, 85, "FVG ▼ Resistance"), low[2], high, -1, 0, 1, "FVG", na, cFvgDn, "", "", bar_index - 1)
    if fvgExt > 0
        box.set_right(gDn.bx, bar_index + fvgExt)
    array.push(fvgs, gDn)
    f_trim(fvgs, fvgMax)

// 5. new liquidity zones on this chart
float lph = ta.pivothigh(high, liqLen, liqLen)
float lpl = ta.pivotlow(low, liqLen, liqLen)
float thinNow = atr14 * 0.5   // a liquidity zone is at least half an average candle wide (from the wick tip inward)
if showLiq and not na(lph)
    // the first body below the high: the highest body of the swing candle and its two neighbours
    float bHi = math.max(math.max(open[liqLen], close[liqLen]), math.max(open[liqLen - 1], close[liqLen - 1]), math.max(open[liqLen + 1], close[liqLen + 1]))
    f_add_liq(liq, lph, math.max(math.min(bHi, lph - thinNow), lph - zoneThick * atr14), bar_index - liqLen, 1, liqTol * atr14, cLiq, "Liq", liqMax)
if showLiq and not na(lpl)
    float bLo = math.min(math.min(open[liqLen], close[liqLen]), math.min(open[liqLen - 1], close[liqLen - 1]), math.min(open[liqLen + 1], close[liqLen + 1]))
    f_add_liq(liq, lpl, math.min(math.max(bLo, lpl + thinNow), lpl + zoneThick * atr14), bar_index - liqLen, -1, liqTol * atr14, cLiq, "Liq", liqMax)

// 6. equal highs and lows: a new swing high (low) is compared with the last 6 swing highs
// (lows); the nearest one at the same price (within eqTol x ATR) that price has not traded
// through in between makes an EQH (EQL), with a dashed line between the two and its name
float eph = ta.pivothigh(high, eqLen, eqLen)
float epl = ta.pivotlow(low, eqLen, eqLen)
var array<float> eqHp = array.new<float>()
var array<int>   eqHb = array.new<int>()
var array<float> eqLp = array.new<float>()
var array<int>   eqLb = array.new<int>()
f_eq(array<float> ps, array<int> bs, float px, int side) =>
    int nb = bar_index - eqLen
    if showEQ and drawNow and array.size(ps) > 0
        bool done = false
        for i = array.size(ps) - 1 to 0
            float p = array.get(ps, i)
            int   b = array.get(bs, i)
            if not done and math.abs(px - p) <= eqTol * atrBig and nb - b >= 3 and nb - b < 1000
                // still untouched: no candle in between went beyond the two
                float ex = side == 1 ? math.max(px, p) : math.min(px, p)
                bool clean = true
                for k = eqLen + 1 to bar_index - b - 1
                    if side == 1 ? high[k] > ex : low[k] < ex
                        clean := false
                        break
                if clean
                    done := true
                    f_keep_line(eqLines, line.new(b, p, nb, px, xloc = xloc.bar_index, color = side == 1 ? cBear : cBull, style = line.style_dashed, width = 1), 10)
                    f_keep_label(eqLabels, label.new(int((b + nb) / 2), side == 1 ? ex + tGap : ex - tGap, side == 1 ? "EQH" : "EQL", xloc = xloc.bar_index, style = side == 1 ? label.style_label_down : label.style_label_up, color = color.new(cGrey, 100), textcolor = side == 1 ? cBear : cBull, size = size.small), 10)
    array.push(ps, px)
    array.push(bs, nb)
    if array.size(ps) > 6
        array.shift(ps)
        array.shift(bs)
    true
if not na(eph)
    f_eq(eqHp, eqHb, eph, 1)
if not na(epl)
    f_eq(eqLp, eqLb, epl, -1)

// 7. liquidity zones from higher timeframes
int sw1 = f_mtf(tf1On, tf1, tf1C, mtf1)
int sw2 = f_mtf(tf2On, tf2, tf2C, mtf2)
int sw3 = f_mtf(tf3On, tf3, tf3C, mtf3)
int sw4 = f_mtf(tf4On, tf4, tf4C, mtf4)

// sweep candles: a hollow box around the wick that went through the zone
bool sweptHi = liqSwept == 1 or liqSwept == 3 or sw1 == 1 or sw1 == 3 or sw2 == 1 or sw2 == 3 or sw3 == 1 or sw3 == 3 or sw4 == 1 or sw4 == 3
bool sweptLo = liqSwept >= 2 or sw1 >= 2 or sw2 >= 2 or sw3 >= 2 or sw4 >= 2
float bodyTop = math.max(open, close)
float bodyBot = math.min(open, close)

// the candles on which Tokyo, London and New York open
bool tyoBar  = f_near_open(tyoH, tyoM, "Asia/Tokyo")
bool lonBar  = f_near_open(lonH, lonM, "Europe/London")
bool nycBar  = f_near_open(nycH, nycM, "America/New_York")

// sessions from open to open: 0 none, 1 Asia, 2 London, 3 New York.
// The trading day ends at 17:00 and reopens at 18:00 New York time.
int  nyMin      = hour(time, "America/New_York") * 60 + minute(time, "America/New_York")
bool nyAfter    = nyMin >= 1020
bool nyAfterWas = nyAfter[1]
// the first candle of the trading day: the first one at or after 18:00 New York time
bool dayOpenBar = nyMin >= 1080 and nz(nyMin[1], 0) < 1080
bool asDayOpen  = asStartIn == "Trading day open (18:00 New York)"
bool asStartBar = asDayOpen ? dayOpenBar : tyoBar
var int sesNow  = 0
if nyAfter and not nyAfterWas
    sesNow := 0
if sesNow == 3 and (nyMin >= nyEndH * 60 + nyEndM or nyMin < nycH * 60 + nycM)
    sesNow := 0
if asStartBar
    sesNow := 1
if lonBar
    sesNow := 2
if nycBar
    sesNow := 3

// sessions: high and low of the latest Asia, London and New York session
bool sessTfOk = timeframe.isintraday and timeframe.in_seconds() <= 3600
bool asIn     = sessTfOk and sesNow == 1
bool lnIn     = sessTfOk and sesNow == 2
bool nyIn     = sessTfOk and sesNow == 3
bool asWas    = asIn[1]
bool lnWas    = lnIn[1]
bool nyWas    = nyIn[1]
[asHi, asLo, asT] = f_session(asIn, asIn and (not asWas or asStartBar), "Asia", cAsia)
[lnHi, lnLo, lnT] = f_session(lnIn, lnIn and (not lnWas or lonBar), "London", cLon)
[nyHi, nyLo, nyT] = f_session(nyIn, nyIn and (not nyWas or nycBar), "NY", cNy)

// session opens: a vertical line at the Tokyo, London and New York open
bool opnTfOk = timeframe.isintraday and timeframe.in_seconds() <= opnMaxTf * 60
bool tyoNow  = showOpn and opnTfOk and tyoOn and tyoBar
bool lonNow  = showOpn and opnTfOk and lonOn and lonBar
bool nycNow  = showOpn and opnTfOk and nycOn and nycBar
// the full names; the old short names (TYO, LON, NYC) still saved in a chart's settings are mapped too
if tyoNow and drawNow
    f_open_mark("← " + tyoTxt + " →", 1)
if lonNow and drawNow
    f_open_mark("← " + lonTxt + " →", 2)
if nycNow and drawNow
    f_open_mark("← " + nycTxt + " →", 3)
// the highest candle on screen: the open labels are kept at that height
var float visHigh = na
if time >= chart.left_visible_bar_time and time <= chart.right_visible_bar_time
    visHigh := na(visHigh) ? high : math.max(visHigh, high)

// engulfing candles: a triangle below a bullish and above a bearish one
string engSz  = engSzIn == "Tiny" ? size.tiny : (engSzIn == "Small" ? size.small : (engSzIn == "Large" ? size.large : size.normal))
// only the latest few are kept, older marks are removed; a bigger body = a stronger colour
int engT = int(math.max(0, math.min(65, 85 - math.abs(close - open) / math.max(nz(atr14), syminfo.mintick) * 45)))
if engUp and drawNow
    f_keep_label(engLbs, label.new(bar_index, low - engGap * nz(atr14), "▲", xloc = xloc.bar_index, yloc = yloc.price, style = label.style_none, color = color.new(cBull, 100), textcolor = color.new(cBull, engT), size = engSz), engMax)
if engDn and drawNow
    f_keep_label(engLbs, label.new(bar_index, high + engGap * nz(atr14), "▼", xloc = xloc.bar_index, yloc = yloc.price, style = label.style_none, color = color.new(cBear, 100), textcolor = color.new(cBear, engT), size = engSz), engMax)

// opening range (ORB): the range, the first close outside it, and the count of past days
// on charts above 15 minutes a candle is longer than the opening range itself, so the range
// is measured on the 5-minute candles inside each chart candle
string orbLtf = timeframe.isintraday and timeframe.in_seconds() > 900 ? "5" : timeframe.period
bool   orbHtf = orbLtf == "5"
[ibT, ibH, ibL] = request.security_lower_tf(syminfo.tickerid, orbLtf, [time, high, low])
int   orbM0 = int(str.tonumber(str.substring(orbS, 0, 2))) * 60 + int(str.tonumber(str.substring(orbS, 2, 4)))
int   orbM1 = int(str.tonumber(str.substring(orbS, 5, 7))) * 60 + int(str.tonumber(str.substring(orbS, 7, 9)))
float ibHi  = na
float ibLo  = na
if orbHtf and showOrb and array.size(ibT) > 0
    for k = 0 to array.size(ibT) - 1
        int tk = array.get(ibT, k)
        int mk = hour(tk, "America/New_York") * 60 + minute(tk, "America/New_York")
        if mk >= orbM0 and mk < orbM1
            ibHi := na(ibHi) ? array.get(ibH, k) : math.max(ibHi, array.get(ibH, k))
            ibLo := na(ibLo) ? array.get(ibL, k) : math.min(ibLo, array.get(ibL, k))
bool inOrb   = orbHtf ? not na(ibHi) : not na(time(timeframe.period, orbS, "America/New_York"))
bool inTrack = not na(time(timeframe.period, orbDayS, "America/New_York"))
bool wasOrb   = inOrb[1]
bool wasTrack = inTrack[1]
var float orbHi    = na
var float orbLo    = na
var int   orbT0    = na
var int   orbT1    = na
var int   orbBreak = 0
var bool  orbBoth  = false
var bool  orbLive  = false
var int   orbN     = 0
var int   orbUpOnly = 0
var int   orbDnOnly = 0
var int   orbTwo   = 0
int orbEvt = 0
if inOrb and not wasOrb
    orbHi    := orbHtf ? ibHi : high
    orbLo    := orbHtf ? ibLo : low
    orbT0    := time
    orbT1    := time
    orbBreak := 0
    orbBoth  := false
    orbLive  := true
else if inOrb
    orbHi := math.max(orbHi, orbHtf ? ibHi : high)
    orbLo := math.min(orbLo, orbHtf ? ibLo : low)
if orbLive and inTrack and not inOrb
    // the box only runs until the first candle that closes outside the range (the arrow)
    if orbBreak == 0
        orbT1 := time
    if orbBreak == 0
        if close > orbHi
            orbBreak := 1
            orbEvt   := 1
        else if close < orbLo
            orbBreak := -1
            orbEvt   := -1
    else if not orbBoth
        if (orbBreak == 1 and close < orbLo) or (orbBreak == -1 and close > orbHi)
            orbBoth := true
if orbLive and wasTrack and not inTrack
    orbLive := false
    orbN += 1
    if orbBoth
        orbTwo += 1
    else if orbBreak == 1
        orbUpOnly += 1
    else if orbBreak == -1
        orbDnOnly += 1
// the candle that broke the opening range: the same arrow as the engulfing marks,
// in the colour of the ORB box
string orbSz = engSzIn == "Tiny" ? size.tiny : (engSzIn == "Small" ? size.small : (engSzIn == "Large" ? size.large : size.normal))
if showOrb and orbMark and drawNow and orbEvt == 1
    f_keep_label(orbLbs, label.new(bar_index, low - engGap * nz(atr14), "▲", xloc = xloc.bar_index, yloc = yloc.price, style = label.style_none, color = color.new(cLevel, 100), textcolor = cLevel, size = orbSz), 6)
if showOrb and orbMark and drawNow and orbEvt == -1
    f_keep_label(orbLbs, label.new(bar_index, high + engGap * nz(atr14), "▼", xloc = xloc.bar_index, yloc = yloc.price, style = label.style_none, color = color.new(cLevel, 100), textcolor = cLevel, size = orbSz), 6)

// candle colour from the internal structure: the last event decides
// candle colour from the last break that is drawn (swing, or internal with confluence):
// 1 CHoCH, 2 CHoCH+, 3 BOS, 4 BOS+ (negative = bearish); stronger break = stronger colour
var int canState = 0
int cEv = swEv != 0 ? swEv : ((inEv > 0 and (not intConf or cfUp)) or (inEv < 0 and (not intConf or cfDn)) ? inEv : 0)
if cEv != 0
    int cA = math.abs(cEv)
    canState := (cEv > 0 ? 1 : -1) * (cA == 2 ? 1 : (cA == 3 ? 2 : (cA == 1 ? 3 : 4)))
int   canT   = math.abs(canState) == 1 ? 65 : (math.abs(canState) == 2 ? 40 : (math.abs(canState) == 3 ? 15 : 0))
color canCol = canState > 0 ? color.new(cBull, canT) : (canState < 0 ? color.new(cBear, canT) : na)
barcolor(colorBars ? canCol : na, title = "Candle colour by structure")

// EMA (off by default)
float ema1 = ta.ema(close, ema1Len)
float ema2 = ta.ema(close, ema2Len)
plot(emaOn ? ema1 : na, "EMA 1", color = ema1C, linewidth = emaW, display = display.pane)
plot(ema2On ? ema2 : na, "EMA 2", color = ema2C, linewidth = emaW, display = display.pane)

// 8. the swing range: used for strong / weak high and low and premium / discount
var float trTop  = na
var float trBot  = na
var int   trTopT = na
var int   trBotT = na
var int   trTopB = na
var int   trBotB = na
if swNewHi
    trTop  := swHi
    trTopT := time[swLen]
    trTopB := bar_index - swLen
if swNewLo
    trBot  := swLo
    trBotT := time[swLen]
    trBotB := bar_index - swLen
if not na(trTop) and high > trTop
    trTop  := high
    trTopT := time
    trTopB := bar_index
if not na(trBot) and low < trBot
    trBot  := low
    trBotT := time
    trBotB := bar_index

// 9. previous day, week and month, and the open of the current ones
[pdH, pdL, pdT, dOpen, dHi, dLo, adr, dMa50, dMa200] = request.security(syminfo.tickerid, "D", [high[1], low[1], time, open, high, low, ta.sma(high - low, adrLen)[1], ta.sma(close, 50)[1], ta.sma(close, 200)[1]], lookahead = barmerge.lookahead_on)
[pwH, pwL, pwT, wOpen, wkHi, wkLo] = request.security(syminfo.tickerid, "W", [high[1], low[1], time, open, high, low], lookahead = barmerge.lookahead_on)
[pmH, pmL, pmT, mOpen, mnHi, mnLo] = request.security(syminfo.tickerid, "M", [high[1], low[1], time, open, high, low], lookahead = barmerge.lookahead_on)
// 4-hour averages for the trend row

// 10. liquidity grabs: a wick through a level, with the close back inside.
// Session and previous-day levels count only once each (the first candle that
// trades through them), so later wicks at the same level are not marked again.
bool grabHiRaw = f_grab(grabHiLv, 1)
bool grabLoRaw = f_grab(grabLoLv, -1)
float gph = ta.pivothigh(high, grabLen, grabLen)
float gpl = ta.pivotlow(low, grabLen, grabLen)
if not na(gph)
    array.push(grabHiLv, gph)
    if array.size(grabHiLv) > 8
        array.shift(grabHiLv)
if not na(gpl)
    array.push(grabLoLv, gpl)
    if array.size(grabLoLv) > 8
        array.shift(grabLoLv)
// every f_once call runs on every candle (it keeps its own state); the switches are applied after
bool lvTfOk   = timeframe.isintraday
bool pdOnceHi = f_once(lvTfOk ? pdH : float(na), 1)
bool pdOnceLo = f_once(lvTfOk ? pdL : float(na), -1)
bool asOnceHi = f_once(asIn ? float(na) : asHi, 1)
bool asOnceLo = f_once(asIn ? float(na) : asLo, -1)
bool lnOnceHi = f_once(lnIn ? float(na) : lnHi, 1)
bool lnOnceLo = f_once(lnIn ? float(na) : lnLo, -1)
bool nyOnceHi = f_once(nyIn ? float(na) : nyHi, 1)
bool nyOnceLo = f_once(nyIn ? float(na) : nyLo, -1)
bool sesGrabHi = grabSess and sessTfOk and (asOnceHi or lnOnceHi or nyOnceHi)
bool sesGrabLo = grabSess and sessTfOk and (asOnceLo or lnOnceLo or nyOnceLo)
bool dayGrabHi = grabPd and pdOnceHi
bool dayGrabLo = grabPd and pdOnceLo
bool grabHi = (showGrab and grabHiRaw) or sesGrabHi or dayGrabHi
bool grabLo = (showGrab and grabLoRaw) or sesGrabLo or dayGrabLo

// sweep candles: outlined in the grab colour (red). Grab candles that are
// not also a sweep: outlined in the grab colour, plus a dashed box to the right.
bool boxHi  = showSweep and sweptHi
bool boxLo  = showSweep and sweptLo
bool gOutHi = showSweep and grabHi and not sweptHi
bool gOutLo = showSweep and grabLo and not sweptLo
// the outline reaches a little past the tip, so the wick never pokes out of it
float wPad = wickPad * nz(atr14) + syminfo.mintick
float wHi  = high + wPad
float wLo  = low - wPad
plotcandle(boxHi ? bodyTop : na, boxHi ? wHi : na, boxHi ? bodyTop : na, boxHi ? wHi : na, title = "Sweep of a high (wick box)", color = color.new(cGrab, 100), wickcolor = color.new(cGrab, 100), bordercolor = cGrab)
plotcandle(boxLo ? bodyBot : na, boxLo ? bodyBot : na, boxLo ? wLo : na, boxLo ? wLo : na, title = "Sweep of a low (wick box)", color = color.new(cGrab, 100), wickcolor = color.new(cGrab, 100), bordercolor = cGrab)
plotcandle(gOutHi ? bodyTop : na, gOutHi ? wHi : na, gOutHi ? bodyTop : na, gOutHi ? wHi : na, title = "Liquidity grab of a high (wick box)", color = color.new(cGrab, 100), wickcolor = color.new(cGrab, 100), bordercolor = cGrab)
plotcandle(gOutLo ? bodyBot : na, gOutLo ? bodyBot : na, gOutLo ? wLo : na, gOutLo ? wLo : na, title = "Liquidity grab of a low (wick box)", color = color.new(cGrab, 100), wickcolor = color.new(cGrab, 100), bordercolor = cGrab)
// the names of the levels that were grabbed on this candle
string gHiTxt = f_add_name("", dayGrabHi, "PDH")
gHiTxt := f_add_name(gHiTxt, grabSess and sessTfOk and asOnceHi, "Asia H")
gHiTxt := f_add_name(gHiTxt, grabSess and sessTfOk and lnOnceHi, "Lon H")
gHiTxt := f_add_name(gHiTxt, grabSess and sessTfOk and nyOnceHi, "NY H")
gHiTxt := f_add_name(gHiTxt, showGrab and grabHiRaw, "Swing H")
string gLoTxt = f_add_name("", dayGrabLo, "PDL")
gLoTxt := f_add_name(gLoTxt, grabSess and sessTfOk and asOnceLo, "Asia L")
gLoTxt := f_add_name(gLoTxt, grabSess and sessTfOk and lnOnceLo, "Lon L")
gLoTxt := f_add_name(gLoTxt, grabSess and sessTfOk and nyOnceLo, "NY L")
gLoTxt := f_add_name(gLoTxt, showGrab and grabLoRaw, "Swing L")

// what was swept: chart and higher-timeframe liquidity zones, then the levels
string swHiTxt = f_add_name("", liqSwept == 1 or liqSwept == 3, "Liq")
swHiTxt := f_add_name(swHiTxt, sw1 == 1 or sw1 == 3, f_tf_name(tf1))
swHiTxt := f_add_name(swHiTxt, sw2 == 1 or sw2 == 3, f_tf_name(tf2))
swHiTxt := f_add_name(swHiTxt, sw3 == 1 or sw3 == 3, f_tf_name(tf3))
swHiTxt := f_add_name(swHiTxt, sw4 == 1 or sw4 == 3, f_tf_name(tf4))
string swLoTxt = f_add_name("", liqSwept >= 2, "Liq")
swLoTxt := f_add_name(swLoTxt, sw1 >= 2, f_tf_name(tf1))
swLoTxt := f_add_name(swLoTxt, sw2 >= 2, f_tf_name(tf2))
swLoTxt := f_add_name(swLoTxt, sw3 >= 2, f_tf_name(tf3))
swLoTxt := f_add_name(swLoTxt, sw4 >= 2, f_tf_name(tf4))
string whatHi = f_join(swHiTxt, gHiTxt)
string whatLo = f_join(swLoTxt, gLoTxt)
// "BSL swept · Asia H" / "SSL swept · PDL" right above / below the candle, short, on one row
bool takenHi = boxHi or gOutHi
bool takenLo = boxLo or gOutLo
if grabTxt and drawNow and takenHi and f_room(3, bar_index, wHi + gGap)
    // a thin line from the middle of the candle (tip of the outline) up to the text
    f_keep_line(grabLns, line.new(bar_index, wHi, bar_index, wHi + gGap, xloc = xloc.bar_index, color = color.new(cGrab, math.max(lnFade - 20, 0)), style = line.style_solid, width = 1), grabMax)
    f_keep_label(grabLbs, label.new(bar_index, wHi + gGap, whatHi == "" ? "BSL swept" : "BSL swept\n" + whatHi, xloc = xloc.bar_index, yloc = yloc.price, style = label.style_label_down, color = color.new(cGrab, 75), textcolor = cGrab, size = size.tiny, text_formatting = text.format_bold), grabMax)
if grabTxt and drawNow and takenLo and f_room(3, bar_index, wLo - gGap)
    f_keep_line(grabLns, line.new(bar_index, wLo, bar_index, wLo - gGap, xloc = xloc.bar_index, color = color.new(cGrab, math.max(lnFade - 20, 0)), style = line.style_solid, width = 1), grabMax)
    f_keep_label(grabLbs, label.new(bar_index, wLo - gGap, whatLo == "" ? "SSL swept" : "SSL swept\n" + whatLo, xloc = xloc.bar_index, yloc = yloc.price, style = label.style_label_up, color = color.new(cGrab, 75), textcolor = cGrab, size = size.tiny, text_formatting = text.format_bold), grabMax)

// optional: a small dashed zone from the wick to the right (off by default)
if drawNow and ((boxHi and sweepBox and not grabHi) or (grabHi and showSweep and grabBox))
    f_keep_box(grabBoxes, box.new(bar_index, wHi, bar_index + (grabHi ? grabExt : sweepExt), math.min(bodyTop, high - syminfo.mintick), xloc = xloc.bar_index, border_color = cGrab, border_width = 1, border_style = line.style_dashed, bgcolor = color.new(cGrab, 85)), grabMax)
if drawNow and ((boxLo and sweepBox and not grabLo) or (grabLo and showSweep and grabBox))
    f_keep_box(grabBoxes, box.new(bar_index, math.max(bodyBot, low + syminfo.mintick), bar_index + (grabLo ? grabExt : sweepExt), wLo, xloc = xloc.bar_index, border_color = cGrab, border_width = 1, border_style = line.style_dashed, bgcolor = color.new(cGrab, 85)), grabMax)

// confluence memory for the next breaks: zones price traded in, and liquidity swept
f_zn_hit(obs, false)
f_zn_hit(fvgs, false)
f_zn_hit(liq, true)
f_zn_hit(mtf1, true)
f_zn_hit(mtf2, true)
f_zn_hit(mtf3, true)
f_zn_hit(mtf4, true)
if sweptLo or grabLo
    array.set(znHit, 0, bar_index)
if sweptHi or grabHi
    array.set(znHit, 1, bar_index)

// the colour the chart shows at price y right of the last candle: the premium, equilibrium
// or discount band (a light tint over the background) or the plain background
f_mask(float y) =>
    color bg = chart.bg_color
    color c  = na
    if showPD and not na(trTop) and not na(trBot) and trTop > trBot
        float mid  = (trTop + trBot) / 2.0
        float band = (trTop - trBot) * pdPct / 100.0
        float pBot = pdFull ? mid + band / 2.0 : trTop - band
        float dTop = pdFull ? mid - band / 2.0 : trBot + band
        c := y <= trTop and y >= pBot ? cPrem : (y <= mid + band / 2.0 and y >= mid - band / 2.0 ? cEq : (y <= dTop and y >= trBot ? cDisc : na))
    color r = bg
    if not na(c)
        float a = (100 - pdDimC) / 100.0
        r := color.rgb(color.r(bg) * (1 - a) + color.r(c) * a, color.g(bg) * (1 - a) + color.g(c) * a, color.b(bg) * (1 - a) + color.b(c) * a)
    r

// ================================================== drawn on the last bar ===
var line  zLive = na
var line  tgtLn = na
// the buy / sell zone of the last update, for the alert
// the buy / sell zone stays the same zone while it stands (it is not picked again on every tick)
var Zone  lkBuy  = na
var Zone  lkSell = na
var bool  lkBuyW  = false
var bool  lkSellW = false
var float zBuyT  = na
var float zBuyB  = na
var float zSellT = na
var float zSellB = na
// SL, TP and strength of the current buy / sell zone, for the alert messages
var float zBuySl  = na
var float zBuyTp  = na
var int   zBuyPct = 0
var float zSellSl  = na
var float zSellTp  = na
var int   zSellPct = 0
var box   buyBx  = box.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_left, text_valign = text.align_center)
var box   sellBx = box.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_left, text_valign = text.align_center)
var line  buySl  = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
var line  sellSl = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
var label buySlLb  = label.new(bar_index, close, "", xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.gray, 100), textcolor = color.new(color.gray, 100), size = szTxt)
var line  buyTp  = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
var line  sellTp = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
var label buyTpLb  = label.new(bar_index, close, "", xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.gray, 100), textcolor = color.new(color.gray, 100), size = szTxt)
var label sellTpLb = label.new(bar_index, close, "", xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.gray, 100), textcolor = color.new(color.gray, 100), size = szTxt)
var line  buyEn  = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
var line  sellEn = line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
var label buyEnLb  = label.new(bar_index, close, "", xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.gray, 100), textcolor = color.new(color.gray, 100), size = szTxt)
var label sellEnLb = label.new(bar_index, close, "", xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.gray, 100), textcolor = color.new(color.gray, 100), size = szTxt)
var label sellSlLb = label.new(bar_index, close, "", xloc = xloc.bar_index, style = label.style_label_left, color = color.new(color.gray, 100), textcolor = color.new(color.gray, 100), size = szTxt)

// ------------------------------------------- buy / sell zone: the evidence ---
// adds a name to a list once
// true while zone z still exists in one of the lists and is not taken
f_alive_in(array<Zone> a, Zone z) =>
    bool r = false
    for q in a
        if not r and q.state != 2 and q.t0 == z.t0 and q.dir == z.dir and q.tag == z.tag
            r := true
    r

f_alive(Zone z) =>
    bool r = not na(z) and (f_alive_in(obs, z) or f_alive_in(fvgs, z) or f_alive_in(liq, z) or f_alive_in(mtf1, z) or f_alive_in(mtf2, z) or f_alive_in(mtf3, z) or f_alive_in(mtf4, z))
    r

// strength word for 0-100 %
f_word(int pct) =>
    string r = pct >= 75 ? "very strong" : (pct >= 50 ? "strong" : (pct >= 25 ? "weak" : "very weak"))
    r

// what meets in the price range tp..bt: higher-timeframe and chart liquidity, order
// blocks, gaps, key levels, and premium / discount
f_conf_names(float tp, float bt, int side) =>
    array<string> nm = array.new<string>()
    int   w   = 0
    float tol = 0.1 * nz(atr14)
    // liquidity of the higher timeframes (heavier the higher the timeframe) and of this chart
    for z in mtf4
        if z.state == 0 and z.top >= bt - tol and z.bot <= tp + tol and not array.includes(nm, z.tag + " liquidity")
            array.push(nm, z.tag + " liquidity")
            w += 3
    for z in mtf3
        if z.state == 0 and z.top >= bt - tol and z.bot <= tp + tol and not array.includes(nm, z.tag + " liquidity")
            array.push(nm, z.tag + " liquidity")
            w += 2
    for z in mtf2
        if z.state == 0 and z.top >= bt - tol and z.bot <= tp + tol and not array.includes(nm, z.tag + " liquidity")
            array.push(nm, z.tag + " liquidity")
            w += 2
    for z in mtf1
        if z.state == 0 and z.top >= bt - tol and z.bot <= tp + tol and not array.includes(nm, z.tag + " liquidity")
            array.push(nm, z.tag + " liquidity")
            w += 1
    for z in liq
        if z.state == 0 and z.top >= bt - tol and z.bot <= tp + tol and not array.includes(nm, "liquidity")
            array.push(nm, "liquidity")
            w += 1
            // equal highs / lows (several touches merged into one zone) = more resting orders
            if z.hits >= 2 and not array.includes(nm, side == 1 ? "equal lows" : "equal highs")
                array.push(nm, side == 1 ? "equal lows" : "equal highs")
                w += 1
    // order blocks and breakers that work the same way as the zone
    for z in obs
        if z.state != 2 and z.top >= bt - tol and z.bot <= tp + tol
            int works = z.state == 1 ? -z.dir : z.dir
            if works == side and not array.includes(nm, z.state == 1 ? "breaker" : "order block")
                array.push(nm, z.state == 1 ? "breaker" : "order block")
                w += z.state == 1 ? 1 : 2
    // gaps that work the same way
    for z in fvgs
        if z.top >= bt - tol and z.bot <= tp + tol
            int works = z.state == 1 ? -z.dir : z.dir
            if works == side and not array.includes(nm, z.state == 1 ? "IFVG" : "FVG")
                array.push(nm, z.state == 1 ? "IFVG" : "FVG")
                w += 1
    // key levels inside the zone (weekly and monthly count double)
    array<float>  lp = array.from(pmH, pmL, pwH, pwL, pdH, pdL, asHi, asLo, lnHi, lnLo, nyHi, nyLo, dOpen, wOpen, mOpen)
    array<string> ln = array.from("PMH", "PML", "PWH", "PWL", "PDH", "PDL", "Asia H", "Asia L", "London H", "London L", "NY H", "NY L", "day open", "week open", "month open")
    array<int>    lw = array.from(2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
    for i = 0 to array.size(lp) - 1
        float v = array.get(lp, i)
        if not na(v) and v <= tp + tol and v >= bt - tol
            array.push(nm, array.get(ln, i))
            w += array.get(lw, i)
    // a round number inside the zone
    if roundStep > 0
        float rn = math.ceil(bt / roundStep) * roundStep
        if rn <= tp
            array.push(nm, "round " + str.tostring(rn, "#"))
            w += 1
    // the swing range: the extreme itself, discount / premium, and the OTE (62-79 % retracement)
    if not na(trTop) and not na(trBot) and trTop > trBot
        float rng = trTop - trBot
        float mid = (trTop + trBot) / 2.0
        if side == 1 and trBot <= tp + tol and trBot >= bt - tol
            array.push(nm, "swing low")
            w += 1
        if side == -1 and trTop <= tp + tol and trTop >= bt - tol
            array.push(nm, "swing high")
            w += 1
        if side == 1 and tp <= mid
            array.push(nm, "discount")
            w += 1
        if side == -1 and bt >= mid
            array.push(nm, "premium")
            w += 1
        float oHi = side == 1 ? trTop - 0.618 * rng : trBot + 0.786 * rng
        float oLo = side == 1 ? trTop - 0.786 * rng : trBot + 0.618 * rng
        if tp >= oLo and bt <= oHi
            array.push(nm, "OTE")
            w += 2
    // the daily trend points the same way
    int dTrd = f_trend(close, dMa50, dMa200)
    if dTrd == side
        array.push(nm, "daily trend")
        w += 2
    // the 50 / 200 EMA inside the zone (also when they are not drawn)
    if ema1 <= tp + tol and ema1 >= bt - tol
        array.push(nm, "EMA " + str.tostring(ema1Len))
        w += 1
    if ema2 <= tp + tol and ema2 >= bt - tol
        array.push(nm, "EMA " + str.tostring(ema2Len))
        w += 1
    [nm, w]

// how many separate times price came back into tp..bt after the zone formed
// (from = candle number where the zone started)
f_touches(float tp, float bt, int from) =>
    int cnt = 0
    int n = math.min(bar_index - from - 3, 1500)
    bool was = true
    if n > 1
        for i = n to 1
            bool inZ = high[i] >= bt and low[i] <= tp
            if inZ and not was
                cnt += 1
            was := inZ
    cnt

if barstate.islast
    int rightT = bar_index + padBars
    int tagT   = bar_index + tagBars

    // liquidity zones: own label and odds first, then overlapping ones become one
    f_reset(liq, 0)
    f_reset(mtf1, 1)
    f_reset(mtf2, 1)
    f_reset(mtf3, 1)
    f_reset(mtf4, 1)
    if mergeZn
        array<Zone> allZ = array.new<Zone>()
        f_collect(allZ, mtf4)
        f_collect(allZ, mtf3)
        f_collect(allZ, mtf2)
        f_collect(allZ, mtf1)
        f_collect(allZ, liq)
        f_merge(allZ)
    // liquidity size in dollars, after zones on the same price were combined
    f_dollars(liq)
    f_dollars(mtf1)
    f_dollars(mtf2)
    f_dollars(mtf3)
    f_dollars(mtf4)
    if nearAtr > 0
        float farDist = nearAtr * nz(atr14)
        // liquidity zones only: gaps and order blocks are not passed here
        f_hide_far(liq, farDist)
        f_hide_far(mtf1, farDist)
        f_hide_far(mtf2, farDist)
        f_hide_far(mtf3, farDist)
        f_hide_far(mtf4, farDist)

    int leftT = leftBars > 0 ? bar_index - leftBars : 0
    f_style_obs(obs, nearAtr * nz(atr14))
    f_style_fvgs(fvgs)
    f_extend(obs, rightT, leftT)
    // gaps: from the candles that formed them, gapLen candles long, at most to the end
    // of the liquidity zones
    f_gap_len(fvgs, gapLen, rightT)
    // liquidity zones start at the candle that made the high or low (0 = no cut)
    int liqLeftT = liqFull ? (liqBack > 0 ? bar_index - liqBack : 0) : leftT
    f_extend(liq, rightT, liqLeftT)
    f_extend(mtf1, rightT, liqLeftT)
    f_extend(mtf2, rightT, liqLeftT)
    f_extend(mtf3, rightT, liqLeftT)
    f_extend(mtf4, rightT, liqLeftT)

    if array.size(lastLines) > 0
        for oldLine in lastLines
            line.delete(oldLine)
    if array.size(lastLbs) > 0
        for oldLabel in lastLbs
            label.delete(oldLabel)
    if array.size(lastBoxes) > 0
        for oldBox in lastBoxes
            box.delete(oldBox)
    array.clear(lastLines)
    array.clear(lastLbs)
    array.clear(lastBoxes)
    array.clear(lvPx)
    array.clear(lvLb)
    array.clear(lvC)

    bool haveRange = not na(trTop) and not na(trBot) and trTop > trBot

    float lvTol = nz(atr14) * lvMergeAtr

    // confluence: the key levels, then a score for every zone, then the look
    array<float> keyLv = array.new<float>()
    array.push(keyLv, pdH)
    array.push(keyLv, pdL)
    array.push(keyLv, pwH)
    array.push(keyLv, pwL)
    array.push(keyLv, pmH)
    array.push(keyLv, pmL)
    if not asIn
        array.push(keyLv, asHi)
        array.push(keyLv, asLo)
    if not lnIn
        array.push(keyLv, lnHi)
        array.push(keyLv, lnLo)
    if not nyIn
        array.push(keyLv, nyHi)
        array.push(keyLv, nyLo)
    if haveRange
        array.push(keyLv, (trTop + trBot) / 2.0)
    if not swHiDone
        array.push(keyLv, swHi)
    if not swLoDone
        array.push(keyLv, swLo)
    float cTol = nz(atr14) * 0.1
    array<int> scOb = f_scores(obs, 0, cTol, keyLv)
    array<int> scFv = f_scores(fvgs, 1, cTol, keyLv)
    array<int> scLq = f_scores(liq, 2, cTol, keyLv)
    array<int> scM1 = f_scores(mtf1, 2, cTol, keyLv)
    array<int> scM2 = f_scores(mtf2, 2, cTol, keyLv)
    array<int> scM3 = f_scores(mtf3, 2, cTol, keyLv)
    array<int> scM4 = f_scores(mtf4, 2, cTol, keyLv)
    f_conf_apply(obs, scOb, false)
    f_conf_apply(fvgs, scFv, false)
    f_conf_apply(liq, scLq, true)
    f_conf_apply(mtf1, scM1, true)
    f_conf_apply(mtf2, scM2, true)
    f_conf_apply(mtf3, scM3, true)
    f_conf_apply(mtf4, scM4, true)

    // buy zone and sell zone: the strongest support below and resistance above price
    Zone byZ = na
    Zone slZ = na
    bool byWeak = false
    bool slWeak = false
    int  bsSec  = bsTfIn == "15m" ? 900 : (bsTfIn == "1H" ? 3600 : (bsTfIn == "4H" ? 14400 : (bsTfIn == "D" ? 86400 : 0)))
    bool bsTfOk = timeframe.in_seconds() >= bsSec
    if showBS and bsTfOk
        array<Zone> bsZ = array.new<Zone>()
        array<int>  bsS = array.new<int>()
        array<int>  bsK = array.new<int>()
        array<bool> bsH = array.new<bool>()
        f_bs_add(bsZ, bsS, bsK, bsH, obs, scOb, 0)
        f_bs_add(bsZ, bsS, bsK, bsH, fvgs, scFv, 1)
        f_bs_add(bsZ, bsS, bsK, bsH, liq, scLq, 2)
        f_bs_add(bsZ, bsS, bsK, bsH, mtf1, scM1, 2)
        f_bs_add(bsZ, bsS, bsK, bsH, mtf2, scM2, 2)
        f_bs_add(bsZ, bsS, bsK, bsH, mtf3, scM3, 2)
        f_bs_add(bsZ, bsS, bsK, bsH, mtf4, scM4, 2)
        float eqPx = haveRange ? (trTop + trBot) / 2.0 : na
        float bsLim = bsAtr * nz(atr14)
        [pkB, pkBw] = f_bs_pick(bsZ, bsS, bsK, bsH, 1, eqPx, bsLim)
        [pkS, pkSw] = f_bs_pick(bsZ, bsS, bsK, bsH, -1, eqPx, bsLim)
        byZ    := pkB
        byWeak := pkBw
        slZ    := pkS
        slWeak := pkSw
        // a zone stays the buy / sell zone until price closes through it or it is taken;
        // only then is a new one picked
        if f_alive(lkBuy) and close >= lkBuy.bot
            byZ    := lkBuy
            byWeak := lkBuyW
        else
            lkBuy  := byZ
            lkBuyW := byWeak
        if f_alive(lkSell) and close <= lkSell.top
            slZ    := lkSell
            slWeak := lkSellW
        else
            lkSell  := slZ
            lkSellW := slWeak

    // focus: only the zones nearest to price stay
    if focusOn
        array<Zone> shownZ = array.new<Zone>()
        f_collect_shown(shownZ, obs)
        // with 'Show every gap' on, gaps are left out here: only order blocks are thinned out
        if not fvgAll and ifvgAlways
            // inverse gaps get their own slot: the nearest one above and below
            f_collect_inv(shownZ, fvgs, false)
            array<Zone> shownI = array.new<Zone>()
            f_collect_inv(shownI, fvgs, true)
            f_focus_zones(shownI, 1)
        else if not fvgAll
            f_collect_shown(shownZ, fvgs)
        f_focus_zones(shownZ, focusZn)
        array<Zone> shownL = array.new<Zone>()
        f_collect_shown(shownL, liq)
        f_collect_shown(shownL, mtf1)
        f_collect_shown(shownL, mtf2)
        f_collect_shown(shownL, mtf3)
        f_collect_shown(shownL, mtf4)
        f_focus_zones(shownL, focusLq)

    // always liquidity on both sides of price
    f_liq_side(1, liq, mtf1, mtf2, mtf3, mtf4)
    f_liq_side(-1, liq, mtf1, mtf2, mtf3, mtf4)
    // and this chart's own nearest buy-side liquidity (above) and sell-side liquidity (below)
    array<Zone> noZ = array.new<Zone>()
    f_liq_side(1, liq, noZ, noZ, noZ, noZ)
    f_liq_side(-1, liq, noZ, noZ, noZ, noZ)

    // story: the zone price is in now, the next target, and the live leg
    f_inside_glow(obs)
    f_inside_glow(fvgs)
    f_inside_glow(liq)
    f_inside_glow(mtf1)
    f_inside_glow(mtf2)
    f_inside_glow(mtf3)
    f_inside_glow(mtf4)
    Zone tgt = na
    if storyTgt and swTrend != 0
        array<Zone> lq = array.new<Zone>()
        f_collect_shown(lq, liq)
        f_collect_shown(lq, mtf1)
        f_collect_shown(lq, mtf2)
        f_collect_shown(lq, mtf3)
        f_collect_shown(lq, mtf4)
        float best = na
        if array.size(lq) > 0
            for z in lq
                float d = swTrend == 1 ? box.get_bottom(z.bx) - close : close - box.get_top(z.bx)
                if d > 0 and (na(best) or d < best)
                    best := d
                    tgt  := z
    color tgtC = swTrend == 1 ? cBull : cBear
    if not na(tgt)
        box.set_border_width(tgt.bx, 2)
        box.set_border_color(tgt.bx, color.new(tgt.col, 0))
        box.set_bgcolor(tgt.bx, color.new(tgt.col, 75))
        float edge = swTrend == 1 ? box.get_bottom(tgt.bx) : box.get_top(tgt.bx)
        int   tipT = bar_index + math.max(padBars - 1, 1)
        if na(tgtLn)
            tgtLn := line.new(bar_index, close, tipT, edge, xloc = xloc.bar_index, color = color.new(tgtC, math.max(lnFade - 20, 0)), style = line.style_arrow_right, width = 1)
        else
            line.set_xy1(tgtLn, bar_index, close)
            line.set_xy2(tgtLn, tipT, edge)
            line.set_color(tgtLn, color.new(tgtC, math.max(lnFade - 20, 0)))
    else if not na(tgtLn)
        line.set_color(tgtLn, color.new(tgtC, 100))
    if storyOn and not na(zPx)
        color lc = close >= zPx ? cBull : cBear
        if na(zLive)
            zLive := line.new(zBar, zPx, bar_index, close, xloc = xloc.bar_index, color = color.new(lc, storyTr), style = line.style_dashed, width = 1)
        else
            line.set_xy1(zLive, zBar, zPx)
            line.set_xy2(zLive, bar_index, close)
            line.set_color(zLive, color.new(lc, storyTr))

    // the buy / sell frames and their lines are made anew every update, so they are drawn
    // on top of the zone boxes (newer drawings lie above older ones)
    // (new drawings start at this candle: a copy of the first-candle drawing would point
    // more than 10000 candles back, which TradingView refuses)
    box.delete(buyBx)
    buyBx := box.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_right, text_valign = text.align_center)
    box.delete(sellBx)
    sellBx := box.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, border_color = color.new(color.gray, 100), bgcolor = color.new(color.gray, 100), text_size = szTxt, text_halign = text.align_right, text_valign = text.align_center)
    line.delete(buySl)
    buySl := line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
    line.delete(sellSl)
    sellSl := line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
    line.delete(buyTp)
    buyTp := line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
    line.delete(sellTp)
    sellTp := line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
    line.delete(buyEn)
    buyEn := line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)
    line.delete(sellEn)
    sellEn := line.new(bar_index, close, bar_index, close, xloc = xloc.bar_index, color = color.new(color.gray, 100), style = line.style_dashed, width = 1)

    // zones on one price become one box, then the buy / sell frames
    array<Zone>   mZ   = array.new<Zone>()
    array<float>  gTop = array.new<float>()
    array<float>  gBot = array.new<float>()
    array<int>    gLf  = array.new<int>()
    array<box>    gBox = array.new<box>()
    array<string> gTxt = array.new<string>()
    f_mcollect(mZ, obs, 0)
    // gaps are not combined: each one keeps its own box at its exact prices
    array<Zone> gapZ = array.new<Zone>()
    f_mcollect(gapZ, fvgs, 1)
    f_mcollect(mZ, liq, 2)
    f_mcollect(mZ, mtf1, 2)
    f_mcollect(mZ, mtf2, 2)
    f_mcollect(mZ, mtf3, 2)
    f_mcollect(mZ, mtf4, 2)
    if combZn
        f_combine(mZ, gTop, gBot, gLf, gBox, gTxt, rightT)
    if gapDedupe
        f_gap_dedupe(gapZ)
        array.clear(gapZ)
        f_mcollect(gapZ, fvgs, 1)
    f_gap_texts(gapZ, rightT + int(bsW / 2))
    [byT, byB, byL, byNm, byZb, byVis] = f_bs_frame(buyBx, buySl, buySlLb, f_shown(byZ), 1, gTop, gBot, gLf, gBox, gTxt, rightT)
    [seT, seB, seL, seNm, seZb, seVis] = f_bs_frame(sellBx, sellSl, sellSlLb, f_shown(slZ), -1, gTop, gBot, gLf, gBox, gTxt, rightT)
    // entry, stop and take profit of each side
    bool  midE    = entryIn == "Middle of the zone"
    zBuyT  := byT
    zBuyB  := byB
    zSellT := seT
    zSellB := seB
    // the evidence behind each zone: what meets there, how often price came back to it,
    // and how often this kind of liquidity held on this chart in the past
    [byConf, byW] = f_conf_names(nz(byT), nz(byB), 1)
    [seConf, seW] = f_conf_names(nz(seT), nz(seB), -1)
    int byTch = 0
    int seTch = 0
    if not na(byT) and not na(byZb)
        byTch := f_touches(byT, byB, box.get_left(byZb))
    if not na(seT) and not na(seZb)
        seTch := f_touches(seT, seB, box.get_left(seZb))
    int loN   = array.get(stTot, 1) + array.get(stTot, 3)
    int loHeld = loN > 0 ? math.round(100.0 * (array.get(stRev, 1) + array.get(stRev, 3)) / loN) : 0
    int hiN   = array.get(stTot, 0) + array.get(stTot, 2)
    int hiHeld = hiN > 0 ? math.round(100.0 * (array.get(stRev, 0) + array.get(stRev, 2)) / hiN) : 0
    // one number for how strong a zone is to hold, 0-100 %:
    //   up to 50 for confluence (6 or more things meeting = 50), up to 30 for how often this
    //   kind of liquidity held on this chart (15 when there are too few past cases), up to 20
    //   for the size of the liquidity ($ to $$$$$), minus 7 for every retest after the first
    int byPts = na(byZ) ? 1 : math.max(1, math.min(byZ.pts, 5))
    int sePts = na(slZ) ? 1 : math.max(1, math.min(slZ.pts, 5))
    // weighted confluence (14 points = full) gives up to 60, the past hold rate up to 25,
    // the liquidity size up to 15; every retest after the first takes 6 off
    int byPct = na(byT) ? 0 : int(math.max(0, math.min(100, math.min(byW, 14) / 14.0 * 60 + (loN >= oddsMin ? loHeld * 0.25 : 12) + byPts / 5.0 * 15 - math.max(byTch - 1, 0) * 6)))
    int sePct = na(seT) ? 0 : int(math.max(0, math.min(100, math.min(seW, 14) / 14.0 * 60 + (hiN >= oddsMin ? hiHeld * 0.25 : 12) + sePts / 5.0 * 15 - math.max(seTch - 1, 0) * 6)))
    string byEvid = ""
    string seEvid = ""
    // strong / weak high and low that sit at the sell / buy zone: written inside that zone
    float swNear = 3.0 * nz(atr14)
    bool  hiOnZn = showSW and haveRange and not na(seT) and math.abs(trTop - seT) <= swNear
    bool  loOnZn = showSW and haveRange and not na(byB) and math.abs(trBot - byB) <= swNear
    float byEntry = na(byT) ? na : f_entry(byT, byB, 1)
    float seEntry = na(seT) ? na : f_entry(seT, seB, -1)
    [bySl, byFix, byRR] = f_trade(byT, byB, 1)
    [seSl, seFix, seRR] = f_trade(seT, seB, -1)
    f_sl_draw(buySl, buySlLb, bySl, rightT, rightT + bsW, "B")
    f_sl_draw(sellSl, sellSlLb, seSl, rightT, rightT + bsW, "S")
    // targets above: the sell zone, liquidity, the highs of the range, day, week, month and sessions
    array<float> upC = array.new<float>()
    f_tg_push(upC, seB)
    f_tg_add(upC, liq, 1)
    f_tg_add(upC, mtf1, 1)
    f_tg_add(upC, mtf2, 1)
    f_tg_add(upC, mtf3, 1)
    f_tg_add(upC, mtf4, 1)
    f_tg_push(upC, trTop)
    f_tg_push(upC, pdH)
    f_tg_push(upC, pwH)
    f_tg_push(upC, pmH)
    f_tg_push(upC, asHi)
    f_tg_push(upC, lnHi)
    f_tg_push(upC, nyHi)
    array<float> dnC = array.new<float>()
    f_tg_push(dnC, byT)
    f_tg_add(dnC, liq, -1)
    f_tg_add(dnC, mtf1, -1)
    f_tg_add(dnC, mtf2, -1)
    f_tg_add(dnC, mtf3, -1)
    f_tg_add(dnC, mtf4, -1)
    f_tg_push(dnC, trBot)
    f_tg_push(dnC, pdL)
    f_tg_push(dnC, pwL)
    f_tg_push(dnC, pmL)
    f_tg_push(dnC, asLo)
    f_tg_push(dnC, lnLo)
    f_tg_push(dnC, nyLo)
    bool  tpOn    = showBS and showTp
    bool  fixRR   = tpMode == "Fixed R:R"
    // fixed R:R: the stop sits slMult x the zone height past the zone; the target sits
    // minRR x that same distance on the other side of the zone (from its edge, not its middle)
    float buyTgt  = not tpOn or na(byEntry) ? na : (fixRR ? byFix : f_pick_tp(upC, byEntry, bySl, 1, seB))
    float sellTgt = not tpOn or na(seEntry) ? na : (fixRR ? seFix : f_pick_tp(dnC, seEntry, seSl, -1, byT))
    f_bs_entry(buyEn, buyEnLb, buyBx, byZb, byVis, byNm, byEntry, byT, byB, 1, rightT, rightT + bsW, tpOn and not na(byEntry) and na(buyTgt), byWeak, "", f_word(byPct) + " " + str.tostring(byPct) + "%", byPct)
    f_bs_entry(sellEn, sellEnLb, sellBx, seZb, seVis, seNm, seEntry, seT, seB, -1, rightT, rightT + bsW, tpOn and not na(seEntry) and na(sellTgt), slWeak, "", f_word(sePct) + " " + str.tostring(sePct) + "%", sePct)
    f_bs_tp(buyTp, buyTpLb, buyTgt, byEntry, bySl, rightT, rightT + bsW, "B", fixRR ? byRR : na)
    f_bs_tp(sellTp, sellTpLb, sellTgt, seEntry, seSl, rightT, rightT + bsW, "S", fixRR ? seRR : na)
    zBuySl   := bySl
    zBuyTp   := buyTgt
    zBuyPct  := byPct
    zSellSl  := seSl
    zSellTp  := sellTgt
    zSellPct := sePct
    // two price labels on (almost) the same height become one label with two rows
    f_lb_pair(buyTpLb, sellTpLb)
    f_lb_pair(buySlLb, sellSlLb)
    f_lb_pair(buyTpLb, sellEnLb)
    f_lb_pair(sellTpLb, buyEnLb)
    f_lb_pair(buyTpLb, sellSlLb)
    f_lb_pair(sellTpLb, buySlLb)

    // level tags are collected first, then only the relevant ones are drawn
    array<Lvl> lvs = array.new<Lvl>()

    // strong / weak high and low: when the sell zone (buy zone) is near, just the words
    // "Strong High" / "Weak High" right above that zone (below the buy zone for the low);
    // otherwise a level tag at its price as before
    if showSW and haveRange and not hiOnZn
        f_lv(lvs, trTop, swTrend == -1 ? "Strong High" : "Weak High", trTopT, line.style_solid, cBear)
    if showSW and haveRange and not loOnZn
        f_lv(lvs, trBot, swTrend == 1 ? "Strong Low" : "Weak Low", trBotT, line.style_solid, cBull)


    // the open (not yet broken) swing points, and what a break of each would be
    if showLvSw and not swHiDone and not na(swHi) and not (not na(seT) and math.abs(swHi - seT) <= swNear)
        f_lv(lvs, swHi, swHiName + " (" + swUpName + ")", swHiT, line.style_dashed, cBear)
    if showLvSw and not swLoDone and not na(swLo) and not (not na(byB) and math.abs(swLo - byB) <= swNear)
        f_lv(lvs, swLo, swLoName + " (" + swDnName + ")", swLoT, line.style_dashed, cBull)
    if showLvInt and not inHiDone and not na(inHi)
        f_lv(lvs, inHi, "i" + inHiName + " (" + inUpName + ")", inHiT, line.style_dotted, cBear)
    if showLvInt and not inLoDone and not na(inLo)
        f_lv(lvs, inLo, "i" + inLoName + " (" + inDnName + ")", inLoT, line.style_dotted, cBull)

    if showPD and haveRange
        float rng   = trTop - trBot
        float midPx = (trTop + trBot) / 2.0
        float band  = rng * pdPct / 100.0
        // full halves: premium = upper half, discount = lower half, equilibrium = a band in the middle
        float pTop = trTop
        float pBot = pdFull ? midPx + band / 2.0 : trTop - band
        float eTop = midPx + band / 2.0
        float eBot = midPx - band / 2.0
        float dTop = pdFull ? midPx - band / 2.0 : trBot + band
        float dBot = trBot
        // long: from the start of the swing range (or pdBars back) to the column
        int   pdLeft = f_bx(pdBars > 0 ? bar_index - pdBars : math.min(trTopB, trBotB))
        // the named column right of the zones
        int   colL = bar_index + pdColL
        int   colR = bar_index + pdColR
        f_pd_box(pdPremBk, pdLeft, pTop, colL, pBot, cPrem, pdDimC, "")
        f_pd_box(pdEqBk, pdLeft, eTop, colL, eBot, cEq, pdDimC, "")
        f_pd_box(pdDiscBk, pdLeft, dTop, colL, dBot, cDisc, pdDimC, "")
        f_pd_box(pdPremBx, colL, pTop, colR, pBot, cPrem, pdDim, "Premium")
        f_pd_box(pdEqBx, colL, eTop, colR, eBot, cEq, pdDim, "Equilibrium")
        f_pd_box(pdDiscBx, colL, dTop, colR, dBot, cDisc, pdDim, "Discount")
        line.set_xy1(pdEqLn, pdLeft, midPx)
        line.set_xy2(pdEqLn, colR, midPx)
        line.set_color(pdEqLn, color.new(cEq, lnFade))
        // the exact high and low the range is measured from: a line from the candle to the column
        line.set_xy1(pdHiLn, f_bx(trTopB), trTop)
        line.set_xy2(pdHiLn, colL, trTop)
        line.set_color(pdHiLn, color.new(cPrem, lnFade))
        line.set_xy1(pdLoLn, f_bx(trBotB), trBot)
        line.set_xy2(pdLoLn, colL, trBot)
        line.set_color(pdLoLn, color.new(cDisc, lnFade))
    else
        line.set_color(pdEqLn, color.new(cEq, 100))
        line.set_color(pdHiLn, color.new(cPrem, 100))
        line.set_color(pdLoLn, color.new(cDisc, 100))
        f_pd_hide(pdPremBk)
        f_pd_hide(pdEqBk)
        f_pd_hide(pdDiscBk)
        f_pd_hide(pdPremBx)
        f_pd_hide(pdEqBx)
        f_pd_hide(pdDiscBx)

    // previous month / week / day high and low: always shown until price trades through them
    if showM
        f_lvk(lvs, pmH, "PMH", pmT, line.style_solid, cLevel, mnHi > pmH)
        f_lvk(lvs, pmL, "PML", pmT, line.style_solid, cLevel, mnLo < pmL)
    if showW
        f_lvk(lvs, pwH, "PWH", pwT, line.style_dashed, cLevel, wkHi > pwH)
        f_lvk(lvs, pwL, "PWL", pwT, line.style_dashed, cLevel, wkLo < pwL)
    if showD
        f_lvk(lvs, pdH, "PDH", pdT, line.style_dotted, cLevel, dHi > pdH)
        f_lvk(lvs, pdL, "PDL", pdT, line.style_dotted, cLevel, dLo < pdL)
    if showOpen
        f_lv(lvs, mOpen, "M Open", pmT, line.style_solid, cGrey)
        f_lv(lvs, wOpen, "W Open", pwT, line.style_dashed, cGrey)
        f_lv(lvs, dOpen, "D Open", pdT, line.style_dotted, cGrey)
    if adrTags and not na(adr) and adr > 0
        f_lv(lvs, dLo + adr, "ADR High", time, line.style_dotted, cGrey)
        f_lv(lvs, dHi - adr, "ADR Low", time, line.style_dotted, cGrey)
    if showRound
        float rnLo = math.floor(close / roundStep) * roundStep
        f_lv(lvs, rnLo + roundStep, str.tostring(rnLo + roundStep), time, line.style_dotted, cGrey)
        f_lv(lvs, rnLo, str.tostring(rnLo), time, line.style_dotted, cGrey)
    if showSess and sessTag
        f_lv(lvs, asHi, "Asia H", asT, line.style_solid, cAsia)
        f_lv(lvs, asLo, "Asia L", asT, line.style_solid, cAsia)
        f_lv(lvs, lnHi, "Lon H", lnT, line.style_solid, cLon)
        f_lv(lvs, lnLo, "Lon L", lnT, line.style_solid, cLon)
        f_lv(lvs, nyHi, "NY H", nyT, line.style_solid, cNy)
        f_lv(lvs, nyLo, "NY L", nyT, line.style_solid, cNy)
    // draw the level tags (with focus: only the nearest above and below price)
    array<bool> lvKeep = f_focus_levels(lvs, focusOn, focusLv)
    if array.size(lvs) > 0
        for i = 0 to array.size(lvs) - 1
            if array.get(lvKeep, i)
                Lvl l = array.get(lvs, i)
                // the tags sit on the same centre line as the buy / sell zone, SL and TP
                f_level(l.px, l.name, l.t0, l.st, rightT + int(bsW / 2), lvTol, l.c)
    // a tag that would sit on the buy / sell zone column is moved just above or below it
    if array.size(lvLb) > 0
        for k = 0 to array.size(lvLb) - 1
            label tg = array.get(lvLb, k)
            float ty = label.get_y(tg)
            // the text sits on the column, so a tag in or right at the buy / sell zone moves just
            // above or below the zone, clear of its text
            float tagG = 0.6 * nz(atr14)
            if not na(zSellT) and ty <= zSellT + tagG and ty >= zSellB - tagG
                label.set_y(tg, ty >= (zSellT + zSellB) / 2.0 ? zSellT + tagG : zSellB - tagG)
            ty := label.get_y(tg)
            if not na(zBuyT) and ty <= zBuyT + tagG and ty >= zBuyB - tagG
                label.set_y(tg, ty >= (zBuyT + zBuyB) / 2.0 ? zBuyT + tagG : zBuyB - tagG)
            // a level on (almost) the same price as an SL or TP text: written one after the
            // other on one row ("SL 4144  ·  PDH") instead of on top of each other; the level
            // keeps its own dashed line at its exact price
            for slt in array.from(buySlLb, sellSlLb, buyTpLb, sellTpLb)
                string tgTxt = label.get_text(tg)
                float  ly    = label.get_y(slt)
                if tgTxt != "" and label.get_text(slt) != "" and math.abs(label.get_y(tg) - ly) < 0.6 * nz(atr14)
                    label.set_text(slt, label.get_text(slt) + "  ·  " + tgTxt)
                    label.set_text(tg, "")
    // every text gets a background in exactly the colour behind it, so it is invisible
    // and only cuts the dashed line where the text is: the line breaks tight around the name
    for tl in array.concat(array.copy(lvLb), array.from(buySlLb, sellSlLb, buyTpLb, sellTpLb))
        label.set_color(tl, f_mask(label.get_y(tl)))
    // session open labels stay at the height of the highest candle on screen
    if showOpn and not na(visHigh) and array.size(opnLbs) > 0
        for openLb in opnLbs
            box.set_top(openLb, visHigh + 0.5 * nz(atr14))
            box.set_bottom(openLb, visHigh)
    if showOrb and not na(orbHi)
        string orbTxt = "ORB" + (orbBreak == 1 ? " ▲" : (orbBreak == -1 ? " ▼" : "")) + (orbBoth ? " (both sides)" : "")
        array.push(lastBoxes, box.new(orbT0, orbHi, math.max(orbLive and orbBreak == 0 ? time : orbT1, orbT0 + 4 * tfMs), orbLo, xloc = xloc.bar_time, border_color = color.new(cLevel, 20), border_style = line.style_dashed, bgcolor = color.new(cLevel, 92), text = orbTxt, text_size = szTxt, text_color = cLevel, text_halign = text.align_center, text_valign = text.align_center))

// ----------------------------------------------------------------- alerts ---
// every message starts with symbol and timeframe: "XAUUSD 15m · ..."
f_al(string msg) =>
    syminfo.ticker + " " + f_tf_name(timeframe.period) + " · " + msg + " · price " + str.tostring(close, format.mintick)

f_plan(float b, float t, int pct, float sl, float tp) =>
    f_px(b) + " - " + f_px(t) + " · " + f_word(pct) + " " + str.tostring(pct) + "%" + (na(sl) ? "" : " · SL " + f_px(sl)) + (na(tp) ? "" : " · TP " + f_px(tp))

// the trade of each side: 0 = waiting, 1 = price touched the zone (then TP or SL is watched)
var int   bTr  = 0
var float bSlA = na
var float bTpA = na
var int   sTr  = 0
var float sSlA = na
var float sTpA = na
// heads-up given (reset when price is 2 ATR away again)
var bool  bNear = false
var bool  sNear = false

if alertsOn
    float a1 = nz(atr14)
    // buy zone: heads-up, touch, then TP or SL
    if not na(zBuyT)
        float dB = low - zBuyT
        if dB > 2 * a1
            bNear := false
        if alNear and not bNear and bTr == 0 and dB > 0 and dB <= a1
            bNear := true
            alert(f_al("Price is close to the BUY ZONE " + f_plan(zBuyB, zBuyT, zBuyPct, zBuySl, zBuyTp)), alert.freq_once_per_bar)
        if bTr == 0 and low <= zBuyT and high >= zBuyB
            bTr  := 1
            bSlA := zBuySl
            bTpA := zBuyTp
            bNear := true
            if alZone
                alert(f_al("Price reached the BUY ZONE " + f_plan(zBuyB, zBuyT, zBuyPct, zBuySl, zBuyTp)), alert.freq_once_per_bar)
    if bTr == 1
        if not na(bSlA) and low <= bSlA
            bTr := 0
            if alTpSl
                alert(f_al("Buy zone trade: STOP LOSS reached at " + f_px(bSlA)), alert.freq_once_per_bar)
        else if not na(bTpA) and high >= bTpA
            bTr := 0
            if alTpSl
                alert(f_al("Buy zone trade: TAKE PROFIT reached at " + f_px(bTpA)), alert.freq_once_per_bar)
    // sell zone: the same the other way
    if not na(zSellT)
        float dS = zSellB - high
        if dS > 2 * a1
            sNear := false
        if alNear and not sNear and sTr == 0 and dS > 0 and dS <= a1
            sNear := true
            alert(f_al("Price is close to the SELL ZONE " + f_plan(zSellB, zSellT, zSellPct, zSellSl, zSellTp)), alert.freq_once_per_bar)
        if sTr == 0 and high >= zSellB and low <= zSellT
            sTr  := 1
            sSlA := zSellSl
            sTpA := zSellTp
            sNear := true
            if alZone
                alert(f_al("Price reached the SELL ZONE " + f_plan(zSellB, zSellT, zSellPct, zSellSl, zSellTp)), alert.freq_once_per_bar)
    if sTr == 1
        if not na(sSlA) and high >= sSlA
            sTr := 0
            if alTpSl
                alert(f_al("Sell zone trade: STOP LOSS reached at " + f_px(sSlA)), alert.freq_once_per_bar)
        else if not na(sTpA) and low <= sTpA
            sTr := 0
            if alTpSl
                alert(f_al("Sell zone trade: TAKE PROFIT reached at " + f_px(sTpA)), alert.freq_once_per_bar)
    if alStruct and swEv != 0
        alert(f_al("Swing " + f_ev_name(swEv) + (swEv > 0 ? " up" : " down")), alert.freq_once_per_bar_close)
    if alInt and showInt and inEv != 0 and math.abs(inEv) != 1
        alert(f_al("Internal " + f_ev_name(inEv) + (inEv > 0 ? " up" : " down")), alert.freq_once_per_bar_close)
    if alOb and obBroke != 0
        alert(f_al(obBroke == 1 ? "Bullish order block broken" : "Bearish order block broken"), alert.freq_once_per_bar_close)
    if alGap and showFVG and showIFVG and fvgFlip != 0
        alert(f_al(fvgFlip == 1 ? "Bearish gap closed through: now IFVG support" : "Bullish gap closed through: now IFVG resistance"), alert.freq_once_per_bar_close)
    if alSweep and sweptHi
        alert(f_al("Buy-side liquidity swept (above)"), alert.freq_once_per_bar_close)
    if alSweep and sweptLo
        alert(f_al("Sell-side liquidity swept (below)"), alert.freq_once_per_bar_close)
    if alSweep and grabHi and not sweptHi
        alert(f_al("Liquidity grab at a high"), alert.freq_once_per_bar_close)
    if alSweep and grabLo and not sweptLo
        alert(f_al("Liquidity grab at a low"), alert.freq_once_per_bar_close)
    if alOrb and showOrb and orbEvt != 0
        alert(f_al(orbEvt == 1 ? "Opening range broken up" : "Opening range broken down"), alert.freq_once_per_bar_close)
    if opnAlert and tyoNow
        alert(f_al("Asia session open"), alert.freq_once_per_bar)
    if opnAlert and lonNow
        alert(f_al("London session open"), alert.freq_once_per_bar)
    if opnAlert and nycNow
        alert(f_al("New York session open"), alert.freq_once_per_bar)
    if engAlert and engUp
        alert(f_al("Bullish engulfing candle"), alert.freq_once_per_bar_close)
    if engAlert and engDn
        alert(f_al("Bearish engulfing candle"), alert.freq_once_per_bar_close)