goscript 0.0.23 → 0.0.25

package/dist/gs/builtin/map.js

@@ -0,0 +1,44 @@
+/**
+ * Creates a new map (TypeScript Map).
+ * @returns A new TypeScript Map.
+ */
+export const makeMap = () => {
+    return new Map();
+};
+/**
+ * Gets a value from a map, with a default value if the key doesn't exist.
+ * @param map The map to get from.
+ * @param key The key to get.
+ * @param defaultValue The default value to return if the key doesn't exist (defaults to 0).
+ * @returns The value for the key, or the default value if the key doesn't exist.
+ */
+export const mapGet = (map, key, defaultValue = null) => {
+    return map.has(key) ? map.get(key) : defaultValue;
+};
+/**
+ * Sets a value in a map.
+ * @param map The map to set in.
+ * @param key The key to set.
+ * @param value The value to set.
+ */
+export const mapSet = (map, key, value) => {
+    map.set(key, value);
+};
+/**
+ * Deletes a key from a map.
+ * @param map The map to delete from.
+ * @param key The key to delete.
+ */
+export const deleteMapEntry = (map, key) => {
+    map.delete(key);
+};
+/**
+ * Checks if a key exists in a map.
+ * @param map The map to check in.
+ * @param key The key to check.
+ * @returns True if the key exists, false otherwise.
+ */
+export const mapHas = (map, key) => {
+    return map.has(key);
+};
+//# sourceMappingURL=map.js.map

package/dist/gs/builtin/map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","sourceRoot":"","sources":["../../../gs/builtin/map.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,GAAoB,EAAE;IAC3C,OAAO,IAAI,GAAG,EAAQ,CAAA;AACxB,CAAC,CAAA;AACD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CACpB,GAAc,EACd,GAAM,EACN,eAAyB,IAAI,EACnB,EAAE;IACZ,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC,CAAC,CAAC,YAAY,CAAA;AACpD,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAO,GAAc,EAAE,GAAM,EAAE,KAAQ,EAAQ,EAAE;IACrE,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;AACrB,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAO,GAAc,EAAE,GAAM,EAAQ,EAAE;IACnE,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;AACjB,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAO,GAAc,EAAE,GAAM,EAAW,EAAE;IAC9D,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AACrB,CAAC,CAAA"}

package/dist/gs/builtin/slice.d.ts

@@ -0,0 +1,173 @@
+/**
+ * GoSliceObject contains metadata for complex slice views
+ */
+interface GoSliceObject<T> {
+    backing: T[];
+    offset: number;
+    length: number;
+    capacity: number;
+}
+/**
+ * SliceProxy is a proxy object for complex slices
+ */
+export type SliceProxy<T> = T[] & {
+    __meta__: GoSliceObject<T>;
+};
+/**
+ * Slice<T> is a union type that is either a plain array or a proxy
+ * null represents the nil state.
+ *
+ * Slice<number> can be represented as Uint8Array.
+ */
+export type Slice<T> = T[] | SliceProxy<T> | null | (T extends number ? Uint8Array : never);
+export declare function asArray<T>(slice: Slice<T>): T[];
+/**
+ * Creates a new slice with the specified length and capacity.
+ * @param length The length of the slice.
+ * @param capacity The capacity of the slice (optional).
+ * @returns A new slice.
+ */
+export declare const makeSlice: <T>(length: number, capacity?: number, typeHint?: string) => Slice<T>;
+/**
+ * goSlice creates a slice from s[low:high:max]
+ * Arguments mirror Go semantics; omitted indices are undefined.
+ *
+ * @param s The original slice
+ * @param low Starting index (defaults to 0)
+ * @param high Ending index (defaults to s.length)
+ * @param max Capacity limit (defaults to original capacity)
+ */
+export declare const goSlice: <T>(// T can be number for Uint8Array case
+s: Slice<T>, low?: number, high?: number, max?: number) => Slice<T>;
+/**
+ * Converts a JavaScript array to a Go slice.
+ * For multi-dimensional arrays, recursively converts nested arrays to slices.
+ * @param arr The JavaScript array to convert
+ * @param depth How many levels of nesting to convert (default: 1, use Infinity for all levels)
+ * @returns A Go slice containing the same elements
+ */
+export declare const arrayToSlice: <T>(arr: T[] | null | undefined, depth?: number) => Slice<T>;
+/**
+ * Returns the length of a collection (string, array, slice, map, or set).
+ * @param obj The collection to get the length of.
+ * @returns The length of the collection.
+ */
+export declare const len: <T = unknown, V = unknown>(obj: string | Array<T> | Slice<T> | Map<T, V> | Set<T> | Uint8Array | null | undefined) => number;
+/**
+ * Returns the capacity of a slice.
+ * @param obj The slice.
+ * @returns The capacity of the slice.
+ */
+export declare const cap: <T>(obj: Slice<T> | Uint8Array) => number;
+/**
+ * Appends elements to a slice.
+ * Note: In Go, append can return a new slice if the underlying array is reallocated.
+ * This helper emulates that by returning the modified or new slice.
+ * @param slice The slice to append to.
+ * @param elements The elements to append.
+ * @returns The modified or new slice.
+ */
+export declare const append: <T>(slice: Slice<T> | Uint8Array, ...elements: any[]) => Slice<T>;
+/**
+ * Copies elements from src to dst.
+ * @param dst The destination slice.
+ * @param src The source slice.
+ * @returns The number of elements copied.
+ */
+export declare const copy: <T>(dst: Slice<T>, src: Slice<T>) => number;
+/**
+ * Accesses an element at a specific index for various Go-like types (string, slice, array).
+ * Mimics Go's indexing behavior: `myCollection[index]`
+ * For strings, it returns the byte value at the specified byte index.
+ * For slices/arrays, it returns the element at the specified index.
+ * This is used when dealing with types like "string | []byte"
+ * @param collection The string, Slice, or Array to access.
+ * @param index The index.
+ * @returns The element or byte value at the specified index.
+ * @throws Error if index is out of bounds or type is unsupported.
+ */
+export declare function index<T>(collection: string | Slice<T> | T[], index: number): T | number;
+/**
+ * Converts a string to an array of Unicode code points (runes).
+ * @param str The input string.
+ * @returns An array of numbers representing the Unicode code points.
+ */
+export declare const stringToRunes: (str: string) => number[];
+/**
+ * Converts an array of Unicode code points (runes) to a string.
+ * @param runes The input array of numbers representing Unicode code points.
+ * @returns The resulting string.
+ */
+export declare const runesToString: (runes: Slice<number>) => string;
+/**
+ * Converts a number to a byte (uint8) by truncating to the range 0-255.
+ * Equivalent to Go's byte() conversion.
+ * @param n The number to convert to a byte.
+ * @returns The byte value (0-255).
+ */
+export declare const byte: (n: number) => number;
+/**
+ * Accesses the byte value at a specific index of a UTF-8 encoded string.
+ * Mimics Go's string indexing behavior: `myString[index]`
+ * @param str The string to access.
+ * @param index The byte index.
+ * @returns The byte value (0-255) at the specified index.
+ * @throws Error if index is out of bounds.
+ */
+export declare const indexString: (str: string, index: number) => number;
+/**
+ * Returns the byte length of a string.
+ * Mimics Go's `len(string)` behavior.
+ * @param str The string.
+ * @returns The number of bytes in the UTF-8 representation of the string.
+ */
+export declare const stringLen: (str: string) => number;
+/**
+ * Slices a string based on byte indices.
+ * Mimics Go's string slicing behavior: `myString[low:high]` for valid UTF-8 slices only.
+ * @param str The string to slice.
+ * @param low The starting byte index (inclusive). Defaults to 0.
+ * @param high The ending byte index (exclusive). Defaults to string byte length.
+ * @returns The sliced string.
+ * @throws Error if the slice would create invalid UTF-8.
+ */
+export declare const sliceString: (str: string, low?: number, high?: number) => string;
+/**
+ * Converts a Slice<number> (byte array) to a string using TextDecoder.
+ * @param bytes The Slice<number> to convert.
+ * @returns The resulting string.
+ */
+export declare const bytesToString: (bytes: Slice<number> | Uint8Array) => string;
+/**
+ * Converts a string to a Uint8Array (byte slice).
+ * @param s The input string.
+ * @returns A Uint8Array representing the UTF-8 bytes of the string.
+ */
+export declare function stringToBytes(s: string): Uint8Array;
+/**
+ * Handles string() conversion for values that could be either string or []byte.
+ * Used for generic type parameters with constraint []byte|string.
+ * @param value Value that is either a string or Uint8Array
+ * @returns The string representation
+ */
+export declare function genericBytesOrStringToString(value: string | Uint8Array): string;
+/**
+ * Indexes into a value that could be either a string or Uint8Array.
+ * Used for generic type parameters with constraint string | []byte.
+ * Both cases return a byte value (number).
+ * @param value Value that is either a string or Uint8Array
+ * @param index The index to access
+ * @returns The byte value at the specified index
+ */
+export declare function indexStringOrBytes(value: string | Uint8Array, index: number): number;
+/**
+ * Slices a value that could be either a string or Uint8Array.
+ * Used for generic type parameters with constraint string | []byte.
+ * @param value Value that is either a string or Uint8Array
+ * @param low Starting index (inclusive). Defaults to 0.
+ * @param high Ending index (exclusive). Defaults to length.
+ * @param max Capacity limit (only used for Uint8Array, ignored for strings)
+ * @returns The sliced value of the same type as input
+ */
+export declare function sliceStringOrBytes<T extends string | Uint8Array>(value: T, low?: number, high?: number, max?: number): T;
+export {};