transone-cli 0.6.3 → 0.10.0

package/dist/index-d51tp4y9.js

@@ -0,0 +1,1402 @@
+// @bun
+import {
+  COMPONENT_PLATFORM_DEFINITIONS,
+  canonicalPath,
+  createComponentIndex
+} from "./index-j4h0wd27.js";
+
+// src/web-styles.ts
+import { dirname, extname } from "path";
+import ts from "typescript";
+var ROOT_RPX_RULE = ":root{--tu-rpx:calc(min(100vw, 750px) / 750);}";
+var RPX_PATTERN = /(-?\d+(?:\.\d+)?)rpx/g;
+var SOURCE_FILTER = /\.(?:[cm]?js|jsx|tsx?)$/;
+function createWebStylesPlugin(disabledFiles = new Set, transformSource, extract = true) {
+  const styles = new Map;
+  const runtimeFiles = new Set;
+  const candidates = new Set;
+  const owners = new Map;
+  let unknownSelector = false;
+  let unknownInheritance = false;
+  return {
+    name: "transone-web-styles",
+    styles,
+    runtimeFiles,
+    setup(build) {
+      styles.clear();
+      runtimeFiles.clear();
+      candidates.clear();
+      owners.clear();
+      unknownSelector = false;
+      unknownInheritance = false;
+      const load = async (path, definitions = false) => {
+        styles.delete(path);
+        const filePath = definitions ? path.replace(/\?transone-definitions$/, "") : path;
+        const original = await Bun.file(filePath).text();
+        const contents = transformSource?.(filePath, original, definitions) ?? original;
+        const transformedResult = () => contents !== original || definitions ? {
+          contents,
+          loader: sourceLoader(filePath),
+          resolveDir: dirname(filePath)
+        } : undefined;
+        if (!extract || !contents.includes("styleManager") && !contents.includes("extends"))
+          return transformedResult();
+        const source = ts.createSourceFile(filePath, contents, ts.ScriptTarget.Latest, true, scriptKind(filePath));
+        const extracted = extractStyles(source);
+        if (extracted.bodies.length)
+          candidates.add(path);
+        for (const { selector, owner } of extracted.selectors) {
+          const selectorOwners = owners.get(selector) ?? new Map;
+          selectorOwners.set(`${path}:${owner}`, path);
+          owners.set(selector, selectorOwners);
+          if (selectorOwners.size > 1)
+            for (const file of selectorOwners.values())
+              runtimeFiles.add(file);
+        }
+        unknownSelector ||= extracted.unknownSelector;
+        unknownInheritance ||= extracted.unknownInheritance;
+        if (unknownSelector || unknownInheritance)
+          for (const file of candidates)
+            runtimeFiles.add(file);
+        if (!extracted.bodies.length || disabledFiles.has(path))
+          return transformedResult();
+        styles.set(path, extracted.css);
+        let transformed = contents;
+        for (const body of extracted.bodies.sort((left, right) => right.getStart(source) - left.getStart(source))) {
+          transformed = transformed.slice(0, body.getStart(source)) + "{}" + transformed.slice(body.end);
+        }
+        return {
+          contents: transformed,
+          loader: sourceLoader(filePath),
+          resolveDir: dirname(filePath)
+        };
+      };
+      if (transformSource)
+        build.onLoad({ filter: /.*/, namespace: "transone-definitions" }, ({ path }) => load(path, true));
+      build.onLoad({ filter: SOURCE_FILTER, namespace: "file" }, ({ path }) => load(path));
+    }
+  };
+}
+function extractStyles(source) {
+  const bindings = collectBindings(source);
+  const unsafeBindings = findUnsafeBindings(source, bindings);
+  const classes = topLevelClasses(source);
+  const descendants = [];
+  walk(source, (node) => {
+    if (ts.isClassDeclaration(node) || ts.isClassExpression(node))
+      descendants.push(node);
+  });
+  const { names: componentNames, roots: componentRoots } = componentBindings(source, classes, unsafeBindings);
+  const selectorAnalysis = collectSelectors(classes, componentNames, bindings, unsafeBindings);
+  const css = [];
+  const bodies = [];
+  for (const declaration of classes) {
+    if (!extendsComponent(declaration, componentNames))
+      continue;
+    const methods = declaration.members.filter((member) => ts.isMethodDeclaration(member) && memberName(member) === "initStyles");
+    if (methods.length !== 1)
+      continue;
+    const method = methods[0];
+    if (!method.body || method.parameters.length || method.asteriskToken || hasModifier(method, ts.SyntaxKind.StaticKeyword) || hasModifier(method, ts.SyntaxKind.AsyncKeyword) || ts.canHaveDecorators(method) && ts.getDecorators(method)?.length || ts.canHaveDecorators(declaration) && ts.getDecorators(declaration)?.length || hasManagerAccessOutside(declaration, method) || hasUnsafeAncestor(declaration, classes, componentRoots) || hasUnsafeDescendant(declaration, descendants))
+      continue;
+    const entries = new Map;
+    let safe = true;
+    for (const statement of method.body.statements) {
+      if (ts.isEmptyStatement(statement))
+        continue;
+      if (!ts.isExpressionStatement(statement)) {
+        safe = false;
+        break;
+      }
+      for (const expression of splitComma(statement.expression)) {
+        const entry = readAddStyle(expression, bindings, unsafeBindings, declaration);
+        if (!entry) {
+          safe = false;
+          break;
+        }
+        entries.set(entry.name, entry.style);
+      }
+      if (!safe)
+        break;
+    }
+    if (!safe || !entries.size)
+      continue;
+    const rendered = [...entries.values()].map(renderStyle).join("");
+    if (hasRelativeResource(rendered))
+      continue;
+    css.push(rendered);
+    bodies.push(method.body);
+  }
+  return {
+    css: bodies.length ? ROOT_RPX_RULE + `
+` + css.join(`
+`) : "",
+    bodies,
+    ...selectorAnalysis,
+    unknownInheritance: hasUnknownUnsafeAncestor(descendants, componentRoots, bindings)
+  };
+}
+function collectSelectors(classes, componentNames, bindings, unsafe) {
+  const selectors = [];
+  let unknownSelector = false;
+  for (const declaration of classes) {
+    if (!extendsComponent(declaration, componentNames))
+      continue;
+    const method = declaration.members.find((member) => ts.isMethodDeclaration(member) && memberName(member) === "initStyles");
+    if (!method?.body)
+      continue;
+    let calls = 0;
+    walk(declaration, (node) => {
+      if (!ts.isCallExpression(node) || !isAddStyleCall(node))
+        return;
+      calls++;
+      const options = node.arguments[1] && unwrap(node.arguments[1]);
+      let selector;
+      let hover = false;
+      if (options && ts.isObjectLiteralExpression(options)) {
+        const evaluate = (expression) => staticValue(expression, bindings, unsafe, declaration.name?.text);
+        selector = objectMember(options, "selector", evaluate).value;
+        const hoverMember = objectMember(options, "hover", evaluate);
+        hover = hoverMember.present && (hoverMember.value === undefined || !!hoverMember.value);
+      } else if (options) {
+        const value = staticValue(options, bindings, unsafe, declaration.name?.text);
+        if (isRecord(value)) {
+          selector = value.selector;
+          hover = !!value.hover;
+        }
+      }
+      if (typeof selector !== "string") {
+        unknownSelector = true;
+        return;
+      }
+      const items = splitSelectorList(selector);
+      const hoverItems = hover ? splitSelectorList(selector + ":hover") : [];
+      if (!items || !hoverItems) {
+        unknownSelector = true;
+        return;
+      }
+      for (const item of [...items, ...hoverItems]) {
+        selectors.push({
+          selector: item,
+          owner: String(declaration.getStart())
+        });
+      }
+    });
+    if (!calls && method.body.statements.some((statement) => !ts.isEmptyStatement(statement)))
+      unknownSelector = true;
+  }
+  return { selectors, unknownSelector };
+}
+function objectMember(object, key, evaluate) {
+  let result = {
+    value: undefined,
+    present: false
+  };
+  for (const property of object.properties) {
+    if (ts.isSpreadAssignment(property)) {
+      const value = evaluate(property.expression);
+      if (!isRecord(value))
+        result = { value: undefined, present: true };
+      else if (Object.prototype.hasOwnProperty.call(value, key))
+        result = { value: value[key], present: true };
+      continue;
+    }
+    const name = ts.isComputedPropertyName(property.name) ? evaluate(property.name.expression) : ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) || ts.isNumericLiteral(property.name) ? property.name.text : undefined;
+    if (name === undefined) {
+      result = { value: undefined, present: true };
+      continue;
+    }
+    if (name !== key)
+      continue;
+    result = {
+      value: ts.isPropertyAssignment(property) ? evaluate(property.initializer) : ts.isShorthandPropertyAssignment(property) ? evaluate(property.name) : undefined,
+      present: true
+    };
+  }
+  return result;
+}
+function hasUnknownUnsafeAncestor(classes, roots, bindings) {
+  const reachesUnknown = (name, seen) => {
+    if (!name || seen.has(name))
+      return true;
+    if (roots.has(name))
+      return false;
+    seen.add(name);
+    const ancestor = classes.find((declaration) => classBinding(declaration) === name);
+    if (ancestor) {
+      if (!ancestor.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword))
+        return false;
+      return reachesUnknown(baseName(ancestor), seen);
+    }
+    const initializer = bindings.get(name)?.expression;
+    if (initializer) {
+      const alias = unwrap(initializer);
+      if (ts.isIdentifier(alias))
+        return reachesUnknown(alias.text, seen);
+      if (ts.isPropertyAccessExpression(alias) && ts.isIdentifier(alias.expression))
+        return reachesUnknown(`${alias.expression.text}.${alias.name.text}`, seen);
+    }
+    return true;
+  };
+  return classes.some((declaration) => {
+    if (!declaration.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword))
+      return false;
+    let unsafe = declaration.members.some((member) => memberName(member) === "styleManager");
+    walk(declaration, (node) => {
+      if (unsafeManagerAccess(node))
+        unsafe = true;
+    });
+    return unsafe && reachesUnknown(baseName(declaration), new Set);
+  });
+}
+function splitSelectorList(selector) {
+  const items = [];
+  const delimiters = [];
+  let quote;
+  let escaped = false;
+  let start = 0;
+  for (let index = 0;index < selector.length; index++) {
+    const character = selector[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (character === quote)
+        quote = undefined;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "/" && selector[index + 1] === "*" || character === "{" || character === "}")
+      return;
+    if (character === "(" || character === "[") {
+      delimiters.push(character);
+    } else if (character === ")" || character === "]") {
+      if (delimiters.pop() !== (character === ")" ? "(" : "["))
+        return;
+    } else if (character === "," && delimiters.length === 0) {
+      const item2 = selector.slice(start, index).trim();
+      if (!item2)
+        return;
+      items.push(item2);
+      start = index + 1;
+    }
+  }
+  if (quote || escaped || delimiters.length)
+    return;
+  const item = selector.slice(start).trim();
+  return item ? [...items, item] : undefined;
+}
+function sourceLoader(path) {
+  const extension = extname(path);
+  return extension === ".tsx" ? "tsx" : extension === ".jsx" ? "jsx" : extension === ".ts" ? "ts" : "js";
+}
+function scriptKind(path) {
+  const loader = sourceLoader(path);
+  return loader === "tsx" ? ts.ScriptKind.TSX : loader === "jsx" ? ts.ScriptKind.JSX : loader === "ts" ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+}
+function memberName(member) {
+  return member.name && (ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)) ? member.name.text : undefined;
+}
+function hasModifier(node, kind) {
+  return ts.canHaveModifiers(node) && !!ts.getModifiers(node)?.some((modifier) => modifier.kind === kind);
+}
+function topLevelClasses(source) {
+  const classes = [];
+  for (const statement of source.statements) {
+    if (ts.isClassDeclaration(statement))
+      classes.push(statement);
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (declaration.initializer && ts.isClassExpression(declaration.initializer))
+          classes.push(declaration.initializer);
+      }
+    }
+  }
+  return classes;
+}
+function classBinding(declaration) {
+  const parent = declaration.parent;
+  return ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name) ? parent.name.text : declaration.name?.text;
+}
+function componentBindings(source, classes, unsafe) {
+  const names = new Set;
+  for (const statement of source.statements) {
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        const initializer = declaration.initializer && unwrap(declaration.initializer);
+        if (!initializer)
+          continue;
+        if (isTransoneRequire(initializer)) {
+          if (ts.isIdentifier(declaration.name) && !unsafe.has(declaration.name.text)) {
+            names.add(`${declaration.name.text}.Component`);
+            names.add(`${declaration.name.text}.BaseComponent`);
+          }
+          if (ts.isObjectBindingPattern(declaration.name)) {
+            for (const binding of declaration.name.elements) {
+              const imported = binding.propertyName ?? binding.name;
+              if (ts.isIdentifier(imported) && ["Component", "BaseComponent"].includes(imported.text) && ts.isIdentifier(binding.name) && !binding.initializer && !binding.dotDotDotToken && !unsafe.has(binding.name.text))
+                names.add(binding.name.text);
+            }
+          }
+        } else if (ts.isPropertyAccessExpression(initializer) && ["Component", "BaseComponent"].includes(initializer.name.text) && isTransoneRequire(initializer.expression) && ts.isIdentifier(declaration.name) && !unsafe.has(declaration.name.text))
+          names.add(declaration.name.text);
+      }
+    }
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "transone" || statement.importClause?.isTypeOnly)
+      continue;
+    const named = statement.importClause?.namedBindings;
+    if (named && ts.isNamedImports(named)) {
+      for (const binding of named.elements) {
+        if (!binding.isTypeOnly && ["Component", "BaseComponent"].includes(binding.propertyName?.text ?? binding.name.text))
+          names.add(binding.name.text);
+      }
+    } else if (named && ts.isNamespaceImport(named)) {
+      names.add(`${named.name.text}.Component`);
+      names.add(`${named.name.text}.BaseComponent`);
+    }
+  }
+  const managers = new Set(classes.filter((declaration) => isBundledStyleManager(declaration, source)).map(classBinding));
+  for (const declaration of classes) {
+    if (!["mount", "mountToNode", "update", "unmount"].every((name2) => declaration.members.some((member) => memberName(member) === name2)))
+      continue;
+    const constructor = declaration.members.find((member) => ts.isConstructorDeclaration(member));
+    if (!constructor?.body)
+      continue;
+    let createsManager = 0;
+    let unsafeConstructor = false;
+    let initializesState = false;
+    let initializesStyles = false;
+    walk(constructor.body, (node) => {
+      if (unsafeManagerAccess(node)) {
+        const assignment = node.parent;
+        if (thisProperty(node) === "styleManager" && ts.isBinaryExpression(assignment) && assignment.operatorToken.kind === ts.SyntaxKind.EqualsToken && assignment.left === node && ts.isNewExpression(assignment.right) && ts.isIdentifier(assignment.right.expression) && managers.has(assignment.right.expression.text))
+          createsManager++;
+        else
+          unsafeConstructor = true;
+      }
+      if (ts.isCallExpression(node)) {
+        if (thisProperty(node.expression) === "initState")
+          initializesState = true;
+        if (thisProperty(node.expression) === "initStyles")
+          initializesStyles = true;
+      }
+    });
+    const name = classBinding(declaration);
+    if (createsManager === 1 && !unsafeConstructor && initializesState && initializesStyles && name)
+      names.add(name);
+  }
+  const roots = new Set(names);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const statement of source.statements)
+      if (ts.isVariableStatement(statement) && statement.declarationList.flags & ts.NodeFlags.Const)
+        for (const declaration of statement.declarationList.declarations) {
+          if (!ts.isIdentifier(declaration.name) || !declaration.initializer || unsafe.has(declaration.name.text) || names.has(declaration.name.text))
+            continue;
+          const initializer = unwrap(declaration.initializer);
+          const target = ts.isIdentifier(initializer) ? initializer.text : ts.isPropertyAccessExpression(initializer) && ts.isIdentifier(initializer.expression) ? `${initializer.expression.text}.${initializer.name.text}` : undefined;
+          if (target && names.has(target)) {
+            names.add(declaration.name.text);
+            if (roots.has(target))
+              roots.add(declaration.name.text);
+            changed = true;
+          }
+        }
+    for (const declaration of classes) {
+      const name = classBinding(declaration);
+      if (name && !names.has(name) && extendsComponent(declaration, names)) {
+        names.add(name);
+        changed = true;
+      }
+    }
+  }
+  return { names, roots };
+}
+function isBundledStyleManager(declaration, source) {
+  const method = (name) => declaration.members.find((member) => ts.isMethodDeclaration(member) && memberName(member) === name);
+  const mutatesMap = (name, operation, count) => {
+    const member = method(name);
+    if (!member?.body || member.parameters.length !== count)
+      return false;
+    const calls = [];
+    for (const statement of member.body.statements) {
+      if (!ts.isExpressionStatement(statement))
+        return false;
+      calls.push(...splitComma(statement.expression));
+    }
+    if (calls.length !== 2 || !ts.isCallExpression(calls[0]) || !ts.isCallExpression(calls[1]))
+      return false;
+    const write = calls[0];
+    const update = calls[1];
+    return ts.isPropertyAccessExpression(write.expression) && write.expression.name.text === operation && thisProperty(write.expression.expression) === "styles" && write.arguments.length === count && write.arguments.every((argument, index) => ts.isIdentifier(argument) && ts.isIdentifier(member.parameters[index].name) && argument.text === member.parameters[index].name.text) && thisProperty(update.expression) === "updateStyles" && update.arguments.length === 0;
+  };
+  if (!mutatesMap("addStyle", "set", 2) || !mutatesMap("removeStyle", "delete", 1) || !method("clearStyles") || !method("destroy") || !method("convertToCSS") || !method("updateStyles"))
+    return false;
+  const ensure = method("ensureStyleElement");
+  if (!ensure?.body)
+    return false;
+  let createsStyleElement = false;
+  walk(ensure.body, (node) => {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "document" && node.expression.name.text === "createElement" && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0]) && node.arguments[0].text === "style")
+      createsStyleElement = true;
+  });
+  if (!createsStyleElement)
+    return false;
+  let hasRpxRule = false;
+  walk(source, (node) => {
+    if (ts.isStringLiteral(node) && node.text === ROOT_RPX_RULE)
+      hasRpxRule = true;
+  });
+  return hasRpxRule;
+}
+function isTransoneRequire(node) {
+  return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0]) && node.arguments[0].text === "transone";
+}
+function baseName(declaration) {
+  const base = declaration.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+  if (base && ts.isIdentifier(base))
+    return base.text;
+  if (base && ts.isPropertyAccessExpression(base) && ts.isIdentifier(base.expression))
+    return `${base.expression.text}.${base.name.text}`;
+  return;
+}
+function extendsComponent(declaration, names) {
+  const name = baseName(declaration);
+  return name !== undefined && names.has(name);
+}
+function thisProperty(expression) {
+  if (ts.isPropertyAccessExpression(expression) && expression.expression.kind === ts.SyntaxKind.ThisKeyword)
+    return expression.name.text;
+  if (ts.isElementAccessExpression(expression) && expression.expression.kind === ts.SyntaxKind.ThisKeyword && expression.argumentExpression && ts.isStringLiteral(expression.argumentExpression))
+    return expression.argumentExpression.text;
+  return;
+}
+function hasManagerAccessOutside(declaration, method) {
+  let unsafe = false;
+  for (const member of declaration.members) {
+    if (member === method)
+      continue;
+    if (memberName(member) === "styleManager")
+      return true;
+    walk(member, (node) => {
+      if (unsafeManagerAccess(node))
+        unsafe = true;
+    });
+  }
+  return unsafe;
+}
+function unsafeManagerAccess(node) {
+  if (thisProperty(node) === "styleManager")
+    return true;
+  if (ts.isElementAccessExpression(node) && node.expression.kind === ts.SyntaxKind.ThisKeyword)
+    return true;
+  if (node.kind !== ts.SyntaxKind.ThisKeyword)
+    return false;
+  const parent = node.parent;
+  return !(ts.isPropertyAccessExpression(parent) && parent.expression === node) && !(ts.isElementAccessExpression(parent) && parent.expression === node);
+}
+function hasUnsafeAncestor(declaration, classes, roots, seen = new Set) {
+  const name = baseName(declaration);
+  if (!name || roots.has(name) || seen.has(name))
+    return false;
+  seen.add(name);
+  const ancestor = classes.find((candidate) => classBinding(candidate) === name);
+  if (!ancestor)
+    return false;
+  const initStyles = ancestor.members.find((member) => ts.isMethodDeclaration(member) && memberName(member) === "initStyles");
+  let unsafe = false;
+  for (const member of ancestor.members) {
+    if (member === initStyles)
+      continue;
+    walk(member, (node) => {
+      if (unsafeManagerAccess(node))
+        unsafe = true;
+    });
+  }
+  return unsafe || hasUnsafeAncestor(ancestor, classes, roots, seen);
+}
+function hasUnsafeDescendant(declaration, classes, seen = new Set) {
+  const name = classBinding(declaration);
+  if (!name || seen.has(name))
+    return false;
+  seen.add(name);
+  return classes.some((child) => {
+    if (baseName(child) !== name)
+      return false;
+    let unsafe = false;
+    walk(child, (node) => {
+      if (unsafeManagerAccess(node))
+        unsafe = true;
+    });
+    return unsafe || hasUnsafeDescendant(child, classes, seen);
+  });
+}
+function collectBindings(source) {
+  const bindings = new Map;
+  for (const statement of source.statements) {
+    if (!ts.isVariableStatement(statement))
+      continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.initializer) {
+        bindings.set(declaration.name.text, {
+          expression: declaration.initializer,
+          declaration,
+          exported: hasModifier(statement, ts.SyntaxKind.ExportKeyword)
+        });
+      }
+    }
+  }
+  return bindings;
+}
+function rootIdentifier(node) {
+  if (ts.isIdentifier(node))
+    return node.text;
+  if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node))
+    return rootIdentifier(node.expression);
+  return;
+}
+function findUnsafeBindings(source, bindings) {
+  const unsafe = new Set;
+  const markWritten = (node) => {
+    const name = rootIdentifier(node);
+    if (name) {
+      unsafe.add(name);
+      return;
+    }
+    if (ts.isPropertyAssignment(node)) {
+      markWritten(node.initializer);
+      return;
+    }
+    ts.forEachChild(node, markWritten);
+  };
+  walk(source, (node) => {
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
+      markWritten(node.left);
+    }
+    if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) && (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken)) {
+      const name = rootIdentifier(node.operand);
+      if (name)
+        unsafe.add(name);
+    }
+    if (ts.isDeleteExpression(node)) {
+      const name = rootIdentifier(node.expression);
+      if (name)
+        unsafe.add(name);
+    }
+    if (ts.isForOfStatement(node) || ts.isForInStatement(node)) {
+      markWritten(node.initializer);
+    }
+  });
+  for (const [name, binding] of bindings) {
+    if (!containsObject(binding.expression, bindings, new Set))
+      continue;
+    if (binding.exported) {
+      unsafe.add(name);
+      continue;
+    }
+    walk(source, (node) => {
+      if (!ts.isIdentifier(node) || node.text !== name || !isReference(node))
+        return;
+      let parent = node.parent;
+      while (parent && !ts.isStatement(parent) && !ts.isVariableDeclaration(parent) && !ts.isCallExpression(parent) && !ts.isExportSpecifier(parent))
+        parent = parent.parent;
+      if (parent && ts.isCallExpression(parent) && isAddStyleCall(parent))
+        return;
+      if (parent && ts.isVariableDeclaration(parent) && ts.isVariableDeclarationList(parent.parent) && ts.isVariableStatement(parent.parent.parent) && parent.parent.parent.parent === source)
+        return;
+      unsafe.add(name);
+    });
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [name, binding] of bindings) {
+      const dependencies = new Set;
+      walk(binding.expression, (node) => {
+        if (ts.isIdentifier(node) && isReference(node) && bindings.has(node.text))
+          dependencies.add(node.text);
+      });
+      for (const dependency of dependencies) {
+        if (unsafe.has(dependency) && !unsafe.has(name)) {
+          unsafe.add(name);
+          changed = true;
+        }
+        if (unsafe.has(name) && containsObject(bindings.get(dependency).expression, bindings, new Set) && !unsafe.has(dependency)) {
+          unsafe.add(dependency);
+          changed = true;
+        }
+      }
+    }
+  }
+  return unsafe;
+}
+function isReference(node) {
+  const parent = node.parent;
+  if ((ts.isVariableDeclaration(parent) || ts.isParameter(parent) || ts.isBindingElement(parent)) && parent.name === node)
+    return false;
+  if ((ts.isPropertyAccessExpression(parent) || ts.isPropertyAssignment(parent) || ts.isMethodDeclaration(parent) || ts.isPropertyDeclaration(parent)) && parent.name === node)
+    return false;
+  return true;
+}
+function containsObject(expression, bindings, seen) {
+  const node = unwrap(expression);
+  if (ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node))
+    return true;
+  if (ts.isIdentifier(node) && !seen.has(node.text)) {
+    seen.add(node.text);
+    const binding = bindings.get(node.text);
+    return !!binding && containsObject(binding.expression, bindings, seen);
+  }
+  return false;
+}
+function unwrap(expression) {
+  while (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression) || ts.isSatisfiesExpression(expression))
+    expression = expression.expression;
+  return expression;
+}
+function splitComma(expression) {
+  const node = unwrap(expression);
+  return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.CommaToken ? [...splitComma(node.left), ...splitComma(node.right)] : [node];
+}
+function isAddStyleCall(node) {
+  const callee = node.expression;
+  return !node.questionDotToken && ts.isPropertyAccessExpression(callee) && !callee.questionDotToken && callee.name.text === "addStyle" && thisProperty(callee.expression) === "styleManager";
+}
+function readAddStyle(expression, bindings, unsafe, declaration) {
+  if (!ts.isCallExpression(expression) || !isAddStyleCall(expression) || expression.arguments.length !== 2)
+    return;
+  const evaluate = (node) => staticValue(node, bindings, unsafe, declaration.name?.text);
+  const name = evaluate(expression.arguments[0]);
+  const options = evaluate(expression.arguments[1]);
+  if (typeof name !== "string" || !isRecord(options) || typeof options.selector !== "string" || !isProperties(options.properties) || Object.keys(options).some((key) => !["selector", "properties", "hover", "media"].includes(key)))
+    return;
+  if (options.hover !== undefined && !isProperties(options.hover))
+    return;
+  if (options.media !== undefined && (!isRecord(options.media) || !Object.values(options.media).every(isProperties)))
+    return;
+  return { name, style: options };
+}
+function staticValue(expression, bindings, unsafe, className, seen = new Set) {
+  const node = unwrap(expression);
+  const evaluate = (value) => staticValue(value, bindings, unsafe, className, seen);
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+    return node.text;
+  if (ts.isNumericLiteral(node))
+    return Number(node.text);
+  if (node.kind === ts.SyntaxKind.TrueKeyword)
+    return true;
+  if (node.kind === ts.SyntaxKind.FalseKeyword)
+    return false;
+  if (node.kind === ts.SyntaxKind.NullKeyword)
+    return null;
+  if (ts.isIdentifier(node)) {
+    const binding = bindings.get(node.text);
+    if (!binding || unsafe.has(node.text) || seen.has(node.text) || node.text === className || identifierIsShadowed(node) || binding.declaration.getStart() >= node.getStart())
+      return;
+    const next = new Set(seen);
+    next.add(node.text);
+    return staticValue(binding.expression, bindings, unsafe, className, next);
+  }
+  if (ts.isTemplateExpression(node)) {
+    let value = node.head.text;
+    for (const span of node.templateSpans) {
+      const item = evaluate(span.expression);
+      if (item === undefined || isRecord(item))
+        return;
+      value += String(item) + span.literal.text;
+    }
+    return value;
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    const result = Object.create(null);
+    for (const property of node.properties) {
+      if (ts.isShorthandPropertyAssignment(property)) {
+        const value2 = evaluate(property.name);
+        if (value2 === undefined || property.objectAssignmentInitializer)
+          return;
+        result[property.name.text] = value2;
+        continue;
+      }
+      if (!ts.isPropertyAssignment(property))
+        return;
+      const name = ts.isComputedPropertyName(property.name) ? evaluate(property.name.expression) : ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) || ts.isNumericLiteral(property.name) ? property.name.text : undefined;
+      const value = evaluate(property.initializer);
+      if (typeof name !== "string" && typeof name !== "number" || name === "__proto__" || value === undefined)
+        return;
+      result[String(name)] = value;
+    }
+    return result;
+  }
+  if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+    const object = evaluate(node.expression);
+    const key = ts.isPropertyAccessExpression(node) ? node.name.text : node.argumentExpression && evaluate(node.argumentExpression);
+    if (isRecord(object) && (typeof key === "string" || typeof key === "number"))
+      return object[String(key)];
+    return;
+  }
+  if (ts.isPrefixUnaryExpression(node)) {
+    const operand = evaluate(node.operand);
+    if (operand === undefined || isRecord(operand))
+      return;
+    if (node.operator === ts.SyntaxKind.ExclamationToken)
+      return !operand;
+    if (typeof operand !== "number")
+      return;
+    if (node.operator === ts.SyntaxKind.MinusToken)
+      return -operand;
+    if (node.operator === ts.SyntaxKind.PlusToken)
+      return operand;
+  }
+  if (ts.isConditionalExpression(node)) {
+    const condition = evaluate(node.condition);
+    return condition === undefined || isRecord(condition) ? undefined : evaluate(condition ? node.whenTrue : node.whenFalse);
+  }
+  if (ts.isBinaryExpression(node)) {
+    const left = evaluate(node.left);
+    const right = evaluate(node.right);
+    if (left === undefined || right === undefined || isRecord(left) || isRecord(right))
+      return;
+    if (node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      if (typeof left === "string" || typeof right === "string")
+        return String(left) + String(right);
+      if (typeof left === "number" && typeof right === "number")
+        return left + right;
+      return;
+    }
+    if (typeof left !== "number" || typeof right !== "number")
+      return;
+    switch (node.operatorToken.kind) {
+      case ts.SyntaxKind.MinusToken:
+        return left - right;
+      case ts.SyntaxKind.AsteriskToken:
+        return left * right;
+      case ts.SyntaxKind.SlashToken:
+        return left / right;
+      case ts.SyntaxKind.PercentToken:
+        return left % right;
+      case ts.SyntaxKind.AsteriskAsteriskToken:
+        return left ** right;
+    }
+  }
+  return;
+}
+function identifierIsShadowed(identifier) {
+  for (let parent = identifier.parent;parent && !ts.isSourceFile(parent); parent = parent.parent) {
+    if (!ts.isFunctionLike(parent))
+      continue;
+    let shadowed = false;
+    walk(parent, (node) => {
+      if ((ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isBindingElement(node) || ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node)) && node.name && ts.isIdentifier(node.name) && node.name.text === identifier.text)
+        shadowed = true;
+    });
+    if (shadowed)
+      return true;
+  }
+  return false;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isProperties(value) {
+  return isRecord(value) && Object.values(value).every((item) => typeof item === "string" || typeof item === "number" && Number.isFinite(item));
+}
+function renderProperties(properties) {
+  return Object.entries(properties).map(([key, value]) => `${key.replace(/([A-Z])/g, "-$1").toLowerCase()}: ${String(value).replace(RPX_PATTERN, (_match, number) => `calc(${number} * var(--tu-rpx))`)};`).join(`
+`);
+}
+function renderStyle(style) {
+  let css = `${style.selector} {
+${renderProperties(style.properties)}
+}
+`;
+  if (style.hover)
+    css += `${style.selector}:hover {
+${renderProperties(style.hover)}
+}
+`;
+  for (const [query, properties] of Object.entries(style.media ?? {})) {
+    css += `@media ${query} {
+${style.selector} {
+${renderProperties(properties)}
+}
+}
+`;
+  }
+  return css;
+}
+function hasRelativeResource(css) {
+  if (css.includes("\\") || /@import\b|(?:-webkit-)?image(?:-set)?\s*\(/i.test(css))
+    return true;
+  for (const match of css.matchAll(/url\s*\(\s*(?:(["'])(.*?)\1|([^)]*))\s*\)/gi)) {
+    const url = (match[2] ?? match[3] ?? "").trim();
+    if (!/^(?:\/|[a-z][a-z\d+.-]*:)/i.test(url))
+      return true;
+  }
+  return false;
+}
+function walk(node, visit) {
+  visit(node);
+  ts.forEachChild(node, (child) => walk(child, visit));
+}
+
+// src/components/web.ts
+import ts2 from "typescript";
+import { createHash } from "crypto";
+import { dirname as dirname2 } from "path";
+var BOOT = "transone:platform-bootstrap";
+var DEFINITIONS = "transone:component-definitions:";
+var alias = (reference) => `__transone_${createHash("sha256").update(reference.id).digest("hex").slice(0, 16)}`;
+var localName = (reference) => reference.className === "default" ? `${alias(reference)}_default` : reference.className;
+function apply(contents, edits) {
+  for (const edit of edits.sort((a, b) => b.start - a.start))
+    contents = contents.slice(0, edit.start) + edit.text + contents.slice(edit.end);
+  return contents;
+}
+function bindingIdentifiers(name) {
+  return ts2.isIdentifier(name) ? [name] : name.elements.flatMap((element) => ts2.isOmittedExpression(element) ? [] : bindingIdentifiers(element.name));
+}
+function directlyConstructed(node) {
+  let expression = node;
+  while (expression.parent && (ts2.isPropertyAccessExpression(expression.parent) && expression.parent.name === expression || ts2.isParenthesizedExpression(expression.parent) || ts2.isAsExpression(expression.parent) || ts2.isNonNullExpression(expression.parent)))
+    expression = expression.parent;
+  return ts2.isNewExpression(expression.parent) && expression.parent.expression === expression;
+}
+function componentSources(config, entries) {
+  return [
+    ...new Set([
+      ...entries,
+      ...ts2.sys.readDirectory(config.root, [".ts", ".tsx"], [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/*.d.ts",
+        ...config.components?.exclude ?? []
+      ], ["src/**/*.ts", "src/**/*.tsx", ...config.components?.include ?? []])
+    ])
+  ];
+}
+function createWebComponentContext(config, entry) {
+  const files = componentSources(config, [entry]);
+  if (![...files].some((path) => /@\s*[\w$]|abstract\s+class|\bfrom\s*['"](?!transone(?:['"/]))/.test(ts2.sys.readFile(path) ?? ""))) {
+    return {
+      active: false,
+      sourcePaths: files,
+      entrypoint: entry,
+      plugin: {
+        name: "transone-no-platform-components",
+        setup() {}
+      },
+      transform: (_path, contents, _definitions = false) => contents
+    };
+  }
+  const index = createComponentIndex({
+    root: config.root,
+    entrypoints: [entry],
+    platform: config.platform,
+    include: config.components?.include,
+    exclude: config.components?.exclude
+  });
+  const rootPath = canonicalPath(config.root);
+  const eligibleSources = new Set(files.map(canonicalPath));
+  for (const source of index.sources) {
+    const path = canonicalPath(source.fileName);
+    if (path.startsWith(rootPath + "/") && !source.isDeclarationFile && /\.tsx?$/.test(path) && !/(?:^|[/\\])(?:node_modules|dist)(?:[/\\]|$)/.test(path))
+      eligibleSources.add(path);
+  }
+  const frameworkEntry = Bun.resolveSync("transone", canonicalPath(entry));
+  const platformDirectory = canonicalPath(dirname2(frameworkEntry) + "/platform");
+  const platformNames = new Set(COMPONENT_PLATFORM_DEFINITIONS.map((definition) => definition.decorator));
+  const consumedDecorators = new Set;
+  for (const ref of index.classes)
+    if (index.metadata(ref).platforms.length) {
+      for (const decorator of ts2.getDecorators(ref.declaration) ?? []) {
+        const expression = ts2.isCallExpression(decorator.expression) ? decorator.expression.expression : undefined;
+        const symbol = expression && index.symbolAt(expression, ref.source);
+        if (symbol && platformNames.has(symbol.name) && symbol.declarations?.some((declaration) => canonicalPath(dirname2(declaration.getSourceFile().fileName)) === platformDirectory))
+          consumedDecorators.add(decorator);
+      }
+    }
+  const allPairs = index.bindings();
+  const pairs = [];
+  const decorated = index.classes.filter((ref) => index.metadata(ref).platforms.length);
+  const removed = new Set(decorated.map((ref) => ref.id));
+  const keep = (ref) => {
+    for (const ancestor of index.hierarchy(ref))
+      removed.delete(ancestor.id);
+  };
+  const classAt = new Map(index.classes.map((ref) => [ref.declaration, ref]));
+  const liveSymbols = (source, dropped = new Set) => {
+    const symbols = new Set;
+    const visit = (node) => {
+      const owner = (ts2.isClassDeclaration(node) || ts2.isClassExpression(node)) && classAt.get(node);
+      if (dropped.has(node) || owner && removed.has(owner.id) || ts2.isImportDeclaration(node) || ts2.isHeritageClause(node) && node.token !== ts2.SyntaxKind.ExtendsKeyword || ts2.isTypeNode(node) && !ts2.isExpressionWithTypeArguments(node) || ts2.isDecorator(node) && consumedDecorators.has(node))
+        return;
+      if (ts2.isIdentifier(node)) {
+        const symbol = index.symbolAt(node, source);
+        if (symbol)
+          symbols.add(symbol);
+      }
+      ts2.forEachChild(node, visit);
+    };
+    visit(source);
+    return symbols;
+  };
+  const reachable = new Set([canonicalPath(entry)]);
+  const expandReachable = () => {
+    let graphChanged = true;
+    while (graphChanged) {
+      graphChanged = false;
+      for (const source of index.sources)
+        if (reachable.has(source.fileName)) {
+          const live = liveSymbols(source);
+          for (const statement of source.statements) {
+            if (!(ts2.isImportDeclaration(statement) || ts2.isExportDeclaration(statement)) || !statement.moduleSpecifier)
+              continue;
+            if (ts2.isImportDeclaration(statement) && statement.importClause) {
+              const clause = statement.importClause;
+              if (clause.isTypeOnly)
+                continue;
+              const named = clause.namedBindings;
+              const names = [
+                ...clause.name ? [clause.name] : [],
+                ...named && ts2.isNamedImports(named) ? named.elements.filter((item) => !item.isTypeOnly).map((item) => item.name) : named ? [named.name] : []
+              ];
+              if (!names.some((name) => {
+                const symbol = index.symbolAt(name, source);
+                return symbol && live.has(symbol);
+              }))
+                continue;
+            }
+            if (ts2.isExportDeclaration(statement) && statement.isTypeOnly)
+              continue;
+            if (ts2.isExportDeclaration(statement) && statement.exportClause && ts2.isNamedExports(statement.exportClause) && !statement.exportClause.elements.some((item) => {
+              const ref = index.resolve(item.name, source);
+              return !ref || !removed.has(ref.id);
+            }))
+              continue;
+            const declarations = index.symbolAt(statement.moduleSpecifier, source)?.declarations ?? [];
+            for (const declaration of declarations)
+              if (ts2.isSourceFile(declaration) && !reachable.has(declaration.fileName)) {
+                reachable.add(declaration.fileName);
+                graphChanged = true;
+              }
+          }
+        }
+    }
+  };
+  let changed = true;
+  while (changed) {
+    changed = false;
+    expandReachable();
+    const consume = (ref, dispatch = true) => {
+      if (!index.isComponent(ref))
+        return;
+      if (dispatch && index.metadata(ref).abstract)
+        index.select(ref);
+      if (removed.has(ref.id)) {
+        keep(ref);
+        changed = true;
+      }
+      const pair = dispatch && allPairs.find((pair2) => pair2.base.id === ref.id);
+      if (pair && !pairs.some((item) => item.base.id === ref.id)) {
+        pairs.push(pair);
+        keep(pair.base);
+        keep(pair.implementation);
+        reachable.add(pair.implementation.filePath);
+        changed = true;
+      }
+    };
+    for (const source of index.sources) {
+      if (!reachable.has(source.fileName))
+        continue;
+      const visit = (node) => {
+        const owner = (ts2.isClassDeclaration(node) || ts2.isClassExpression(node)) && index.classes.find((ref) => ref.declaration === node);
+        if (owner && removed.has(owner.id))
+          return;
+        if (ts2.isTypeNode(node) || ts2.isHeritageClause(node) || ts2.isImportDeclaration(node) || ts2.isExportDeclaration(node) || ts2.isDecorator(node) && consumedDecorators.has(node))
+          return;
+        if (ts2.isIdentifier(node) && !((ts2.isClassDeclaration(node.parent) || ts2.isClassExpression(node.parent)) && node.parent.name === node)) {
+          const namespace = index.symbolAt(node, source);
+          if (namespace?.exports && !(ts2.isPropertyAccessExpression(node.parent) && node.parent.expression === node)) {
+            for (const value of namespace.exports.values())
+              for (const declaration of value.declarations ?? []) {
+                const explicit = index.classes.find((item) => item.declaration === declaration);
+                if (explicit)
+                  consume(explicit);
+              }
+          }
+          const ref = index.resolve(node, source);
+          if (ref)
+            consume(ref, !directlyConstructed(node));
+        }
+        ts2.forEachChild(node, visit);
+      };
+      visit(source);
+    }
+  }
+  const active = decorated.length > 0;
+  const exported = new Map;
+  for (const pair of pairs)
+    for (const ref of [pair.base, pair.implementation]) {
+      const refs = exported.get(ref.filePath) ?? [];
+      if (!refs.some((item) => item.id === ref.id))
+        refs.push(ref);
+      exported.set(ref.filePath, refs);
+    }
+  const entryPath = canonicalPath(entry);
+  const entrySource = index.classes.find((ref) => ref.filePath === entryPath)?.source;
+  const hoisted = new Set;
+  const hoistedNames = new Set;
+  if (entrySource && exported.has(entryPath)) {
+    const statements = new Set(entrySource.statements);
+    const include = (statement) => {
+      if (hoisted.has(statement) || ts2.isImportDeclaration(statement))
+        return;
+      hoisted.add(statement);
+      const visit = (node) => {
+        if (ts2.isIdentifier(node)) {
+          const symbol = index.symbolAt(node, entrySource);
+          for (const declaration of symbol?.declarations ?? []) {
+            let top = declaration;
+            while (top.parent && top.parent !== entrySource)
+              top = top.parent;
+            if (statements.has(top))
+              include(top);
+          }
+        }
+        ts2.forEachChild(node, visit);
+      };
+      ts2.forEachChild(statement, visit);
+    };
+    for (const ref of index.classes.filter((ref2) => ref2.filePath === entryPath && !removed.has(ref2.id) && index.isComponent(ref2))) {
+      let top = ref.declaration;
+      while (top.parent !== entrySource)
+        top = top.parent;
+      include(top);
+    }
+    for (const statement of entrySource.statements) {
+      if (ts2.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts2.isNamedExports(statement.exportClause) && statement.exportClause.elements.every((item) => {
+        const ref = index.resolve(item.name, entrySource);
+        return ref && hoisted.has(ref.declaration);
+      }))
+        include(statement);
+      if (ts2.isExportAssignment(statement)) {
+        const ref = index.resolve(statement.expression, entrySource);
+        if (ref && hoisted.has(ref.declaration))
+          include(statement);
+      }
+    }
+    for (const statement of hoisted) {
+      if (ts2.isClassDeclaration(statement) && !statement.name) {
+        const ref = index.classes.find((item) => item.declaration === statement);
+        if (ref)
+          hoistedNames.add(localName(ref));
+      }
+      if ((ts2.isClassDeclaration(statement) || ts2.isFunctionDeclaration(statement) || ts2.isEnumDeclaration(statement)) && statement.name)
+        hoistedNames.add(statement.name.text);
+      if (ts2.isVariableStatement(statement))
+        for (const declaration of statement.declarationList.declarations)
+          for (const name of bindingIdentifiers(declaration.name))
+            hoistedNames.add(name.text);
+    }
+  }
+  const hoistedExports = new Set;
+  for (const statement of hoisted) {
+    const modifiers = ts2.canHaveModifiers(statement) ? ts2.getModifiers(statement) : undefined;
+    if (modifiers?.some((item) => item.kind === ts2.SyntaxKind.DefaultKeyword) || ts2.isExportAssignment(statement))
+      hoistedExports.add("default");
+    else if (modifiers?.some((item) => item.kind === ts2.SyntaxKind.ExportKeyword) && (ts2.isClassDeclaration(statement) || ts2.isFunctionDeclaration(statement) || ts2.isEnumDeclaration(statement)) && statement.name)
+      hoistedExports.add(statement.name.text);
+    if (modifiers?.some((item) => item.kind === ts2.SyntaxKind.ExportKeyword) && ts2.isVariableStatement(statement))
+      for (const declaration of statement.declarationList.declarations)
+        for (const name of bindingIdentifiers(declaration.name))
+          hoistedExports.add(name.text);
+    if (ts2.isExportDeclaration(statement) && statement.exportClause && ts2.isNamedExports(statement.exportClause))
+      for (const item of statement.exportClause.elements)
+        hoistedExports.add(item.name.text);
+  }
+  if (entrySource && hoisted.size) {
+    let earlierEffect;
+    for (const statement of entrySource.statements) {
+      if (hoisted.has(statement)) {
+        if (earlierEffect && !ts2.isFunctionDeclaration(statement))
+          throw new Error(`Cannot initialize entry-owned platform component after application side effects in ${entryPath}; move component definitions to a separate module`);
+      } else if (!ts2.isImportDeclaration(statement) && !ts2.isFunctionDeclaration(statement) && !ts2.isInterfaceDeclaration(statement) && !ts2.isTypeAliasDeclaration(statement) && !ts2.isExportDeclaration(statement))
+        earlierEffect = statement;
+    }
+    const dependencySymbols = new Set;
+    for (const statement of hoisted) {
+      const name = ts2.isClassDeclaration(statement) || ts2.isFunctionDeclaration(statement) || ts2.isEnumDeclaration(statement) ? statement.name : undefined;
+      if (name) {
+        const symbol = index.symbolAt(name, entrySource);
+        if (symbol)
+          dependencySymbols.add(symbol);
+      }
+      if (ts2.isVariableStatement(statement))
+        for (const declaration of statement.declarationList.declarations) {
+          for (const name2 of bindingIdentifiers(declaration.name)) {
+            const symbol = index.symbolAt(name2, entrySource);
+            if (symbol)
+              dependencySymbols.add(symbol);
+          }
+        }
+    }
+    const visit = (node) => {
+      if (hoisted.has(node))
+        return;
+      const target = ts2.isBinaryExpression(node) && node.operatorToken.kind >= ts2.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts2.SyntaxKind.LastAssignment ? node.left : (ts2.isPrefixUnaryExpression(node) || ts2.isPostfixUnaryExpression(node)) && (node.operator === ts2.SyntaxKind.PlusPlusToken || node.operator === ts2.SyntaxKind.MinusMinusToken) ? node.operand : undefined;
+      if (target && ts2.isIdentifier(target) && dependencySymbols.has(index.symbolAt(target, entrySource)))
+        throw new Error(`Cannot mutate entry-owned component dependency ${target.text} outside its definition module; move component definitions to a separate module`);
+      ts2.forEachChild(node, visit);
+    };
+    visit(entrySource);
+  }
+  const definitionPath = (path) => path === entryPath && hoisted.size ? DEFINITIONS + path : path;
+  function transform(path, contents, definitions = false) {
+    if (!active)
+      return contents;
+    if (!eligibleSources.has(path) && !exported.has(path))
+      return contents;
+    const source = index.sources.find((source2) => source2.fileName === path) ?? ts2.createSourceFile(path, contents, ts2.ScriptTarget.Latest, true);
+    const edits = [];
+    const dropped = [];
+    for (const ref of index.classes.filter((ref2) => ref2.filePath === path)) {
+      if (removed.has(ref.id)) {
+        let node = ref.declaration;
+        if (ts2.isClassExpression(node) && ts2.isVariableDeclaration(node.parent))
+          node = node.parent.parent.parent;
+        edits.push({ start: node.getStart(source), end: node.end, text: "" });
+        dropped.push(node);
+        continue;
+      }
+      for (const decorator of ts2.getDecorators(ref.declaration) ?? [])
+        if (consumedDecorators.has(decorator)) {
+          edits.push({
+            start: decorator.getStart(source),
+            end: decorator.end,
+            text: ""
+          });
+          dropped.push(decorator);
+        }
+    }
+    if (path === entryPath && hoisted.size) {
+      for (const statement of source.statements) {
+        if (ts2.isImportDeclaration(statement))
+          continue;
+        const remove = definitions ? !hoisted.has(statement) : hoisted.has(statement);
+        if (remove && !dropped.some((node) => node === statement)) {
+          for (let i = edits.length - 1;i >= 0; i--)
+            if (edits[i].start >= statement.getStart(source) && edits[i].end <= statement.end)
+              edits.splice(i, 1);
+          edits.push({
+            start: statement.getStart(source),
+            end: statement.end,
+            text: ""
+          });
+          dropped.push(statement);
+        }
+      }
+    }
+    for (const statement of source.statements)
+      if (ts2.isExportDeclaration(statement) && statement.exportClause && ts2.isNamedExports(statement.exportClause) && !dropped.includes(statement)) {
+        const elements = statement.exportClause.elements.filter((item) => {
+          const ref = index.resolve(item.name, source);
+          if (ref && removed.has(ref.id)) {
+            dropped.push(item);
+            return false;
+          }
+          return true;
+        });
+        const entryExports = hoisted.size && statement.moduleSpecifier && elements.length && elements.every((item) => index.resolve(item.name, source)?.filePath === entryPath);
+        if (entryExports || elements.length !== statement.exportClause.elements.length)
+          edits.push({
+            start: statement.getStart(source),
+            end: statement.end,
+            text: elements.length ? `export {${elements.map((item) => item.getText(source)).join(",")}}${statement.moduleSpecifier ? ` from ${entryExports ? JSON.stringify(DEFINITIONS + entryPath) : statement.moduleSpecifier.getText(source)}` : ""};` : ""
+          });
+      }
+    const used = liveSymbols(source, new Set(dropped));
+    for (const statement of source.statements)
+      if (ts2.isImportDeclaration(statement) && statement.importClause) {
+        const clause = statement.importClause;
+        const named = clause.namedBindings;
+        const alive = (node) => {
+          const symbol = index.symbolAt(node, source);
+          return !!symbol && used.has(symbol);
+        };
+        const defaultName = clause.name && alive(clause.name) ? clause.name.text : undefined;
+        const namedText = named && ts2.isNamedImports(named) ? named.elements.filter((item) => !item.isTypeOnly && alive(item.name)).map((item) => item.getText(source)) : [];
+        const namespace = named && ts2.isNamespaceImport(named) && alive(named.name) ? named.getText(source) : undefined;
+        const parts = [
+          defaultName,
+          namespace ?? (namedText.length ? `{${namedText.join(",")}}` : undefined)
+        ].filter(Boolean);
+        const originalNames = [
+          ...clause.name ? [clause.name] : [],
+          ...named && ts2.isNamedImports(named) ? named.elements.map((item) => item.name) : named ? [named.name] : []
+        ];
+        const originallyUsed = originalNames.some((name) => {
+          const symbol = index.symbolAt(name, source);
+          let found = false;
+          const scan = (node) => {
+            if (ts2.isImportDeclaration(node))
+              return;
+            if (ts2.isIdentifier(node) && node !== name && index.symbolAt(node, source) === symbol)
+              found = true;
+            ts2.forEachChild(node, scan);
+          };
+          scan(source);
+          return found;
+        });
+        if (!parts.length && originallyUsed)
+          edits.push({
+            start: statement.getStart(source),
+            end: statement.end,
+            text: ""
+          });
+        else if (parts.length) {
+          let module = statement.moduleSpecifier.getText(source);
+          if (ts2.isStringLiteral(statement.moduleSpecifier) && hoisted.size) {
+            const values = [
+              ...clause.name ? [clause.name] : [],
+              ...named && ts2.isNamedImports(named) ? named.elements.map((item) => item.name) : []
+            ];
+            const refs = values.map((item) => index.resolve(item, source));
+            if (refs.length && refs.every((ref) => ref?.filePath === entryPath))
+              module = JSON.stringify(DEFINITIONS + entryPath);
+            if (named && ts2.isNamespaceImport(named)) {
+              const namespaceSymbol = index.symbolAt(named.name, source);
+              const moduleSource = namespaceSymbol?.declarations?.find(ts2.isSourceFile);
+              if (moduleSource?.fileName === entryPath) {
+                let onlyDefinitions = true;
+                const scan = (node) => {
+                  if (dropped.includes(node) || ts2.isImportDeclaration(node))
+                    return;
+                  if (ts2.isIdentifier(node) && index.symbolAt(node, source) === namespaceSymbol) {
+                    if (!ts2.isPropertyAccessExpression(node.parent) || node.parent.expression !== node || !hoistedExports.has(node.parent.name.text))
+                      onlyDefinitions = false;
+                  }
+                  ts2.forEachChild(node, scan);
+                };
+                scan(source);
+                if (!onlyDefinitions)
+                  throw new Error(`Platform implementation namespace import from ${entryPath} also consumes app initialization; move component definitions to a separate module`);
+                module = JSON.stringify(DEFINITIONS + entryPath);
+              }
+            }
+          }
+          edits.push({
+            start: statement.getStart(source),
+            end: statement.end,
+            text: `import ${parts.join(",")} from ${module};`
+          });
+        }
+      }
+    for (const ref of exported.get(path) ?? [])
+      if (ref.className === "default" && (path !== entryPath || definitions || !hoisted.size)) {
+        const keyword = ref.declaration.getChildren(source).find((node) => node.kind === ts2.SyntaxKind.ClassKeyword);
+        if (!keyword)
+          throw new Error(`Cannot name anonymous component in ${path}`);
+        edits.push({
+          start: keyword.end,
+          end: keyword.end,
+          text: " " + localName(ref)
+        });
+      }
+    let result = apply(contents, edits);
+    if (path === entryPath && hoisted.size && !definitions) {
+      result = `import {${[...hoistedNames].join(",")}} from ${JSON.stringify(DEFINITIONS + entryPath)};
+` + result;
+      for (const statement of hoisted) {
+        if (ts2.isClassDeclaration(statement) && !statement.name) {
+          const ref = index.classes.find((item) => item.declaration === statement);
+          if (ref)
+            result += `
+export {${localName(ref)} as default};`;
+        }
+        if (ts2.isExportDeclaration(statement) || ts2.isExportAssignment(statement))
+          result += `
+` + statement.getText(source);
+        if (ts2.canHaveModifiers(statement) && ts2.getModifiers(statement)?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword)) {
+          if ((ts2.isClassDeclaration(statement) || ts2.isFunctionDeclaration(statement) || ts2.isEnumDeclaration(statement)) && statement.name)
+            result += `
+export {${statement.name.text}${ts2.getModifiers(statement)?.some((item) => item.kind === ts2.SyntaxKind.DefaultKeyword) ? " as default" : ""}};`;
+          if (ts2.isVariableStatement(statement))
+            for (const declaration of statement.declarationList.declarations)
+              for (const name of bindingIdentifiers(declaration.name))
+                result += `
+export {${name.text}};`;
+        }
+      }
+    }
+    if (definitions) {
+      const alreadyExported = new Set;
+      for (const statement of hoisted)
+        if (ts2.canHaveModifiers(statement) && ts2.getModifiers(statement)?.some((item) => item.kind === ts2.SyntaxKind.ExportKeyword)) {
+          if ((ts2.isClassDeclaration(statement) || ts2.isFunctionDeclaration(statement) || ts2.isEnumDeclaration(statement)) && statement.name && !ts2.getModifiers(statement)?.some((item) => item.kind === ts2.SyntaxKind.DefaultKeyword))
+            alreadyExported.add(statement.name.text);
+          if (ts2.isVariableStatement(statement))
+            for (const declaration of statement.declarationList.declarations)
+              for (const name of bindingIdentifiers(declaration.name))
+                alreadyExported.add(name.text);
+        }
+      const names = [...hoistedNames].filter((name) => !alreadyExported.has(name));
+      if (names.length)
+        result += `
+export {${names.join(",")}};`;
+    }
+    if (path !== entryPath || definitions || !hoisted.size)
+      for (const ref of exported.get(path) ?? []) {
+        result += `
+export {${localName(ref)} as ${alias(ref)}};`;
+      }
+    return result;
+  }
+  const imports = pairs.flatMap((pair) => [pair.base, pair.implementation]);
+  const unique = [...new Map(imports.map((ref) => [ref.id, ref])).values()];
+  const bootstrap = [
+    `import {bindComponentImplementations} from ${JSON.stringify(frameworkEntry)};`,
+    ...unique.map((ref) => `import {${alias(ref)}} from ${JSON.stringify(definitionPath(ref.filePath))};`),
+    `bindComponentImplementations([${pairs.map((pair) => `[${alias(pair.base)},${alias(pair.implementation)}]`).join(",")}]);`,
+    `const entry = await import(${JSON.stringify(entryPath)}); export const app = entry.app;`
+  ].join(`
+`);
+  const plugin = {
+    name: "transone-platform-bootstrap",
+    setup(build) {
+      build.onResolve({ filter: /^transone:platform-bootstrap$/ }, () => ({
+        path: BOOT,
+        namespace: "transone-platform"
+      }));
+      build.onLoad({ filter: /.*/, namespace: "transone-platform" }, () => ({
+        contents: bootstrap,
+        loader: "ts",
+        resolveDir: dirname2(entryPath)
+      }));
+      build.onResolve({ filter: /^transone:component-definitions:/ }, ({ path }) => ({
+        path: path.slice(DEFINITIONS.length) + "?transone-definitions",
+        namespace: "transone-definitions"
+      }));
+    }
+  };
+  return {
+    sourcePaths: index.sources.map((source) => source.fileName),
+    active,
+    entrypoint: active ? BOOT : entry,
+    plugin,
+    transform: (path, contents, definitions = false) => transform(canonicalPath(path), contents, definitions)
+  };
+}
+
+export { createWebStylesPlugin, createWebComponentContext };
+
+//# debugId=C803F75040FC727464756E2164756E21
+//# sourceMappingURL=index-d51tp4y9.js.map