@rpgjs/vite 5.0.0-alpha.13 → 5.0.0-alpha.14

package/dist/index.js

@@ -199,457 +199,89 @@ const rpgjsModuleViteConfig = () => {
   });
 };
 
-var sourcemapCodec_umd$1 = {exports: {}};
-
-var sourcemapCodec_umd = sourcemapCodec_umd$1.exports;
-
-var hasRequiredSourcemapCodec_umd;
-
-function requireSourcemapCodec_umd () {
-	if (hasRequiredSourcemapCodec_umd) return sourcemapCodec_umd$1.exports;
-	hasRequiredSourcemapCodec_umd = 1;
-	(function (module, exports) {
-		(function (global, factory) {
-		    factory(exports) ;
-		})(sourcemapCodec_umd, (function (exports) {
-		    const comma = ','.charCodeAt(0);
-		    const semicolon = ';'.charCodeAt(0);
-		    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-		    const intToChar = new Uint8Array(64); // 64 possible chars.
-		    const charToInt = new Uint8Array(128); // z is 122 in ASCII
-		    for (let i = 0; i < chars.length; i++) {
-		        const c = chars.charCodeAt(i);
-		        intToChar[i] = c;
-		        charToInt[c] = i;
-		    }
-		    function decodeInteger(reader, relative) {
-		        let value = 0;
-		        let shift = 0;
-		        let integer = 0;
-		        do {
-		            const c = reader.next();
-		            integer = charToInt[c];
-		            value |= (integer & 31) << shift;
-		            shift += 5;
-		        } while (integer & 32);
-		        const shouldNegate = value & 1;
-		        value >>>= 1;
-		        if (shouldNegate) {
-		            value = -2147483648 | -value;
-		        }
-		        return relative + value;
-		    }
-		    function encodeInteger(builder, num, relative) {
-		        let delta = num - relative;
-		        delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
-		        do {
-		            let clamped = delta & 0b011111;
-		            delta >>>= 5;
-		            if (delta > 0)
-		                clamped |= 0b100000;
-		            builder.write(intToChar[clamped]);
-		        } while (delta > 0);
-		        return num;
-		    }
-		    function hasMoreVlq(reader, max) {
-		        if (reader.pos >= max)
-		            return false;
-		        return reader.peek() !== comma;
-		    }
-
-		    const bufLength = 1024 * 16;
-		    // Provide a fallback for older environments.
-		    const td = typeof TextDecoder !== 'undefined'
-		        ? /* #__PURE__ */ new TextDecoder()
-		        : typeof Buffer !== 'undefined'
-		            ? {
-		                decode(buf) {
-		                    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
-		                    return out.toString();
-		                },
-		            }
-		            : {
-		                decode(buf) {
-		                    let out = '';
-		                    for (let i = 0; i < buf.length; i++) {
-		                        out += String.fromCharCode(buf[i]);
-		                    }
-		                    return out;
-		                },
-		            };
-		    class StringWriter {
-		        constructor() {
-		            this.pos = 0;
-		            this.out = '';
-		            this.buffer = new Uint8Array(bufLength);
-		        }
-		        write(v) {
-		            const { buffer } = this;
-		            buffer[this.pos++] = v;
-		            if (this.pos === bufLength) {
-		                this.out += td.decode(buffer);
-		                this.pos = 0;
-		            }
-		        }
-		        flush() {
-		            const { buffer, out, pos } = this;
-		            return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
-		        }
-		    }
-		    class StringReader {
-		        constructor(buffer) {
-		            this.pos = 0;
-		            this.buffer = buffer;
-		        }
-		        next() {
-		            return this.buffer.charCodeAt(this.pos++);
-		        }
-		        peek() {
-		            return this.buffer.charCodeAt(this.pos);
-		        }
-		        indexOf(char) {
-		            const { buffer, pos } = this;
-		            const idx = buffer.indexOf(char, pos);
-		            return idx === -1 ? buffer.length : idx;
-		        }
-		    }
-
-		    const EMPTY = [];
-		    function decodeOriginalScopes(input) {
-		        const { length } = input;
-		        const reader = new StringReader(input);
-		        const scopes = [];
-		        const stack = [];
-		        let line = 0;
-		        for (; reader.pos < length; reader.pos++) {
-		            line = decodeInteger(reader, line);
-		            const column = decodeInteger(reader, 0);
-		            if (!hasMoreVlq(reader, length)) {
-		                const last = stack.pop();
-		                last[2] = line;
-		                last[3] = column;
-		                continue;
-		            }
-		            const kind = decodeInteger(reader, 0);
-		            const fields = decodeInteger(reader, 0);
-		            const hasName = fields & 0b0001;
-		            const scope = (hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind]);
-		            let vars = EMPTY;
-		            if (hasMoreVlq(reader, length)) {
-		                vars = [];
-		                do {
-		                    const varsIndex = decodeInteger(reader, 0);
-		                    vars.push(varsIndex);
-		                } while (hasMoreVlq(reader, length));
-		            }
-		            scope.vars = vars;
-		            scopes.push(scope);
-		            stack.push(scope);
-		        }
-		        return scopes;
-		    }
-		    function encodeOriginalScopes(scopes) {
-		        const writer = new StringWriter();
-		        for (let i = 0; i < scopes.length;) {
-		            i = _encodeOriginalScopes(scopes, i, writer, [0]);
-		        }
-		        return writer.flush();
-		    }
-		    function _encodeOriginalScopes(scopes, index, writer, state) {
-		        const scope = scopes[index];
-		        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
-		        if (index > 0)
-		            writer.write(comma);
-		        state[0] = encodeInteger(writer, startLine, state[0]);
-		        encodeInteger(writer, startColumn, 0);
-		        encodeInteger(writer, kind, 0);
-		        const fields = scope.length === 6 ? 0b0001 : 0;
-		        encodeInteger(writer, fields, 0);
-		        if (scope.length === 6)
-		            encodeInteger(writer, scope[5], 0);
-		        for (const v of vars) {
-		            encodeInteger(writer, v, 0);
-		        }
-		        for (index++; index < scopes.length;) {
-		            const next = scopes[index];
-		            const { 0: l, 1: c } = next;
-		            if (l > endLine || (l === endLine && c >= endColumn)) {
-		                break;
-		            }
-		            index = _encodeOriginalScopes(scopes, index, writer, state);
-		        }
-		        writer.write(comma);
-		        state[0] = encodeInteger(writer, endLine, state[0]);
-		        encodeInteger(writer, endColumn, 0);
-		        return index;
-		    }
-		    function decodeGeneratedRanges(input) {
-		        const { length } = input;
-		        const reader = new StringReader(input);
-		        const ranges = [];
-		        const stack = [];
-		        let genLine = 0;
-		        let definitionSourcesIndex = 0;
-		        let definitionScopeIndex = 0;
-		        let callsiteSourcesIndex = 0;
-		        let callsiteLine = 0;
-		        let callsiteColumn = 0;
-		        let bindingLine = 0;
-		        let bindingColumn = 0;
-		        do {
-		            const semi = reader.indexOf(';');
-		            let genColumn = 0;
-		            for (; reader.pos < semi; reader.pos++) {
-		                genColumn = decodeInteger(reader, genColumn);
-		                if (!hasMoreVlq(reader, semi)) {
-		                    const last = stack.pop();
-		                    last[2] = genLine;
-		                    last[3] = genColumn;
-		                    continue;
-		                }
-		                const fields = decodeInteger(reader, 0);
-		                const hasDefinition = fields & 0b0001;
-		                const hasCallsite = fields & 0b0010;
-		                const hasScope = fields & 0b0100;
-		                let callsite = null;
-		                let bindings = EMPTY;
-		                let range;
-		                if (hasDefinition) {
-		                    const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
-		                    definitionScopeIndex = decodeInteger(reader, definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0);
-		                    definitionSourcesIndex = defSourcesIndex;
-		                    range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
-		                }
-		                else {
-		                    range = [genLine, genColumn, 0, 0];
-		                }
-		                range.isScope = !!hasScope;
-		                if (hasCallsite) {
-		                    const prevCsi = callsiteSourcesIndex;
-		                    const prevLine = callsiteLine;
-		                    callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
-		                    const sameSource = prevCsi === callsiteSourcesIndex;
-		                    callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
-		                    callsiteColumn = decodeInteger(reader, sameSource && prevLine === callsiteLine ? callsiteColumn : 0);
-		                    callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
-		                }
-		                range.callsite = callsite;
-		                if (hasMoreVlq(reader, semi)) {
-		                    bindings = [];
-		                    do {
-		                        bindingLine = genLine;
-		                        bindingColumn = genColumn;
-		                        const expressionsCount = decodeInteger(reader, 0);
-		                        let expressionRanges;
-		                        if (expressionsCount < -1) {
-		                            expressionRanges = [[decodeInteger(reader, 0)]];
-		                            for (let i = -1; i > expressionsCount; i--) {
-		                                const prevBl = bindingLine;
-		                                bindingLine = decodeInteger(reader, bindingLine);
-		                                bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
-		                                const expression = decodeInteger(reader, 0);
-		                                expressionRanges.push([expression, bindingLine, bindingColumn]);
-		                            }
-		                        }
-		                        else {
-		                            expressionRanges = [[expressionsCount]];
-		                        }
-		                        bindings.push(expressionRanges);
-		                    } while (hasMoreVlq(reader, semi));
-		                }
-		                range.bindings = bindings;
-		                ranges.push(range);
-		                stack.push(range);
-		            }
-		            genLine++;
-		            reader.pos = semi + 1;
-		        } while (reader.pos < length);
-		        return ranges;
-		    }
-		    function encodeGeneratedRanges(ranges) {
-		        if (ranges.length === 0)
-		            return '';
-		        const writer = new StringWriter();
-		        for (let i = 0; i < ranges.length;) {
-		            i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
-		        }
-		        return writer.flush();
-		    }
-		    function _encodeGeneratedRanges(ranges, index, writer, state) {
-		        const range = ranges[index];
-		        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, isScope, callsite, bindings, } = range;
-		        if (state[0] < startLine) {
-		            catchupLine(writer, state[0], startLine);
-		            state[0] = startLine;
-		            state[1] = 0;
-		        }
-		        else if (index > 0) {
-		            writer.write(comma);
-		        }
-		        state[1] = encodeInteger(writer, range[1], state[1]);
-		        const fields = (range.length === 6 ? 0b0001 : 0) | (callsite ? 0b0010 : 0) | (isScope ? 0b0100 : 0);
-		        encodeInteger(writer, fields, 0);
-		        if (range.length === 6) {
-		            const { 4: sourcesIndex, 5: scopesIndex } = range;
-		            if (sourcesIndex !== state[2]) {
-		                state[3] = 0;
-		            }
-		            state[2] = encodeInteger(writer, sourcesIndex, state[2]);
-		            state[3] = encodeInteger(writer, scopesIndex, state[3]);
-		        }
-		        if (callsite) {
-		            const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
-		            if (sourcesIndex !== state[4]) {
-		                state[5] = 0;
-		                state[6] = 0;
-		            }
-		            else if (callLine !== state[5]) {
-		                state[6] = 0;
-		            }
-		            state[4] = encodeInteger(writer, sourcesIndex, state[4]);
-		            state[5] = encodeInteger(writer, callLine, state[5]);
-		            state[6] = encodeInteger(writer, callColumn, state[6]);
-		        }
-		        if (bindings) {
-		            for (const binding of bindings) {
-		                if (binding.length > 1)
-		                    encodeInteger(writer, -binding.length, 0);
-		                const expression = binding[0][0];
-		                encodeInteger(writer, expression, 0);
-		                let bindingStartLine = startLine;
-		                let bindingStartColumn = startColumn;
-		                for (let i = 1; i < binding.length; i++) {
-		                    const expRange = binding[i];
-		                    bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
-		                    bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
-		                    encodeInteger(writer, expRange[0], 0);
-		                }
-		            }
-		        }
-		        for (index++; index < ranges.length;) {
-		            const next = ranges[index];
-		            const { 0: l, 1: c } = next;
-		            if (l > endLine || (l === endLine && c >= endColumn)) {
-		                break;
-		            }
-		            index = _encodeGeneratedRanges(ranges, index, writer, state);
-		        }
-		        if (state[0] < endLine) {
-		            catchupLine(writer, state[0], endLine);
-		            state[0] = endLine;
-		            state[1] = 0;
-		        }
-		        else {
-		            writer.write(comma);
-		        }
-		        state[1] = encodeInteger(writer, endColumn, state[1]);
-		        return index;
-		    }
-		    function catchupLine(writer, lastLine, line) {
-		        do {
-		            writer.write(semicolon);
-		        } while (++lastLine < line);
-		    }
-
-		    function decode(mappings) {
-		        const { length } = mappings;
-		        const reader = new StringReader(mappings);
-		        const decoded = [];
-		        let genColumn = 0;
-		        let sourcesIndex = 0;
-		        let sourceLine = 0;
-		        let sourceColumn = 0;
-		        let namesIndex = 0;
-		        do {
-		            const semi = reader.indexOf(';');
-		            const line = [];
-		            let sorted = true;
-		            let lastCol = 0;
-		            genColumn = 0;
-		            while (reader.pos < semi) {
-		                let seg;
-		                genColumn = decodeInteger(reader, genColumn);
-		                if (genColumn < lastCol)
-		                    sorted = false;
-		                lastCol = genColumn;
-		                if (hasMoreVlq(reader, semi)) {
-		                    sourcesIndex = decodeInteger(reader, sourcesIndex);
-		                    sourceLine = decodeInteger(reader, sourceLine);
-		                    sourceColumn = decodeInteger(reader, sourceColumn);
-		                    if (hasMoreVlq(reader, semi)) {
-		                        namesIndex = decodeInteger(reader, namesIndex);
-		                        seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
-		                    }
-		                    else {
-		                        seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
-		                    }
-		                }
-		                else {
-		                    seg = [genColumn];
-		                }
-		                line.push(seg);
-		                reader.pos++;
-		            }
-		            if (!sorted)
-		                sort(line);
-		            decoded.push(line);
-		            reader.pos = semi + 1;
-		        } while (reader.pos <= length);
-		        return decoded;
-		    }
-		    function sort(line) {
-		        line.sort(sortComparator);
-		    }
-		    function sortComparator(a, b) {
-		        return a[0] - b[0];
-		    }
-		    function encode(decoded) {
-		        const writer = new StringWriter();
-		        let sourcesIndex = 0;
-		        let sourceLine = 0;
-		        let sourceColumn = 0;
-		        let namesIndex = 0;
-		        for (let i = 0; i < decoded.length; i++) {
-		            const line = decoded[i];
-		            if (i > 0)
-		                writer.write(semicolon);
-		            if (line.length === 0)
-		                continue;
-		            let genColumn = 0;
-		            for (let j = 0; j < line.length; j++) {
-		                const segment = line[j];
-		                if (j > 0)
-		                    writer.write(comma);
-		                genColumn = encodeInteger(writer, segment[0], genColumn);
-		                if (segment.length === 1)
-		                    continue;
-		                sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
-		                sourceLine = encodeInteger(writer, segment[2], sourceLine);
-		                sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
-		                if (segment.length === 4)
-		                    continue;
-		                namesIndex = encodeInteger(writer, segment[4], namesIndex);
-		            }
-		        }
-		        return writer.flush();
-		    }
-
-		    exports.decode = decode;
-		    exports.decodeGeneratedRanges = decodeGeneratedRanges;
-		    exports.decodeOriginalScopes = decodeOriginalScopes;
-		    exports.encode = encode;
-		    exports.encodeGeneratedRanges = encodeGeneratedRanges;
-		    exports.encodeOriginalScopes = encodeOriginalScopes;
-
-		    Object.defineProperty(exports, '__esModule', { value: true });
-
-		}));
-		
-	} (sourcemapCodec_umd$1, sourcemapCodec_umd$1.exports));
-	return sourcemapCodec_umd$1.exports;
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function encodeInteger(builder, num, relative) {
+  let delta = num - relative;
+  delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+  do {
+    let clamped = delta & 31;
+    delta >>>= 5;
+    if (delta > 0) clamped |= 32;
+    builder.write(intToChar[clamped]);
+  } while (delta > 0);
+  return num;
 }
 
-var sourcemapCodec_umdExports = requireSourcemapCodec_umd();
+// src/strings.ts
+var bufLength = 1024 * 16;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
+  decode(buf) {
+    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+    return out.toString();
+  }
+} : {
+  decode(buf) {
+    let out = "";
+    for (let i = 0; i < buf.length; i++) {
+      out += String.fromCharCode(buf[i]);
+    }
+    return out;
+  }
+};
+var StringWriter = class {
+  constructor() {
+    this.pos = 0;
+    this.out = "";
+    this.buffer = new Uint8Array(bufLength);
+  }
+  write(v) {
+    const { buffer } = this;
+    buffer[this.pos++] = v;
+    if (this.pos === bufLength) {
+      this.out += td.decode(buffer);
+      this.pos = 0;
+    }
+  }
+  flush() {
+    const { buffer, out, pos } = this;
+    return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+  }
+};
+function encode(decoded) {
+  const writer = new StringWriter();
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    if (i > 0) writer.write(semicolon);
+    if (line.length === 0) continue;
+    let genColumn = 0;
+    for (let j = 0; j < line.length; j++) {
+      const segment = line[j];
+      if (j > 0) writer.write(comma);
+      genColumn = encodeInteger(writer, segment[0], genColumn);
+      if (segment.length === 1) continue;
+      sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+      sourceLine = encodeInteger(writer, segment[2], sourceLine);
+      sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+      if (segment.length === 4) continue;
+      namesIndex = encodeInteger(writer, segment[4], namesIndex);
+    }
+  }
+  return writer.flush();
+}
 
 class BitSet {
 	constructor(arg) {
@@ -865,7 +497,7 @@ class SourceMap {
 		this.sources = properties.sources;
 		this.sourcesContent = properties.sourcesContent;
 		this.names = properties.names;
-		this.mappings = sourcemapCodec_umdExports.encode(properties.mappings);
+		this.mappings = encode(properties.mappings);
 		if (typeof properties.x_google_ignoreList !== 'undefined') {
 			this.x_google_ignoreList = properties.x_google_ignoreList;
 		}
@@ -2808,6 +2440,49 @@ pp$8.isAsyncFunction = function() {
      !(isIdentifierChar(after = this.input.charCodeAt(next + 8)) || after > 0xd7ff && after < 0xdc00))
 };
 
+pp$8.isUsingKeyword = function(isAwaitUsing, isFor) {
+  if (this.options.ecmaVersion < 17 || !this.isContextual(isAwaitUsing ? "await" : "using"))
+    { return false }
+
+  skipWhiteSpace.lastIndex = this.pos;
+  var skip = skipWhiteSpace.exec(this.input);
+  var next = this.pos + skip[0].length;
+
+  if (lineBreak.test(this.input.slice(this.pos, next))) { return false }
+
+  if (isAwaitUsing) {
+    var awaitEndPos = next + 5 /* await */, after;
+    if (this.input.slice(next, awaitEndPos) !== "using" ||
+      awaitEndPos === this.input.length ||
+      isIdentifierChar(after = this.input.charCodeAt(awaitEndPos)) ||
+      (after > 0xd7ff && after < 0xdc00)
+    ) { return false }
+
+    skipWhiteSpace.lastIndex = awaitEndPos;
+    var skipAfterUsing = skipWhiteSpace.exec(this.input);
+    if (skipAfterUsing && lineBreak.test(this.input.slice(awaitEndPos, awaitEndPos + skipAfterUsing[0].length))) { return false }
+  }
+
+  if (isFor) {
+    var ofEndPos = next + 2 /* of */, after$1;
+    if (this.input.slice(next, ofEndPos) === "of") {
+      if (ofEndPos === this.input.length ||
+        (!isIdentifierChar(after$1 = this.input.charCodeAt(ofEndPos)) && !(after$1 > 0xd7ff && after$1 < 0xdc00))) { return false }
+    }
+  }
+
+  var ch = this.input.charCodeAt(next);
+  return isIdentifierStart(ch, true) || ch === 92 // '\'
+};
+
+pp$8.isAwaitUsing = function(isFor) {
+  return this.isUsingKeyword(true, isFor)
+};
+
+pp$8.isUsing = function(isFor) {
+  return this.isUsingKeyword(false, isFor)
+};
+
 // Parse a single statement.
 //
 // If expecting a statement and finding a slash operator, parse a
@@ -2884,6 +2559,23 @@ pp$8.parseStatement = function(context, topLevel, exports) {
       return this.parseFunctionStatement(node, true, !context)
     }
 
+    var usingKind = this.isAwaitUsing(false) ? "await using" : this.isUsing(false) ? "using" : null;
+    if (usingKind) {
+      if (topLevel && this.options.sourceType === "script") {
+        this.raise(this.start, "Using declaration cannot appear in the top level when source type is `script`");
+      }
+      if (usingKind === "await using") {
+        if (!this.canAwait) {
+          this.raise(this.start, "Await using cannot appear outside of async function");
+        }
+        this.next();
+      }
+      this.next();
+      this.parseVar(node, false, usingKind);
+      this.semicolon();
+      return this.finishNode(node, "VariableDeclaration")
+    }
+
     var maybeName = this.value, expr = this.parseExpression();
     if (starttype === types$1.name && expr.type === "Identifier" && this.eat(types$1.colon))
       { return this.parseLabeledStatement(node, maybeName, expr, context) }
@@ -2959,18 +2651,19 @@ pp$8.parseForStatement = function(node) {
     this.next();
     this.parseVar(init$1, true, kind);
     this.finishNode(init$1, "VariableDeclaration");
-    if ((this.type === types$1._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1) {
-      if (this.options.ecmaVersion >= 9) {
-        if (this.type === types$1._in) {
-          if (awaitAt > -1) { this.unexpected(awaitAt); }
-        } else { node.await = awaitAt > -1; }
-      }
-      return this.parseForIn(node, init$1)
-    }
-    if (awaitAt > -1) { this.unexpected(awaitAt); }
-    return this.parseFor(node, init$1)
+    return this.parseForAfterInit(node, init$1, awaitAt)
   }
   var startsWithLet = this.isContextual("let"), isForOf = false;
+
+  var usingKind = this.isUsing(true) ? "using" : this.isAwaitUsing(true) ? "await using" : null;
+  if (usingKind) {
+    var init$2 = this.startNode();
+    this.next();
+    if (usingKind === "await using") { this.next(); }
+    this.parseVar(init$2, true, usingKind);
+    this.finishNode(init$2, "VariableDeclaration");
+    return this.parseForAfterInit(node, init$2, awaitAt)
+  }
   var containsEsc = this.containsEsc;
   var refDestructuringErrors = new DestructuringErrors;
   var initPos = this.start;
@@ -2996,6 +2689,20 @@ pp$8.parseForStatement = function(node) {
   return this.parseFor(node, init)
 };
 
+// Helper method to parse for loop after variable initialization
+pp$8.parseForAfterInit = function(node, init, awaitAt) {
+  if ((this.type === types$1._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1) {
+    if (this.options.ecmaVersion >= 9) {
+      if (this.type === types$1._in) {
+        if (awaitAt > -1) { this.unexpected(awaitAt); }
+      } else { node.await = awaitAt > -1; }
+    }
+    return this.parseForIn(node, init)
+  }
+  if (awaitAt > -1) { this.unexpected(awaitAt); }
+  return this.parseFor(node, init)
+};
+
 pp$8.parseFunctionStatement = function(node, isAsync, declarationPosition) {
   this.next();
   return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
@@ -3252,6 +2959,8 @@ pp$8.parseVar = function(node, isFor, kind, allowMissingInitializer) {
       decl.init = this.parseMaybeAssign(isFor);
     } else if (!allowMissingInitializer && kind === "const" && !(this.type === types$1._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
       this.unexpected();
+    } else if (!allowMissingInitializer && (kind === "using" || kind === "await using") && this.options.ecmaVersion >= 17 && this.type !== types$1._in && !this.isContextual("of")) {
+      this.raise(this.lastTokEnd, ("Missing initializer in " + kind + " declaration"));
     } else if (!allowMissingInitializer && decl.id.type !== "Identifier" && !(isFor && (this.type === types$1._in || this.isContextual("of")))) {
       this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
     } else {
@@ -3264,7 +2973,10 @@ pp$8.parseVar = function(node, isFor, kind, allowMissingInitializer) {
 };
 
 pp$8.parseVarId = function(decl, kind) {
-  decl.id = this.parseBindingAtom();
+  decl.id = kind === "using" || kind === "await using"
+    ? this.parseIdent()
+    : this.parseBindingAtom();
+
   this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
 };
 
@@ -4995,7 +4707,8 @@ pp$5.parseLiteral = function(value) {
   var node = this.startNode();
   node.value = value;
   node.raw = this.input.slice(this.start, this.end);
-  if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint = node.raw.slice(0, -1).replace(/_/g, ""); }
+  if (node.raw.charCodeAt(node.raw.length - 1) === 110)
+    { node.bigint = node.value != null ? node.value.toString() : node.raw.slice(0, -1).replace(/_/g, ""); }
   this.next();
   return this.finishNode(node, "Literal")
 };
@@ -8025,11 +7738,9 @@ pp.readWord = function() {
 // Please use the [github bug tracker][ghbt] to report issues.
 //
 // [ghbt]: https://github.com/acornjs/acorn/issues
-//
-// [walk]: util/walk.js
 
 
-var version = "8.14.1";
+var version = "8.15.0";
 
 Parser.acorn = {
   Parser: Parser,
@@ -8639,7 +8350,7 @@ class Room {
         this.storageData.delete(key);
       },
       list: async () => {
-        return Array.from(this.storageData.keys());
+        return Array.from(this.storageData.entries());
       }
     };
   }
@@ -8663,6 +8374,113 @@ function serverPlugin(serverModule) {
   let wsServer = null;
   let rooms = /* @__PURE__ */ new Map();
   let servers = /* @__PURE__ */ new Map();
+  async function ensureRoomAndServer(roomId) {
+    let room = rooms.get(roomId);
+    if (!room) {
+      room = new Room(roomId);
+      rooms.set(roomId, room);
+      console.log(`Created new room: ${roomId}`);
+    }
+    let rpgServer = servers.get(roomId);
+    if (!rpgServer) {
+      rpgServer = new serverModule(room);
+      servers.set(roomId, rpgServer);
+      console.log(`Created new server instance for room: ${roomId}`);
+      if (typeof rpgServer.onStart === "function") {
+        try {
+          await rpgServer.onStart();
+          console.log(`Server started for room: ${roomId}`);
+        } catch (error) {
+          console.error(`Error starting server for room ${roomId}:`, error);
+        }
+      }
+      try {
+        const mapId = roomId.startsWith("map-") ? roomId.slice(4) : roomId;
+        const defaultMapPayload = {
+          id: mapId,
+          width: 1e3,
+          height: 1e3,
+          events: []
+        };
+        const req = {
+          url: `http://localhost/parties/main/${roomId}/map/update`,
+          method: "POST",
+          headers: new Headers({}),
+          json: async () => defaultMapPayload,
+          text: async () => JSON.stringify(defaultMapPayload)
+        };
+        await rpgServer.onRequest(req);
+        console.log(`Initialized map for room ${roomId} via POST /map/update`);
+      } catch (error) {
+        console.warn(`Failed initializing map for room ${roomId}:`, error);
+      }
+    }
+    room.context.parties = buildPartiesContext();
+    return { room, rpgServer };
+  }
+  function buildPartiesContext() {
+    return {
+      main: {
+        get: async (targetRoomId) => {
+          const { rpgServer } = await ensureRoomAndServer(targetRoomId);
+          return {
+            fetch: async (path, init) => {
+              try {
+                const url = `http://localhost/parties/main/${targetRoomId}${path}`;
+                const method = (init?.method || "GET").toUpperCase();
+                const headers = new Headers(init?.headers || {});
+                const bodyRaw = init?.body;
+                const req = {
+                  url,
+                  method,
+                  headers,
+                  json: async () => {
+                    if (!bodyRaw) return void 0;
+                    return typeof bodyRaw === "string" ? JSON.parse(bodyRaw) : bodyRaw;
+                  },
+                  text: async () => {
+                    if (typeof bodyRaw === "string") return bodyRaw;
+                    if (typeof bodyRaw === "undefined") return "";
+                    return JSON.stringify(bodyRaw);
+                  }
+                };
+                const result = await rpgServer.onRequest(req);
+                const ok = !!result && (result.ok === true || typeof result !== "undefined");
+                const response = {
+                  ok,
+                  status: ok ? 200 : 404,
+                  async json() {
+                    if (result && typeof result.json === "function") return result.json();
+                    return result ?? {};
+                  },
+                  async text() {
+                    if (typeof result === "string") return result;
+                    try {
+                      return JSON.stringify(result ?? {});
+                    } catch {
+                      return "";
+                    }
+                  }
+                };
+                return response;
+              } catch (error) {
+                return {
+                  ok: false,
+                  status: 500,
+                  async json() {
+                    return { error: error?.message || "Internal error" };
+                  },
+                  async text() {
+                    return error?.message || "Internal error";
+                  }
+                };
+              }
+            }
+          };
+        }
+      }
+    };
+  }
   return {
     name: "server-plugin",
     async configureServer(server) {
@@ -8724,29 +8542,13 @@ function serverPlugin(serverModule) {
                       `Room: ${roomName}, Query params:`,
                       queryParams
                     );
-                    let room = rooms.get(roomName);
-                    if (!room) {
-                      room = new Room(roomName);
-                      rooms.set(roomName, room);
-                      console.log(`Created new room: ${roomName}`);
-                    }
-                    let rpgServer = servers.get(roomName);
-                    if (!rpgServer) {
-                      rpgServer = new serverModule(room);
-                      servers.set(roomName, rpgServer);
-                      console.log(`Created new server instance for room: ${roomName}`);
-                      if (typeof rpgServer.onStart === "function") {
-                        try {
-                          await rpgServer.onStart();
-                          console.log(`Server started for room: ${roomName}`);
-                        } catch (error) {
-                          console.error(`Error starting server for room ${roomName}:`, error);
-                        }
-                      }
-                    }
+                    const ensured = await ensureRoomAndServer(roomName);
+                    const room = ensured.room;
+                    const rpgServer = ensured.rpgServer;
+                    room.context.parties = buildPartiesContext();
                     const connection = new PartyConnection(
                       ws,
-                      void 0,
+                      queryParams._pk,
                       request.url
                     );
                     room.addConnection(connection);
@@ -8803,7 +8605,7 @@ function serverPlugin(serverModule) {
                             keys: () => headers.keys(),
                             values: () => headers.values()
                           },
-                          url: request.url,
+                          url: url.toString(),
                           method: request.method
                         },
                         url