Reference ​

const a = 10;
let b = 10;
let c: number | string = 0;
let d: boolean;
var v: any;

var sos, square;
sos = 0;
for (const item of iterable) {
  square = item * item;
  sos += square;
}

let sos = 0;
for (const item of iterable) {
  let square = item * item;
  sos += square;
}

let sos = 0;
for (const item of iterable) {
  const square = item * item;
  sos += square;
}

var size;
cache = {};
version = "1.2.3";
size = 1024;

let ref;
if ((ref = regex.exec(string))) {
  const match = ref;
  console.log(match[1], match[2]);
}

function len<
  T extends readonly unknown[],
  N extends number,
>(arr: T, length: N): arr is T & { length: N } {
  return arr.length === length;
}
let ref;
if (
  (ref = /^(.*\/)?([^/]*)$/.exec(file)) &&
  Array.isArray(ref) &&
  len(ref, 3)
) {
  const [, dir, base] = ref;
  console.log(dir, base);
}

let ref;
if (
  (ref = getLocation()) &&
  typeof ref === "object" &&
  "x" in ref &&
  "y" in ref
) {
  const { x, y } = ref;
  console.log(`At ${x}, ${y}`);
} else {
  console.log("Not anywhere");
}

let node = linkedList.head;
while (
  node &&
  typeof node === "object" &&
  "data" in node &&
  "next" in node
) {
  const { data, next } = node;
  console.log(data);
  node = next;
}

let sum = 0;
let ref;
while ((ref = next()) != null) {
  const number = ref;
  sum += number;
}

let ref;
while (
  !(
    (ref = attempt()) &&
    typeof ref === "object" &&
    "status" in ref &&
    ref.status === "OK" &&
    "data" in ref
  )
);
const { data } = ref;
console.log(data);

let ref;
if (!((ref = getItem()) != null)) return;
const item = ref;
let ref1;
if (
  !(
    (ref1 = item.getCoords()) &&
    typeof ref1 === "object" &&
    "x" in ref1 &&
    "y" in ref1
  )
) {
  throw new Error("Item missing coordinates");
}
const { x, y } = ref1;
console.log(`(${x}, ${y})`);

const person = { name: "Henry", age: 4 };
const obj = {
  a: 1,
  b: 2,
  c: {
    x: "pretty",
    y: "cool",
  },
};

const another = {
  name: person.name,
  x: obj?.c?.x,
};
const computed = { foo: foo(), bar: bar() };
let ref;
const named = {
  [((ref = x + y), ref)]: lookup[ref],
};
const cast = { value: value as T };
const bool = { available: !!available };

const obj = {
  a: 1,
  b,
  name: person.name,
  method() {
    return console.log("hi");
  },
};

const negate = { [-1]: +1, [+1]: -1 };
const templated = {
  [`${prefix}${suffix}`]: result,
};
const headers = {
  "Content-Type": "text/html",
  "Content-Encoding": "gzip",
};

point = { x: data.x, y: data.y };
point = { x: data.x, y: data.y };
({ x: point.x, y: point.y } = data);
point3D = { x: point.x, y: point.y, z: 0 };
const complex = { x: obj.a, y: obj.b.c()?.y };
const merged = { ...data.global, ...data.user };
({ a: data.a, b: data.b, ...data.rest } = result);

const config = {
  debug: true,
  live: false,
  verbose: false,
};

const p = {
  name: "Mary",
  say(msg) {
    return console.log(this.name, "says", msg);
  },
  setName(name1) {
    this.name = name1;
  },
  get NAME() {
    return this.name.toUpperCase();
  },
};
p.say(p.NAME);

json["long property"];
json[`${movie} name`];
matrix[0][0];
array[array.length - 1];

json?.data?.value;
account!.name?.first;

mario.brother.name;
mario?.name;
json["long property"][`${movie} name`];

array.length;
array.length;
"a string also".length;

var modulo = ((a: number, b: number) =>
  ((a % b) + b) % b) as ((
  a: number,
  b: number,
) => number) &
  ((a: bigint, b: bigint) => bigint);
class List {
  push(item) {
    return (this[this.length] = item);
  }
  wrap(index) {
    return this[modulo(index, this.length)];
  }
}

"length" in x;

const array = { 0: "a", length: 1 };

getItems(url)
  .filter(($) => $.match)
  .sort();

document
  ?.querySelectorAll(pattern)
  .forEach((element) => {
    return (element.style.color = "purple");
  });

const rotate = [c, -s, s, c];

func.apply(this, [arg1, arg2]);

const people = [
  { name: "Alice", id: 7 },
  { name: "Bob", id: 9 },
];

const rotate = [c, -s, s, c];
func.apply(this, [arg1, arg2]);

const rotate = [c, -s, s, c];

func.apply(this, [arg1, arg2]);

const people = [
  { name: "Alice", id: 7 },
  { name: "Bob", id: 9 },
];

const colorPairs = [
  ["red", "#f00"],
  ["green", "#0f0"],
  ["blue", "#00f"],
];

([...head] = [1, 2, 3, 4, 5]),
  ([last] = head.splice(-1));

({ a, b, ...rest } = { a: 7, b: 8, x: 0, y: 1 });

function justDoIt(a, ...args) {
  let [cb] = args.splice(-1);
  return cb.apply(a, args);
}

let ref;
([first, ...ref] = array),
  ([last] = ref.splice(-1));

var range: (
  start: number,
  end: number,
) => number[] = (start, end) => {
  const length = end - start;
  if (length <= 0) return [];
  const arr = Array(length);
  for (let i = 0; i < length; ++i) {
    arr[i] = i + start;
  }
  return arr;
};
const letters = ["a", "b", "c", "d", "e", "f"];
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const indices = range(0, array.length);

var range: (
  start: number,
  end: number,
) => number[] = (start, end) => {
  const length = end - start;
  if (length <= 0) return [];
  const arr = Array(length);
  for (let i = 0; i < length; ++i) {
    arr[i] = i + start;
  }
  return arr;
};
const indices = range(0, array.length);
const strict = range(a + 1, b);
// [a<=..≤b] same as [a..b]

var revRange: (
  start: number,
  end: number,
) => number[] = (start, end) => {
  const length = start - end;
  if (length <= 0) return [];
  const arr = Array(length);
  for (let i = 0; i < length; ++i) {
    arr[i] = start - i;
  }
  return arr;
};
const reversed = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
const reversedIndices = revRange(
  array.length - 1,
  0 - 1,
);

const start = numbers.slice(0, 2 + 1 || 1 / 0);
const mid = numbers.slice(3, -2);
const end = numbers.slice(-2);
numbers.splice(1, -1 - 1, ...[]);

const strict = numbers.slice(first + 1, last);

type RSliceable<R> =
  | string
  | {
      length: number;
      slice(
        start: number,
        end: number,
      ): { reverse(): R };
    };
var rslice: <R, T extends string | RSliceable<R>>(
  a: T,
  start?: number,
  end?: number,
) => T extends string
  ? string
  : T extends RSliceable<infer R>
    ? R
    : never = (a, start = -1, end = -1) => {
  const l = a.length;
  if (start < 0) start += l;
  if (++end < 0) end += l;
  if (typeof a === "string") {
    let r = "";
    if (start > l - 1) start = l - 1;
    if (end < 0) end = 0;
    for (let i = start; i >= end; --i) r += a[i];
    return r as any;
  } else {
    return a.slice(end, start + 1).reverse();
  }
};
const reversed = rslice(x, -1, 0 - 1);

[left, right] = [
  x.slice(0, i + 1),
  x.slice(i + 1),
];
[left, right] = [x.slice(0, i), x.slice(i)];

var modulo = ((a: number, b: number) =>
  ((a % b) + b) % b) as ((
  a: number,
  b: number,
) => number) &
  ((a: bigint, b: bigint) => bigint);
for (let end = a.length, i1 = 0; i1 < end; ++i1) {
  const i = i1;
  drawAngle(
    v[modulo(i - 1, v.length)],
    v[i],
    v[modulo(i + 1, v.length)],
  );
}

console.log("Hello,\nworld!");

console.log(`<div>
  Civet
</div>`);

console.log(`<div>
  Civet
</div>`);

console.log(`<div>
  Civet ${version}
</div>`);

const phoneNumber =
  /^\+?(\d[\d-. ]+)?(\([\d-. ]+\))?(?=\d)[\d-. ]+\d$/;

const r = RegExp(`${prefix}\\s+${suffix}`);

const magicSymbol = Symbol.for("magic");
iterable = {
  *[Symbol.iterator]() {
    yield 1;
    yield 2;
    yield 3;
  },
  [Symbol.isConcatSpreadable]: true,
};
iterable[Symbol.iterator]();

const magicSymbol = Symbol.magic;
const iteratorSymbol = Symbol.for("iterator");

const magicSymbol = Symbol.for("magic-symbol");

const center = min + length / 2;
const name = user?.name ?? defaultName;
typeof x === "string" && (x += "!");
result! as string | number;

a + (b = c);

(count[key] ??= 0), count[key]++;
(count[key] ??= 0), (count[key] += 1);
++count, (count *= 2);

([first, ...rest] = points), ({ x, y } = first);

({ name } = person), ({ first, last } = name);

a === b;
a !== b;
a && b;
a || b;
!(a in b);
!(a instanceof b);
!(a in b);
!(a instanceof b);
a != null;

array.includes(item);
!array.includes(item);
string.includes(substring);
container.includes(item1) &&
  !container.includes(item2); // Unicode

a.concat(b).concat(c);
[1, 2, 3].concat(rest);

var concatAssign: <
  B,
  A extends
    | { push: (this: A, b: B) => void }
    | (B extends unknown[]
        ? { push: (this: A, ...b: B) => void }
        : never),
>(
  lhs: A,
  rhs: B,
) => A = (lhs, rhs) => (
  (rhs as any)?.[Symbol.isConcatSpreadable] ??
  Array.isArray(rhs)
    ? (lhs as any).push.apply(lhs, rhs as any)
    : (lhs as any).push(rhs),
  lhs
);
concatAssign(a, b);

a &&= b;
a ||= b;
a ??= b;
obj.key ??= "civet";

obj?.prop;
obj?.[key];
fun?.(arg);

obj != null ? (obj.prop = value) : void 0;
obj != null ? (obj[key] = value) : void 0;
fun != null ? (fun(arg).prop = value) : void 0;
let ref;
fun != null &&
(ref = fun(arg)) != null &&
(ref = ref.prop) != null
  ? (ref[key] = value)
  : void 0;

x != null;
x.y[z] != null;
x == null;
(x != null) + (y != null);

a < b && b <= c;
a <= b && b <= c; // Unicode
a == b && b === c && c != d && d !== e;
a === b && b !== c;
a != null && 0 <= a && a < n;
a instanceof b && !(b instanceof c);
x != null && x instanceof Function;

function haveAccess(doc, user) {
  return (
    user != null &&
    (user.super ||
      doc.worldReadable ||
      user.name === doc.owner ||
      (doc.groupReadable &&
        user.group === doc.group))
  );
}

a instanceof b;
!(a instanceof b);
a instanceof b && !(b instanceof c);

typeof a === "string";
typeof a !== "string";
typeof a === "number";
typeof a !== "number";
typeof a !== "number";

type Falsy = false | 0 | '' | 0n | null | undefined;
var xor: <A, B>(a: A, b: B) => A extends Falsy ? B : B extends Falsy ? A : (false | (A & Falsy extends never ? never : B) | (B & Falsy extends never ? never : A)) = (a, b) => (a ? !b && a : b) as any;
xor(a, b)
xor(a, b)
a = xor(a, b)
a = xor(a, b)

type Falsy = false | 0 | '' | 0n | null | undefined;
var xnor: <A, B>(a: A, b: B) => A & Falsy extends never ? B : (true | (B extends Falsy ? never : A) | (A extends Falsy ? never : B)) = (a, b) => (a ? b : !b || a) as any;
xnor(a, b)
xnor(a, b)
a = xnor(a, b)
a = xnor(a, b)

var div1: (a: number, b: number) => number = (
  a,
  b,
) => Math.floor(a / b);
let a = -3;
let b = 5;
let frac = a / b; // -0.6
let div = div1(a, b); // -1
console.log(frac, div);