ranger-compiler 3.4.0 → 3.5.0

package/CHANGELOG.md

@@ -7,27 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [3.4.0] - 2026-09-16
-
-The last package on npm was **3.2.0**. 3.2.1, 3.3.0 and 3.3.1 were
-already dated in this file and never published there, so this tarball
-is the first that carries them.
-
-On the compiler: generic classes (`class History @params(Op)`),
-expanded into ordinary classes before any writer runs; a dotted call
-in return position now parses (`return this.helper()`); Swift string
-operators walk UTF-16 in amortised constant time; Kotlin emits
-`open class` for the header form of inheritance; a Python empty
-constructor writes `pass`; the C++ `Any` union only names classes the
-program actually emits. The TypeScript module build type-checks: a
-`sort` comparator in the serializer used `forEach`, which the ES6
-writer emits as `async`, and `Array.sort` will not take a
-`Promise<number>`. `npm run test:publish` skips the JS-engine
-conformance suites (they are not the published compiler) and runs each
-file in its own fork so a two-minute `shapes` run cannot starve the
-reporter. The gallery grew in the same window — EVG, Office,
-the book engine, Mermaid, Figma — and is not in the npm tarball.
-
 - **All thirty-eight of Mermaid's header keywords are drawn.** The matrix in
   `docs/MERMAID_PARITY.md` is read off Mermaid's own detector registry — the
   record its parser itself consults. It used to say thirty of thirty, and both
@@ -40,10 +19,12 @@ the book engine, Mermaid, Figma — and is not in the npm tarball.
   token is a coloured speck, the slider is the viewport, a problem is a tick,
   and a click or a drag there jumps the view without moving the caret. The
   picture keeps a compact scale (two pixels a line, shrinking only when the
-  file would not fit); the pointer's place on that picture, as a fraction of
-  its height, is how far the editor scrolls. On r5 a finger on the strip
-  stays a pointer, not a line-by-line flick. A panel too narrow to spare
-  the strip hides it. The same map shows on the r5 page, on the light theme.
+  file would not fit); each letter is a faint cell at the opacity of its
+  glyph (~3 % for `.`, ~10 % for `I`, ~20 % for `R`) rather than a solid
+  bar. The pointer's place on that picture, as a fraction of its height,
+  is how far the editor scrolls. On r5 a finger on the strip stays a
+  pointer, not a line-by-line flick. A panel too narrow to spare the strip
+  hides it. The same map shows on the r5 page, on the light theme.
 
 - **FigJam boards draw.** A sticky, a shape with text, a connector and a table
   carry no children: Figma builds their layers itself and a `.jam` ships only

package/README.md

@@ -1,6 +1,6 @@
 # Ranger cross language compiler
 
-**Version 3.4.0** | Status: `experimental`
+**Version 3.3.0** | Status: `experimental`
 
 **Licensing:** Ranger-authored compiler and language sources are MIT licensed,
 unless a file says otherwise. Ranger-authored applications and technology
@@ -78,7 +78,8 @@ host.notifyPath = (path) => { /* sync view model + re-render */ };
 ## Where To Start
 
 - [Documentation site](https://terotests.github.io/Ranger/docs/) — install, first program, types, optionals, and the **generated operator reference** (838 operators, compiled from the sources of the commit that publishes the site, so it cannot drift)
-- [Online playground](https://terotests.github.io/Ranger/) — try Ranger in the browser (`playground/`, Vite + current compiler)
+- [The front page](https://terotests.github.io/Ranger/) — what Ranger is, the targets, the platforms and the gallery (`landing/`)
+- [Online playground](https://terotests.github.io/Ranger/playground/) — try Ranger in the browser (`playground/`, Vite + current compiler)
 - `README.md` - language overview, installation, and syntax notes
 - [`gallery/README.md`](gallery/README.md) - index of the application stack (AGPL): EVG, Office, DataGrid, parsers, games, and `@process` host apps
 - [`LICENSING.md`](LICENSING.md) - MIT compiler vs AGPL gallery

package/dist/api.d.ts

@@ -1697,7 +1697,9 @@ export declare class PkgImport {
     static walkUp(env: InputEnv, start: string): string;
     static readText(env: InputEnv, dir: string, name: string): Promise<string>;
     static findChar(s: string, code: number): number;
+    static manifestChain(env: InputEnv, startDir: string, libraryPaths: Array<string>): Array<string>;
     static resolve(env: InputEnv, startDir: string, spec: string, libraryPaths: Array<string>): Promise<PkgHit>;
+    static resolveIn(env: InputEnv, manDir: string, spec: string): Promise<PkgHit>;
     static lockRoot(env: InputEnv, lockText: string, pkgName: string, manDir: string): string;
 }
 export declare class ClassJoinPoint {
@@ -3704,6 +3706,396 @@ export declare class CLIProgress {
     printFlag(flag: string, description: string): void;
     printSection(title: string): void;
 }
+export declare class GitSha1 {
+    constructor();
+    static mask32(): number;
+    static add32(a: number, b: number): number;
+    static not32(x: number): number;
+    static rotl(x: number, n: number): number;
+    static copyRange(data: Uint8Array, start: number, count: number): Uint8Array;
+    static ascii(data: Uint8Array, start: number, count: number): string;
+    static u32be(data: Uint8Array, i: number): number;
+    static hexDigit(d: number): string;
+    static toHex(data: Uint8Array): string;
+    static fromHex(hex: string): Uint8Array;
+    static hash(data: Uint8Array): Uint8Array;
+    static writeU32be(out: Uint8Array, i: number, v: number): void;
+    static hashHex(data: Uint8Array): string;
+    static objectId(kind: string, payload: Uint8Array): string;
+    static hexEq(a: string, b: string): boolean;
+}
+export declare class GitPkt {
+    ok: boolean;
+    err: string;
+    lines: Array<string>;
+    raw: Array<Uint8Array>;
+    isFlush: Array<boolean>;
+    constructor();
+}
+export declare class GitRef {
+    name: string;
+    sha: string;
+    peeled: string;
+    constructor();
+}
+export declare class GitAdvertisement {
+    ok: boolean;
+    err: string;
+    service: string;
+    caps: string;
+    head: string;
+    refs: Array<GitRef>;
+    constructor();
+}
+export declare class GitWant {
+    ok: boolean;
+    err: string;
+    sha: string;
+    body: Uint8Array;
+    constructor();
+}
+export declare class GitSideband {
+    ok: boolean;
+    err: string;
+    pack: Uint8Array;
+    progress: string;
+    constructor();
+}
+export declare class GitPktIO {
+    constructor();
+    static hexVal(ch: string): number;
+    static parseHex4(data: Uint8Array, at: number): number;
+    static hex4(n: number): string;
+    static encodeLine(text: string): Uint8Array;
+    static encodeFlush(): Uint8Array;
+    static parse(data: Uint8Array): GitPkt;
+    static parseAdvertisement(data: Uint8Array): GitAdvertisement;
+    static findRef(adv: GitAdvertisement, spec: string): string;
+    static hasToken(caps: string, name: string): boolean;
+    static joinBuf(parts: Array<Uint8Array>): Uint8Array;
+    static encodeDelim(): Uint8Array;
+    static buildWant(adv: GitAdvertisement, spec: string): GitWant;
+    static buildWantFetch(sha: string, deepen: number, filter: string, extras: Array<string>): GitWant;
+    static buildWantTrees(adv: GitAdvertisement, spec: string): GitWant;
+    static buildWantSha(sha: string): GitWant;
+    static buildFetchV2(sha: string, deepen: number, filter: string): GitWant;
+    static demux(data: Uint8Array): GitSideband;
+    static indexOfPack(data: Uint8Array): number;
+    static indexOfChar(s: string, code: number): number;
+    static trimNl(s: string): string;
+}
+export declare class ZipBuffer {
+    data: Uint8Array;
+    pos: number;
+    length: number;
+    constructor();
+    initWithBuffer(buf: Uint8Array): void;
+    initWithSize(size: number): void;
+    getPosition(): number;
+    setPosition(newPos: number): void;
+    seek(offset: number): void;
+    skip(count: number): void;
+    remaining(): number;
+    isEOF(): boolean;
+    readUint8(): number;
+    readUint16LE(): number;
+    readUint32LE(): number;
+    readBytes(count: number): Uint8Array;
+    readString(count: number): string;
+    peekUint8(): number;
+    peekUint32LE(): number;
+    writeUint8(value: number): void;
+    writeUint16LE(value: number): void;
+    writeUint32LE(value: number): void;
+    writeBytes(src: Uint8Array, srcOffset: number, count: number): void;
+    writeBuffer(src: Uint8Array): void;
+    writeString(s: string): void;
+    getBuffer(): Uint8Array;
+    getLength(): number;
+    findSignatureBackward(sig: number, startPos: number): number;
+}
+export declare class GrowableZipBuffer {
+    chunks: Array<Uint8Array>;
+    chunkLens: Array<number>;
+    chunkSize: number;
+    currentChunk: Uint8Array;
+    currentPos: number;
+    totalSize: number;
+    constructor();
+    setChunkSize(size: number): void;
+    allocateNewChunk(): void;
+    writeUint8(value: number): void;
+    writeUint16LE(value: number): void;
+    writeUint32LE(value: number): void;
+    writeBytes(src: Uint8Array, srcOffset: number, count: number): void;
+    writeBuffer(src: Uint8Array): void;
+    writeString(s: string): void;
+    getSize(): number;
+    toBuffer(): Uint8Array;
+}
+export declare class InflateHuffmanTable {
+    counts: Array<number>;
+    symbols: Array<number>;
+    maxBits: number;
+    constructor();
+    build(lengths: Array<number>, numSymbols: number): void;
+    decode(reader: InflateBitReader): number;
+}
+export declare class InflateBitReader {
+    data: Uint8Array;
+    bytePos: number;
+    bitPos: number;
+    currentByte: number;
+    dataLength: number;
+    constructor();
+    init(buf: Uint8Array, offset: number, length: number): void;
+    readBit(): number;
+    readBits(count: number): number;
+    alignToByte(): void;
+    readByte(): number;
+    readUint16LE(): number;
+    getBytePosition(): number;
+    isEOF(): boolean;
+}
+export declare class Inflate {
+    input: Uint8Array;
+    reader: InflateBitReader;
+    outBuf: Uint8Array;
+    outLen: number;
+    outCap: number;
+    fixedLitLen: InflateHuffmanTable;
+    fixedDist: InflateHuffmanTable;
+    fixedTablesBuilt: boolean;
+    lengthBase: Array<number>;
+    lengthExtra: Array<number>;
+    distBase: Array<number>;
+    distExtra: Array<number>;
+    constructor();
+    resetOutput(hint: number): void;
+    ensureCapacity(extra: number): void;
+    pushByte(b: number): void;
+    finalOutput(): Uint8Array;
+    buildLengthDistTables(): void;
+    buildFixedTables(): void;
+    decompress(data: Uint8Array): Uint8Array;
+    decompressFrom(data: Uint8Array, offset: number): Uint8Array;
+    inputPos(): number;
+    decompressStored(): void;
+    decompressHuffman(litLenTable: InflateHuffmanTable, distTable: InflateHuffmanTable): void;
+    decompressDynamic(): void;
+    copyFromOutput(distance: number, length: number): void;
+}
+export declare class GitZlib {
+    ok: boolean;
+    err: string;
+    nextPos: number;
+    constructor();
+    inflateAt(data: Uint8Array, offset: number): Uint8Array;
+    inflate(data: Uint8Array): Uint8Array;
+}
+export declare class GitObj {
+    kind: number;
+    sha: string;
+    data: Uint8Array;
+    packOff: number;
+    resolved: boolean;
+    delta: boolean;
+    baseOff: number;
+    baseSha: string;
+    constructor();
+}
+export declare class GitPack {
+    ok: boolean;
+    err: string;
+    version: number;
+    count: number;
+    objects: Array<GitObj>;
+    bySha: {
+        [key: string]: GitObj;
+    };
+    byOff: {
+        [key: number]: GitObj;
+    };
+    constructor();
+}
+export declare class GitDelta {
+    constructor();
+    static varInt(data: Uint8Array, pos: Array<number>): number;
+    static apply(src: Uint8Array, delta: Uint8Array): Uint8Array;
+}
+export declare class GitPackIO {
+    constructor();
+    static kindName(kind: number): string;
+    static parse(data: Uint8Array): GitPack;
+    static resolveDeltas(pack: GitPack): void;
+    static lookup(pack: GitPack, sha: string): GitObj | undefined;
+    static merge(a: GitPack, b: GitPack): GitPack;
+}
+export declare class GitEntry {
+    name: string;
+    sha: string;
+    isTree: boolean;
+    mode: string;
+    constructor();
+}
+export declare class GitFile {
+    path: string;
+    data: Uint8Array;
+    constructor();
+}
+export declare class GitTree {
+    sha: string;
+    entries: Array<GitEntry>;
+    constructor();
+}
+export declare class GitMem {
+    files: Array<GitFile>;
+    paths: Array<string>;
+    byPath: {
+        [key: string]: GitFile;
+    };
+    constructor();
+}
+export declare class GitStore {
+    pack: GitPack;
+    ok: boolean;
+    err: string;
+    constructor(p: GitPack);
+    takeObj(sha: string): GitObj | undefined;
+    parseTree(payload: Uint8Array): GitTree;
+    commitTree(payload: Uint8Array): string;
+    checkout(sha: string, subdir: string): GitMem;
+    walk(mem: GitMem, treeSha: string, prefix: string, want: string): void;
+    mayEnter(path: string, want: string): boolean;
+    splitSegs(path: string): Array<string>;
+    asTreeSha(sha: string): string;
+    treeAt(sha: string, subdir: string): string;
+    underSubdir(path: string, want: string): boolean;
+    stripSubdir(path: string, want: string): string;
+    baseName(path: string): string;
+    writeDisk(mem: GitMem, root: string): void;
+    dirOf(path: string): string;
+    splitPath(path: string): Array<string>;
+    fileText(mem: GitMem, path: string): string;
+}
+export declare class PkgVal {
+    kind: string;
+    str: string;
+    num: number;
+    flag: boolean;
+    keys: Array<string>;
+    vals: Array<PkgVal>;
+    constructor();
+}
+export declare class PkgJson {
+    text: string;
+    i: number;
+    n: number;
+    ok: boolean;
+    err: string;
+    constructor();
+    parse(src: string): PkgVal;
+    skip(): void;
+    value(): PkgVal;
+    object(): PkgVal;
+    str(): string;
+    num(): number;
+    static child(obj: PkgVal, key: string): PkgVal | undefined;
+    static strOf(obj: PkgVal, key: string): string;
+    static intOf(obj: PkgVal, key: string): number;
+}
+export declare class PkgDep {
+    name: string;
+    path: string;
+    git: string;
+    rev: string;
+    tag: string;
+    subdir: string;
+    constructor();
+}
+export declare class PkgManifest {
+    name: string;
+    version: string;
+    entry: string;
+    license: string;
+    deps: Array<PkgDep>;
+    ok: boolean;
+    err: string;
+    constructor();
+}
+export declare class PkgLockEnt {
+    name: string;
+    path: string;
+    git: string;
+    rev: string;
+    subdir: string;
+    sha256: string;
+    constructor();
+}
+export declare class PkgLock {
+    lockVersion: number;
+    packages: Array<PkgLockEnt>;
+    ok: boolean;
+    err: string;
+    constructor();
+}
+export declare class PkgManifestIO {
+    constructor();
+    static load(src: string): PkgManifest;
+    static loadLock(src: string): PkgLock;
+    static escape(s: string): string;
+    static dumpLock(lock: PkgLock): string;
+    static dumpManifest(m: PkgManifest): string;
+}
+export declare class PkgCache {
+    constructor();
+    static lessStr(a: string, b: string): boolean;
+    static hashMem(mem: GitMem): string;
+    static put(mem: GitMem, cacheRoot: string): string;
+    static lockFor(name: string, git: string, rev: string, subdir: string, hash: string): PkgLockEnt;
+}
+export declare class PkgFetchWork {
+    dir: string;
+    man: PkgManifest;
+    git: string;
+    rev: string;
+    subdir: string;
+    fromGit: boolean;
+    constructor();
+}
+export declare class PkgFetch {
+    ok: boolean;
+    err: string;
+    cacheRoot: string;
+    cacheOverride: string;
+    rootDir: string;
+    tmpRoot: string;
+    httpTool: string;
+    vendor: boolean;
+    frozen: boolean;
+    force: boolean;
+    lock: PkgLock;
+    previous: PkgLock;
+    seen: {
+        [key: string]: boolean;
+    };
+    lastRev: string;
+    lastMem: GitMem;
+    constructor();
+    runHttp(args: Array<string>): boolean;
+    advertise(url: string, dest: string): boolean;
+    post(url: string, body: string, dest: string): boolean;
+    fetchInto(name: string, url: string, wantRev: string, subdir: string): string;
+    storeMem(mem: GitMem): string;
+    cachedFor(env: InputEnv, name: string, git: string, rev: string, subdir: string): string;
+    install(env: InputEnv, manDir: string): Promise<boolean>;
+    oneDep(env: InputEnv, pending: Array<PkgFetchWork>, w: PkgFetchWork, d: PkgDep): Promise<boolean>;
+    static findHttpTool(env: InputEnv): string;
+    static splitPath(path: string): Array<string>;
+    static readBytes(path: string): Uint8Array;
+    static writeBytes(path: string, data: Uint8Array): void;
+    static loadPack(path: string): GitPack;
+}
 export declare class RangerDocGenerator {
     constructor();
     writeTypeDef(item: CodeNode, ctx: RangerAppWriterContext, wr: CodeWriter): Promise<void>;
@@ -3863,6 +4255,7 @@ export declare class VirtualCompiler {
     fillStr(cnt: number): string;
     detectLanguageFromExtension(filename: string): string;
     isTypeScriptExtension(filename: string): boolean;
+    runInstall(env: InputEnv, params: CmdParams, cli: CLIProgress): Promise<boolean>;
     run(env: InputEnv): Promise<CompilerResults>;
     static create_env(): Promise<void>;
     static displayCompilerErrorsWithCLI(appCtx: RangerAppWriterContext, cli: CLIProgress): void;