warpo 3.1.3 → 3.2.1

package/assemblyscript/std/assembly/util/uri.ts

@@ -0,0 +1,251 @@
+import { E_URI_MALFORMED } from "./error";
+import { CharCode } from "./string";
+
+// Truncated lookup boolean table that helps us quickly determine
+// if a char needs to be escaped for URIs (RFC 2396).
+// @ts-ignore: decorator
+@lazy export const URI_UNSAFE = memory.data<u8>([
+  /* skip 32 + 1 always set to '1' head slots
+   */ 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0 /*
+  skip 128 + 1 always set to '1' tail slots */,
+]);
+
+// Truncated lookup boolean table that helps us quickly determine
+// if a char needs to be escaped for URLs (RFC 3986).
+// @ts-ignore: decorator
+@lazy export const URL_UNSAFE = memory.data<u8>([
+  /* skip 32 + 1 always set to '1' head slots
+   */ 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0 /*
+  skip 128 + 1 always set to '1' tail slots */,
+]);
+
+// Truncated lookup boolean table for determine reserved chars: ;/?:@&=+$,#
+// @ts-ignore: decorator
+@lazy export const URI_RESERVED = memory.data<u8>([
+  /*  skip 32 + 3 always set to '0' head slots
+   */ 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1,
+  1 /* skip 191 always set to '0' tail slots */,
+]);
+
+export function encode(src: usize, len: usize, table: usize): usize {
+  if (!len) return src;
+
+  let i: usize = 0,
+    offset: usize = 0,
+    outSize = len << 1;
+  let dst = __new(outSize, idof<String>());
+
+  while (i < len) {
+    let org = i;
+    let c: u32, c1: u32;
+    // fast scan a check chars until it valid ASCII
+    // and safe for copying without escaping.
+    do {
+      c = <u32>load<u16>(src + (i << 1));
+      // is it valid ASCII and safe?
+      if (c - 33 < 94) {
+        // 127 - 33
+        if (load<u8>(table + (c - 33))) break;
+      } else break;
+    } while (++i < len);
+
+    // if we have some safe range of sequence just copy it without encoding
+    if (i > org) {
+      let size = (i - org) << 1;
+      if (offset + size > outSize) {
+        outSize = offset + size;
+        dst = __renew(dst, outSize);
+      }
+      // TODO: should we optimize for short cases like 2 byte size?
+      memory.copy(dst + offset, src + (org << 1), size);
+      offset += size;
+      // return if we reach end on input string
+      if (i >= len) break;
+    }
+
+    // decode UTF16 with checking for unpaired surrogates
+    if (c >= 0xd800) {
+      if (c >= 0xdc00 && c <= 0xdfff) {
+        throw new URIError(E_URI_MALFORMED);
+      }
+      if (c <= 0xdbff) {
+        if (i >= len) {
+          throw new URIError(E_URI_MALFORMED);
+        }
+        c1 = <u32>load<u16>(src + (++i << 1));
+        if (c1 < 0xdc00 || c1 > 0xdfff) {
+          throw new URIError(E_URI_MALFORMED);
+        }
+        c = (((c & 0x3ff) << 10) | (c1 & 0x3ff)) + 0x10000;
+      }
+    }
+
+    let estSize = offset + (c < 0x80 ? 1 * 6 : 4 * 6);
+    if (estSize > outSize) {
+      // doubling estimated size but only for greater than one
+      // input length due to we already estimated it for worst case
+      outSize = len > 1 ? estSize << 1 : estSize;
+      dst = __renew(dst, outSize);
+    }
+
+    if (c < 0x80) {
+      // encode ASCII unsafe code point
+      storeHex(dst, offset, c);
+      offset += 6;
+    } else {
+      // encode UTF-8 unsafe code point
+      if (c < 0x800) {
+        storeHex(dst, offset, (c >> 6) | 0xc0);
+        offset += 6;
+      } else {
+        if (c < 0x10000) {
+          storeHex(dst, offset, (c >> 12) | 0xe0);
+          offset += 6;
+        } else {
+          storeHex(dst, offset, (c >> 18) | 0xf0);
+          offset += 6;
+          storeHex(dst, offset, ((c >> 12) & 0x3f) | 0x80);
+          offset += 6;
+        }
+        storeHex(dst, offset, ((c >> 6) & 0x3f) | 0x80);
+        offset += 6;
+      }
+      storeHex(dst, offset, (c & 0x3f) | 0x80);
+      offset += 6;
+    }
+    ++i;
+  }
+  // shrink output string buffer if necessary
+  if (outSize > offset) {
+    dst = __renew(dst, offset);
+  }
+  return dst;
+}
+
+export function decode(src: usize, len: usize, component: bool): usize {
+  if (!len) return src;
+
+  let i: usize = 0,
+    offset: usize = 0,
+    ch: u32 = 0;
+  let dst = __new(len << 1, idof<String>());
+
+  while (i < len) {
+    let org = i;
+    while (i < len && (ch = load<u16>(src + (i << 1))) != CharCode.PERCENT) i++;
+
+    if (i > org) {
+      let size = (i - org) << 1;
+      // TODO: should we optimize for short cases like 2 byte size?
+      memory.copy(dst + offset, src + (org << 1), size);
+      offset += size;
+      if (i >= len) break;
+    }
+
+    // decode hex
+    if (i + 2 >= len || ch != CharCode.PERCENT || (ch = loadHex(src, (i + 1) << 1)) == -1)
+      throw new URIError(E_URI_MALFORMED);
+
+    i += 3;
+    if (ch < 0x80) {
+      if (!component && isReserved(ch)) {
+        ch = CharCode.PERCENT;
+        i -= 2;
+      }
+    } else {
+      // decode UTF-8 sequence
+      let nb = utf8LenFromUpperByte(ch);
+      // minimal surrogate: 2 => 0x80, 3 => 0x800, 4 => 0x10000, _ => -1
+      let lo: u32 = 1 << (((17 * nb) >> 2) - 1);
+      // mask: 2 => 31, 3 => 15, 4 => 7, _ =>  0
+      ch &= nb ? (0x80 >> nb) - 1 : 0;
+
+      while (--nb != 0) {
+        let c1: u32;
+        // decode hex
+        if (i + 2 >= len || load<u16>(src + (i << 1)) != CharCode.PERCENT || (c1 = loadHex(src, (i + 1) << 1)) == -1)
+          throw new URIError(E_URI_MALFORMED);
+
+        i += 3;
+        if ((c1 & 0xc0) != 0x80) {
+          ch = 0;
+          break;
+        }
+        ch = (ch << 6) | (c1 & 0x3f);
+      }
+
+      // check if UTF8 code point properly fit into invalid UTF16 encoding
+      if (ch < lo || lo == -1 || ch > 0x10ffff || (ch >= 0xd800 && ch < 0xe000)) {
+        throw new URIError(E_URI_MALFORMED);
+      }
+
+      // encode UTF16
+      if (ch >= 0x10000) {
+        ch -= 0x10000;
+        let lo = (ch >> 10) | 0xd800;
+        let hi = (ch & 0x03ff) | 0xdc00;
+        store<u32>(dst + offset, lo | (hi << 16));
+        offset += 4;
+        continue;
+      }
+    }
+    store<u16>(dst + offset, ch);
+    offset += 2;
+  }
+
+  assert(offset <= len << 1);
+  // shrink output string buffer if necessary
+  if (len << 1 > offset) {
+    dst = __renew(dst, offset);
+  }
+  return dst;
+}
+
+function storeHex(dst: usize, offset: usize, ch: u32): void {
+  // @ts-ignore: decorator
+  const HEX_CHARS = memory.data<u8>([
+    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+  ]);
+
+  store<u16>(dst + offset, CharCode.PERCENT, 0); // %
+  store<u32>(
+    dst + offset,
+    (<u32>load<u8>(HEX_CHARS + ((ch >> 4) & 0x0f))) | ((<u32>load<u8>(HEX_CHARS + (ch & 0x0f))) << 16),
+    2
+  ); // XX
+}
+
+function loadHex(src: usize, offset: usize): u32 {
+  let c0 = <u32>load<u16>(src + offset, 0);
+  let c1 = <u32>load<u16>(src + offset, 2);
+  return isHex(c0) && isHex(c1) ? (fromHex(c0) << 4) | fromHex(c1) : -1;
+}
+
+// @ts-ignore: decorator
+@inline function fromHex(ch: u32): u32 {
+  return ((ch | 32) % 39) - 9;
+}
+
+// @ts-ignore: decorator
+@inline function utf8LenFromUpperByte(c0: u32): u32 {
+  // same as
+  // if (c0 - 0xC0 <= 0xDF - 0xC0) return 2;
+  // if (c0 - 0xE0 <= 0xEF - 0xE0) return 3;
+  // if (c0 - 0xF0 <= 0xF7 - 0xF0) return 4;
+  // return 0;
+  return c0 - 0xc0 < 56 ? clz(~(c0 << 24)) : 0;
+}
+
+// @ts-ignore: decorator
+@inline function isReserved(ch: u32): bool {
+  return ch - 35 < 30 ? <bool>load<u8>(URI_RESERVED + (ch - 35)) : false;
+}
+
+// @ts-ignore: decorator
+@inline function isHex(ch: u32): bool {
+  return ch - CharCode._0 < 10 || (ch | 32) - CharCode.a < 6;
+}

package/assemblyscript/std/assembly/vector.ts

@@ -0,0 +1,3 @@
+/** Vector abstraction. */
+@final @unmanaged
+export abstract class V128 {}

package/dist/common/leb128.d.ts

@@ -0,0 +1,5 @@
+export interface ULEB128Result {
+    value: number;
+    nextOffset: number;
+}
+export declare function readULEB128(bytes: Uint8Array, offset: number): ULEB128Result;

package/dist/common/leb128.js

@@ -0,0 +1,17 @@
+// Copyright (C) 2026 wasm-ecosystem
+// SPDX-License-Identifier: Apache-2.0
+export function readULEB128(bytes, offset) {
+    const startOffset = offset;
+    let value = 0;
+    let shift = 0;
+    while (offset < bytes.byteLength) {
+        const byte = bytes[offset++];
+        value |= (byte & 0x7f) << shift;
+        shift += 7;
+        if ((byte & 0x80) === 0) {
+            return { value: value >>> 0, nextOffset: offset };
+        }
+    }
+    throw new Error(`ULEB128 read past end of buffer at offset ${startOffset}`);
+}
+//# sourceMappingURL=leb128.js.map

package/dist/common/leb128.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"leb128.js","sourceRoot":"","sources":["../../tools/common/leb128.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,sCAAsC;AAOtC,MAAM,UAAU,WAAW,CAAC,KAAiB,EAAE,MAAc;IAC3D,MAAM,WAAW,GAAG,MAAM,CAAC;IAC3B,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,OAAO,MAAM,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QACjC,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;QAC7B,KAAK,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,KAAK,CAAC;QAChC,KAAK,IAAI,CAAC,CAAC;QACX,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;QACpD,CAAC;IACH,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,6CAA6C,WAAW,EAAE,CAAC,CAAC;AAC9E,CAAC"}

package/dist/debug_server/debugSession.d.ts

@@ -8,6 +8,7 @@ interface WarpoLaunchRequestArguments extends DebugProtocol.LaunchRequestArgumen
     cwd?: string;
     warpoPath?: string;
     debugSessionLogging?: boolean;
+    debugSessionLogFile?: string;
     args?: number[];
 }
 export declare class WarpoDebugSession extends LoggingDebugSession {
@@ -20,8 +21,11 @@ export declare class WarpoDebugSession extends LoggingDebugSession {
     private nextVariablesReference;
     private loadedModule;
     private runtime;
+    private configurationDone;
     private stoppedWasmBytecodeOffset;
     private stoppedForTrap;
+    private stepMode;
+    private stepStartSourceLocation;
     private debugSessionLogging;
     private log;
     private sendStoppedEvent;
@@ -30,22 +34,32 @@ export declare class WarpoDebugSession extends LoggingDebugSession {
     protected setBreakPointsRequest(response: DebugProtocol.SetBreakpointsResponse, args: DebugProtocol.SetBreakpointsArguments): void;
     protected configurationDoneRequest(response: DebugProtocol.ConfigurationDoneResponse, _args: DebugProtocol.ConfigurationDoneArguments): void;
     protected launchRequest(response: DebugProtocol.LaunchResponse, args: WarpoLaunchRequestArguments): void;
+    protected restartRequest(response: DebugProtocol.RestartResponse, _args: DebugProtocol.RestartArguments): void;
+    private doRestartRequest;
     private doLaunchRequest;
     protected threadsRequest(response: DebugProtocol.ThreadsResponse): void;
     protected stackTraceRequest(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments): void;
     protected scopesRequest(response: DebugProtocol.ScopesResponse, args: DebugProtocol.ScopesArguments): void;
     protected variablesRequest(response: DebugProtocol.VariablesResponse, args: DebugProtocol.VariablesArguments): void;
     protected continueRequest(response: DebugProtocol.ContinueResponse, _args: DebugProtocol.ContinueArguments): void;
+    protected stepInRequest(response: DebugProtocol.StepInResponse, _args: DebugProtocol.StepInArguments): void;
+    protected nextRequest(response: DebugProtocol.NextResponse, _args: DebugProtocol.NextArguments): void;
+    protected pauseRequest(response: DebugProtocol.PauseResponse, _args: DebugProtocol.PauseArguments): void;
+    protected terminateRequest(response: DebugProtocol.TerminateResponse, _args: DebugProtocol.TerminateArguments): void;
+    protected stepOutRequest(response: DebugProtocol.StepOutResponse, _args: DebugProtocol.StepOutArguments): void;
     protected disconnectRequest(response: DebugProtocol.DisconnectResponse, _args: DebugProtocol.DisconnectArguments): void;
+    private doDisconnectRequest;
     private doStackTraceRequest;
     private resolveSourceLocation;
     private doScopesRequest;
     private doVariablesRequest;
     private resolveLocalScopes;
     private resolveLocalScopeVariables;
+    private decodeScopeChainVariables;
+    private resolveClosureScopeVariables;
     private decodeObjectAtAddress;
     private resolveRawWasmValues;
-    private readClosureTupleChain;
+    private resolveClosureTupleAddress;
     private resolvePausedStackFrame;
     private toDebugSessionVariable;
     private toDebugSessionVariableValue;
@@ -60,12 +74,14 @@ export declare class WarpoDebugSession extends LoggingDebugSession {
     private readTupleElementValues;
     private decodeTupleElements;
     private resolveObjectFields;
+    private decodeFunctionElements;
     private resolveRuntimeObjectPayloadSize;
     private decodeTupleReferenceValue;
     private decodeTupleBasicValue;
     private decodeTupleReferenceElement;
     private decodeArrayElements;
     private decodeArrayBufferElements;
+    private decodeTypedArrayElements;
     private decodeStaticArrayElements;
     private decodeArrayElementVariables;
     private decodeSetElements;
@@ -81,13 +97,27 @@ export declare class WarpoDebugSession extends LoggingDebugSession {
     private decodeIntegerBySize;
     private decodeStringAtAddress;
     private doContinueRequest;
+    private doStepRequest;
+    private handleStepPause;
+    private handleNonStepPause;
+    private hasReachedNextSourceLine;
+    private isLibrarySource;
+    private advanceStep;
+    private completeStep;
+    private handleStepFailure;
+    private cancelStep;
     private resumeRuntime;
     private handleRuntimeExit;
     private disposeRuntimeAndTerminate;
     private resetRuntimeState;
+    private queueAllBreakpointUpdates;
     private logAllBreakpoints;
+    private toDebugProtocolBreakpoint;
     private requestBreakpointUpdate;
+    private maybeStartRuntime;
     private applyPendingBreakpointUpdates;
+    private collectBreakpointOffsets;
+    private collectBreakpointLocations;
     private disposeLoadedModule;
 }
 export {};