poe-code 14.0.61 → 14.0.62

package/packages/safe-js/dist/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-VAYQP2VZ.js";
+} from "./chunks/chunk-F7TJSPDZ.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-ZTGKRKQH.js";
+} from "./chunks/chunk-VKGWGZBH.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/core.js

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-ZTGKRKQH.js";
+} from "./chunks/chunk-VKGWGZBH.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safe-js/dist/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-VAYQP2VZ.js";
+} from "./chunks/chunk-F7TJSPDZ.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-ZTGKRKQH.js";
+} from "./chunks/chunk-VKGWGZBH.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/async.js

@@ -8,6 +8,7 @@ import { awaitSandboxValue } from "./cancel.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
 import { createPatternContext } from "./interpreter.js";
 import { getGuestFunctionProperty, setSandboxPrototype } from "./object-model.js";
+import { functionSources } from "../parse/function-source.js";
 import { boundIdentifiers, containsParameterExpression, getFunctionLength, hoistedVarDeclarations } from "../parse/bindings.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxPromise, allocateProducedSandboxValue, reconcileCompiledValues, isSandboxPromise } from "./values.js";
 export function emitResumeBreakpoint(context, breakpoint) {
@@ -62,6 +63,7 @@ export function createInterpretedClosure(node, context, evaluateNode) {
         }
         : undefined;
     const closure = createSandboxClosure({
+        sourceRange: functionSources.get(node),
         guest: true,
         sandbox: true,
         length: getFunctionLength(node.params),
@@ -116,6 +118,7 @@ export function executeAsyncFunction(execute, budget, signal) {
 }
 function createGeneratorClosure(node, context, evaluateNode) {
     return createSandboxClosure({
+        sourceRange: functionSources.get(node),
         guest: true,
         generator: true,
         sandbox: true,

package/packages/safe-js/dist/interp/function-string.d.ts

@@ -0,0 +1,2 @@
+import type { SandboxClosure } from "./values.js";
+export declare function functionString(value: SandboxClosure): string;

package/packages/safe-js/dist/interp/function-string.js

@@ -0,0 +1,21 @@
+import { runResources } from "./resources.js";
+export function functionString(value) {
+    if (runResources.getStore()?.functionSourceText === false)
+        return "[object Object]";
+    const source = value.sourceRange;
+    if (source !== undefined)
+        return source.text.slice(source.start, source.end);
+    let name = value.boundTarget === undefined ? (value.name?.split("#").at(-1) ?? "") : "";
+    for (let index = 0; index < name.length; index++) {
+        const code = name.charCodeAt(index);
+        if (!((code >= 65 && code <= 90) ||
+            (code >= 97 && code <= 122) ||
+            code === 36 ||
+            code === 95 ||
+            (index > 0 && code >= 48 && code <= 57))) {
+            name = "";
+            break;
+        }
+    }
+    return `function ${name}() { [native code] }`;
+}

package/packages/safe-js/dist/interp/globals/misc.js

@@ -1,6 +1,8 @@
 import { isSandboxCollectionIterator } from "../collection-iterator.js";
 import { assertSandboxGraphDepth } from "../../graph-depth.js";
 import { CompileScope } from "../regex/compile-guard.js";
+import { createNumericParsers } from "./numeric-parsers.js";
+import { sandboxNumber } from "../string-coercion.js";
 import { allocateProducedSandboxValue, cloneSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet, reconcileCompiledValues } from "../values.js";
 export function createMiscGlobals(options) {
     return {
@@ -9,24 +11,21 @@ export function createMiscGlobals(options) {
             call: ([value], context) => structuredCloneSandboxValue(value, options.budget, context?.compilation),
             name: "structuredClone"
         }),
-        parseInt: createSandboxClosure({
-            sandbox: true,
-            call: (args) => Reflect.apply(globalThis.parseInt, globalThis, [...args]),
-            name: "parseInt"
-        }),
-        parseFloat: createSandboxClosure({
-            sandbox: true,
-            call: (args) => Reflect.apply(globalThis.parseFloat, globalThis, [...args]),
-            name: "parseFloat"
-        }),
+        ...createNumericParsers(options.budget),
         isNaN: createSandboxClosure({
             sandbox: true,
-            call: ([value]) => globalThis.isNaN(value),
+            call: ([value], context) => {
+                const number = sandboxNumber(value, options.budget, context);
+                return typeof number === "number" ? Number.isNaN(number) : number.then(Number.isNaN);
+            },
             name: "isNaN"
         }),
         isFinite: createSandboxClosure({
             sandbox: true,
-            call: ([value]) => globalThis.isFinite(value),
+            call: ([value], context) => {
+                const number = sandboxNumber(value, options.budget, context);
+                return typeof number === "number" ? Number.isFinite(number) : number.then(Number.isFinite);
+            },
             name: "isFinite"
         })
     };

package/packages/safe-js/dist/interp/globals/numeric-parsers.d.ts

@@ -0,0 +1,5 @@
+import type { Budget } from "../budget.js";
+export declare function createNumericParsers(budget: Budget): {
+    parseInt: import("../values.js").SandboxClosure;
+    parseFloat: import("../values.js").SandboxClosure;
+};

package/packages/safe-js/dist/interp/globals/numeric-parsers.js

@@ -0,0 +1,47 @@
+import { retainValues } from "../resources.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
+import { createSandboxClosure } from "../values.js";
+export function createNumericParsers(budget) {
+    return {
+        parseInt: createSandboxClosure({
+            sandbox: true,
+            name: "parseInt",
+            call: ([value, radix], context) => {
+                const parse = (text) => {
+                    const release = retainValues(budget, () => [text]);
+                    let convertedRadix;
+                    try {
+                        convertedRadix = sandboxNumber(radix, budget, context);
+                    }
+                    catch (error) {
+                        release();
+                        throw error;
+                    }
+                    if (typeof convertedRadix === "number") {
+                        try {
+                            return globalThis.parseInt(text, convertedRadix);
+                        }
+                        finally {
+                            release();
+                        }
+                    }
+                    return convertedRadix
+                        .then((number) => globalThis.parseInt(text, number))
+                        .finally(release);
+                };
+                const text = sandboxString(value, budget, context);
+                return typeof text === "string" ? parse(text) : text.then(parse);
+            }
+        }),
+        parseFloat: createSandboxClosure({
+            sandbox: true,
+            name: "parseFloat",
+            call: ([value], context) => {
+                const text = sandboxString(value, budget, context);
+                return typeof text === "string"
+                    ? globalThis.parseFloat(text)
+                    : text.then(globalThis.parseFloat);
+            }
+        })
+    };
+}

package/packages/safe-js/dist/interp/globals/object-array.js

@@ -10,6 +10,7 @@ import { isFloat32Array } from "../float32.js";
 import { setSandboxProperty } from "../interpreter.js";
 import { getSandboxIterator } from "../iteration.js";
 import { sandboxNumber, sandboxString } from "../string-coercion.js";
+import { createNumericParsers } from "./numeric-parsers.js";
 import { getSandboxDataProperty, getSandboxPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
 import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, defineOwnDataProperty, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, measureSandboxData, ownEnumerableSandboxEntries as getOwnEnumerableEntries } from "../values.js";
 export function createObjectArrayGlobals(options) {
@@ -222,16 +223,7 @@ export function createObjectArrayGlobals(options) {
                     call: ([value]) => typeof value === "number" && Number.isInteger(value),
                     name: "isInteger"
                 }),
-                parseInt: createSandboxClosure({
-                    sandbox: true,
-                    call: (args) => Reflect.apply(Number.parseInt, Number, [...args]),
-                    name: "parseInt"
-                }),
-                parseFloat: createSandboxClosure({
-                    sandbox: true,
-                    call: (args) => Reflect.apply(Number.parseFloat, Number, [...args]),
-                    name: "parseFloat"
-                }),
+                ...createNumericParsers(options.budget),
                 isSafeInteger: createSandboxClosure({
                     sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isSafeInteger(value),

package/packages/safe-js/dist/interp/interpreter.js

@@ -2546,6 +2546,7 @@ function createSetMethodOptions(context) {
 }
 function createFunctionMethodOptions(context) {
     return {
+        budget: context.budget,
         callClosure: (closure, args, stack, thisValue, construct) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue, construct)
     };
 }

package/packages/safe-js/dist/interp/methods/function.d.ts

@@ -1,5 +1,7 @@
 import { type SandboxClosure, type SandboxValue } from "../values.js";
+import type { Budget } from "../budget.js";
 export type FunctionMethodOptions = {
+    budget?: Budget;
     callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue: SandboxValue, construct?: boolean) => Promise<SandboxValue> | SandboxValue;
 };
 export declare function getFunctionMember(target: SandboxClosure, property: string | number, options: FunctionMethodOptions): SandboxValue | undefined;

package/packages/safe-js/dist/interp/methods/function.js

@@ -1,6 +1,8 @@
 import { createSandboxClosure, isSandboxClosure } from "../values.js";
 import { getGuestFunctionProperty, isGuestClosure } from "../object-model.js";
-const functionMethodNames = new Set(["apply", "bind", "call"]);
+import { functionString } from "../function-string.js";
+import { runResources } from "../resources.js";
+const functionMethodNames = new Set(["apply", "bind", "call", "toString"]);
 export function getFunctionMember(target, property, options) {
     if (isGuestClosure(target)) {
         const value = getGuestFunctionProperty(target, String(property));
@@ -16,12 +18,15 @@ export function getFunctionMember(target, property, options) {
     if (property === "length") {
         return target.length;
     }
+    if (property === "toString" && runResources.getStore()?.functionSourceText === false)
+        return undefined;
     if (!isFunctionMethodName(property)) {
         return undefined;
     }
     return createSandboxClosure({
         sandbox: true,
         name: `Function#${property}`,
+        ...(property === "toString" ? { length: 0 } : {}),
         call: (args, context) => callFunctionMethod(context?.thisValue, property, args, options, context?.stack ?? [])
     });
 }
@@ -32,6 +37,10 @@ function callFunctionMethod(target, methodName, args, options, stack) {
     if (!isSandboxClosure(target)) {
         throw new TypeError(`Function#${methodName} requires a callable receiver.`);
     }
+    if (methodName === "toString") {
+        const text = functionString(target);
+        return options.budget?.allocateString(text) ?? text;
+    }
     const thisValue = args[0];
     if (methodName === "bind") {
         const boundArgs = args.slice(1);

package/packages/safe-js/dist/interp/resources.d.ts

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import type { Budget } from "./budget.js";
 export type RunResources = {
     signal: AbortSignal;
+    functionSourceText?: boolean;
     referenceReleases: Set<() => void>;
     add(close: () => Promise<void>): void;
 };

package/packages/safe-js/dist/interp/string-coercion.js

@@ -8,6 +8,7 @@ import { collectionIteratorState, isSandboxCollectionIterator } from "./collecti
 import { getGuestFunctionProperties, getSandboxPrototype, hasExplicitSandboxPrototype, isGuestClosure } from "./object-model.js";
 import { getRegexMember } from "./methods/regex.js";
 import { retainValues } from "./resources.js";
+import { functionString } from "./function-string.js";
 import { isSandboxClosure, isSandboxPromise, isSandboxMap, isSandboxSet, isSandboxRegex, isSandboxGenerator } from "./values.js";
 const defaultStringHook = Symbol("defaultStringHook");
 const defaultValueHook = Symbol("defaultValueHook");
@@ -96,6 +97,8 @@ function conversionHook(value, name, budget) {
     return undefined;
 }
 async function defaultToString(value, budget, context, joining) {
+    if (isSandboxClosure(value))
+        return budget.allocateString(functionString(value));
     if (isSandboxMap(value))
         return "[object Map]";
     if (isSandboxSet(value))

package/packages/safe-js/dist/interp/values.d.ts

@@ -4,6 +4,7 @@ import type { Budget, CompileTicket } from "./budget.js";
 import { CompileScope } from "./regex/compile-guard.js";
 import type { GeneratorChannel } from "./generator.js";
 import { type RegexPattern } from "./regex/parse.js";
+import type { FunctionSource } from "../parse/function-source.js";
 export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
 export { isSandboxMap, isSandboxSet } from "./collection-brands.js";
 declare const sandboxClosureBrand: unique symbol;
@@ -57,6 +58,7 @@ export type SandboxCallContext = {
     readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue, construct?: boolean) => Promise<SandboxValue>;
 };
 export type SandboxClosure = {
+    readonly sourceRange?: FunctionSource;
     readonly async?: true;
     readonly generator?: true;
     readonly sandbox?: true;
@@ -94,6 +96,7 @@ type CopyFromSandboxOptions = {
     compilation?: CompileScope;
 };
 export declare function createSandboxClosure(input: {
+    sourceRange?: FunctionSource;
     guest?: boolean;
     async?: boolean;
     generator?: boolean;

package/packages/safe-js/dist/interp/values.js

@@ -39,6 +39,9 @@ export function createSandboxClosure(input) {
         enumerable: false,
         value: true
     });
+    if (input.sourceRange !== undefined) {
+        Object.defineProperty(closure, "sourceRange", { value: input.sourceRange });
+    }
     if (input.sandbox === true) {
         Object.defineProperty(closure, "sandbox", { value: true });
     }

package/packages/safe-js/dist/migrate.js

@@ -12,7 +12,7 @@ export function inspectSnapshotMigration(snapshot, options) {
     validateSnapshotData(snapshot);
     validateDumpEnvelope(snapshot);
     validateMigrationSemantics(snapshot.executionSemantics);
-    const sourceHash = hashSource(options.source);
+    const sourceHash = hashSource(options.source, undefined, snapshot.executionSemantics === EXECUTION_SEMANTICS);
     if (snapshot.sourceHash !== sourceHash)
         throw new TypeError(`Migration requires the original executable source (checkpoint hash ${snapshot.sourceHash}, supplied ${sourceHash}). Preserve the checkpoint; do not replace its hash.`);
     validateSnapshotMigration(snapshot.migration, sourceHash);

package/packages/safe-js/dist/parse/function-source.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionNode } from "./parser.js";
+export type FunctionSource = {
+    readonly text: string;
+    readonly start: number;
+    readonly end: number;
+};
+export declare const functionSources: WeakMap<FunctionNode, FunctionSource>;

package/packages/safe-js/dist/parse/function-source.js

@@ -0,0 +1 @@
+export const functionSources = new WeakMap();

package/packages/safe-js/dist/parse/hash.d.ts

@@ -1,4 +1,4 @@
 import { type Module, type ParseResult } from "./parser.js";
 import { type CompileOwner } from "../interp/budget.js";
-export declare function hashSource(source: string, owner?: CompileOwner): string;
-export declare function hashParsedAst(ast: Module | ParseResult): string;
+export declare function hashSource(source: string, owner?: CompileOwner, includeFunctionSource?: boolean): string;
+export declare function hashParsedAst(ast: Module | ParseResult, includeFunctionSource?: boolean): string;

package/packages/safe-js/dist/parse/hash.js

@@ -1,23 +1,24 @@
 import { parse, parseModule } from "./parser.js";
 import { SandboxError } from "../interp/budget.js";
+import { functionSources } from "./function-source.js";
 const FNV_OFFSET_BASIS = 0x811c9dc5;
 const FNV_PRIME = 0x01000193;
 const IGNORED_KEYS = new Set(["nodeId", "raw", "span"]);
-export function hashSource(source, owner) {
+export function hashSource(source, owner, includeFunctionSource = true) {
     try {
-        return hashParsedAst(parse(source, "<input>", owner));
+        return hashParsedAst(parse(source, "<input>", owner), includeFunctionSource);
     }
     catch (error) {
         if (error instanceof SandboxError)
             throw error;
-        return hashParsedAst(parseModule(source, "<input>", owner));
+        return hashParsedAst(parseModule(source, "<input>", owner), includeFunctionSource);
     }
 }
-export function hashParsedAst(ast) {
+export function hashParsedAst(ast, includeFunctionSource = true) {
     let hash = FNV_OFFSET_BASIS;
     visit(ast);
     return hash.toString(16).padStart(8, "0");
-    function visit(value, includeTemplateRaw = false) {
+    function visit(value, includeTemplateRaw = false, enclosingSource) {
         if (value === null) {
             write("null");
             return;
@@ -29,7 +30,7 @@ export function hashParsedAst(ast) {
         if (Array.isArray(value)) {
             write("[");
             for (const entry of value) {
-                visit(entry, includeTemplateRaw);
+                visit(entry, includeTemplateRaw, enclosingSource);
                 write(",");
             }
             write("]");
@@ -47,6 +48,19 @@ export function hashParsedAst(ast) {
                 return;
             case "object": {
                 const record = value;
+                const source = includeFunctionSource
+                    ? functionSources.get(value)
+                    : undefined;
+                if (source !== undefined &&
+                    !(enclosingSource !== undefined &&
+                        source.text === enclosingSource.text &&
+                        source.start >= enclosingSource.start &&
+                        source.end <= enclosingSource.end)) {
+                    write("function-source:");
+                    write(String(source.end - source.start));
+                    write(":");
+                    write(source.text, source.start, source.end);
+                }
                 const keys = Object.keys(value)
                     .filter((key) => shouldHashKey(record, key, includeTemplateRaw))
                     .sort();
@@ -54,7 +68,7 @@ export function hashParsedAst(ast) {
                 for (const key of keys) {
                     write(JSON.stringify(key));
                     write(":");
-                    visit(record[key], shouldIncludeTemplateRaw(record, key, includeTemplateRaw));
+                    visit(record[key], shouldIncludeTemplateRaw(record, key, includeTemplateRaw), source ?? enclosingSource);
                     write(",");
                 }
                 write("}");
@@ -64,8 +78,8 @@ export function hashParsedAst(ast) {
                 throw new TypeError(`Unsupported AST value type: ${typeof value}`);
         }
     }
-    function write(chunk) {
-        for (let index = 0; index < chunk.length; index += 1) {
+    function write(chunk, start = 0, end = chunk.length) {
+        for (let index = start; index < end; index += 1) {
             hash ^= chunk.charCodeAt(index);
             hash = Math.imul(hash, FNV_PRIME) >>> 0;
         }

package/packages/safe-js/dist/parse/parser.js

@@ -1,6 +1,7 @@
 import { boundIdentifiers } from "./bindings.js";
 import { tokenize } from "./tokenizer.js";
 import { assignIds } from "./assign-ids.js";
+import { functionSources } from "./function-source.js";
 import { formatParseError } from "./format-error.js";
 import { createExportDefaultDeclaration, createExportNamedDeclaration } from "./parse-export.js";
 import { createImportMeta, isImportMetaTokenSequence } from "./parse-import-meta.js";
@@ -42,7 +43,7 @@ const TOP_LEVEL_STATEMENT_KEYWORDS = new Set([
 export function parse(source, filename = "<input>", owner) {
     const compilation = new CompileScope(owner);
     try {
-        const result = assignIds(parseTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
+        const result = assignIds(new Parser(tokenize(source, { allowRegexLiterals: true, compilation }), source, compilation).parseTopLevel());
         const regexLiteral = findRegexLiteral(result);
         if (regexLiteral !== undefined) {
             throw new Error(`Regular expression literals are not supported at line ${regexLiteral.span.start.line}, column ${regexLiteral.span.start.column}.`);
@@ -66,7 +67,7 @@ export function parse(source, filename = "<input>", owner) {
 export function parseModule(source, filename = "<input>", owner) {
     const compilation = new CompileScope(owner);
     try {
-        return assignIds(parseModuleTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
+        return assignIds(new Parser(tokenize(source, { allowRegexLiterals: true, compilation }), source, compilation).parseModule());
     }
     catch (error) {
         if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
@@ -84,7 +85,7 @@ export function parseModule(source, filename = "<input>", owner) {
 export function parseExecutableModule(source, filename = "<input>", owner) {
     const compilation = new CompileScope(owner);
     try {
-        const result = assignIds(parseModuleTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
+        const result = assignIds(new Parser(tokenize(source, { allowRegexLiterals: true, compilation }), source, compilation).parseModule());
         throwIfImportMetaAssignment(result);
         return result;
     }
@@ -101,14 +102,9 @@ export function parseExecutableModule(source, filename = "<input>", owner) {
         compilation.dispose();
     }
 }
-function parseTokens(tokens, compilation) {
-    return new Parser(tokens, compilation).parseTopLevel();
-}
-function parseModuleTokens(tokens, compilation) {
-    return new Parser(tokens, compilation).parseModule();
-}
 class Parser {
     tokens;
+    source;
     compilation;
     functionContext;
     index = 0;
@@ -119,12 +115,21 @@ class Parser {
     scopes = [new Map()];
     functionScopes = new WeakSet();
     varNames = new WeakMap();
-    constructor(tokens, compilation, functionContext = "normal") {
+    constructor(tokens, source, compilation, functionContext = "normal") {
         this.tokens = tokens;
+        this.source = source;
         this.compilation = compilation;
         this.functionContext = functionContext;
         this.functionScopes.add(this.scopes[0]);
     }
+    withFunctionSource(node) {
+        functionSources.set(node, {
+            text: this.source,
+            start: node.span.start.offset,
+            end: node.span.end.offset
+        });
+        return node;
+    }
     parseTopLevel() {
         if (this.isExportToken(this.currentToken())) {
             throw new DisallowedSyntaxError("export", this.currentToken().start);
@@ -270,14 +275,14 @@ class Parser {
         });
         this.expectPunctuator("=>");
         const body = this.parseArrowFunctionBody(params);
-        return {
+        return this.withFunctionSource({
             type: "ArrowFunctionExpression",
             async: isAsync,
             body,
             expression: body.type !== "BlockStatement",
             params,
             span: createSpan(start, body.span.end)
-        };
+        });
     }
     parseConditionalExpression() {
         if (this.conditionalExpressionDepth >= MAX_CONDITIONAL_EXPRESSION_DEPTH) {
@@ -920,7 +925,7 @@ class Parser {
         });
         const generator = generatorToken !== undefined;
         const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
-        return {
+        return this.withFunctionSource({
             type: "FunctionDeclaration",
             async: asyncToken !== undefined,
             body,
@@ -928,7 +933,7 @@ class Parser {
             id,
             params,
             span: createSpan(asyncToken?.start ?? functionToken.start, body.span.end)
-        };
+        });
     }
     parseVariableDeclarator(kind) {
         const id = this.parseBindingTarget();
@@ -1669,7 +1674,11 @@ class Parser {
                 continue;
             }
             if (this.currentToken().type === "template") {
-                const quasi = createTemplateLiteral(this.currentToken(), { allowMalformedEscapes: true, functionContext: this.functionContext }, this.compilation);
+                const quasi = createTemplateLiteral(this.currentToken(), {
+                    allowMalformedEscapes: true,
+                    functionContext: this.functionContext,
+                    source: this.source
+                }, this.compilation);
                 this.index += 1;
                 expression = {
                     node: {
@@ -1757,7 +1766,11 @@ class Parser {
         if (token.type === "template") {
             this.index += 1;
             return {
-                node: createTemplateLiteral(token, { allowMalformedEscapes: false, functionContext: this.functionContext }, this.compilation),
+                node: createTemplateLiteral(token, {
+                    allowMalformedEscapes: false,
+                    functionContext: this.functionContext,
+                    source: this.source
+                }, this.compilation),
                 parenthesized: false
             };
         }
@@ -1875,7 +1888,7 @@ class Parser {
         });
         const generator = generatorToken !== undefined;
         const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
-        return {
+        return this.withFunctionSource({
             type: "FunctionExpression",
             async: asyncToken !== undefined,
             body,
@@ -1883,7 +1896,7 @@ class Parser {
             id,
             params,
             span: createSpan(asyncToken?.start ?? functionToken.start, body.span.end)
-        };
+        });
     }
     parseArrayExpression() {
         const start = this.expectPunctuator("[");
@@ -2139,7 +2152,7 @@ class Parser {
             return parsedParams;
         });
         const body = this.withFunctionContext("normal", () => this.parseBlockStatement(params));
-        return {
+        return this.withFunctionSource({
             type: "FunctionExpression",
             async: asyncToken !== undefined,
             body,
@@ -2148,7 +2161,7 @@ class Parser {
             method: true,
             params,
             span: createSpan(asyncToken?.start ?? methodStart, body.span.end)
-        };
+        });
     }
     parseIdentifierName() {
         const token = this.currentToken();
@@ -3033,7 +3046,7 @@ function createTemplateLiteral(token, options, compilation) {
             quasis.push(createTemplateElement(token.start, raw, quasiStart, cursor, false, options));
             const expressionStart = cursor + 2;
             const expressionEnd = findTemplateExpressionEnd(raw, expressionStart);
-            expressions.push(parseEmbeddedExpression(raw.slice(expressionStart, expressionEnd), positionWithinRaw(token.start, raw, expressionStart), options.functionContext, compilation));
+            expressions.push(parseEmbeddedExpression(raw.slice(expressionStart, expressionEnd), positionWithinRaw(token.start, raw, expressionStart), options.functionContext, options.source, compilation));
             quasiStart = expressionEnd + 1;
             cursor = expressionEnd + 1;
             continue;
@@ -3394,13 +3407,13 @@ function decodeHexEscape(value, start) {
         end: index + 2
     };
 }
-function parseEmbeddedExpression(source, base, functionContext, compilation) {
+function parseEmbeddedExpression(source, base, functionContext, fullSource, compilation) {
     const tokens = tokenize(source, { allowRegexLiterals: true, compilation }).map((token) => ({
         ...token,
         start: rebasePosition(token.start, base),
         end: rebasePosition(token.end, base)
     }));
-    return new Parser(tokens, compilation, functionContext).parseExpressionOnly();
+    return new Parser(tokens, fullSource, compilation, functionContext).parseExpressionOnly();
 }
 export function findRegexLiteral(node) {
     if (node === null || node === undefined) {