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 ref;
if ((ref = regex.exec(string))) {
  const match = ref;
  console.log(match[1], match[2]);
}

let ref;
if (
  (ref = /^(.*\/)?([^/]*)$/.exec(file)) &&
  Array.isArray(ref) &&
  ref.length === 3
) {
  const [, dir, base] = ref;
  console.log(dir, base);
}

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

let node = linkedList.head;
let ref;
while ((ref = node)) {
  const { data, next } = ref;
  console.log(data);
  node = next;
}

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

$: document.title = title;
({ $: "dollar" });
({ $: "dollar" });

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 templated = {
  [`${prefix}${suffix}`]: result,
};

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.at(-1);

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

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

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

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

([...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);
}

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

const letters = ["a", "b", "c", "d", "e", "f"];
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const reversed = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
const indices = ((s, e) => {
  let step = e > s ? 1 : -1;
  return Array.from(
    { length: Math.abs(e - s) },
    (_, i) => s + i * step
  );
})(0, array.length);

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

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

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

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

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

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

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);

a === b;
a !== b;
a && b;
a || 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 &&= b;
a ||= b;
a ??= b;
obj.key ??= "civet";

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

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 instanceof b && !(b instanceof c);
x != null && x instanceof Function;

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

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

var xor: (a: unknown, b: unknown) => boolean = (
  a,
  b
) => (a ? !b && a : b);
xor(a, b);
xor(a, b);
a = xor(a, b);
a = xor(a, b);

var xnor: (a: unknown, b: unknown) => boolean = (
  a,
  b
) => (a ? b : !b || a);
xnor(a, b);
xnor(a, b);
a = xnor(a, b);
a = xnor(a, b);

var modulo: (a: number, b: number) => number = (
  a,
  b
) => ((a % b) + b) % b;
let a = -3;
let b = 5;
let rem = a % b;
let mod = modulo(a, b);
console.log(rem, mod);

var is: {
  <B, A extends B>(a: A, b: B): b is A;
  <A, B>(a: A, b: B): a is A & B;
} = Object.is as any;
is(a, b);
!is(a, b);

console.log(Object.keys(data));

(x.length + 1).toString();

return await(await fetch(url)).json();

data = data.content;

array.pop(),
  array.push(5),
  array.sort(),
  array.reverse(),
  array;

let ref;
console.log((ref = count + 1)),
  console.log((ref = ref * 2)),
  ref;

let ref;
((response) => console.log(response.status))(
  (ref = await fetch(url))
),
  ((json) => console.log("json:", json))(
    (ref = await ref.json())
  ),
  callback(ref);

let ref;
(data = func2((ref = func1(data)))), func3(ref);

await Promise.allSettled(promises);

await Promise.all(
  (() => {
    const results = [];
    for (const url of urls) {
      results.push(fetch(url));
    }
    return results;
  })()
);

await Promise.all(
  (() => {
    const results = [];
    for (const url of urls) {
      results.push(
        (async () => {
          {
            return await (
              await fetch(url)
            ).json();
          }
        })()
      );
    }
    return results;
  })()
);

console.log(x, f(x), f(g(x)), g(f(x)));

console.log(
  "Hello",
  name,
  "!",
  JSON.stringify({
    id: getId(),
    date: new Date(),
  })
);

function abort() {
  return process.exit(1);
}

function circle(degrees: number): {
  x: number;
  y: number;
} {
  const radians = (degrees * Math.PI) / 180;
  return {
    x: Math.cos(radians),
    y: Math.sin(radians),
  };
}

function abort() {
  process.exit(1);
}

function abort(): void {
  process.exit(1);
}

async function run(
  command: string
): Promise<void> {
  await exec(command);
}

(function () {
  {
    return console.log("Anonymous");
  }
});
function f() {
  {
    return console.log("Named");
  }
}
function f(x) {
  {
    return console.log(x);
  }
}

function add(a: string, b: string): string;
function add(a: number, b: number): number {
  return a + b;
}

const abort = () => process.exit(1);

createEffect(() => console.log(data()));
const greet = (name) =>
  console.log("Hello", name);

const add = (a: number, b: number) => a + b;

function add(a: number, b: number) {
  return a + b;
}

const circle = (
  degrees: number
): { x: number; y: number } => {
  const radians = (degrees * Math.PI) / 180;
  return {
    x: Math.cos(radians),
    y: Math.sin(radians),
  };
};

function curryAdd(a: number) {
  return (b: number) => a + b;
}

function sum(list: number[]) {
  let ret = 0;
  for (const item of list) {
    ret += item;
  }
  return ret;
}

function search<T>(list: T[]): T | undefined {
  let ret: T | undefined;
  if (!list) {
    return ret;
  }
  for (const item of list) {
    if (match(item)) {
      ret = item;
    }
  }
  if (ret) {
    ret++;
  }
  list.destroy();
  return ret;
}

x.map(($) => $.name);
x.map(($1) => $1.profile?.name.slice(0, 3));
x.map(($2) => $2.callback(a, b));
x.map(($3) => +$3);
x.filter(($4) => $4);

x.map(($) => $.name);
x.map(($1) => $1?.profile?.name.slice(0, 3));

contains(x, y);
!contains(x, y);

const { min, max } = Math;
max(min(value, ceiling), floor);

function calls<T, R>(t: T, f: (this: T) => R): R {
  return f.call(t);
}
calls(this, callback);

foo(x, foo(y, z));
x(foo(y));

import { contains } from "bar";
contains(x, y);
export function has(x, y) {
  return contains(y, x);
}

const { min, max } = Math;
let smallest = Infinity;
let largest = -Infinity;
for (const item in items) {
  smallest = min(smallest, item);
  largest = max(largest, item);
}

if (coffee || relaxed) {
  code();
} else {
  sleep();
}

if (coffee || relaxed) code();
else sleep();

const name =
  power === Infinity
    ? "Saitama"
    : power > 9000
    ? "Goku"
    : void 0;
const caps =
  name != null ? name.toUpperCase() : "ANON";

if (!tired) {
  code();
}

if (civet.rested) {
  civet.speed = 15;
}

switch (dir) {
  case ">": {
    civet.x++;
    break;
  }
  case "<": {
    civet.x--;
    if (civet.x < 0) {
      civet.x = 0;
    }
    break;
  }
  default: {
    civet.waiting += 5;
  }
}

const getX = (civet: Civet, dir: Dir) => {
  switch (dir) {
    case ">": {
      return civet.x + 3;
    }
    case "<": {
      return civet.x - 1;
    }
    case "^": {
      return civet.x + 0.3;
    }
  }
};

if (s === "") {
  console.log("nothing");
} else if (
  typeof s === "string" &&
  /\s+/.test(s)
) {
  console.log("whitespace");
} else if (s === "hi") {
  console.log("greeting");
}

if (Array.isArray(a) && a.length === 0) {
  console.log("empty");
} else if (Array.isArray(a) && a.length === 1) {
  const [item] = a;
  console.log("one", item);
} else if (Array.isArray(a) && a.length >= 2) {
  const [first, ...middle] = a,
    [last] = middle.splice(-1);
  console.log("multiple", first, "...", last);
} else {
  console.log("not array");
}

if (
  typeof x === "object" &&
  x != null &&
  "type" in x &&
  x.type === "text" &&
  "content" in x
) {
  const { type, content } = x;
  console.log(`"${content}"`);
} else if (
  typeof x === "object" &&
  x != null &&
  "type" in x
) {
  const { type, ...rest } = x;
  console.log(`unknown type ${type}`);
} else {
  console.log("unknown");
}