@vxrn/compiler 1.25.13 → 1.25.16-1788753284749

package/dist/cjs/worklets/scope.cjs

@@ -0,0 +1,370 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var scope_exports = {};
+__export(scope_exports, {
+  getClosureVariables: () => getClosureVariables
+});
+module.exports = __toCommonJS(scope_exports);
+function getClosureVariables(fnNode, globals) {
+  const rootScope = {
+    parent: null,
+    isFunction: true,
+    bindings: /* @__PURE__ */new Set(),
+    varBindings: /* @__PURE__ */new Set()
+  };
+  let currentScope = rootScope;
+  const freeVariables = /* @__PURE__ */new Set();
+  if (fnNode.id && fnNode.id.name) {
+    rootScope.bindings.add(fnNode.id.name);
+  }
+  function pushScope(isFunction) {
+    const newScope = {
+      parent: currentScope,
+      isFunction,
+      bindings: /* @__PURE__ */new Set(),
+      varBindings: isFunction ? /* @__PURE__ */new Set() : currentScope.varBindings
+    };
+    currentScope = newScope;
+    return newScope;
+  }
+  function popScope() {
+    if (currentScope.parent) {
+      currentScope = currentScope.parent;
+    }
+  }
+  function addBindings(pattern, targetSet) {
+    if (!pattern) return;
+    switch (pattern.type) {
+      case "Identifier":
+        targetSet.add(pattern.name);
+        break;
+      case "AssignmentPattern":
+        addBindings(pattern.left, targetSet);
+        walk(pattern.right);
+        break;
+      case "RestElement":
+        addBindings(pattern.argument, targetSet);
+        break;
+      case "ArrayPattern":
+        for (const el of pattern.elements) {
+          if (el) addBindings(el, targetSet);
+        }
+        break;
+      case "ObjectPattern":
+        for (const prop of pattern.properties) {
+          if (prop.type === "Property") {
+            if (prop.computed) walk(prop.key);
+            addBindings(prop.value, targetSet);
+          } else if (prop.type === "RestElement") {
+            addBindings(prop.argument, targetSet);
+          }
+        }
+        break;
+    }
+  }
+  function addBindingsOnly(pattern, targetSet) {
+    if (!pattern) return;
+    switch (pattern.type) {
+      case "Identifier":
+        targetSet.add(pattern.name);
+        break;
+      case "AssignmentPattern":
+        addBindingsOnly(pattern.left, targetSet);
+        break;
+      case "RestElement":
+        addBindingsOnly(pattern.argument, targetSet);
+        break;
+      case "ArrayPattern":
+        for (const el of pattern.elements) {
+          if (el) addBindingsOnly(el, targetSet);
+        }
+        break;
+      case "ObjectPattern":
+        for (const prop of pattern.properties) {
+          if (prop.type === "Property") {
+            addBindingsOnly(prop.value, targetSet);
+          } else if (prop.type === "RestElement") {
+            addBindingsOnly(prop.argument, targetSet);
+          }
+        }
+        break;
+    }
+  }
+  function hoistDeclarations(node, direct) {
+    if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+    switch (node.type) {
+      case "FunctionDeclaration":
+        if (node.id?.name) {
+          currentScope.bindings.add(node.id.name);
+          currentScope.varBindings.add(node.id.name);
+        }
+        return;
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        return;
+      case "ClassDeclaration":
+        if (direct && node.id?.name) currentScope.bindings.add(node.id.name);
+        return;
+      case "VariableDeclaration":
+        if (node.kind === "var") {
+          for (const d of node.declarations) addBindingsOnly(d.id, currentScope.varBindings);
+        } else if (direct) {
+          for (const d of node.declarations) addBindingsOnly(d.id, currentScope.bindings);
+        }
+        return;
+      case "ExportNamedDeclaration":
+      case "ExportDefaultDeclaration":
+        hoistDeclarations(node.declaration, direct);
+        return;
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) hoistDeclarations(item, false);
+      } else if (child && typeof child === "object") {
+        hoistDeclarations(child, false);
+      }
+    }
+  }
+  if (fnNode.params) {
+    for (const param of fnNode.params) {
+      addBindings(param, rootScope.bindings);
+    }
+  }
+  function isDeclaredInScopes(name, fromScope) {
+    let s = fromScope;
+    while (s) {
+      if (s.bindings.has(name) || s.varBindings.has(name)) {
+        return true;
+      }
+      s = s.parent;
+    }
+    return false;
+  }
+  function resolveIdentifier(name) {
+    if (!isDeclaredInScopes(name, currentScope) && !globals.has(name)) {
+      freeVariables.add(name);
+    }
+  }
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "TSTypeAnnotation" || node.type === "TSTypeReference" || node.type === "TSTypeAliasDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSTypeParameterDeclaration" || node.type === "TSTypeParameterInstantiation" || node.type === "TSTypeQuery" || node.type === "TSQualifiedName") {
+      return;
+    }
+    if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSInstantiationExpression") {
+      walk(node.expression);
+      return;
+    }
+    switch (node.type) {
+      case "BlockStatement":
+        {
+          const isRootBody = node === fnNode.body;
+          if (!isRootBody) {
+            pushScope(false);
+          }
+          for (const stmt of node.body) {
+            hoistDeclarations(stmt, true);
+          }
+          for (const stmt of node.body) {
+            walk(stmt);
+          }
+          if (!isRootBody) {
+            popScope();
+          }
+          return;
+        }
+      case "VariableDeclaration":
+        {
+          const isVar = node.kind === "var";
+          const targetSet = isVar ? currentScope.varBindings : currentScope.bindings;
+          for (const decl of node.declarations) {
+            addBindings(decl.id, targetSet);
+            if (decl.init) walk(decl.init);
+          }
+          return;
+        }
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+        {
+          if (node.id && node.id.name) {
+            currentScope.bindings.add(node.id.name);
+          }
+          pushScope(true);
+          if (node.params) {
+            for (const param of node.params) {
+              addBindings(param, currentScope.bindings);
+            }
+          }
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "ArrowFunctionExpression":
+        {
+          pushScope(true);
+          if (node.params) {
+            for (const param of node.params) {
+              addBindings(param, currentScope.bindings);
+            }
+          }
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "CatchClause":
+        {
+          pushScope(false);
+          if (node.param) {
+            addBindings(node.param, currentScope.bindings);
+          }
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "ForStatement":
+        {
+          pushScope(false);
+          if (node.init) walk(node.init);
+          if (node.test) walk(node.test);
+          if (node.update) walk(node.update);
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "ForInStatement":
+      case "ForOfStatement":
+        {
+          pushScope(false);
+          walk(node.left);
+          walk(node.right);
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "ClassDeclaration":
+      case "ClassExpression":
+        {
+          if (node.id && node.id.name) {
+            currentScope.bindings.add(node.id.name);
+          }
+          if (node.superClass) walk(node.superClass);
+          pushScope(false);
+          walk(node.body);
+          popScope();
+          return;
+        }
+      case "MemberExpression":
+        {
+          walk(node.object);
+          if (node.computed) {
+            walk(node.property);
+          }
+          return;
+        }
+      case "Property":
+        {
+          if (node.computed) {
+            walk(node.key);
+          }
+          walk(node.value);
+          return;
+        }
+      case "MethodDefinition":
+        {
+          if (node.computed) {
+            walk(node.key);
+          }
+          walk(node.value);
+          return;
+        }
+      case "Identifier":
+        {
+          resolveIdentifier(node.name);
+          return;
+        }
+      case "JSXElement":
+        {
+          if (node.openingElement) {
+            const nameNode = node.openingElement.name;
+            if (nameNode.type === "JSXIdentifier") {
+              if (/^[A-Z]/.test(nameNode.name)) {
+                resolveIdentifier(nameNode.name);
+              }
+            } else if (nameNode.type === "JSXMemberExpression") {
+              let root = nameNode.object;
+              while (root.type === "JSXMemberExpression") {
+                root = root.object;
+              }
+              if (root.type === "JSXIdentifier") {
+                resolveIdentifier(root.name);
+              }
+            }
+            if (node.openingElement.attributes) {
+              for (const attr of node.openingElement.attributes) {
+                walk(attr);
+              }
+            }
+          }
+          if (node.children) {
+            for (const child of node.children) {
+              walk(child);
+            }
+          }
+          return;
+        }
+      case "JSXAttribute":
+        {
+          if (node.value) {
+            walk(node.value);
+          }
+          return;
+        }
+      case "JSXExpressionContainer":
+        {
+          walk(node.expression);
+          return;
+        }
+      case "BreakStatement":
+      case "ContinueStatement":
+      case "LabeledStatement":
+        {
+          if (node.body) walk(node.body);
+          return;
+        }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          walk(item);
+        }
+      } else if (child && typeof child === "object") {
+        walk(child);
+      }
+    }
+  }
+  walk(fnNode.body);
+  return Array.from(freeVariables).sort();
+}

package/dist/cjs/worklets/serialize.cjs

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var serialize_exports = {};
+__export(serialize_exports, {
+  buildLocalFunction: () => buildLocalFunction,
+  serializeWorkletForUI: () => serializeWorkletForUI
+});
+module.exports = __toCommonJS(serialize_exports);
+var import_oxc_transform = require("oxc-transform");
+var import_autoworklet = require("./autoworklet.cjs");
+function assertTransformed(transformed, name, what) {
+  const error = transformed.errors?.[0];
+  if (error) {
+    throw new Error(`[worklets] failed to build ${what} code for ${name || "anonymous worklet"}: ${error.message || error}`);
+  }
+  if (!transformed.code.trim()) {
+    throw new Error(`[worklets] built empty ${what} code for ${name || "anonymous worklet"}`);
+  }
+}
+function serializeWorkletForUI(fnNode, code, name, closureVars) {
+  let rawParams = "";
+  if (fnNode.params && fnNode.params.length > 0) {
+    const pStart = fnNode.params[0].start;
+    const pEnd = fnNode.params[fnNode.params.length - 1].end;
+    rawParams = code.slice(pStart, pEnd);
+  }
+  let rawBody = "";
+  if (fnNode.body.type === "BlockStatement") {
+    const bodyStart = (0, import_autoworklet.bodyStartAfterDirectives)(fnNode, code);
+    const bodyEnd = fnNode.body.end - 1;
+    rawBody = code.slice(bodyStart, bodyEnd);
+  } else {
+    rawBody = `return ${code.slice(fnNode.body.start, fnNode.body.end)};`;
+  }
+  const unpacker = closureVars.length > 0 ? `const { ${closureVars.join(", ")} } = this.__closure ?? this._closure;
+` : "";
+  const asyncPrefix = fnNode.async ? "async " : "";
+  const genPrefix = fnNode.generator ? "*" : "";
+  const fnName = name || "_worklet";
+  const fullFn = `${asyncPrefix}function${genPrefix} ${fnName}(${rawParams}) {
+${unpacker}${rawBody}
+}`;
+  const transformed = (0, import_oxc_transform.transformSync)("worklet.ts", fullFn);
+  assertTransformed(transformed, name, "serialized");
+  return transformed.code.trim();
+}
+function buildLocalFunction(fnNode, code, name) {
+  let rawParams = "";
+  if (fnNode.params && fnNode.params.length > 0) {
+    const pStart = fnNode.params[0].start;
+    const pEnd = fnNode.params[fnNode.params.length - 1].end;
+    rawParams = code.slice(pStart, pEnd);
+  }
+  let rawBody = "";
+  if (fnNode.body.type === "BlockStatement") {
+    const bodyStart = (0, import_autoworklet.bodyStartAfterDirectives)(fnNode, code);
+    const bodyEnd = fnNode.body.end - 1;
+    rawBody = code.slice(bodyStart, bodyEnd);
+  } else {
+    rawBody = code.slice(fnNode.body.start, fnNode.body.end);
+  }
+  let rawFn = "";
+  const asyncPrefix = fnNode.async ? "async " : "";
+  const genPrefix = fnNode.generator ? "*" : "";
+  if (fnNode.type === "ArrowFunctionExpression") {
+    if (fnNode.body.type === "BlockStatement") {
+      rawFn = `${asyncPrefix}(${rawParams}) => {
+${rawBody}
+}`;
+    } else {
+      rawFn = `${asyncPrefix}(${rawParams}) => (${rawBody})`;
+    }
+  } else {
+    rawFn = `${asyncPrefix}function${genPrefix} ${name || "_worklet"}(${rawParams}) {
+${rawBody}
+}`;
+  }
+  const transformed = (0, import_oxc_transform.transformSync)("local.ts", rawFn);
+  assertTransformed(transformed, name, "local");
+  return transformed.code.trim().replace(/;$/, "");
+}

package/dist/cjs/worklets/transform.cjs

@@ -0,0 +1,232 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var transform_exports = {};
+__export(transform_exports, {
+  executeWorkletTransform: () => executeWorkletTransform
+});
+module.exports = __toCommonJS(transform_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_magic_string = __toESM(require("magic-string"), 1);
+var import_remapping = __toESM(require("@jridgewell/remapping"), 1);
+var import_oxc_parser = require("oxc-parser");
+var import_autoworklet = require("./autoworklet.cjs");
+var import_globals = require("./globals.cjs");
+var import_hash = require("./hash.cjs");
+var import_scope = require("./scope.cjs");
+var import_serialize = require("./serialize.cjs");
+const FUNCTION_TYPES = /* @__PURE__ */new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+function findEnclosingFunction(program, node) {
+  let best = void 0;
+  const walk = n => {
+    if (!n || typeof n !== "object") return;
+    if (Array.isArray(n)) {
+      for (const c of n) walk(c);
+      return;
+    }
+    if (typeof n.type !== "string") return;
+    if (typeof n.start === "number" && (n.start > node.start || n.end < node.end)) return;
+    if (FUNCTION_TYPES.has(n.type) && n !== node && n.body?.type === "BlockStatement" && n.body.start < node.start && n.body.end > node.end && (!best || n.body.start > best.body.start)) {
+      best = n;
+    }
+    for (const key in n) {
+      if (key === "parent") continue;
+      walk(n[key]);
+    }
+  };
+  walk(program);
+  return best;
+}
+function executeWorkletTransform(id, code, sourceMaps = false, options, resolveVersionFn) {
+  const cleanId = id.split("?")[0];
+  const lang = /\.[cm]?ts$/.test(cleanId) ? "ts" : cleanId.endsWith(".tsx") ? "tsx" : "jsx";
+  const initialParse = (0, import_oxc_parser.parseSync)(cleanId, code, {
+    sourceType: "module",
+    lang
+  });
+  if (initialParse.errors && initialParse.errors.length > 0) {
+    const err = initialParse.errors[0];
+    throw new Error(err.codeframe || err.message || "Syntax Error while parsing worklet");
+  }
+  const initialCandidates = (0, import_autoworklet.findWorkletCandidates)(initialParse.program);
+  if (initialCandidates.length === 0) {
+    let map2 = void 0;
+    if (sourceMaps) {
+      const ms = new import_magic_string.default(code);
+      map2 = ms.generateMap({
+        source: cleanId,
+        file: cleanId,
+        hires: true,
+        includeContent: true
+      });
+    }
+    return {
+      code,
+      map: map2
+    };
+  }
+  const pluginVersion = options?.pluginVersion || (resolveVersionFn ? resolveVersionFn(options?.projectRoot, cleanId) : "0.0.0");
+  const globals = (0, import_globals.createGlobalsSet)(options?.globals, options?.strictGlobal);
+  let location = cleanId;
+  if (options?.relativeSourceLocation && options?.projectRoot) {
+    location = import_node_path.default.relative(options.projectRoot, cleanId).replace(/\\/g, "/");
+  }
+  let currentCode = code;
+  const initDataDefs = /* @__PURE__ */new Map();
+  const passMaps = [];
+  let remainingPassBudget = 100;
+  while (remainingPassBudget-- > 0) {
+    const parseResult = (0, import_oxc_parser.parseSync)(cleanId, currentCode, {
+      sourceType: "module",
+      lang
+    });
+    if (parseResult.errors && parseResult.errors.length > 0) {
+      const err = parseResult.errors[0];
+      throw new Error(err.codeframe || err.message || "Syntax Error while parsing worklet");
+    }
+    const candidates = (0, import_autoworklet.findWorkletCandidates)(parseResult.program);
+    if (candidates.length === 0) {
+      break;
+    }
+    const innermostCandidates = candidates.filter(c => {
+      return !candidates.some(other => other !== c && other.fnNode.start >= c.fnNode.start && other.fnNode.end <= c.fnNode.end);
+    });
+    if (innermostCandidates.length === 0) {
+      throw new Error(`[worklets] Cyclic or unresolvable worklet nesting detected in ${cleanId}`);
+    }
+    const ms = new import_magic_string.default(currentCode);
+    const inlinedInitData = /* @__PURE__ */new Map();
+    for (const candidate of innermostCandidates) {
+      const closureVars = (0, import_autoworklet.hasDirective)(candidate.fnNode, "no-worklet-closure") ? [] : (0, import_scope.getClosureVariables)(candidate.fnNode, globals);
+      const fnName = candidate.name;
+      const serializedCode = (0, import_serialize.serializeWorkletForUI)(candidate.fnNode, currentCode, fnName, closureVars);
+      const workletHash = (0, import_hash.calculateWorkletHash)(serializedCode);
+      const initDataVar = `_worklet_${workletHash}_init_data`;
+      const initDataDecl = `var ${initDataVar} = {
+    code: ${JSON.stringify(serializedCode)},
+    location: ${JSON.stringify(location)}
+};`;
+      const enclosingFn = (0, import_autoworklet.hasDirective)(candidate.fnNode, "limit-init-data-hoisting") ? findEnclosingFunction(parseResult.program, candidate.fnNode) : void 0;
+      if (enclosingFn) {
+        const insertAt = (0, import_autoworklet.bodyStartAfterDirectives)(enclosingFn, currentCode);
+        let declared = inlinedInitData.get(insertAt);
+        if (!declared) {
+          declared = /* @__PURE__ */new Set();
+          inlinedInitData.set(insertAt, declared);
+        }
+        if (!declared.has(initDataVar)) {
+          declared.add(initDataVar);
+          ms.appendLeft(insertAt, `
+${initDataDecl}
+`);
+        }
+      } else if (!initDataDefs.has(initDataVar)) {
+        initDataDefs.set(initDataVar, initDataDecl);
+      }
+      const localFnCode = (0, import_serialize.buildLocalFunction)(candidate.fnNode, currentCode, fnName);
+      const localName = fnName || "_worklet";
+      const closureProps = closureVars.map(v => `${v}: ${v}`).join(", ");
+      const iife = `(function () {
+    var _e = [new (typeof global !== 'undefined' ? global : globalThis).Error(), 1, -27];
+    var ${localName} = ${localFnCode};
+    ${localName}.__closure = { ${closureProps} };
+    ${localName}.__workletHash = ${workletHash};
+    ${localName}.__pluginVersion = ${JSON.stringify(pluginVersion)};
+    ${localName}.__initData = ${initDataVar};
+    ${localName}.__stackDetails = _e;
+    return ${localName};
+})()`;
+      if (candidate.kind === "function_declaration") {
+        if (candidate.parent?.type === "ExportNamedDeclaration") {
+          ms.overwrite(candidate.parent.start, candidate.parent.end, `export var ${candidate.name} = ${iife};`);
+        } else if (candidate.parent?.type === "ExportDefaultDeclaration") {
+          ms.overwrite(candidate.parent.start, candidate.parent.end, `var ${candidate.name || "_defaultWorklet"} = ${iife};
+export default ${candidate.name || "_defaultWorklet"};`);
+        } else {
+          ms.overwrite(candidate.node.start, candidate.node.end, `var ${candidate.name} = ${iife};`);
+        }
+      } else if (candidate.kind === "object_method") {
+        ms.overwrite(candidate.node.start, candidate.node.end, `${candidate.name}: ${iife}`);
+      } else {
+        ms.overwrite(candidate.node.start, candidate.node.end, iife);
+      }
+    }
+    if (sourceMaps) {
+      passMaps.push(ms.generateMap({
+        source: cleanId,
+        file: cleanId,
+        hires: true,
+        includeContent: true
+      }));
+    }
+    currentCode = ms.toString();
+  }
+  const finalCheck = (0, import_oxc_parser.parseSync)(cleanId, currentCode, {
+    sourceType: "module",
+    lang
+  });
+  const remaining = (0, import_autoworklet.findWorkletCandidates)(finalCheck.program);
+  if (remaining.length > 0) {
+    throw new Error(`[worklets] Exceeded maximum pass budget while transforming worklets in ${cleanId}. ${remaining.length} worklet(s) remained untransformed.`);
+  }
+  if (initDataDefs.size > 0) {
+    const initDataCode = Array.from(initDataDefs.values()).join("\n") + "\n";
+    const msPrepend = new import_magic_string.default(currentCode);
+    msPrepend.prepend(initDataCode);
+    if (sourceMaps) {
+      passMaps.push(msPrepend.generateMap({
+        source: cleanId,
+        file: cleanId,
+        hires: true,
+        includeContent: true
+      }));
+    }
+    currentCode = msPrepend.toString();
+  }
+  let map = void 0;
+  if (sourceMaps && passMaps.length > 0) {
+    if (passMaps.length === 1) {
+      map = passMaps[0];
+    } else {
+      map = (0, import_remapping.default)(passMaps.slice().reverse(), () => null);
+    }
+    if (map) {
+      map.sources = [cleanId];
+      map.file = cleanId;
+    }
+  }
+  return {
+    code: currentCode,
+    map
+  };
+}