typenative 0.0.19 → 0.0.21

package/.github/workflows/npm-publish-github-packages.yml

@@ -1,9 +1,14 @@
 # Triggered by tags matching "TypeNative_{version}" (e.g. TypeNative_0.0.18)
 # Runs tests, creates a GitHub release, and publishes to npm.
 #
-# Requires an NPM_TOKEN secret set in your GitHub repository settings.
-# Setup: npmjs.com → Access Tokens → Generate New Token (Automation)
-#        GitHub repo → Settings → Secrets → Actions → New secret: NPM_TOKEN
+# Uses npm Trusted Publishing (OIDC) — no NPM_TOKEN secret needed.
+# One-time setup on npmjs.com:
+#   typenative package page → Settings → Publishing access → Trusted Publisher → Connect GitHub
+#     - Organization or user: danisss9
+#     - Repository:           typenative
+#     - Workflow filename:    npm-publish-github-packages.yml
+#     - Environment name:     (leave blank)
+# Requires npm >= 11.5.1 (ensured below) and the `id-token: write` permission.
 
 name: Release & Publish
 
@@ -61,6 +66,9 @@ jobs:
           node-version: 24
           registry-url: https://registry.npmjs.org/
 
+      # Trusted Publishing (OIDC) requires npm >= 11.5.1 — ensure we have it
+      - run: npm install -g npm@latest
+
       - name: Extract version from tag
         id: version
         run: echo "VERSION=${GITHUB_REF_NAME#TypeNative_}" >> $GITHUB_OUTPUT
@@ -70,6 +78,6 @@ jobs:
 
       - run: npm ci
 
+      # Authenticates via OIDC (id-token: write) — no NODE_AUTH_TOKEN needed.
+      # Provenance is included automatically; the flag is kept for explicitness.
       - run: npm publish --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -5,6 +5,65 @@ All notable changes to TypeNative will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.21] - 2026-09-06
+
+Self-hosting milestone: the compiler no longer depends on `execa`, `fs-extra`, or `nanoid`, and the
+TypeScript parser is decoupled behind an injectable, normalized JSON AST — produced either by the
+`typescript` npm package (dev CLI) or by the new Go-native `tsparser` tool (self-hosted binary).
+Verified: all 33 test specs transpile identically through both parser paths, and the compiler now
+transpiles its own source all the way to `go build`.
+
+### Added
+
+- **`node:fs` mappings**: `readFileSync`, `writeFileSync`, `appendFileSync`, `existsSync`, `mkdirSync`, `readdirSync`, `copyFileSync`, `rmSync` → Go helpers (`TnReadFile`, `TnWriteFile`, …)
+- **`node:url` mappings**: `fileURLToPath`, `pathToFileURL`
+- **`node:os` mappings**: `platform` (returns `win32`/`darwin`/linux like Node), `homedir`, `tmpdir`
+- **`node:child_process` mappings**: sync `exec`/`execSync`/`spawnSync` shaped like Node's `spawnSync` (`{ stdout, stderr, status }`); `{ stdio: 'inherit' }` runs with the parent's stdio (`TnRunInherit`); `{ input }` pipes stdin (`TnExecInput`)
+- **`node:readline` mapping**: synchronous `question(prompt)` for interactive native prompts (`TnQuestion`, single buffered stdin reader)
+- **`process.env.X`** → `TnGetenv("X")`
+- **Go helper registry**: node-stdlib helpers are emitted once into the main output file with correct per-file import scoping (helpers register their Go packages lazily; import lists are computed after function bodies are visited)
+- **`tsparser/` Go tool**: parses TypeScript via `github.com/buke/typescript-go-internal` (native Go port of the TypeScript parser — no embedded JS runtime) and emits a normalized JSON AST with TypeScript-API kind and field names
+- **`src/parse-node.ts`**: Node adapter producing the identical JSON AST from the `typescript` npm package; verified byte-identical against `tsparser` on all test specs and all compiler sources
+- **`src/parse-native.ts`**: self-hosted parser client (spawns the `tsparser` binary, `TYPENATIVE_TSPARSER` env override)
+- **Injectable parser**: `transpileToNative(code, { parse, readFile })` — the transpiler no longer imports `typescript`
+- **Unbraced `if`/`else if`/`else` statements**: single-statement branches now emit valid Go blocks
+- **`%` and `%=` on numbers** → `math.Mod`
+- **`./x.js` → `x.ts` import resolution** for ES-style relative specifiers
+- **Tests 31–32**: node-stdlib end-to-end spec (fs round-trip, os platform, shell exec) and subprocess/control-flow spec
+
+### Changed
+
+- **CLI entry split**: `bin/cli.js` (npm `bin`) keeps inquirer for interactive Node use; the transpilable core lives in `src/index.ts` (`run`/`createProject`), with `src/main.ts` as the self-hosting entry and `src/prompt.ts` (transpilable sync prompts) replacing inquirer in native builds
+- **Transpiler internals**: the `ts` typechecker is replaced by syntactic `typeNodeToText`; node predicates became plain `isX()` kind-string functions; operator tokens map through a kind-name table
+- Dropped runtime dependencies: `execa`, `fs-extra`, `nanoid` (replaced by a local `goSafeId`)
+
+## [0.0.20] - 2026-03-16
+
+### Added
+
+- **Spread in array literals**: `[...arr1, ...arr2]` → `append(append([]T{}, arr1...), arr2...)`
+- **Rest parameters**: `function(...args: T[])` → Go variadic `func(...args T)`
+- **Spread in function calls**: `fn(...args)` → `fn(args...)`
+- **Array destructuring**: `const [a, b] = arr` → Go index assignments
+- **Object shorthand**: `{ name }` → `{ name: name }` in struct literals
+- **Static class members**: `static method()` / `static prop` → `ClassName_method()` / `ClassName_prop` package-level declarations; `ClassName.method()` calls correctly resolve
+- **Getters/Setters**: `get prop()` → `Get_prop()` method, `set prop(v)` → `Set_prop(v)` method
+- **`for...in` loops**: `for (const k in obj)` → `for k := range obj`
+- **`Object.entries()` in `for...of`**: `for (const [k, v] of Object.entries(map))` unwraps to `for k, v := range map`
+- **Named function expression IIFEs**: `(function name() { ... })()` → anonymous `func() { ... }()`
+- **`process` global**: `process.argv` → `os.Args`, `process.platform` → `runtime.GOOS`, `process.exit()` → `os.Exit()`, `process.cwd()` → `os.Getwd()`
+- **`JSON.stringify()` / `JSON.parse()`**: mapped to `encoding/json` `Marshal`/`Unmarshal`
+- **`Object.keys()` / `Object.values()` / `Object.entries()`**: map iteration helpers
+- **Array methods**: `findIndex`, `every`, `forEach`, `reduce`, `pop`, `shift`, `unshift`, `reverse`, `sort`, `concat`, `flat`, `at`
+- **String methods**: `padStart`, `padEnd`, `match`, `matchAll`, `search`, `at`
+- **Math methods**: `log`, `log2`, `log10`, `sin`, `cos`, `tan`, `trunc`, `sign`
+- **`console.error()`**: maps to `fmt.Fprintln(os.Stderr, ...)`
+- **`String()` / `Number()` / `Boolean()`** conversion functions
+- **Go reserved words protection**: `getSafeName()` now covers all Go keywords (`break`, `case`, `chan`, `continue`, `default`, `defer`, `else`, `fallthrough`, `for`, `func`, `go`, `goto`, `if`, `import`, `interface`, `map`, `package`, `range`, `return`, `select`, `struct`, `switch`, `type`, `var`)
+- **Default import namespaces from npm/local packages**: `import ts from 'typescript'` registers `ts` as a stripped namespace so `ts.method()` → `method()`
+- **Better unsupported syntax warnings**: `console.warn` with syntax kind name and source snippet instead of `console.log`
+- **Type definitions (`typenative.d.ts`)**: added `findIndex`, `every`, `forEach`, `reduce`, `pop`, `shift`, `unshift`, `reverse`, `sort`, `flat`, `concat`, `at` to `Array`; `padStart`, `padEnd`, `match`, `matchAll`, `search`, `at` to `String`; added `JSON`, `Object`, `Process`, extended `Math` and `Console`
+
 ## [0.0.19] - 2026-03-07
 
 ### Added

package/README.md

@@ -29,10 +29,13 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 
 **Variables & Objects**
 
-| Feature               | Supported | Notes                            |
-| --------------------- | :-------: | -------------------------------- |
-| Variable declarations |    ✅     | `let` and `const`                |
-| Object literals       |    ✅     | Transpiled to Go struct literals |
+| Feature                | Supported | Notes                                           |
+| ---------------------- | :-------: | ----------------------------------------------- |
+| Variable declarations  |    ✅     | `let` and `const`                               |
+| Object literals        |    ✅     | Transpiled to Go struct literals                |
+| Object shorthand       |    ✅     | `{ name }` → `{ name: name }`                  |
+| Array destructuring    |    ✅     | `const [a, b] = arr`                            |
+| Object destructuring   |    ✅     | `const { x, y } = obj`                          |
 
 **Operators**
 
@@ -42,6 +45,7 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Comparison operators     |    ✅     | `==`, `!=`, `===`, `!==`, etc. |
 | Logical operators        |    ✅     | `&&`, `\|\|`                   |
 | Increment/Decrement      |    ✅     | `++`, `--`                     |
+| Spread operator          |    ✅     | `[...arr]`, `fn(...args)`      |
 | Non-null assertion (`!`) |    ✅     | Stripped during transpilation  |
 | Ternary expressions      |    ✅     | `condition ? a : b`            |
 | Nullish coalescing       |    ✅     | `??` operator                  |
@@ -54,21 +58,22 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | If/Else statements |    ✅     | Fully supported                                        |
 | Switch statements  |    ✅     | Case and default statements                            |
 | For loops          |    ✅     | Standard `for` loops                                   |
-| For...of loops     |    ✅     | Iteration over arrays                                  |
+| For...of loops     |    ✅     | Arrays, Maps, Sets; `Object.entries()` unwrapping      |
+| For...in loops     |    ✅     | Iterates keys via Go `range`                           |
 | While loops        |    ✅     | Transpiled to Go's `for` loops                         |
 | Do...while loops   |    ✅     | Implemented with conditional break                     |
 | Try/Catch/Finally  |    ✅     | `throw` → `panic`; catch/finally via `defer`/`recover` |
 
 **Data Structures & Array Methods**
 
-| Feature                    | Supported | Notes                                                                                      |
-| -------------------------- | :-------: | ------------------------------------------------------------------------------------------ |
-| Arrays                     |    ✅     | Basic array operations                                                                     |
-| Array methods              |    ✅     | `push`, `join`, `slice`                                                                    |
-| Higher-order array methods |    ✅     | `.map()`, `.filter()`, `.some()`, `.find()`                                                |
-| Method chaining            |    ✅     | Chaining array methods such as `.map(...).filter(...).join(...)`                           |
-| Map                        |    ✅     | `Map<K, V>` → Go `map[K]V`; `.set()`, `.get()`, `.has()`, `.delete()`, `.clear()`, `.size` |
-| Set                        |    ✅     | `Set<T>` → Go `map[T]struct{}`; `.add()`, `.has()`, `.delete()`, `.clear()`, `.size`       |
+| Feature                    | Supported | Notes                                                                                         |
+| -------------------------- | :-------: | --------------------------------------------------------------------------------------------- |
+| Arrays                     |    ✅     | Basic array operations                                                                        |
+| Array methods              |    ✅     | `push`, `pop`, `shift`, `unshift`, `join`, `slice`, `concat`, `reverse`, `sort`, `flat`, `at` |
+| Higher-order array methods |    ✅     | `.map()`, `.filter()`, `.some()`, `.find()`, `.findIndex()`, `.every()`, `.forEach()`, `.reduce()` |
+| Method chaining            |    ✅     | e.g. `.map(...).filter(...).join(...)`                                                        |
+| Map                        |    ✅     | `Map<K, V>` → Go `map[K]V`; `.set()`, `.get()`, `.has()`, `.delete()`, `.clear()`, `.size`  |
+| Set                        |    ✅     | `Set<T>` → Go `map[T]struct{}`; `.add()`, `.has()`, `.delete()`, `.clear()`, `.size`         |
 
 **Functions**
 
@@ -76,10 +81,12 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | ---------------------------- | :-------: | ----------------------------------------------------------- |
 | Function declarations        |    ✅     | Transpiled to Go functions                                  |
 | Arrow functions              |    ✅     | Transpiled to anonymous functions                           |
+| IIFEs                        |    ✅     | `(() => { ... })()` and `(function name() { ... })()`       |
 | Closures over mutable state  |    ✅     | Functions capturing and mutating outer variables            |
 | Function types               |    ✅     | `() => number`, `(x: number) => string` as type annotations |
 | Generics (functions/classes) |    ✅     | Type parameters via Go generics                             |
 | Default parameter values     |    ✅     | `function(x = defaultValue)`                                |
+| Rest parameters              |    ✅     | `function(...args: T[])` → Go variadic                      |
 
 **Classes & Interfaces**
 
@@ -87,6 +94,8 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | ------------------- | :-------: | -------------------------------------------------------------- |
 | Classes             |    ✅     | Transpiled to Go structs with constructor and receiver methods |
 | Class inheritance   |    ✅     | `extends` via embedded structs, `super()` supported            |
+| Static members      |    ✅     | `static method()` / `static prop` → package-level declarations |
+| Getters / Setters   |    ✅     | `get prop()` → `Get_prop()`, `set prop(v)` → `Set_prop(v)`    |
 | Interfaces          |    ✅     | Transpiled to Go interfaces, supports `extends`                |
 | Optional properties |    ✅     | `prop?: Type` in interfaces/types                              |
 | Enums               |    ✅     | `enum` declarations and member access                          |
@@ -104,9 +113,16 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Feature               | Supported | Notes                                                 |
 | --------------------- | :-------: | ----------------------------------------------------- |
 | console.log           |    ✅     | Mapped to `fmt.Println`                               |
+| console.error         |    ✅     | Mapped to `fmt.Fprintln(os.Stderr, ...)`              |
 | console.time/timeEnd  |    ✅     | Performance measurement via `time.Now` / `time.Since` |
 | assert                |    ✅     | Transpiled to `panic` on failure                      |
 | parseInt / parseFloat |    ✅     | Mapped to Go's `strconv` package                      |
+| JSON.stringify        |    ✅     | Mapped to `encoding/json` `Marshal` / `MarshalIndent` |
+| JSON.parse            |    ✅     | Mapped to `encoding/json` `Unmarshal`                 |
+| Object.keys/values    |    ✅     | Map key/value iteration helpers                       |
+| process.argv          |    ✅     | Mapped to `os.Args`                                   |
+| process.platform      |    ✅     | Mapped to `runtime.GOOS`                              |
+| process.exit          |    ✅     | Mapped to `os.Exit`                                   |
 
 **Math Methods**
 
@@ -116,6 +132,9 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Math.floor / ceil / round |    ✅     | Mapped to `math.Floor`, `math.Ceil`, `math.Round` |
 | Math.abs / sqrt / pow     |    ✅     | Mapped to corresponding `math` functions          |
 | Math.min / max            |    ✅     | Mapped to `math.Min`, `math.Max`                  |
+| Math.log / log2 / log10   |    ✅     | Mapped to `math.Log`, `math.Log2`, `math.Log10`   |
+| Math.sin / cos / tan      |    ✅     | Mapped to `math.Sin`, `math.Cos`, `math.Tan`      |
+| Math.trunc / sign         |    ✅     | Mapped to `math.Trunc` and inline sign check      |
 
 **String Methods**
 
@@ -129,6 +148,9 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | replace / replaceAll       |    ✅     | Via `strings` package                         |
 | charAt / substring / slice |    ✅     | Direct Go string indexing/slicing             |
 | concat / repeat            |    ✅     | String concatenation and `strings.Repeat`     |
+| padStart / padEnd          |    ✅     | Via `strings.Repeat`                          |
+| match / matchAll / search  |    ✅     | Via `regexp` package                          |
+| at                         |    ✅     | Supports negative indices                     |
 
 **Number / Object Methods**
 
@@ -147,12 +169,15 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 
 **Modules & Imports**
 
-| Feature                  | Supported | Notes                                                        |
-| ------------------------ | :-------: | ------------------------------------------------------------ |
-| Local file imports       |    ✅     | `import { x } from './file'` transpiled to Go package import |
-| Node.js built-in imports |    ✅     | `import { join } from 'node:path'` mapped to Go stdlib       |
-| Go package imports       |    ✅     | `import { x } from 'go:pkg'`                                 |
-| npm package imports      |    ✅     | `import { x } from 'pkg'` mapped to Go module imports        |
-| Named exports            |    ✅     | `export function` / `export const` declarations              |
+| Feature                  | Supported | Notes                                                              |
+| ------------------------ | :-------: | ------------------------------------------------------------------ |
+| Named imports            |    ✅     | `import { x } from './file'`                                       |
+| Default imports          |    ✅     | `import x from 'pkg'` — namespace stripped in output               |
+| Namespace imports        |    ✅     | `import * as x from 'pkg'`                                         |
+| Local file imports       |    ✅     | Relative paths transpiled to a separate Go file                    |
+| Node.js built-in imports |    ✅     | `import { join } from 'node:path'` mapped to Go stdlib             |
+| Go package imports       |    ✅     | `import { x } from 'go:pkg'`                                       |
+| npm package imports      |    ✅     | `import { x } from 'pkg'` mapped to Go module imports              |
+| Named exports            |    ✅     | `export function` / `export const` declarations                    |
 
 TypeNative is currently in early development and new features are being added regularly. The goal for `1.0` release is for TypeNative to transpile itself.

package/TODO.md

@@ -1,29 +1,34 @@
-**index.ts needs:**
+# Self-Hosting Roadmap
 
-| Feature                         | Example                                                             |
-| ------------------------------- | ------------------------------------------------------------------- |
-| Default imports                 | `import inquirer from 'inquirer'`, `import fs from 'fs-extra'`      |
-| `process` global                | `process.argv`, `process.platform`                                  |
-| Array `findIndex`               | `process.argv.findIndex(a => a === '--script')`                     |
-| `JSON.parse` / `JSON.stringify` | `JSON.parse(fs.readFileSync(...))`, `JSON.stringify(pckg, null, 2)` |
-| Named async IIFE                | `(async function main() { ... })()`                                 |
+Goal: TypeNative transpiles itself into a native Go binary (1.0 milestone).
 
-**transpiler.ts additionally needs:**
+## Done
+- [x] node:fs mappings (read/write/append/exists/mkdir/readdir/copy/rm) via Go helpers
+- [x] node:url (fileURLToPath/pathToFileURL), node:os (platform/homedir/tmpdir)
+- [x] node:child_process (spawnSync-shaped sync API, stdio-inherit runs)
+- [x] node:readline sync `question` (stdin prompts in native binaries)
+- [x] Go helper-function registry emitted into the main output file
+- [x] Per-file import scoping (imports registered after function-body visits)
+- [x] Unbraced if/else-if/else statements, `%`/`%=` → math.Mod
+- [x] nanoid/fs-extra/execa removed from src; inquirer isolated in Node-only cli.ts
+- [x] Transpilable core: src/index.ts (run/createProject), src/prompt.ts, src/main.ts (self-host entry)
 
-| Feature                             | Example                                             |
-| ----------------------------------- | --------------------------------------------------- |
-| Default imports                     | `import ts from 'typescript'`                       |
-| Spread in array literals            | `[...importedPackages]`, `[...arr1, ...arr2]`       |
-| `for...of` with tuple destructuring | `for (const [funcName, fn] of Object.entries(...))` |
-| `Object.entries()`                  | `Object.entries(mapping.functions)`                 |
-| Arrow function IIFE                 | `(() => { ... })()`                                 |
-| Array `findIndex`                   | `parameters.findIndex(p => !!p.initializer)`        |
+## Done (phase 3a/3b)
+- [x] tsparser/ Go tool: parses TS via buke/typescript-go-internal (no JS runtime),
+      emits normalized JSON AST (kind + TS-spec field names)
+- [x] src/parse-node.ts: Node adapter (typescript npm pkg → same JSON shape)
+- [x] Verified byte-identical AST signatures across all 32 test specs AND all
+      compiler sources (incl. transpiler.ts, 521k-char signature)
 
-**Priority order** (most blocking first):
-
-1. **Default imports** — used at the top of both files, nothing runs without this
-2. **Spread in array literals** — used throughout transpiler.ts for array construction
-3. **`for...of` with tuple destructuring + `Object.entries`** — used for iterating import mappings
-4. **`process` global** — core to CLI argument parsing in index.ts
-5. **IIFE** — the entire entry point of index.ts is an async IIFE
-6. **`findIndex`**, **`JSON.parse/stringify`** — utility methods used in both files
+- [x] ts shim converted to plain isX() functions + string kind literals
+      (object-literal shim was itself untranspilable)
+- [x] Phase 3c: transpiler.ts no longer imports `typescript` — consumes the JSON AST
+      via an injected parse function (ts shim keeps predicate call sites); operator
+      tokens, process.env, stdin-exec mappings added; verified identical Go output
+      via npm parser and Go-parser paths on all 33 test specs
+- [ ] Phase 4: dogfood src/transpiler.ts (2.6k lines): regex /g semantics,
+      String.replace with function replacer, JSON.parse result typing, object spread,
+      Array.includes on untyped values, default-import namespace stripping (ts.x → x)
+- [ ] import.meta.url lowering
+- [ ] Phase 5: stage-1/stage-2 bootstrap + run test suite through the native binary
+- [ ] Phase 5: CI self-hosting job; README/CHANGELOG updates

package/bin/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// Node CLI entry point (npm `bin`). Interactive prompts use inquirer here;
+// the actual compiler logic lives in the transpilable src/index.ts.
+import inquirer from 'inquirer';
+import { run, createProject } from './index.js';
+import { parseAstJson } from './parse-node.js';
+(async function main() {
+    const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
+    const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
+    const sourceIndex = process.argv.findIndex((a) => a === '--source');
+    const source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
+    const outputIndex = process.argv.findIndex((a) => a === '--output');
+    const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter Project Name:',
+            when: newCommand,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'confirm',
+            name: 'installDependencies',
+            message: 'Do you want to install dependencies?',
+            when: newCommand
+        },
+        {
+            type: 'input',
+            name: 'path',
+            message: 'Enter Path to typescript main file:',
+            when: !newCommand && !scriptMode && !source,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'input',
+            name: 'output',
+            message: 'Enter Output Path:',
+            when: !newCommand && !scriptMode && !output,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'editor',
+            name: 'tsCode',
+            message: 'Write your typescript code here:',
+            when: !newCommand && scriptMode && !source,
+            default: `console.log('Hello, World!');`
+        }
+    ]);
+    if (newCommand) {
+        createProject(answers.projectName.trim(), answers.installDependencies);
+        return;
+    }
+    const sourcePath = answers.tsCode ? null : (source ?? answers.path ?? null);
+    run({
+        source: sourcePath,
+        output: output ?? answers.output ?? null,
+        scriptMode,
+        tsCode: answers.tsCode ?? null,
+        parse: parseAstJson
+    });
+})();