openalgo-script 0.1.0-alpha.0 → 0.2.0

package/src/core/engine/bars.ts

@@ -0,0 +1,224 @@
+/**
+ * Step 4 of the bar cycle: the host's bar written into every `"bar"` register.
+ *
+ * The derived price fields are written out as expressions rather than as
+ * formulas because **their order of operations is part of the contract**
+ * (`compiled-program.md` 2.10): `hlc3` adds high to low, adds close to that,
+ * then divides. A different association gives a different last bit, and a study
+ * that matches a reference implementation on one engine and not on another is
+ * exactly the failure this project exists to prevent.
+ *
+ * **An absent volume rather than a zero is deliberate**, on the same ground as
+ * the chart contract's treatment of an unknown tick size: a script that sizes
+ * something by volume has to be able to tell "no trades" from "nobody told me".
+ *
+ * Four of the eight bar facts are the host's and four are the engine's, and a
+ * fact the engine can derive is never also stated by the host, because two
+ * sources for one number can disagree and no rule would say which of them wins.
+ * The session facts are on the derived side of that line: they follow from the
+ * hours in the instrument record, and nothing here asks a host about them.
+ */
+import type { BarView } from './library/index.js';
+import type { SessionFacts } from './session/index.js';
+import type { Value } from './values/index.js';
+import { ABSENT, numberValue } from './values/index.js';
+
+/** One bar as a host supplies it. */
+export interface HostBar {
+  readonly open: number | null;
+  readonly high: number | null;
+  readonly low: number | null;
+  readonly close: number | null;
+  /** Absent, not zero, when the host has no volume for this instrument. */
+  readonly volume?: number | null;
+  /** Bar open time, milliseconds since the Unix epoch, UTC. */
+  readonly time: number | null;
+  /** Contracts outstanding as at the bar, spelled as `host-interface.md` 3.1. */
+  readonly oi?: number | null;
+}
+
+/**
+ * What the host states about the execution, `language.md` 7.2.
+ *
+ * Four facts and never a fifth. `isNew` and `updates` are the hand-over itself,
+ * so they are the call the host made rather than a field on it: `append` is a
+ * new bar and `update` is the same bar again, and the engine counts the
+ * executions the host asked for. Everything else about a bar the engine derives
+ * from the dataset and the position in it, and a host that offered one of those
+ * would be a second source for a number the engine already holds.
+ */
+export interface BarState {
+  /** This bar's interval has elapsed. True for every historical bar. */
+  readonly isConfirmed?: boolean;
+  /** A live feed is driving updates. */
+  readonly isRealtime?: boolean;
+}
+
+/** The facts about the bar being executed, derived once per execution. */
+export interface BarFacts {
+  readonly index: number;
+  readonly count: number;
+  readonly isFirst: boolean;
+  readonly isLast: boolean;
+  readonly isConfirmed: boolean;
+  readonly isRealtime: boolean;
+  readonly isNew: boolean;
+  readonly updates: number;
+  /**
+   * The session this bar falls in, derived from the instrument's own hours.
+   *
+   * Absent where the host stated no session, no timezone or no interval, which
+   * is what `host-interface.md` 4.1 says a script sees when the record holds no
+   * session: absent, and the per-bar session facts absent with it.
+   */
+  readonly isSessionFirst: boolean | null;
+  readonly isSessionLast: boolean | null;
+}
+
+/** The bar fields 2.10 names, and nothing else. */
+export const BAR_FIELDS: readonly string[] = [
+  'open',
+  'high',
+  'low',
+  'close',
+  'volume',
+  'time',
+  'hl2',
+  'hlc3',
+  'ohlc4',
+  'hlcc4',
+  'oi',
+  'bar.index',
+  'bar.count',
+  'bar.isFirst',
+  'bar.isLast',
+  'bar.isConfirmed',
+  'bar.isRealtime',
+  'bar.isNew',
+  'bar.updates',
+];
+
+export function isBarField(name: string): boolean {
+  return BAR_FIELDS.includes(name);
+}
+
+function present(value: number | null | undefined): value is number {
+  return typeof value === 'number';
+}
+
+/** One bar field's value, by the definitions of 2.10. */
+export function barField(field: string, bar: HostBar, facts: BarFacts): Value {
+  const { open, high, low, close } = bar;
+  switch (field) {
+    case 'open':
+      return open ?? ABSENT;
+    case 'high':
+      return high ?? ABSENT;
+    case 'low':
+      return low ?? ABSENT;
+    case 'close':
+      return close ?? ABSENT;
+    case 'volume':
+      return bar.volume ?? ABSENT;
+    case 'oi':
+      return bar.oi ?? ABSENT;
+    case 'time':
+      return bar.time ?? ABSENT;
+    case 'hl2':
+      return present(high) && present(low) ? numberValue((high + low) / 2) : ABSENT;
+    case 'hlc3':
+      return present(high) && present(low) && present(close)
+        ? numberValue((high + low + close) / 3)
+        : ABSENT;
+    case 'ohlc4':
+      return present(open) && present(high) && present(low) && present(close)
+        ? numberValue((open + high + low + close) / 4)
+        : ABSENT;
+    case 'hlcc4':
+      return present(high) && present(low) && present(close)
+        ? numberValue((high + low + close + close) / 4)
+        : ABSENT;
+    case 'bar.index':
+      return facts.index;
+    case 'bar.count':
+      return facts.count;
+    case 'bar.isFirst':
+      return facts.isFirst;
+    case 'bar.isLast':
+      return facts.isLast;
+    case 'bar.isConfirmed':
+      return facts.isConfirmed;
+    case 'bar.isRealtime':
+      return facts.isRealtime;
+    case 'bar.isNew':
+      return facts.isNew;
+    case 'bar.updates':
+      return facts.updates;
+    default:
+      return ABSENT;
+  }
+}
+
+/**
+ * The eight bar facts.
+ *
+ * `bar.index` is a position in the supplied data, not a universal address:
+ * loading more history shifts every index, which is why a script that has to
+ * remember a bar stores `time` instead.
+ */
+export function factsFor(
+  index: number,
+  supplied: number,
+  state: BarState,
+  isNew: boolean,
+  updates: number,
+  session: SessionFacts,
+): BarFacts {
+  return {
+    index,
+    count: index + 1,
+    isFirst: index === 0,
+    // True when this is the greatest index the host has supplied. A live chart
+    // supplies bars one at a time, so its newest bar is always the last; a run
+    // over a whole dataset supplies them together, so only its final bar is.
+    isLast: index === supplied - 1,
+    isConfirmed: state.isConfirmed ?? true,
+    isRealtime: state.isRealtime ?? false,
+    isNew,
+    updates,
+    isSessionFirst: session.isFirstBar,
+    isSessionLast: session.isLastBar,
+  };
+}
+
+/**
+ * The bar as a library call sees it, `compiled-program.md` 2.10.
+ *
+ * The same numbers the registers above are filled from, in the shape a call
+ * reads them in, so that a call and a register can never disagree about what
+ * the bar was. `previousClose` is a fact about the dataset rather than about
+ * any one call, which is why it travels here rather than in a state region.
+ */
+export function barViewOf(
+  bar: HostBar,
+  facts: BarFacts,
+  previousClose: Value,
+): BarView {
+  return {
+    index: facts.index,
+    open: bar.open ?? null,
+    high: bar.high ?? null,
+    low: bar.low ?? null,
+    close: bar.close ?? null,
+    volume: bar.volume ?? null,
+    time: bar.time ?? null,
+    previousClose: typeof previousClose === 'number' ? previousClose : null,
+    isConfirmed: facts.isConfirmed,
+    isRealtime: facts.isRealtime,
+    isNew: facts.isNew,
+    isLast: facts.isLast,
+    updates: facts.updates,
+    isSessionFirst: facts.isSessionFirst,
+    isSessionLast: facts.isSessionLast,
+  };
+}

package/src/core/engine/budget.ts

@@ -0,0 +1,284 @@
+/**
+ * The counters that make a runaway script stop.
+ *
+ * The engine owns the loop, so every one of these is a number it increments
+ * rather than something it hopes about. A platform running many customers'
+ * scripts in one process needs exactly that: exceeding a budget is a diagnostic
+ * on the script that did it, never a hang and never a frozen tab.
+ *
+ * **Two kinds of budget, and the difference matters.**
+ *
+ * The *loop budget* is part of the language. `compiled-program.md` 8.5 requires
+ * two engines to fail at the same iteration of the same loop on the same bar,
+ * so it counts `TICK` executions and nothing else, it comes from the program's
+ * own `limits()` line, and it is identical on every engine.
+ *
+ * The *host budgets* are not part of the language and cannot be, because a
+ * wall clock measures the machine rather than the program. They exist so that
+ * one script cannot take a process down, and a host that sets one accepts that
+ * a program refused here may run elsewhere. That is why the clock is off unless
+ * a host asks for it and why the step ceiling is derived from the program
+ * rather than chosen: see `stepBound`.
+ *
+ * The clock is read once every `clockEvery` steps rather than every step. A
+ * clock read costs more than an instruction, and reading it per instruction
+ * would make the wall clock the thing the wall clock measures.
+ */
+import type { Span } from '../span/index.js';
+import { raise } from './errors.js';
+import type { CompiledProgram } from './types.js';
+
+export interface EngineLimits {
+  /**
+   * Instructions one bar may execute, or null to derive it from the program.
+   *
+   * A verified program's bar has a bound that can be computed at load, so the
+   * derived value is the honest ceiling and a host rarely needs to set one.
+   */
+  readonly steps: number | null;
+  /** Milliseconds one bar may take, or null for no clock at all. */
+  readonly ms: number | null;
+  /** Elements one array may hold, `language.md` 14.1, OS5002. */
+  readonly arrayElements: number;
+  /** Code points one string may hold, OS5008. */
+  readonly stringLength: number;
+  /**
+   * Drawing objects one script may hold at once, OS5010.
+   *
+   * The host's, like the string ceiling: the language fixes no number, and a
+   * host that sets one accepts that a script refused here draws on another.
+   * What the language does fix is that reaching it is reported and that the
+   * oldest object is never dropped to make room, which is `stdlib.md` 14.4.
+   */
+  readonly drawingObjects: number;
+  /** Call frames, OS5005 at load. */
+  readonly frames: number;
+  /** The most a program's own `limits(loops = ...)` may ask for, OS5003. */
+  readonly loops: number | null;
+  /** The most a program's own `limits(history = ...)` may ask for, OS5003. */
+  readonly history: number | null;
+  /** Instructions in the whole program, OS5009 at load, or null for no ceiling. */
+  readonly instructions: number | null;
+  /** State regions, OS5004 at load, or null for no ceiling. */
+  readonly states: number | null;
+  /**
+   * Higher timeframe and other instrument reads one file may make, OS5006.
+   *
+   * The host's, because each read is a series it fetches and keeps in step with
+   * the chart. Reported at load rather than silently capped: dropping the reads
+   * past a ceiling is a plot that quietly turns absent, and nothing on the chart
+   * would say which one went.
+   */
+  readonly requests: number | null;
+  /** Steps between two readings of the clock. */
+  readonly clockEvery: number;
+}
+
+/**
+ * What an engine allows when a host says nothing.
+ *
+ * The ceilings that have a catalogue code are set; the clock is off, because a
+ * default wall clock would make the same script pass on a fast machine and fail
+ * on a slow one with nobody having asked for that trade.
+ *
+ * **`arrayElements` is the one number here the language fixes.** `language.md`
+ * 14.1 states it, so it is not a host's choice and a host lowering it refuses a
+ * script that a conforming engine runs. `scripts/check-limits.mjs` compares it
+ * against that sentence on every build, which is the only reason this file may
+ * write the number at all. Every other ceiling below is the host's, because the
+ * specification leaves it open.
+ */
+export const DEFAULT_LIMITS: EngineLimits = {
+  steps: null,
+  ms: null,
+  arrayElements: 1_000_000,
+  stringLength: 100_000,
+  drawingObjects: 10_000,
+  frames: 64,
+  loops: null,
+  history: null,
+  instructions: null,
+  states: null,
+  requests: null,
+  clockEvery: 4096,
+};
+
+export function limitsWith(given: Partial<EngineLimits> | undefined): EngineLimits {
+  return given === undefined ? DEFAULT_LIMITS : { ...DEFAULT_LIMITS, ...given };
+}
+
+/**
+ * The most instructions one bar of this program can possibly execute.
+ *
+ * Verification proves three things that together bound a bar: the target of
+ * every backward jump is a `TICK` (3.5 check 6), so no cycle runs without
+ * charging the loop budget; recursion is an error, so the call graph is acyclic
+ * and each call site's body runs at most once per acyclic segment; and the
+ * instruction lists are finite. So a segment between two `TICK` executions
+ * costs at most the program's whole instruction count once, and there are at
+ * most `limits.loops` such segments plus the one that ends at `HALT`.
+ *
+ * The number is generous by design. It is not a performance budget: it is the
+ * proof that a bar terminates, turned into a counter so that a program which
+ * somehow exceeds its own static bound stops instead of running forever.
+ */
+export function stepBound(program: CompiledProgram): number {
+  let acyclic = program.code.length;
+  for (const site of program.callSites) {
+    acyclic += program.functions[site.fn]?.code.length ?? 0;
+  }
+  const segments = Math.max(program.limits.loops, 0) + 1;
+  return Math.max(acyclic, 1) * segments + acyclic;
+}
+
+/** A reading of the clock, injected so that a test is not at the mercy of one. */
+export type Clock = () => number;
+
+/**
+ * The per-bar counters.
+ *
+ * One object per engine, reset at step 3 of every execution of a bar, so a long
+ * dataset is never itself a reason to fail.
+ */
+export class Budget {
+  private loops = 0;
+  private steps = 0;
+  private started = 0;
+  private nextClockAt = 0;
+  private bar = 0;
+
+  private readonly limits: EngineLimits;
+  private readonly stepCeiling: number;
+  private readonly loopCeiling: number;
+  private readonly clock: Clock | undefined;
+
+  constructor(
+    limits: EngineLimits,
+    stepCeiling: number,
+    loopCeiling: number,
+    clock: Clock | undefined,
+  ) {
+    this.limits = limits;
+    this.stepCeiling = stepCeiling;
+    this.loopCeiling = loopCeiling;
+    this.clock = clock;
+  }
+
+  /** Step 3: the counters start again for this execution of this bar. */
+  begin(bar: number): void {
+    this.bar = bar;
+    this.loops = 0;
+    this.steps = 0;
+    this.nextClockAt = this.limits.clockEvery;
+    this.started = this.limits.ms !== null && this.clock !== undefined ? this.clock() : 0;
+  }
+
+  /**
+   * One instruction executed.
+   *
+   * Returns whether a budget is spent, rather than raising, so the dispatch
+   * loop does the check inline and the cost is one comparison on the path every
+   * instruction takes.
+   */
+  step(): boolean {
+    this.steps += 1;
+    if (this.steps > this.stepCeiling) return true;
+    if (this.steps >= this.nextClockAt) {
+      this.nextClockAt = this.steps + this.limits.clockEvery;
+      if (this.clock !== undefined && this.limits.ms !== null) {
+        return this.clock() - this.started > this.limits.ms;
+      }
+    }
+    return false;
+  }
+
+  /** Which budget the last `step` ran out of, and the diagnostic for it. */
+  overrun(span: Span, loopLine: number | undefined): never {
+    const max = this.limits.ms;
+    if (this.steps <= this.stepCeiling && max !== null && this.clock !== undefined) {
+      raise('OS5007', span, { bar: this.bar, ms: this.clock() - this.started, max });
+    }
+    // The step ceiling is the static bound of `stepBound`, and a loop is the
+    // only construct that can approach it, so the loop that was running is the
+    // one to name. A bar that passes it with no loop running contradicts what
+    // verification proved about the program, which is OS6018's case.
+    this.spentLoops(span, loopLine);
+  }
+
+  /** Step 5.5: one iteration of loop `l` charged to the per-bar budget. */
+  tick(span: Span, line: number): void {
+    this.loops += 1;
+    if (this.loops > this.loopCeiling) this.spentLoops(span, line);
+  }
+
+  private spentLoops(span: Span, line: number | undefined): never {
+    if (line === undefined) {
+      raise('OS6018', span, {
+        location: `step ${this.steps}`,
+        reason:
+          'the bar executed more instructions than the program can reach without a loop, ' +
+          'so the instruction list is not the one verification walked',
+      });
+    }
+    raise('OS5001', span, {
+      budget: this.loopCeiling,
+      line,
+      suggested: suggestBudget(this.loopCeiling),
+    });
+  }
+
+  /**
+   * The drawing object ceiling, OS5010, charged before the object is built.
+   *
+   * `held` is what the script holds now, so the object about to be created is
+   * number `held + 1` and the refusal names that number. Checked before
+   * building rather than after, because an engine that allocates first and
+   * complains second has already spent the memory it is refusing to spend.
+   */
+  checkDrawing(span: Span, held: number): void {
+    if (held >= this.limits.drawingObjects) {
+      raise('OS5010', span, { max: this.limits.drawingObjects, found: held + 1 });
+    }
+  }
+
+  /** The array ceiling, OS5002. */
+  checkArray(span: Span, name: string, size: number): void {
+    if (size > this.limits.arrayElements) {
+      raise('OS5002', span, { max: this.limits.arrayElements, name, size });
+    }
+  }
+
+  /** The string ceiling, OS5008, counted in code points as 3.1 requires. */
+  checkString(span: Span, text: string): string {
+    this.checkLength(span, [...text].length);
+    return text;
+  }
+
+  /**
+   * The same ceiling against a length that has not been built yet.
+   *
+   * `str.repeat` is where a string ceiling is actually reached, and building
+   * the string first to measure it is how an engine runs out of memory instead
+   * of reporting that it would have.
+   */
+  checkLength(span: Span, length: number): void {
+    if (length > this.limits.stringLength) {
+      raise('OS5008', span, { max: this.limits.stringLength, found: length });
+    }
+  }
+}
+
+/**
+ * A budget with room to spare, for OS5001's fix line.
+ *
+ * The catalogue asks for a budget that would have completed the bar, and the
+ * engine cannot know one: it stopped the loop rather than finishing it. Twice
+ * the budget, rounded to one significant figure so the number reads like
+ * something a person would type, is the nearest honest thing, and the message
+ * beside it says the first fix is the exit condition.
+ */
+function suggestBudget(budget: number): number {
+  const doubled = Math.max(budget * 2, 1000);
+  const magnitude = Math.pow(10, Math.floor(Math.log10(doubled)));
+  return Math.ceil(doubled / magnitude) * magnitude;
+}

package/src/core/engine/channels.ts

@@ -0,0 +1,171 @@
+/**
+ * Channels and the two things step 8 and step 9 do with them.
+ *
+ * A channel holds at most one value per bar and `EMIT` is the only way to write
+ * one. One instruction and one flat table cover plots, levels, markers, alert
+ * conditions, alert messages, bar colouring and pane background; a surface is a
+ * declaration in `outputs` that points at a channel, and is not machinery.
+ *
+ * **Publishing and applying are two different steps, and the split is the whole
+ * of what a script may do on a moving bar.** Step 8 writes every channel into
+ * the bar's output column, absence included, so the drawing is recomputed from
+ * scratch on every update and published every time. Step 9 applies the channels
+ * declared `defer` and the pending effects, and only when the bar is confirmed
+ * or `meta.onUnconfirmed` is true: a signal, an alert or an order waits for the
+ * bar to close.
+ *
+ * **A bar that was not decided reads back absent on its deferred channels.**
+ * Step 9 discards them rather than delivering them (5.1, and 12.7's held
+ * marker), and a reader of the columns is where that discarding has to be
+ * visible: a marker whose text stayed in the buffer would be drawn on the
+ * moving bar by whoever read the column, which is the one thing the deferral
+ * exists to prevent. The value is kept rather than erased, because the next
+ * execution of that bar may be the one that confirms it.
+ *
+ * A second write on the same bar replaces the first, so the last write wins and
+ * no surface needs a rule of its own.
+ */
+import type { Span } from '../span/index.js';
+import type { Effect } from './library/index.js';
+import type { Channel } from './types.js';
+import type { Value } from './values/index.js';
+import { ABSENT } from './values/index.js';
+
+/** A library call with an effect, held until the bar is decided. */
+export interface PendingEffect {
+  /** The index into `lib.functions`, which is what 5.4 says a record holds. */
+  readonly fn: number;
+  readonly name: string;
+  readonly effect: Effect;
+  /** The argument values as they stood when the call executed. */
+  readonly args: readonly Value[];
+  /**
+   * The names those values arrived under, from the engine's own manifest.
+   *
+   * Carried so that step 9 can name an argument without counting one. The
+   * ledger reads an order call by position and has to report it by name, and a
+   * table of names beside the table of positions is the same signature written
+   * out twice.
+   */
+  readonly params: readonly string[];
+  /**
+   * Where the call is written.
+   *
+   * Carried on the record rather than looked up later, because step 9 runs
+   * after the machine has finished and the position of an instruction is
+   * knowable only while it is executing. A refusal that could not name a line
+   * would point a reader at the file and not at the call.
+   */
+  readonly at: Span;
+}
+
+export class Channels {
+  private readonly current: Value[];
+  private readonly deferred: boolean[];
+  /** One column per channel: the value published for each bar. */
+  private readonly columns: Value[][];
+  /** Whether step 9 applied the deferred channels for each bar. */
+  private readonly decided: boolean[] = [];
+  private pending: PendingEffect[] = [];
+  /** Whether any channel at all is deferred, so the common case costs nothing. */
+  private readonly anyDeferred: boolean;
+
+  constructor(channels: readonly Channel[]) {
+    this.current = new Array<Value>(channels.length).fill(ABSENT);
+    this.deferred = channels.map((one) => one.defer);
+    this.anyDeferred = this.deferred.some((one) => one);
+    this.columns = channels.map(() => []);
+  }
+
+  count(): number {
+    return this.current.length;
+  }
+
+  /** Step 3: every channel and the pending effect list start empty. */
+  clear(): void {
+    this.current.fill(ABSENT);
+    this.pending = [];
+  }
+
+  /** `EMIT`: the last write on a bar is the one that counts. */
+  write(channel: number, value: Value): void {
+    this.current[channel] = value;
+  }
+
+  read(channel: number): Value {
+    return this.current[channel] ?? ABSENT;
+  }
+
+  /** 5.4: a call with an effect records itself and pushes absent. */
+  defer(record: PendingEffect): void {
+    this.pending.push(record);
+  }
+
+  /** Step 8: the columns, absence included, whatever the bar's state. */
+  publish(bar: number): void {
+    for (let c = 0; c < this.columns.length; c += 1) {
+      const column = this.columns[c];
+      if (column === undefined) continue;
+      column[bar] = this.current[c] ?? ABSENT;
+    }
+  }
+
+  /**
+   * Step 9: the deferred channels and the effects, or neither.
+   *
+   * Returns the effects to apply, and nothing when the bar is still moving. The
+   * consequence is the one `language.md` 7.5 promises: a condition that was
+   * true halfway through a bar and false when it closed never places an order,
+   * because the execution that produced the record was thrown away.
+   */
+  decide(bar: number, apply: boolean): readonly PendingEffect[] {
+    this.decided[bar] = apply;
+    if (!apply) {
+      this.pending = [];
+      return [];
+    }
+    const effects = this.pending;
+    this.pending = [];
+    return effects;
+  }
+
+  /** Whether a channel's value is held back on a bar that is still moving. */
+  isDeferred(channel: number): boolean {
+    return this.deferred[channel] === true;
+  }
+
+  /** The value published for one channel on one bar, absent where nothing wrote. */
+  at(channel: number, bar: number): Value {
+    if (this.withheld(channel, bar)) return ABSENT;
+    return this.columns[channel]?.[bar] ?? ABSENT;
+  }
+
+  /** One channel's whole column, for a host building a plotted series. */
+  column(channel: number, bars: number): readonly Value[] {
+    const held = this.columns[channel] ?? [];
+    const deferred = this.anyDeferred && this.deferred[channel] === true;
+    const out: Value[] = [];
+    for (let bar = 0; bar < bars; bar += 1) {
+      out.push(deferred && this.decided[bar] !== true ? ABSENT : held[bar] ?? ABSENT);
+    }
+    return out;
+  }
+
+  /** Every channel's value on one bar, which is what a bar's result carries. */
+  row(bar: number): readonly Value[] {
+    return this.columns.map((column, channel) =>
+      this.withheld(channel, bar) ? ABSENT : column[bar] ?? ABSENT,
+    );
+  }
+
+  /**
+   * Whether a channel's value for a bar is one step 9 discarded.
+   *
+   * A channel that is not deferred is never withheld, and a bar step 9 applied
+   * withholds nothing, so this is false for every channel of every confirmed
+   * bar and for every plot column ever.
+   */
+  private withheld(channel: number, bar: number): boolean {
+    return this.anyDeferred && this.deferred[channel] === true && this.decided[bar] !== true;
+  }
+}