goscript 0.0.37 → 0.0.39

package/dist/gs/reflect/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../gs/reflect/index.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,OAAO,EACL,MAAM,EACN,OAAO,EACP,KAAK,EACL,IAAI,EACJ,OAAO,EACP,OAAO,EACP,SAAS,EACT,KAAK,EACL,KAAK,EACL,MAAM,GACP,MAAM,QAAQ,CAAA;AAEf,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,GAAG,EACH,SAAS,EACT,OAAO,EACP,MAAM,EACN,QAAQ,EACR,MAAM,GACP,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC,iCAAiC;AACjC,OAAO,EACL,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,SAAS,EACT,UAAU,EACV,SAAS,EACT,UAAU,EACV,UAAU,EACV,aAAa,EACb,SAAS,GACV,MAAM,SAAS,CAAA;AAYhB,wBAAwB;AACxB,OAAO,EACL,OAAO,EACP,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,KAAK,EACL,MAAM,EACN,MAAM,EACN,MAAM,EACN,OAAO,EACP,OAAO,EACP,OAAO,EACP,SAAS,EACT,UAAU,EACV,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,GAAG,EACH,GAAG,EACH,KAAK,EACL,MAAM,EACN,MAAM,EACN,aAAa,GACd,MAAM,QAAQ,CAAA"}

package/dist/gs/reflect/iter.d.ts

@@ -0,0 +1,4 @@
+import { Type, Value } from './type.js';
+import { uintptr } from './types.js';
+import * as iter from '@goscript/iter/index.js';
+export declare function rangeNum<T extends number | number | number | number | number | number | number | number | number | number | uintptr, N extends number | number>(num: N, t: Type): iter.Seq<Value>;

package/dist/gs/reflect/iter.js

@@ -0,0 +1,24 @@
+import { ValueOf } from './value.js';
+export function rangeNum(num, t) {
+    // cannot use range T(v) because no core type.
+    // if the iteration value type is define by
+    // type T built-in type.
+    return (_yield) => {
+        let convert = t.PkgPath() != '';
+        // cannot use range T(v) because no core type.
+        // if the iteration value type is define by
+        // type T built-in type.
+        for (let i = 0; i < num; i++) {
+            let tmp = ValueOf(i).clone();
+            // if the iteration value type is define by
+            // type T built-in type.
+            if (convert) {
+                tmp = tmp.Convert(t).clone();
+            }
+            if (!_yield(tmp)) {
+                return;
+            }
+        }
+    };
+}
+//# sourceMappingURL=iter.js.map

package/dist/gs/reflect/iter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iter.js","sourceRoot":"","sources":["../../../gs/reflect/iter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAIpC,MAAM,UAAU,QAAQ,CActB,GAAM,EAAE,CAAO;IACf,8CAA8C;IAE9C,2CAA2C;IAC3C,wBAAwB;IACxB,OAAO,CAAC,MAAsC,EAAQ,EAAE;QACtD,IAAI,OAAO,GAAG,CAAE,CAAC,OAAQ,EAAE,IAAI,EAAE,CAAA;QACjC,8CAA8C;QAE9C,2CAA2C;QAC3C,wBAAwB;QACxB,KAAK,IAAI,CAAC,GAAG,CAAiB,EAAE,CAAC,GAAI,GAAoB,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/D,IAAI,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAA;YAC5B,2CAA2C;YAC3C,wBAAwB;YACxB,IAAI,OAAO,EAAE,CAAC;gBACZ,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAA;YAC9B,CAAC;YACD,IAAI,CAAC,MAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBAClB,OAAM;YACR,CAAC;QACH,CAAC;IACH,CAAC,CAAA;AACH,CAAC"}

package/dist/gs/reflect/map.d.ts

@@ -0,0 +1,20 @@
+import { Type, Value } from './type.js';
+export declare function MapOf(key: Type, elem: Type): Type;
+/**
+ * MapIter provides an iterator interface for Go maps.
+ * It wraps a JavaScript Map iterator and provides methods to iterate over key-value pairs.
+ * @template K - The type of keys in the map
+ * @template V - The type of values in the map
+ */
+export declare class MapIter<K = unknown, V = unknown> {
+    map: Map<K, V>;
+    iterator: Iterator<[K, V]>;
+    current: IteratorResult<[K, V]> | null;
+    constructor(map: Map<K, V>);
+    Next(): boolean;
+    Key(): K | null;
+    Value(): V | null;
+    Reset(m: Map<K, V>): void;
+}
+export declare function MakeMap(typ: Type): Value;
+export declare function MakeMapWithSize(typ: Type, _n: number): Value;

package/dist/gs/reflect/map.js

@@ -0,0 +1,74 @@
+import { Kind, Value } from './type.js';
+// Simple MapOf implementation using JavaScript Map
+export function MapOf(key, elem) {
+    return new MapType(key, elem);
+}
+// Simple map type implementation
+class MapType {
+    _keyType;
+    _elemType;
+    constructor(_keyType, _elemType) {
+        this._keyType = _keyType;
+        this._elemType = _elemType;
+    }
+    String() {
+        return `map[${this._keyType.String()}]${this._elemType.String()}`;
+    }
+    Kind() {
+        return new Kind(21); // Map kind
+    }
+    Size() {
+        return 8; // pointer size
+    }
+    Elem() {
+        return this._elemType;
+    }
+    Key() {
+        return this._keyType;
+    }
+    NumField() {
+        return 0;
+    }
+}
+/**
+ * MapIter provides an iterator interface for Go maps.
+ * It wraps a JavaScript Map iterator and provides methods to iterate over key-value pairs.
+ * @template K - The type of keys in the map
+ * @template V - The type of values in the map
+ */
+export class MapIter {
+    map;
+    iterator;
+    current = null;
+    constructor(map) {
+        this.map = map;
+        this.iterator = map.entries();
+        this.Next();
+    }
+    Next() {
+        this.current = this.iterator.next();
+        return !this.current.done;
+    }
+    Key() {
+        return this.current?.value?.[0] ?? null;
+    }
+    Value() {
+        return this.current?.value?.[1] ?? null;
+    }
+    Reset(m) {
+        this.map = m;
+        this.iterator = m.entries();
+        this.current = null;
+        this.Next();
+    }
+}
+// Helper functions for map operations
+export function MakeMap(typ) {
+    const map = new Map();
+    return new Value(map, typ);
+}
+export function MakeMapWithSize(typ, _n) {
+    // JavaScript Map doesn't have initial size, so we ignore n
+    return MakeMap(typ);
+}
+//# sourceMappingURL=map.js.map

package/dist/gs/reflect/map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","sourceRoot":"","sources":["../../../gs/reflect/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAE7C,mDAAmD;AACnD,MAAM,UAAU,KAAK,CAAC,GAAS,EAAE,IAAU;IACzC,OAAO,IAAI,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;AAC/B,CAAC;AAED,iCAAiC;AACjC,MAAM,OAAO;IAED;IACA;IAFV,YACU,QAAc,EACd,SAAe;QADf,aAAQ,GAAR,QAAQ,CAAM;QACd,cAAS,GAAT,SAAS,CAAM;IACtB,CAAC;IAEG,MAAM;QACX,OAAO,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAA;IACnE,CAAC;IAEM,IAAI;QACT,OAAO,IAAI,IAAI,CAAC,EAAE,CAAC,CAAA,CAAC,WAAW;IACjC,CAAC;IAEM,IAAI;QACT,OAAO,CAAC,CAAA,CAAC,eAAe;IAC1B,CAAC;IAEM,IAAI;QACT,OAAO,IAAI,CAAC,SAAS,CAAA;IACvB,CAAC;IAEM,GAAG;QACR,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;IAEM,QAAQ;QACb,OAAO,CAAC,CAAA;IACV,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,OAAO,OAAO;IAIC;IAHZ,QAAQ,CAAkB;IAC1B,OAAO,GAAkC,IAAI,CAAA;IAEpD,YAAmB,GAAc;QAAd,QAAG,GAAH,GAAG,CAAW;QAC/B,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC,OAAO,EAAE,CAAA;QAC7B,IAAI,CAAC,IAAI,EAAE,CAAA;IACb,CAAC;IAEM,IAAI;QACT,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAA;QACnC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAA;IAC3B,CAAC;IAEM,GAAG;QACR,OAAO,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;IACzC,CAAC;IAEM,KAAK;QACV,OAAO,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;IACzC,CAAC;IAEM,KAAK,CAAC,CAAY;QACvB,IAAI,CAAC,GAAG,GAAG,CAAC,CAAA;QACZ,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,OAAO,EAAE,CAAA;QAC3B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;QACnB,IAAI,CAAC,IAAI,EAAE,CAAA;IACb,CAAC;CACF;AAED,sCAAsC;AACtC,MAAM,UAAU,OAAO,CAAC,GAAS;IAC/B,MAAM,GAAG,GAAG,IAAI,GAAG,EAAE,CAAA;IACrB,OAAO,IAAI,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAC5B,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,GAAS,EAAE,EAAU;IACnD,2DAA2D;IAC3D,OAAO,OAAO,CAAC,GAAG,CAAC,CAAA;AACrB,CAAC"}

package/dist/gs/reflect/swapper.d.ts

@@ -0,0 +1,2 @@
+import { ReflectValue } from './types';
+export declare function Swapper(slice: ReflectValue): (i: number, j: number) => void;

package/dist/gs/reflect/swapper.js

@@ -0,0 +1,46 @@
+// Swapper returns a function that swaps the elements in the provided slice.
+// Swapper panics if the provided interface is not a slice.
+export function Swapper(slice) {
+    let actualArray = null;
+    // Try to extract the underlying array
+    if (Array.isArray(slice)) {
+        actualArray = slice;
+    }
+    else if (slice && typeof slice === 'object' && '__meta__' in slice) {
+        // GoScript slice object
+        const meta = slice.__meta__;
+        if (meta && meta.backing && Array.isArray(meta.backing)) {
+            actualArray = meta.backing;
+        }
+    }
+    if (!actualArray) {
+        // Return a no-op function if we can't extract an array
+        return () => { };
+    }
+    // Fast path for slices of size 0 and 1. Nothing to swap.
+    switch (actualArray.length) {
+        case 0:
+            return (_i, _j) => {
+                throw new Error('reflect: slice index out of range');
+            };
+        case 1:
+            return (i, j) => {
+                if (i !== 0 || j !== 0) {
+                    throw new Error('reflect: slice index out of range');
+                }
+            };
+    }
+    // Return the swapper function
+    return (i, j) => {
+        if (actualArray &&
+            i >= 0 &&
+            j >= 0 &&
+            i < actualArray.length &&
+            j < actualArray.length) {
+            const temp = actualArray[i];
+            actualArray[i] = actualArray[j];
+            actualArray[j] = temp;
+        }
+    };
+}
+//# sourceMappingURL=swapper.js.map

package/dist/gs/reflect/swapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapper.js","sourceRoot":"","sources":["../../../gs/reflect/swapper.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,2DAA2D;AAC3D,MAAM,UAAU,OAAO,CAAC,KAAmB;IACzC,IAAI,WAAW,GAAqB,IAAI,CAAA;IAExC,sCAAsC;IACtC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,WAAW,GAAG,KAAK,CAAA;IACrB,CAAC;SAAM,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,UAAU,IAAI,KAAK,EAAE,CAAC;QACrE,wBAAwB;QACxB,MAAM,IAAI,GAAI,KAAgD,CAAC,QAAQ,CAAA;QACvE,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YACxD,WAAW,GAAG,IAAI,CAAC,OAAO,CAAA;QAC5B,CAAC;IACH,CAAC;IAED,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,uDAAuD;QACvD,OAAO,GAAG,EAAE,GAAE,CAAC,CAAA;IACjB,CAAC;IAED,yDAAyD;IACzD,QAAQ,WAAW,CAAC,MAAM,EAAE,CAAC;QAC3B,KAAK,CAAC;YACJ,OAAO,CAAC,EAAU,EAAE,EAAU,EAAQ,EAAE;gBACtC,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAA;YACtD,CAAC,CAAA;QACH,KAAK,CAAC;YACJ,OAAO,CAAC,CAAS,EAAE,CAAS,EAAQ,EAAE;gBACpC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;oBACvB,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAA;gBACtD,CAAC;YACH,CAAC,CAAA;IACL,CAAC;IAED,8BAA8B;IAC9B,OAAO,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE;QAC9B,IACE,WAAW;YACX,CAAC,IAAI,CAAC;YACN,CAAC,IAAI,CAAC;YACN,CAAC,GAAG,WAAW,CAAC,MAAM;YACtB,CAAC,GAAG,WAAW,CAAC,MAAM,EACtB,CAAC;YACD,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;YAC3B,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;YAC/B,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;QACvB,CAAC;IACH,CAAC,CAAA;AACH,CAAC"}

package/dist/gs/reflect/type.d.ts

@@ -0,0 +1,134 @@
+import { ReflectValue, ChanDir, StructField } from './types.js';
+import { MapIter } from './map.js';
+export declare class rtype {
+    kind: Kind;
+    constructor(kind: Kind);
+    Kind(): Kind;
+    String(): string;
+    Pointers(): boolean;
+}
+export declare class funcType extends rtype {
+    inCount: number;
+    outCount: number;
+    constructor(kind: Kind, inCount?: number, outCount?: number);
+}
+export declare class flag {
+    private _value;
+    constructor(_value: number | Kind);
+    valueOf(): number;
+    static from(value: number | Kind): flag;
+}
+export declare class bitVector {
+    private bits;
+    Set(index: number): void;
+    Get(index: number): boolean;
+}
+export declare class Kind {
+    private _value;
+    constructor(_value: number);
+    valueOf(): number;
+    toString(): string;
+    static from(value: number): Kind;
+    String(): string;
+}
+export declare const Invalid: Kind;
+export declare const Bool: Kind;
+export declare const Int: Kind;
+export declare const Int8: Kind;
+export declare const Int16: Kind;
+export declare const Int32: Kind;
+export declare const Int64: Kind;
+export declare const Uint: Kind;
+export declare const Uint8: Kind;
+export declare const Uint16: Kind;
+export declare const Uint32: Kind;
+export declare const Uint64: Kind;
+export declare const Uintptr: Kind;
+export declare const Float32: Kind;
+export declare const Float64: Kind;
+export declare const Complex64: Kind;
+export declare const Complex128: Kind;
+export declare const Array: Kind;
+export declare const Chan: Kind;
+export declare const Func: Kind;
+export declare const Interface: Kind;
+export declare const Map: Kind;
+export declare const Ptr: Kind;
+export declare const Slice: Kind;
+export declare const String: Kind;
+export declare const Struct: Kind;
+export declare const UnsafePointer: Kind;
+export interface Type {
+    String(): string;
+    Kind(): Kind;
+    Size(): number;
+    Elem(): Type | null;
+    NumField(): number;
+    PkgPath?(): string;
+    Field?(i: number): StructField | null;
+    common?(): rtype;
+}
+export declare class Value {
+    private _value;
+    private _type;
+    constructor(_value: ReflectValue, _type: Type);
+    clone(): Value;
+    Int(): number;
+    Uint(): number;
+    Float(): number;
+    Bool(): boolean;
+    String(): string;
+    Len(): number;
+    Kind(): Kind;
+    Type(): Type;
+    IsValid(): boolean;
+    IsNil(): boolean;
+    Index(i: number): Value;
+    Bytes(): Uint8Array;
+    Elem(): Value;
+    NumField(): number;
+    Field(_i: number): Value;
+    UnsafePointer(): unknown;
+    pointer(): unknown;
+    get ptr(): unknown;
+    get value(): ReflectValue;
+    Convert(t: Type): Value;
+    typ(): rtype | null;
+    get flag(): number;
+    MapRange(): MapIter<unknown, unknown> | null;
+    MapIndex(_key: Value): Value;
+    Complex(): number | {
+        real: number;
+        imag: number;
+    } | null;
+    Send(x: Value): void;
+}
+export declare class BasicType implements Type {
+    private _kind;
+    private _name;
+    private _size;
+    constructor(_kind: Kind, _name: string, _size?: number);
+    String(): string;
+    Kind(): Kind;
+    Size(): number;
+    Elem(): Type | null;
+    NumField(): number;
+    PkgPath?(): string;
+    Field?(_i: number): StructField | null;
+    common?(): rtype;
+}
+export declare function TypeOf(i: ReflectValue): Type;
+export declare function ValueOf(i: ReflectValue): Value;
+export declare function ArrayOf(length: number, elem: Type): Type;
+export declare function SliceOf(t: Type): Type;
+export declare function PointerTo(t: Type): Type;
+export declare function PtrTo(t: Type): Type;
+export declare function MapOf(key: Type, elem: Type): Type;
+export declare function ChanOf(dir: ChanDir, t: Type): Type;
+export declare function canRangeFunc(t: Type): boolean;
+export declare function canRangeFunc2(t: Type): boolean;
+export declare function funcLayout(_t: Type, _rcvr: Type | null): {
+    Type: Type | null;
+    InCount: number;
+    OutCount: number;
+};