@casual-simulation/aux-common 3.8.2-alpha.19511653187 → 3.10.3-alpha.20787554310

package/BlobPolyfill.js

@@ -22,7 +22,7 @@ if (!globalThis.Blob) {
     globalThis.Blob = class {
         constructor(parts, options) {
             this.parts = parts.slice();
-            this.type = options === null || options === void 0 ? void 0 : options.type;
+            this.type = options?.type;
         }
         async arrayBuffer() {
             let bytes = [];

package/BlobPolyfill.js.map

@@ -1 +1 @@
-{"version":3,"file":"BlobPolyfill.js","sourceRoot":"","sources":["BlobPolyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IACnB,IAAI,OAAO,OAAO,KAAK,WAAW,EAAE,CAAC;QACjC,OAAO,CAAC,IAAI,CACR,mFAAmF,CACtF,CAAC;IACN,CAAC;IACK,UAAW,CAAC,IAAI,GAAG;QAIrB,YAAY,KAAY,EAAE,OAAY;YAClC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,GAAG,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,CAAC;QAC9B,CAAC;QAED,KAAK,CAAC,WAAW;YACb,IAAI,KAAK,GAAG,EAAc,CAAC;YAC3B,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;YAClC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBAC5B,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;oBAC3B,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;oBACrC,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;gBAC3B,CAAC;qBAAM,IAAI,IAAI,YAAY,WAAW,EAAE,CAAC;oBACrC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;gBACxC,CAAC;qBAAM,IAAI,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;oBAClC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC/C,CAAC;qBAAM,IAAI,IAAI,YAAY,IAAI,EAAE,CAAC;oBAC9B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;oBACxC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC1C,CAAC;YACL,CAAC;YAED,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;YACnC,OAAO,IAAI,CAAC,MAAM,CAAC;QACvB,CAAC;KACJ,CAAC;AACN,CAAC"}
+{"version":3,"file":"BlobPolyfill.js","sourceRoot":"","sources":["BlobPolyfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IACnB,IAAI,OAAO,OAAO,KAAK,WAAW,EAAE,CAAC;QACjC,OAAO,CAAC,IAAI,CACR,mFAAmF,CACtF,CAAC;IACN,CAAC;IACK,UAAW,CAAC,IAAI,GAAG;QAIrB,YAAY,KAAY,EAAE,OAAY;YAClC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,GAAG,OAAO,EAAE,IAAI,CAAC;QAC9B,CAAC;QAED,KAAK,CAAC,WAAW;YACb,IAAI,KAAK,GAAG,EAAc,CAAC;YAC3B,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;YAClC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBAC5B,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;oBAC3B,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;oBACrC,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;gBAC3B,CAAC;qBAAM,IAAI,IAAI,YAAY,WAAW,EAAE,CAAC;oBACrC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;gBACxC,CAAC;qBAAM,IAAI,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;oBAClC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC/C,CAAC;qBAAM,IAAI,IAAI,YAAY,IAAI,EAAE,CAAC;oBAC9B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;oBACxC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC1C,CAAC;YACL,CAAC;YAED,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;YACnC,OAAO,IAAI,CAAC,MAAM,CAAC;QACvB,CAAC;KACJ,CAAC;AACN,CAAC"}

package/README.md

@@ -1,18 +1,336 @@
-# AUX Common
+# @casual-simulation/aux-common
 
 [![npm (scoped)](https://img.shields.io/npm/v/@casual-simulation/aux-common.svg)](https://www.npmjs.com/package/@casual-simulation/aux-common)
 
-A library that contains common operations needed to modify and understand AUX files.
+Core shared library for CasualOS (formerly AUX). This package provides foundational types, utilities, and infrastructure used across all CasualOS components.
+
+## Overview
+
+`aux-common` is the foundation of the CasualOS platform, containing:
+
+-   **Bot System**: Core bot state management, calculations, actions, and events
+-   **Partitions**: Pluggable storage backends for bot state (memory, Yjs CRDT, remote sync)
+-   **WebSockets**: Real-time communication infrastructure for multi-user collaboration
+-   **RPC Framework**: Type-safe remote procedure calls with comprehensive error handling
+-   **Documents**: Collaborative document abstractions using Yjs CRDTs
+-   **Math Utilities**: Vector, quaternion, and rotation classes for 3D graphics
+-   **Common Types**: Actions, events, connections, permissions, and versioning
+-   **Records**: Data record management and WebPush notifications
+-   **Forms**: Form validation and error handling
+-   **State Machines**: State machine abstractions for complex workflows
+-   **Yjs Utilities**: Helper functions and IndexedDB persistence for CRDTs
 
 ## Installation
 
 ```bash
-$ npm install @casual-simulation/aux-common
+npm install @casual-simulation/aux-common
+```
+
+## Package Structure
+
+```
+aux-common/
+├── bots/              # Core bot system (RuntimeBot, actions, events, calculations)
+├── partitions/        # Storage backends (Memory, Yjs, Remote, OtherPlayers)
+├── websockets/        # WebSocket clients and inst records protocol
+├── common/            # Shared types (actions, connections, versioning)
+├── rpc/               # Type-safe RPC framework with error codes
+├── documents/         # Collaborative document abstractions (Yjs)
+├── math/              # Vector2/3, Quaternion, Rotation classes
+├── records/           # Data records and WebPush notifications
+├── yjs/               # Yjs helper functions and IndexedDB persistence
+├── http/              # HTTP interface types
+├── forms/             # Form validation and errors
+├── state-machine/     # State machine abstractions
+├── polyfill/          # Browser polyfills
+├── utils.ts           # General utility functions
+├── Errors.ts          # Error types and handling
+├── Event.ts           # Event system
+└── AppVersion.ts      # Version management
+```
+
+## Core Modules
+
+### Bots (`bots/`)
+
+The bot system is the heart of CasualOS, representing interactive objects with tags and behaviors.
+
+**Key Exports**:
+
+-   `RuntimeBot`: Core bot interface with tags and state
+-   `BotActions`: Actions for creating, updating, and removing bots
+-   `BotCalculations`: Calculate bot properties (positions, rotations, colors)
+-   `BotEvents`: Event types (onClick, onCombine, onDrag, etc.)
+-   `BotIndex`: Fast lookup tables for bot queries
+-   `StateUpdatedEvent`: Bot state change events
+
+**Example**:
+
+```typescript
+import {
+    createBot,
+    botAdded,
+    calculateBotValue,
+} from '@casual-simulation/aux-common';
+
+const bot = createBot('player1', {
+    name: 'Alice',
+    position: { x: 0, y: 0, z: 0 },
+    color: '#ff0000',
+});
+
+const name = calculateBotValue(null, bot, 'name'); // "Alice"
+```
+
+[See bots/README.md for detailed documentation](bots/README.md)
+
+### Partitions (`partitions/`)
+
+Partitions provide pluggable storage backends for bot state, enabling different persistence and synchronization strategies.
+
+**Key Exports**:
+
+-   `AuxPartition`: Base partition interface
+-   `MemoryPartition`: In-memory storage (fast, volatile)
+-   `YjsPartition`: Local Yjs CRDT with IndexedDB persistence
+-   `RemoteYjsPartition`: Networked Yjs with server synchronization
+-   `OtherPlayersPartition`: Multi-user player state aggregation
+-   `PartitionAuthSource`: Authentication coordination
+
+**Example**:
+
+```typescript
+import { createMemoryPartition } from '@casual-simulation/aux-common';
+
+const partition = createMemoryPartition({
+    type: 'memory',
+    initialState: {},
+});
+
+partition.onBotsAdded.subscribe((bots) => {
+    console.log('Bots added:', bots);
+});
+```
+
+[See partitions/README.md for detailed documentation](partitions/README.md)
+
+### WebSockets (`websockets/`)
+
+WebSocket infrastructure for real-time communication and inst records synchronization.
+
+**Key Exports**:
+
+-   `ConnectionClient`: Base WebSocket client interface
+-   `AuthenticatedConnectionClient`: Authentication wrapper
+-   `InstRecordsClient`: Inst records protocol (branch watching, updates, device actions)
+-   `WebsocketEvents`: Complete protocol message types
+-   `MemoryConnectionClient`: In-memory client for testing
+
+**Example**:
+
+```typescript
+import { InstRecordsClient } from '@casual-simulation/aux-common';
+
+const instClient = new InstRecordsClient(connectionClient);
+
+const updates$ = instClient.watchBranchUpdates({
+    recordName: 'myRecord',
+    inst: 'myInst',
+    branch: 'main',
+});
+
+updates$.subscribe((event) => {
+    if (event.type === 'updates') {
+        console.log('Received updates:', event.updates);
+    }
+});
+```
+
+[See websockets/README.md for detailed documentation](websockets/README.md)
+
+### Common (`common/`)
+
+Foundational types and utilities used throughout CasualOS.
+
+**Key Exports**:
+
+-   `Action`: Base action type
+-   `RemoteActions`: Device actions and results
+-   `ConnectionInfo`: Connection metadata
+-   `ConnectionIndicator`: Connection tokens and credentials
+-   `CurrentVersion`: Version vectors for synchronization
+-   `StatusUpdate`: Progress and status messages
+-   `DenialReason`: Permission denial reasons
+
+**Example**:
+
+```typescript
+import type {
+    Action,
+    ConnectionInfo,
+    CurrentVersion,
+} from '@casual-simulation/aux-common';
+
+const action: Action = {
+    type: 'show_toast',
+    message: 'Hello, world!',
+};
+```
+
+[See common/README.md for detailed documentation](common/README.md)
+
+### RPC (`rpc/`)
+
+Type-safe remote procedure call framework with comprehensive error handling.
+
+**Key Exports**:
+
+-   `RPCResult`: Result types (success/error)
+-   `ErrorCodes`: 100+ standardized error codes
+-   `RPCError`: Error type with code and message
+-   Procedure types: `GetAccountInfoProcedure`, `CreateRecordProcedure`, etc.
+
+**Example**:
+
+```typescript
+import type { GetAccountInfoProcedure } from '@casual-simulation/aux-common';
+
+const result = await client.call('getAccountInfo', {});
+
+if (result.success) {
+    console.log('User:', result.data.user);
+} else {
+    console.error('Error:', result.errorCode, result.errorMessage);
+}
+```
+
+### Documents (`documents/`)
+
+Collaborative document abstractions using Yjs CRDTs.
+
+**Key Exports**:
+
+-   `YjsSharedDocument`: Local Yjs document with persistence
+-   `RemoteYjsSharedDocument`: Networked Yjs with server sync
+-   `SharedMap`, `SharedArray`, `SharedText`: Collaborative data structures
+
+**Example**:
+
+```typescript
+import { YjsSharedDocument } from '@casual-simulation/aux-common';
+
+const doc = new YjsSharedDocument({
+    type: 'yjs',
+    branch: 'my-doc',
+});
+
+const map = doc.getMap('data');
+map.set('key', 'value');
+```
+
+[See documents/README.md for detailed documentation](documents/README.md)
+
+### Math (`math/`)
+
+Vector, quaternion, and rotation classes for 3D graphics and spatial calculations.
+
+**Key Exports**:
+
+-   `Vector2`: 2D vectors with arithmetic and geometric operations
+-   `Vector3`: 3D vectors with cross product and direction constants
+-   `Quaternion`: Quaternion representation of rotations
+-   `Rotation`: High-level rotation interface with multiple construction methods
+
+**Example**:
+
+```typescript
+import { Vector3, Rotation } from '@casual-simulation/aux-common';
+
+const position = new Vector3(1, 2, 3);
+const direction = position.normalize();
+
+const rotation = new Rotation({
+    axis: new Vector3(0, 0, 1),
+    angle: Math.PI / 2,
+});
 ```
 
-## Usage
+[See math/README.md for detailed documentation](math/README.md)
+
+### Yjs (`yjs/`)
+
+Yjs utilities and IndexedDB persistence for CRDTs.
+
+**Key Exports**:
+
+-   `YjsIndexedDBPersistence`: Local storage with automatic trimming
+-   `getStateVector`: Get version vector from Yjs document
+-   `createRelativePositionFromStateVector`: CRDT-safe positions
+-   `getTextChar`: Character-level text access
+
+**Example**:
+
+```typescript
+import {
+    YjsIndexedDBPersistence,
+    getStateVector,
+} from '@casual-simulation/aux-common';
+import * as Y from 'yjs';
+
+const doc = new Y.Doc();
+const persistence = new YjsIndexedDBPersistence('my-doc', doc);
+
+await persistence.whenSynced;
+console.log('Document loaded from IndexedDB');
+
+const stateVector = getStateVector(doc);
+console.log('State:', stateVector);
+```
+
+[See yjs/README.md for detailed documentation](yjs/README.md)
+
+## Usage Examples
 
-#### Calculate a formula for some bots
+### Basic Bot Management
+
+```typescript
+import {
+    createBot,
+    botAdded,
+    botUpdated,
+    createMemoryPartition,
+} from '@casual-simulation/aux-common';
+
+// Create partition
+const partition = createMemoryPartition({
+    type: 'memory',
+    initialState: {},
+});
+
+// Add bot
+await partition.applyEvents([
+    botAdded(
+        createBot('bot1', {
+            name: 'My Bot',
+            color: '#ff0000',
+        })
+    ),
+]);
+
+// Update bot
+await partition.applyEvents([
+    botUpdated('bot1', {
+        tags: { color: '#00ff00' },
+    }),
+]);
+
+// Subscribe to changes
+partition.onBotsUpdated.subscribe((updates) => {
+    console.log('Bots updated:', updates);
+});
+```
+
+### Calculate Bot Formulas
 
 ```typescript
 import {
@@ -21,46 +339,36 @@ import {
     calculateFormulaValue,
 } from '@casual-simulation/aux-common';
 
-const file1 = createBot('test1', {
+const bot1 = createBot('test1', {
     quantity: 10,
 });
-const file2 = createBot('test2', {
+const bot2 = createBot('test2', {
     quantity: 5,
 });
-const file3 = createBot('test3', {
+const bot3 = createBot('test3', {
     quantity: 5,
 });
 
-const context = createCalculationContext([file1, file2, file3]);
+const context = createCalculationContext([bot1, bot2, bot3]);
 
 const formula = '=math.sum(getBotTagValues("#quantity"))';
 const result = calculateFormulaValue(context, formula);
 
-console.log(result);
-
-// Outputs:
-// 20
+console.log(result); // 20
 ```
 
-#### Calculate events for an action script
+### Calculate Action Events
 
 ```typescript
 import {
     createBot,
-    createCalculationContext,
     calculateFormulaEvents,
 } from '@casual-simulation/aux-common';
 
 const state = {
-    test1: createBot('test1', {
-        quantity: 10,
-    }),
-    test2: createBot('test2', {
-        quantity: 5,
-    }),
-    test3: createBot('test3', {
-        quantity: 5,
-    }),
+    test1: createBot('test1', { quantity: 10 }),
+    test2: createBot('test2', { quantity: 5 }),
+    test3: createBot('test3', { quantity: 5 }),
 };
 
 const formula = `
@@ -76,7 +384,166 @@ for (let event of events) {
         }
     }
 }
+// Outputs: [Toast] The total is 20
+```
 
-// Outputs:
-// [Toast] The total is 5
+### Real-Time Collaboration
+
+```typescript
+import {
+    InstRecordsClient,
+    AuthenticatedConnectionClient,
+    createRemoteClientYjsPartition,
+} from '@casual-simulation/aux-common';
+
+// Set up connection
+const authClient = new AuthenticatedConnectionClient(baseClient, authSource);
+const instClient = new InstRecordsClient(authClient);
+
+// Create remote partition
+const partition = await createRemoteClientYjsPartition(
+    {
+        type: 'yjs_client',
+        client: instClient,
+        recordName: 'project',
+        inst: 'workspace',
+        branch: 'main',
+    },
+    authSource
+);
+
+partition.connect();
+
+// Watch for updates
+partition.onBotsAdded.subscribe((bots) => {
+    console.log('Bots added:', bots);
+});
+```
+
+### 3D Calculations
+
+```typescript
+import {
+    Vector3,
+    Rotation,
+    calculateBotValue,
+} from '@casual-simulation/aux-common';
+
+const bot = createBot('player', {
+    position: { x: 1, y: 2, z: 3 },
+    rotation: { x: 0, y: 0, z: Math.PI / 4 },
+});
+
+const position = calculateBotValue(null, bot, 'position') as Vector3;
+const rotation = calculateBotValue(null, bot, 'rotation') as Rotation;
+
+const forward = new Vector3(0, 1, 0);
+const worldForward = rotation.rotateVector3(forward);
+
+const newPosition = position.add(worldForward.multiplyScalar(5));
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                        CasualOS                             │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  ┌────────────────────────────────────────────────────┐   │
+│  │              Application Layer                     │   │
+│  │  (aux-vm, aux-runtime, aux-web, casualos-cli)     │   │
+│  └────────────────────┬───────────────────────────────┘   │
+│                       │                                     │
+│  ┌────────────────────▼───────────────────────────────┐   │
+│  │              @casual-simulation/aux-common         │   │
+│  ├────────────────────────────────────────────────────┤   │
+│  │                                                    │   │
+│  │  ┌──────────┐  ┌───────────┐  ┌──────────────┐  │   │
+│  │  │   Bots   │  │Partitions │  │  WebSockets  │  │   │
+│  │  │          │  │           │  │              │  │   │
+│  │  │ Actions  │  │  Memory   │  │ InstRecords  │  │   │
+│  │  │ Events   │  │  Yjs      │  │ Connection   │  │   │
+│  │  │ Calcs    │  │  Remote   │  │ Auth         │  │   │
+│  │  └──────────┘  └───────────┘  └──────────────┘  │   │
+│  │                                                    │   │
+│  │  ┌──────────┐  ┌───────────┐  ┌──────────────┐  │   │
+│  │  │   RPC    │  │ Documents │  │     Math     │  │   │
+│  │  │          │  │           │  │              │  │   │
+│  │  │ Errors   │  │ SharedMap │  │ Vector2/3    │  │   │
+│  │  │ Results  │  │ SharedText│  │ Quaternion   │  │   │
+│  │  │ Procs    │  │ Yjs CRDT  │  │ Rotation     │  │   │
+│  │  └──────────┘  └───────────┘  └──────────────┘  │   │
+│  │                                                    │   │
+│  │  ┌──────────┐  ┌───────────┐  ┌──────────────┐  │   │
+│  │  │  Common  │  │    Yjs    │  │   Records    │  │   │
+│  │  │          │  │           │  │              │  │   │
+│  │  │ Actions  │  │ Helpers   │  │  WebPush     │  │   │
+│  │  │ Connect  │  │ IndexedDB │  │  Policies    │  │   │
+│  │  │ Versions │  │ Persist   │  │  Schemas     │  │   │
+│  │  └──────────┘  └───────────┘  └──────────────┘  │   │
+│  │                                                    │   │
+│  └────────────────────────────────────────────────────┘   │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
 ```
+
+## Key Concepts
+
+### Bot-Centric Architecture
+
+CasualOS uses a bot-centric model where everything is a bot with tags:
+
+-   **Bots**: Objects with ID and tags (key-value pairs)
+-   **Tags**: Properties that define bot behavior and appearance
+-   **Actions**: Events that modify bot state
+-   **Calculations**: Compute derived properties from tags
+
+### Partition-Based Storage
+
+Storage is abstracted through partitions:
+
+-   **Memory**: Fast, volatile in-memory storage
+-   **Yjs**: Local CRDT with IndexedDB persistence
+-   **Remote**: Networked CRDT with server synchronization
+-   **OtherPlayers**: Multi-user player state aggregation
+
+### Real-Time Collaboration
+
+Multi-user collaboration via:
+
+-   **Yjs CRDTs**: Conflict-free replicated data types
+-   **WebSocket Protocol**: Inst records protocol for updates
+-   **State Vectors**: Track document versions
+-   **Operational Transforms**: Apply edits at specific versions
+
+### Type-Safe Communication
+
+Type safety across the stack:
+
+-   **RPC Framework**: Type-safe remote procedures
+-   **Zod Schemas**: Runtime validation
+-   **Error Codes**: Standardized error handling
+-   **Observable Streams**: RxJS for reactive programming
+
+## License
+
+AGPL-3.0-only
+
+## Related Packages
+
+-   `@casual-simulation/aux-runtime`: Runtime execution engine
+-   `@casual-simulation/aux-vm`: Virtual machine implementations
+-   `@casual-simulation/aux-web`: Web application UI
+-   `@casual-simulation/aux-records`: Server-side record management
+-   `@casual-simulation/casualos-cli`: Command-line interface
+
+## Contributing
+
+See [DEVELOPERS.md](../../DEVELOPERS.md) for development guidelines.
+
+## Version
+
+Current version: 3.8.1
+
+See [CHANGELOG.md](../../CHANGELOG.md) for version history

package/bots/BotCalculations.js

@@ -456,8 +456,7 @@ export function parseScript(value) {
  * @param value The value to parse.
  */
 export function parseScriptSafe(value) {
-    var _a;
-    return (_a = parseScript(value)) !== null && _a !== void 0 ? _a : value;
+    return parseScript(value) ?? value;
 }
 /**
  * Parses the given value into a module script.
@@ -478,8 +477,7 @@ export function parseModule(value) {
  * @param value The value to parse.
  */
 export function parseModuleSafe(value) {
-    var _a;
-    return (_a = parseModule(value)) !== null && _a !== void 0 ? _a : value;
+    return parseModule(value) ?? value;
 }
 /**
  * Parses the given value into a formula.
@@ -500,8 +498,7 @@ export function parseFormula(value) {
  * @param value The value to parse.
  */
 export function parseFormulaSafe(value) {
-    var _a;
-    return (_a = parseFormula(value)) !== null && _a !== void 0 ? _a : value;
+    return parseFormula(value) ?? value;
 }
 /**
  * Trims the leading script symbol off the given tag.
@@ -1550,9 +1547,8 @@ export function calculateAnchorPoint(value) {
     return DEFAULT_ANCHOR_POINT;
 }
 export function getMapPortalKind(bot) {
-    var _a;
     const kind = calculateStringTagValue(null, bot, 'auxMapPortalKind', null);
-    return (_a = calculateMapPortalKind(kind)) !== null && _a !== void 0 ? _a : DEFAULT_MAP_PORTAL_KIND;
+    return calculateMapPortalKind(kind) ?? DEFAULT_MAP_PORTAL_KIND;
 }
 export function calculateMapPortalKind(value) {
     if (value === 'globe' || value === 'plane') {
@@ -1816,7 +1812,7 @@ function calculateBotCursor(calc, bot, tag) {
             y: position.y,
         };
     }
-    catch (_a) {
+    catch {
         /* empty because we want to hide the error and return the default */
     }
     return DEFAULT_BOT_CURSOR;
@@ -2372,10 +2368,9 @@ export function simulationIdToString(id) {
     return id.channel;
 }
 export function parseSimulationId(id) {
-    var _a;
     try {
         let uri = new URL(id);
-        const channel = (_a = uri.searchParams.get('inst')) !== null && _a !== void 0 ? _a : uri.searchParams.get('server');
+        const channel = uri.searchParams.get('inst') ?? uri.searchParams.get('server');
         if (channel) {
             return {
                 success: true,
@@ -2827,9 +2822,8 @@ export function hasMaskForTag(bot, tag) {
  * @param space The space.
  */
 export function getTagValueForSpace(bot, tag, space) {
-    var _a, _b;
     if (hasValue(space)) {
-        return (_b = (_a = bot.masks) === null || _a === void 0 ? void 0 : _a[space]) === null || _b === void 0 ? void 0 : _b[tag];
+        return bot.masks?.[space]?.[tag];
     }
     else {
         return bot.tags[tag];
@@ -2843,9 +2837,8 @@ export function getTagValueForSpace(bot, tag, space) {
  * @param tag The tag.
  */
 export function getSpaceForTag(bot, tag) {
-    var _a, _b;
     for (let space of TAG_MASK_SPACE_PRIORITIES) {
-        if (hasValue((_b = (_a = bot.masks) === null || _a === void 0 ? void 0 : _a[space]) === null || _b === void 0 ? void 0 : _b[tag])) {
+        if (hasValue(bot.masks?.[space]?.[tag])) {
             return space;
         }
     }
@@ -2882,10 +2875,9 @@ export function getUpdateForTagAndSpace(tag, value, space) {
  * @param tag The tag to parse.
  */
 export function parseNewTag(tag) {
-    var _a;
     const script = parseScript(tag);
     const formula = parseFormula(tag);
-    const name = (_a = script !== null && script !== void 0 ? script : formula) !== null && _a !== void 0 ? _a : tag;
+    const name = script ?? formula ?? tag;
     return {
         name,
         isScript: !!script,