goscript 0.1.1 → 0.1.2

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

@@ -1,4 +1,13 @@
 import { type VarRef } from './varRef.js';
+export declare class GoBinaryString extends String {
+    readonly bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+    toString(): string;
+    valueOf(): string;
+    [Symbol.toPrimitive](): string;
+}
+type GoStringValue = string | GoBinaryString;
+type GoStringBytes = GoStringValue | Slice<number> | Uint8Array;
 /**
  * GoSliceObject contains metadata for complex slice views
  */
@@ -7,6 +16,7 @@ interface GoSliceObject<T> {
     offset: number;
     length: number;
     capacity: number;
+    target?: T[];
 }
 /**
  * SliceProxy is a proxy object for complex slices
@@ -60,7 +70,7 @@ export declare const arrayToSlice: <T>(arr: T[] | null | undefined, depth?: numb
  * @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 | {
+export declare const len: <T = unknown, V = unknown>(obj: GoStringValue | Array<T> | Slice<T> | Map<T, V> | Set<T> | Uint8Array | {
     len(): number;
 } | null | undefined) => number;
 /**
@@ -68,7 +78,9 @@ export declare const len: <T = unknown, V = unknown>(obj: string | Array<T> | Sl
  * @param obj The slice.
  * @returns The capacity of the slice.
  */
-export declare const cap: <T>(obj: Slice<T> | Uint8Array) => number;
+export declare const cap: <T>(obj: Slice<T> | Uint8Array | {
+    cap(): number;
+} | null | undefined) => number;
 /**
  * Appends elements to a slice.
  * Note: In Go, append can return a new slice if the underlying array is reallocated.
@@ -79,6 +91,7 @@ export declare const cap: <T>(obj: Slice<T> | Uint8Array) => number;
  */
 export declare function append(slice: Uint8Array, ...elements: any[]): Uint8Array;
 export declare function append(slice: null, ...elements: number[]): Slice<number>;
+export declare function append<T>(slice: null, ...elements: T[]): Slice<T>;
 export declare function append<T>(slice: Slice<T>, ...elements: any[]): Slice<T>;
 /**
  * Copies elements from src to dst.
@@ -101,11 +114,17 @@ export declare function copy<T>(dst: Slice<T>, src: string): number;
  * @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;
+export declare function index<T>(collection: GoStringValue | Slice<T> | T[], index: number): T | number;
 /**
  * indexRef returns an addressable reference to a slice or array element.
  */
 export declare function indexRef<T>(collection: Slice<T> | T[] | Uint8Array, index: number): VarRef<T>;
+/**
+ * arrayPointerFromIndexRef turns &slice[i] into a pointer to an N-element array
+ * view. This models unsafe conversions such as (*[64]byte)(unsafe.Pointer(&b[0]))
+ * for packages that immediately slice or index the resulting array pointer.
+ */
+export declare function arrayPointerFromIndexRef<T>(ref: VarRef<T>, length: number): VarRef<Slice<T> | T[] | Uint8Array>;
 /**
  * indexAddress returns a stable synthetic address for an addressable slice or
  * array element.
@@ -151,14 +170,14 @@ export declare const byte: (n: number) => number;
  * @returns The byte value (0-255) at the specified index.
  * @throws Error if index is out of bounds.
  */
-export declare const indexString: (str: string | import('./builtin.js').Bytes, index: number) => number;
+export declare const indexString: (str: GoStringValue | import('./builtin.js').Bytes, 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;
+export declare const stringLen: (str: GoStringValue) => number;
 /**
  * Slices a string based on byte indices.
  * Mimics Go's string slicing behavior: `myString[low:high]` for valid UTF-8 slices only.
@@ -168,19 +187,34 @@ export declare const stringLen: (str: string) => number;
  * @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;
+export declare const sliceString: (str: GoStringValue, 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) => string;
+export declare function stringEqual(left: GoStringBytes, right: GoStringBytes): boolean;
+export declare function stringCompare(left: GoStringBytes, right: GoStringBytes): number;
 /**
  * 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 | import('./builtin.js').Bytes): Uint8Array;
+export declare function stringToBytes(s: GoStringValue | import('./builtin.js').Bytes): Uint8Array;
+type StringHeaderData = {
+    kind: 'string';
+    value: string;
+};
+export declare function stringHeaderRef(s: VarRef<string>): VarRef<{
+    Data: StringHeaderData;
+    Len: number;
+}>;
+export declare function sliceHeaderRef(b: VarRef<Slice<number>>): VarRef<{
+    Data: StringHeaderData | null;
+    Len: number;
+    Cap: number;
+}>;
 /**
  * Handles string() conversion for values that could be either string or []byte.
  * Used for generic type parameters with constraint []byte|string.
@@ -196,7 +230,7 @@ export declare function genericBytesOrStringToString(value: string | import('./b
  * @param index The index to access
  * @returns The byte value at the specified index
  */
-export declare function indexStringOrBytes(value: string | import('./builtin.js').Bytes, index: number): number;
+export declare function indexStringOrBytes(value: GoStringValue | import('./builtin.js').Bytes, index: number): number;
 /**
  * Slices a value that could be either a string or bytes.
  * Used for generic type parameters with constraint string | []byte.
@@ -206,5 +240,5 @@ export declare function indexStringOrBytes(value: string | import('./builtin.js'
  * @param max Capacity limit (only used for bytes, ignored for strings)
  * @returns The sliced value of the same type as input
  */
-export declare function sliceStringOrBytes<T extends string | import('./builtin.js').Bytes>(value: T, low?: number, high?: number, max?: number): T;
+export declare function sliceStringOrBytes<T extends GoStringValue | import('./builtin.js').Bytes>(value: T, low?: number, high?: number, max?: number): T;
 export {};