poe-code 14.0.60 → 14.0.62

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-C7UCTQDN.js";
+} from "./chunks/chunk-F7TJSPDZ.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-MKJBQPBH.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-MKJBQPBH.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-C7UCTQDN.js";
+} from "./chunks/chunk-F7TJSPDZ.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-MKJBQPBH.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

@@ -4,7 +4,8 @@ import { toPropertyKey } from "./property-key.js";
 import { assertPromiseExecutionAllowed } from "./promise-tracker.js";
 import { SandboxJobQueue, runAsyncPrefix, suspendJob } from "./jobs.js";
 import { withCancellationSignal } from "./cancel.js";
-import { runResources } from "./resources.js";
+import { retainValues } from "./resources.js";
+import { sandboxString } from "./string-coercion.js";
 import { attachErrorSpan, formatErrorStack, replaceErrorStack } from "../error/shape.js";
 import { evaluateArrowFunctionExpression, evaluateFunctionExpression, evaluateAwaitExpression, emitResumeBreakpoint, createInterpretedClosure, normalizeClosureResult } from "./async.js";
 import { HostCallResumabilityError } from "./host-call.js";
@@ -360,14 +361,18 @@ function isObjectPrototypeSetterProperty(property, key) {
 }
 async function evaluateTemplateLiteral(node, context) {
     let value = context.budget.allocateString(node.quasis[0]?.value.cooked ?? "");
-    const release = retainValues(context.budget, () => [value]);
+    let input = undefined;
+    const release = retainValues(context.budget, () => [value, input]);
     try {
         for (let index = 0; index < node.expressions.length; index += 1) {
             const expression = await evaluateNode(node.expressions[index], context);
             if (expression.kind !== "normal") {
                 return expression;
             }
-            const expressionText = context.budget.allocateString(String(expression.value));
+            input = expression.value;
+            const text = sandboxString(input, context.budget, createCoercionContext(context));
+            const expressionText = typeof text === "string" ? text : await text;
+            input = undefined;
             value = context.budget.allocateString(value + expressionText);
             const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
             value = context.budget.allocateString(value + quasiText);
@@ -1831,17 +1836,6 @@ async function evaluateMemberAccess(node, context, consume) {
         release();
     }
 }
-function retainValues(budget, values) {
-    const retained = {};
-    budget.setRetainedValues(retained, values);
-    const pending = runResources.getStore()?.referenceReleases;
-    const release = () => {
-        budget.setRetainedValues(retained, undefined);
-        pending?.delete(release);
-    };
-    pending?.add(release);
-    return release;
-}
 async function evaluateMemberProperty(node, context) {
     const property = await evaluateNode(node, context);
     if (property.kind !== "normal") {
@@ -2552,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/methods/string.js

@@ -2,6 +2,7 @@ import { invokeBuiltinClosure } from "../builtin-call.js";
 import { CompileScope } from "../regex/compile-guard.js";
 import { normalizeLastIndex } from "../regex/engine.js";
 import { sandboxNumber, sandboxString } from "../string-coercion.js";
+import { retainValues } from "../resources.js";
 import { createSandboxClosure, createSandboxRegex, deepCopyFromSandbox, isSandboxClosure, isSandboxRegex } from "../values.js";
 import { executeRegex, toMatchArray } from "./regex.js";
 const SPLIT_STRING_MESSAGE = "String#split only supports string separator values.";
@@ -83,6 +84,9 @@ export function isStringMethodName(property) {
 }
 export function validateStringMethodArguments(_methodName, _args) { }
 export function callStringMethod(value, methodName, args, budget, callClosure = async (closure, closureArgs) => await closure.call(closureArgs), parent, context) {
+    if (methodName === "concat" && args.some(argument => argument !== null && typeof argument === "object")) {
+        return callConcat(value, args, budget, context);
+    }
     if (methodName === "isWellFormed") {
         for (let index = 0; index < value.length; index++) {
             const codeUnit = value.charCodeAt(index);
@@ -239,6 +243,20 @@ export function callStringMethod(value, methodName, args, budget, callClosure =
         operation.release();
     }
 }
+async function callConcat(value, args, budget, context) {
+    let result = budget.allocateString(value);
+    const release = retainValues(budget, () => [result]);
+    try {
+        for (const argument of args) {
+            const text = sandboxString(argument, budget, context);
+            result = budget.allocateString(result + (typeof text === "string" ? text : await text));
+        }
+        return result;
+    }
+    finally {
+        release();
+    }
+}
 function callReplaceLikeMethod(value, methodName, args, budget, callClosure, context) {
     const search = args[0];
     const replacement = args[1];

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

@@ -1,8 +1,11 @@
 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;
 };
 export declare const runResources: AsyncLocalStorage<RunResources>;
+export declare function retainValues(budget: Budget, values: () => Iterable<unknown>): () => void;
 export declare function withRunResources<Result>(signal: AbortSignal | undefined, execute: () => Promise<Result>): Promise<Result>;

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

@@ -1,5 +1,16 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 export const runResources = new AsyncLocalStorage();
+export function retainValues(budget, values) {
+    const retained = {};
+    budget.setRetainedValues(retained, values);
+    const pending = runResources.getStore()?.referenceReleases;
+    const release = () => {
+        budget.setRetainedValues(retained, undefined);
+        pending?.delete(release);
+    };
+    pending?.add(release);
+    return release;
+}
 export async function withRunResources(signal, execute) {
     const controller = new AbortController();
     const cancel = () => controller.abort(signal?.reason);

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

@@ -7,6 +7,8 @@ import { isGuestHostObject } from "./host-capabilities.js";
 import { collectionIteratorState, isSandboxCollectionIterator } from "./collection-iterator.js";
 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");
@@ -95,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))
@@ -118,9 +122,10 @@ async function defaultToString(value, budget, context, joining) {
         if (joining.has(value))
             return "";
         joining.add(value);
+        let text = "";
+        const release = retainValues(budget, () => [text]);
         try {
             const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
-            let text = "";
             for (let index = 0; index < length; index++) {
                 budget.visitNode();
                 const element = ownDataValue(value, String(index));
@@ -132,15 +137,22 @@ async function defaultToString(value, budget, context, joining) {
             return text;
         }
         finally {
+            release();
             joining.delete(value);
         }
     }
     if (sandboxErrorTypes.has(value)) {
         const nameValue = ownDataValue(value, "name");
         const name = nameValue === undefined ? "Error" : await sandboxString(nameValue, budget, context, joining);
-        const messageValue = ownDataValue(value, "message");
-        const message = messageValue === undefined ? "" : await sandboxString(messageValue, budget, context, joining);
-        return name === "" ? message : message === "" ? name : `${name}: ${message}`;
+        const release = retainValues(budget, () => [name]);
+        try {
+            const messageValue = ownDataValue(value, "message");
+            const message = messageValue === undefined ? "" : await sandboxString(messageValue, budget, context, joining);
+            return name === "" ? message : message === "" ? name : `${name}: ${message}`;
+        }
+        finally {
+            release();
+        }
     }
     return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
 }

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;
         }