flingit 0.0.63 → 0.0.65

package/node_modules/@glideapps/ts-necessities/dist/index.d.mts

@@ -0,0 +1,113 @@
+/**
+ * Do nothing, but only compile if `_val` is of type `T`.
+ */
+export declare function proveType<T>(_val: T): void;
+/**
+ * Only compile if `_never` has type `never`.  If run, trace the
+ * `message` and return `result`.
+ */
+export declare function proveNever<T>(_never: never, message: string, result: T): never;
+/**
+ * Throw an `Error` and trace `message`.
+ */
+export declare function panic(message?: string): never;
+/**
+ * Assert that `fact` is `true`.  If the assertion fails, [[panic]]
+ * with `message`.
+ */
+export declare function assert(fact: boolean, message?: string): asserts fact;
+/**
+ * Only compile if `_never` has the type `never`.  If run, [[panic]]
+ * with `message`.
+ */
+export declare function assertNever(_never: never, message?: string): never;
+/**
+ * If `v` is not `undefined`, return `v`.  Otherwise, [[panic]] with
+ * a message including `reason`.
+ */
+export declare function defined<T>(v: T | undefined, reason?: string): T;
+/**
+ * The only thing this function does is to trace if the promise
+ * `p` rejects.  It is useful to explain to ESLint that `p` is
+ * intentionally not `await`ed.
+ *
+ * @deprecated Instead of `dontAwait(x)` use `void x`.
+ */
+export declare function dontAwait<T>(p: Promise<T> | T): void;
+/**
+ * A promise that resolves after `ms` milliseconds.
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * If both `a` and `b` are `undefined`, return `undefined`.
+ * If exactly one of the two is `undefined`, return the other.
+ * If both are not `undefined`, return `f(a, b)`.
+ */
+export declare function reduceTwo<T>(a: T | undefined, b: T | undefined, f: (aa: T, bb: T) => T): T | undefined;
+/**
+ * Remove `readonly` from all properties of `T`.
+ */
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type DeepWritable<T> = {
+    -readonly [P in keyof T]: DeepWritable<T[P]>;
+};
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};
+/**
+ * If `x` is undefined, return `undefined`.  Otherwise, return `f(x)`.
+ */
+export declare function definedMap<T, U>(x: T | undefined, f: (xx: T) => U): U | undefined;
+/**
+ * If `x` belongs to the enum `e`, return `true`.  Otherwise, return `false`.
+ */
+export declare function isEnumValue<T extends object>(e: T, x: unknown): x is T[keyof T];
+/**
+ * Returns whether `x` is an array.
+ *
+ * We have this because `Array.isArray(x)` returns `x is any[]`, which means
+ * that this code compiles without error, for example:
+ *
+ * ```typescript
+ * function thisShouldNotCompile(x: string | readonly string[]) {
+ *     if (Array.isArray(x)) {
+ *         const s = x[0];
+ *         s.thisIsAnAny("but it's actually a string");
+ *     }
+ * }
+ * ```
+ */
+export declare function isArray<T, U>(x: readonly T[] | U): x is readonly T[];
+export declare function isArray<T, U>(x: T[] | U): x is T[];
+/**
+ * Returns whether `obj` has `name` as its own property.
+ */
+export declare function hasOwnProperty<T extends string>(obj: unknown, name: T): obj is {
+    [P in T]: unknown;
+};
+/**
+ * Map `f` over `iterable`, and return an array of all results
+ * that are not `undefined`.
+ */
+export declare function mapFilterUndefined<T, U>(iterable: Iterable<T>, f: (x: T, i: number) => U | undefined): U[];
+/**
+ * Filters out all elements in `arr` that are `undefined`.
+ */
+export declare function filterUndefined<T>(arr: Iterable<T | undefined>): T[];
+export declare function mapRecord<T, U>(r: Record<string, T>, f: (v: T, n: string) => U): Record<string, U>;
+export declare function mapRecordFilterUndefined<T, U>(r: Record<string, T>, f: (v: T, n: string) => U | undefined): Record<string, U>;
+/**
+ * Returns a string representation of `e`, which is supposed to be an
+ * exception.
+ */
+export declare function exceptionToString(e: unknown): string;
+/**
+ * Returns the exception `e` as an instance of `Error`.  If `e` is already an
+ * `Error`, it just returns `e`, otherwise it returns an error with
+ * `exceptionToString(e)`.
+ */
+export declare function exceptionToError(e: unknown): Error;
+export { DefaultMap, ReadonlyDefaultMap } from "./default-map";
+export { BrandedString, brandString, makeBrandString } from "./branded-strings";

package/node_modules/@glideapps/ts-necessities/dist/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Do nothing, but only compile if `_val` is of type `T`.
+ */
+export declare function proveType<T>(_val: T): void;
+/**
+ * Only compile if `_never` has type `never`.  If run, trace the
+ * `message` and return `result`.
+ */
+export declare function proveNever<T>(_never: never, message: string, result: T): never;
+/**
+ * Throw an `Error` and trace `message`.
+ */
+export declare function panic(message?: string): never;
+/**
+ * Assert that `fact` is `true`.  If the assertion fails, [[panic]]
+ * with `message`.
+ */
+export declare function assert(fact: boolean, message?: string): asserts fact;
+/**
+ * Only compile if `_never` has the type `never`.  If run, [[panic]]
+ * with `message`.
+ */
+export declare function assertNever(_never: never, message?: string): never;
+/**
+ * If `v` is not `undefined`, return `v`.  Otherwise, [[panic]] with
+ * a message including `reason`.
+ */
+export declare function defined<T>(v: T | undefined, reason?: string): T;
+/**
+ * The only thing this function does is to trace if the promise
+ * `p` rejects.  It is useful to explain to ESLint that `p` is
+ * intentionally not `await`ed.
+ *
+ * @deprecated Instead of `dontAwait(x)` use `void x`.
+ */
+export declare function dontAwait<T>(p: Promise<T> | T): void;
+/**
+ * A promise that resolves after `ms` milliseconds.
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * If both `a` and `b` are `undefined`, return `undefined`.
+ * If exactly one of the two is `undefined`, return the other.
+ * If both are not `undefined`, return `f(a, b)`.
+ */
+export declare function reduceTwo<T>(a: T | undefined, b: T | undefined, f: (aa: T, bb: T) => T): T | undefined;
+/**
+ * Remove `readonly` from all properties of `T`.
+ */
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type DeepWritable<T> = {
+    -readonly [P in keyof T]: DeepWritable<T[P]>;
+};
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};
+/**
+ * If `x` is undefined, return `undefined`.  Otherwise, return `f(x)`.
+ */
+export declare function definedMap<T, U>(x: T | undefined, f: (xx: T) => U): U | undefined;
+/**
+ * If `x` belongs to the enum `e`, return `true`.  Otherwise, return `false`.
+ */
+export declare function isEnumValue<T extends object>(e: T, x: unknown): x is T[keyof T];
+/**
+ * Returns whether `x` is an array.
+ *
+ * We have this because `Array.isArray(x)` returns `x is any[]`, which means
+ * that this code compiles without error, for example:
+ *
+ * ```typescript
+ * function thisShouldNotCompile(x: string | readonly string[]) {
+ *     if (Array.isArray(x)) {
+ *         const s = x[0];
+ *         s.thisIsAnAny("but it's actually a string");
+ *     }
+ * }
+ * ```
+ */
+export declare function isArray<T, U>(x: readonly T[] | U): x is readonly T[];
+export declare function isArray<T, U>(x: T[] | U): x is T[];
+/**
+ * Returns whether `obj` has `name` as its own property.
+ */
+export declare function hasOwnProperty<T extends string>(obj: unknown, name: T): obj is {
+    [P in T]: unknown;
+};
+/**
+ * Map `f` over `iterable`, and return an array of all results
+ * that are not `undefined`.
+ */
+export declare function mapFilterUndefined<T, U>(iterable: Iterable<T>, f: (x: T, i: number) => U | undefined): U[];
+/**
+ * Filters out all elements in `arr` that are `undefined`.
+ */
+export declare function filterUndefined<T>(arr: Iterable<T | undefined>): T[];
+export declare function mapRecord<T, U>(r: Record<string, T>, f: (v: T, n: string) => U): Record<string, U>;
+export declare function mapRecordFilterUndefined<T, U>(r: Record<string, T>, f: (v: T, n: string) => U | undefined): Record<string, U>;
+/**
+ * Returns a string representation of `e`, which is supposed to be an
+ * exception.
+ */
+export declare function exceptionToString(e: unknown): string;
+/**
+ * Returns the exception `e` as an instance of `Error`.  If `e` is already an
+ * `Error`, it just returns `e`, otherwise it returns an error with
+ * `exceptionToString(e)`.
+ */
+export declare function exceptionToError(e: unknown): Error;
+export { DefaultMap, ReadonlyDefaultMap } from "./default-map";
+export { BrandedString, brandString, makeBrandString } from "./branded-strings";

package/node_modules/@glideapps/ts-necessities/dist/index.js

@@ -0,0 +1,237 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DefaultMap: () => DefaultMap,
+  assert: () => assert,
+  assertNever: () => assertNever,
+  brandString: () => brandString,
+  defined: () => defined,
+  definedMap: () => definedMap,
+  dontAwait: () => dontAwait,
+  exceptionToError: () => exceptionToError,
+  exceptionToString: () => exceptionToString,
+  filterUndefined: () => filterUndefined,
+  hasOwnProperty: () => hasOwnProperty,
+  isArray: () => isArray,
+  isEnumValue: () => isEnumValue,
+  makeBrandString: () => makeBrandString,
+  mapFilterUndefined: () => mapFilterUndefined,
+  mapRecord: () => mapRecord,
+  mapRecordFilterUndefined: () => mapRecordFilterUndefined,
+  panic: () => panic,
+  proveNever: () => proveNever,
+  proveType: () => proveType,
+  reduceTwo: () => reduceTwo,
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/default-map.ts
+var DefaultMap = class extends Map {
+  /**
+   *
+   * @param _defaultFunc Must return the default value for key `k`.  Will only be called when necessary.
+   * @param initKVPs An array of [key, value] arrays to initialize the map with.
+   */
+  constructor(_defaultFunc, initKVPs) {
+    super(initKVPs);
+    this._defaultFunc = _defaultFunc;
+  }
+  /**
+   * Returns the value for `k`.  If `k` is not present, creates
+   * the default value via [[_defaultFunc]], sets that default
+   * as the value for `k` and returns it.
+   */
+  get(k) {
+    let v = super.get(k);
+    if (v === void 0) {
+      if (this.has(k)) return v;
+      v = this._defaultFunc(k);
+      this.set(k, v);
+    }
+    return v;
+  }
+  /**
+   * Sets the value for `k` to `f(v)` where `v` is the previous
+   * value for `k`, or the default if not present.  Returns the new
+   * value.
+   *
+   * These two lines are equivalent:
+   *
+   * ```
+   * m.set("foo", m.get("foo") + 1);
+   * m.update("foo", x => x + 1);
+   * ```
+   */
+  update(k, f) {
+    const v = f(this.get(k));
+    this.set(k, v);
+    return v;
+  }
+};
+
+// src/branded-strings.ts
+function brandString(s) {
+  return s;
+}
+function makeBrandString() {
+  return brandString;
+}
+
+// src/index.ts
+function proveType(_val) {
+}
+function proveNever(_never, message, result) {
+  console.trace(message);
+  return result;
+}
+function panic(message = "This should not happen") {
+  console.trace(message);
+  throw new Error(message);
+}
+function assert(fact, message = "Assertion failed") {
+  if (fact) return;
+  return panic(message);
+}
+function assertNever(_never, message = "`never` happened") {
+  return panic(message);
+}
+function defined(v, reason) {
+  if (v === void 0) {
+    return panic("Value was undefined but should be defined" + (reason !== void 0 ? ` because: ${reason}` : ""));
+  }
+  return v;
+}
+function dontAwait(p) {
+  if (!(p instanceof Promise)) return;
+  p.catch((e) => {
+    console.trace("Unhandled error from unawaited promise", e);
+    throw e;
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function reduceTwo(a, b, f) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  return f(a, b);
+}
+function definedMap(x, f) {
+  if (x === void 0) return void 0;
+  return f(x);
+}
+function isEnumValue(e, x) {
+  return Object.keys(e).map((k) => e[k]).some((v) => v === x);
+}
+function isArray(x) {
+  return Array.isArray(x);
+}
+function hasOwnProperty(obj, name) {
+  if (obj === void 0 || obj === null) return false;
+  return Object.prototype.hasOwnProperty.call(obj, name);
+}
+function mapFilterUndefined(iterable, f) {
+  const result = [];
+  let i = 0;
+  for (const x of iterable) {
+    const y = f(x, i);
+    i += 1;
+    if (y === void 0) continue;
+    result.push(y);
+  }
+  return result;
+}
+function filterUndefined(arr) {
+  const result = [];
+  for (const x of arr) {
+    if (x !== void 0) {
+      result.push(x);
+    }
+  }
+  return result;
+}
+function mapRecord(r, f) {
+  const result = {};
+  for (const [name, value] of Object.entries(r)) {
+    result[name] = f(value, name);
+  }
+  return result;
+}
+function mapRecordFilterUndefined(r, f) {
+  const result = {};
+  for (const [name, value] of Object.entries(r)) {
+    const o = f(value, name);
+    if (o === void 0) continue;
+    result[name] = o;
+  }
+  return result;
+}
+function exceptionToString(e) {
+  if (e === void 0) return "";
+  if (hasOwnProperty(e, "message") && typeof e.message === "string") {
+    return e.message;
+  }
+  try {
+    return e.toString();
+  } catch (f) {
+    try {
+      return `Exception can't be stringified: ${exceptionToString(f)}`;
+    } catch (e2) {
+      return "Exception can't be stringified";
+    }
+  }
+}
+function exceptionToError(e) {
+  if (e instanceof Error) {
+    return e;
+  } else {
+    return new Error(exceptionToString(e));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultMap,
+  assert,
+  assertNever,
+  brandString,
+  defined,
+  definedMap,
+  dontAwait,
+  exceptionToError,
+  exceptionToString,
+  filterUndefined,
+  hasOwnProperty,
+  isArray,
+  isEnumValue,
+  makeBrandString,
+  mapFilterUndefined,
+  mapRecord,
+  mapRecordFilterUndefined,
+  panic,
+  proveNever,
+  proveType,
+  reduceTwo,
+  sleep
+});

package/node_modules/@glideapps/ts-necessities/dist/index.mjs

@@ -0,0 +1,189 @@
+// src/default-map.ts
+var DefaultMap = class extends Map {
+  /**
+   *
+   * @param _defaultFunc Must return the default value for key `k`.  Will only be called when necessary.
+   * @param initKVPs An array of [key, value] arrays to initialize the map with.
+   */
+  constructor(_defaultFunc, initKVPs) {
+    super(initKVPs);
+    this._defaultFunc = _defaultFunc;
+  }
+  /**
+   * Returns the value for `k`.  If `k` is not present, creates
+   * the default value via [[_defaultFunc]], sets that default
+   * as the value for `k` and returns it.
+   */
+  get(k) {
+    let v = super.get(k);
+    if (v === void 0) {
+      if (this.has(k)) return v;
+      v = this._defaultFunc(k);
+      this.set(k, v);
+    }
+    return v;
+  }
+  /**
+   * Sets the value for `k` to `f(v)` where `v` is the previous
+   * value for `k`, or the default if not present.  Returns the new
+   * value.
+   *
+   * These two lines are equivalent:
+   *
+   * ```
+   * m.set("foo", m.get("foo") + 1);
+   * m.update("foo", x => x + 1);
+   * ```
+   */
+  update(k, f) {
+    const v = f(this.get(k));
+    this.set(k, v);
+    return v;
+  }
+};
+
+// src/branded-strings.ts
+function brandString(s) {
+  return s;
+}
+function makeBrandString() {
+  return brandString;
+}
+
+// src/index.ts
+function proveType(_val) {
+}
+function proveNever(_never, message, result) {
+  console.trace(message);
+  return result;
+}
+function panic(message = "This should not happen") {
+  console.trace(message);
+  throw new Error(message);
+}
+function assert(fact, message = "Assertion failed") {
+  if (fact) return;
+  return panic(message);
+}
+function assertNever(_never, message = "`never` happened") {
+  return panic(message);
+}
+function defined(v, reason) {
+  if (v === void 0) {
+    return panic("Value was undefined but should be defined" + (reason !== void 0 ? ` because: ${reason}` : ""));
+  }
+  return v;
+}
+function dontAwait(p) {
+  if (!(p instanceof Promise)) return;
+  p.catch((e) => {
+    console.trace("Unhandled error from unawaited promise", e);
+    throw e;
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function reduceTwo(a, b, f) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  return f(a, b);
+}
+function definedMap(x, f) {
+  if (x === void 0) return void 0;
+  return f(x);
+}
+function isEnumValue(e, x) {
+  return Object.keys(e).map((k) => e[k]).some((v) => v === x);
+}
+function isArray(x) {
+  return Array.isArray(x);
+}
+function hasOwnProperty(obj, name) {
+  if (obj === void 0 || obj === null) return false;
+  return Object.prototype.hasOwnProperty.call(obj, name);
+}
+function mapFilterUndefined(iterable, f) {
+  const result = [];
+  let i = 0;
+  for (const x of iterable) {
+    const y = f(x, i);
+    i += 1;
+    if (y === void 0) continue;
+    result.push(y);
+  }
+  return result;
+}
+function filterUndefined(arr) {
+  const result = [];
+  for (const x of arr) {
+    if (x !== void 0) {
+      result.push(x);
+    }
+  }
+  return result;
+}
+function mapRecord(r, f) {
+  const result = {};
+  for (const [name, value] of Object.entries(r)) {
+    result[name] = f(value, name);
+  }
+  return result;
+}
+function mapRecordFilterUndefined(r, f) {
+  const result = {};
+  for (const [name, value] of Object.entries(r)) {
+    const o = f(value, name);
+    if (o === void 0) continue;
+    result[name] = o;
+  }
+  return result;
+}
+function exceptionToString(e) {
+  if (e === void 0) return "";
+  if (hasOwnProperty(e, "message") && typeof e.message === "string") {
+    return e.message;
+  }
+  try {
+    return e.toString();
+  } catch (f) {
+    try {
+      return `Exception can't be stringified: ${exceptionToString(f)}`;
+    } catch (e2) {
+      return "Exception can't be stringified";
+    }
+  }
+}
+function exceptionToError(e) {
+  if (e instanceof Error) {
+    return e;
+  } else {
+    return new Error(exceptionToString(e));
+  }
+}
+export {
+  DefaultMap,
+  assert,
+  assertNever,
+  brandString,
+  defined,
+  definedMap,
+  dontAwait,
+  exceptionToError,
+  exceptionToString,
+  filterUndefined,
+  hasOwnProperty,
+  isArray,
+  isEnumValue,
+  makeBrandString,
+  mapFilterUndefined,
+  mapRecord,
+  mapRecordFilterUndefined,
+  panic,
+  proveNever,
+  proveType,
+  reduceTwo,
+  sleep
+};

package/node_modules/@glideapps/ts-necessities/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@glideapps/ts-necessities",
+    "version": "2.4.0",
+    "description": "Small utilities to make life with TypeScript easier",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "npm run clean && tsc -d --emitDeclarationOnly --outDir dist && node build.js",
+        "lint": "eslint src --ext .ts,.tsx",
+        "typedoc": "typedoc",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:coverage": "vitest run --coverage",
+        "clean": "rm -rf dist",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "typescript"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/glideapps/ts-necessities.git"
+    },
+    "author": "Glide",
+    "license": "MIT",
+    "devDependencies": {
+        "@eslint/js": "^9.23.0",
+        "@types/node": "^22.13.14",
+        "@typescript-eslint/eslint-plugin": "^8.28.0",
+        "@typescript-eslint/parser": "^8.28.0",
+        "@vitest/coverage-v8": "^3.1.1",
+        "esbuild": "^0.25.2",
+        "eslint": "^9.23.0",
+        "eslint-plugin-import": "^2.31.0",
+        "typedoc": "^0.28.1",
+        "typescript": "^5.8.2",
+        "typescript-eslint": "^8.28.0",
+        "vitest": "^3.1.1"
+    }
+}

package/node_modules/@rollup/rollup-linux-x64-gnu/README.md

@@ -0,0 +1,3 @@
+# `@rollup/rollup-linux-x64-gnu`
+
+This is the **x86_64-unknown-linux-gnu** binary for `rollup`