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

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()) &&
  "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) &&
  "data" in ref &&
  "next" in ref
) {
  const { data, next } = ref;
  console.log(data);
  node = next;
}

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

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 cast = { value: value as T };
const bool = { available: !!available };

const negate = { [-1]: +1, [+1]: -1 };
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[array.length - 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>`);

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

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

"length" in x;

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

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

($) => console.log($.toString);

($: number) => Math.round(($ + 1) * 2);

addRecord(JSON.parse(data) as MyRecord);

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;
((ref = document.createElement("div")).className =
  "civet"),
  ref.appendChild(
    document.createTextNode("Civet"),
  ),
  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;

const add = function (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),
  };
};

const curryAdd = function (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;
}