text: "use strict";
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const ts = __importStar(require("typescript"));
  function apply(node, ...transforms) {
      const result = ts.transform(node, transforms);
      return result.transformed[0];
  }
  exports.apply = apply;
  function is_require(node) {
      return ts.isCallExpression(node) &&
          ts.isIdentifier(node.expression) &&
          node.expression.text === "require" &&
          node.arguments.length === 1;
  }
  function relativize_modules(relativize) {
      function relativize_specifier(source, expr) {
          if (expr != null && ts.isStringLiteralLike(expr) && expr.text.length > 0) {
              const relative = relativize(source.fileName, expr.text);
              if (relative != null)
                  return ts.createLiteral(relative);
          }
          return null;
      }
      return (context) => (root) => {
          function visit(node) {
              if (ts.isImportDeclaration(node)) {
                  const moduleSpecifier = relativize_specifier(root, node.moduleSpecifier);
                  if (moduleSpecifier != null) {
                      const { decorators, modifiers, importClause } = node;
                      return ts.updateImportDeclaration(node, decorators, modifiers, importClause, moduleSpecifier);
                  }
              }
              if (ts.isExportDeclaration(node)) {
                  const moduleSpecifier = relativize_specifier(root, node.moduleSpecifier);
                  if (moduleSpecifier != null) {
                      const { decorators, modifiers, exportClause } = node;
                      return ts.updateExportDeclaration(node, decorators, modifiers, exportClause, moduleSpecifier, false);
                  }
              }
              if (is_require(node)) {
                  const moduleSpecifier = relativize_specifier(root, node.arguments[0]);
                  if (moduleSpecifier != null) {
                      const { expression, typeArguments } = node;
                      return ts.updateCall(node, expression, typeArguments, [moduleSpecifier]);
                  }
              }
              return ts.visitEachChild(node, visit, context);
          }
          return ts.visitNode(root, visit);
      };
  }
  exports.relativize_modules = relativize_modules;
  function import_txt(load) {
      return (context) => (root) => {
          function visit(node) {
              if (ts.isImportDeclaration(node)) {
                  const { importClause, moduleSpecifier } = node;
                  if (ts.isStringLiteralLike(moduleSpecifier)) {
                      const txt_path = moduleSpecifier.text;
                      if (txt_path.endsWith(".txt") && importClause != null && importClause.name != null) {
                          const txt_text = load(txt_path);
                          if (txt_text != null) {
                              return ts.createVariableDeclaration(importClause.name, ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), ts.createStringLiteral(txt_text));
                          }
                      }
                  }
              }
              return ts.visitEachChild(node, visit, context);
          }
          return ts.visitNode(root, visit);
      };
  }
  exports.import_txt = import_txt;
  function css_loader(css_text) {
      const dom = ts.createTempVariable(undefined);
      return [
          ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamespaceImport(dom)), ts.createStringLiteral("core/dom")),
          ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(ts.createPropertyAccess(dom, "styles"), "append"), undefined, [ts.createStringLiteral(css_text)])),
      ];
  }
  function import_css(load) {
      return (context) => (root) => {
          function visit(node) {
              if (ts.isImportDeclaration(node)) {
                  const { importClause, moduleSpecifier } = node;
                  if (ts.isStringLiteralLike(moduleSpecifier)) {
                      const css_path = moduleSpecifier.text;
                      if (importClause == null && css_path.endsWith(".css")) {
                          const css_text = load(css_path);
                          if (css_text != null) {
                              return css_loader(css_text);
                          }
                      }
                  }
              }
              return ts.visitEachChild(node, visit, context);
          }
          return ts.visitNode(root, visit);
      };
  }
  exports.import_css = import_css;
  function is_static(node) {
      return node.modifiers != null && node.modifiers.find((modifier) => modifier.kind == ts.SyntaxKind.StaticKeyword) != null;
  }
  function add_init_class() {
      return (context) => (root) => {
          function visit(node) {
              node = ts.visitEachChild(node, visit, context);
              if (ts.isClassDeclaration(node) && node.name != null) {
                  const name = `init_${node.name.getText()}`;
                  if (node.members.find((member) => ts.isMethodDeclaration(member) && member.name.getText() == name && is_static(member)) != null) {
                      const init = ts.createExpressionStatement(ts.createCall(ts.createPropertyAccess(node.name, name), undefined, undefined));
                      return [node, init];
                  }
              }
              return node;
          }
          return ts.visitNode(root, visit);
      };
  }
  exports.add_init_class = add_init_class;
  function insert_class_name() {
      function has__name__(node) {
          return node.members.find((member) => ts.isPropertyDeclaration(member) && member.name.getText() == "__name__" && is_static(member)) != null;
      }
      return (context) => (root) => {
          function visit(node) {
              node = ts.visitEachChild(node, visit, context);
              if (ts.isClassDeclaration(node) && node.name != null && !has__name__(node)) {
                  const property = ts.createProperty(undefined, ts.createModifiersFromModifierFlags(ts.ModifierFlags.Static), "__name__", undefined, undefined, ts.createStringLiteral(node.name.text));
                  node = ts.updateClassDeclaration(node, node.decorators, node.modifiers, node.name, node.typeParameters, node.heritageClauses, [property, ...node.members]);
              }
              return node;
          }
          return ts.visitNode(root, visit);
      };
  }
  exports.insert_class_name = insert_class_name;
  function remove_use_strict() {
      return (_context) => (root) => {
          const statements = root.statements.filter((node) => {
              if (ts.isExpressionStatement(node)) {
                  const expr = node.expression;
                  if (ts.isStringLiteral(expr) && expr.text == "use strict")
                      return false;
              }
              return true;
          });
          return ts.updateSourceFileNode(root, statements);
      };
  }
  exports.remove_use_strict = remove_use_strict;
  function remove_esmodule() {
      return (_context) => (root) => {
          const statements = root.statements.filter((node) => {
              if (ts.isExpressionStatement(node)) {
                  const expr = node.expression;
                  if (ts.isCallExpression(expr) && expr.arguments.length == 3) {
                      const [, arg] = expr.arguments;
                      if (ts.isStringLiteral(arg) && arg.text == "__esModule")
                          return false;
                  }
              }
              return true;
          });
          return ts.updateSourceFileNode(root, statements);
      };
  }
  exports.remove_esmodule = remove_esmodule;
  function isImportCall(node) {
      return ts.isCallExpression(node) && node.expression.kind == ts.SyntaxKind.ImportKeyword;
  }
  function collect_imports(imports) {
      return (context) => (root) => {
          function visit(node) {
              if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
                  const name = node.moduleSpecifier;
                  if (name != null && ts.isStringLiteral(name) && name.text.length != 0)
                      imports.add(name.text);
              }
              else if (isImportCall(node)) {
                  const [name] = node.arguments;
                  if (ts.isStringLiteral(name) && name.text.length != 0)
                      imports.add(name.text);
              }
              return ts.visitEachChild(node, visit, context);
          }
          return ts.visitNode(root, visit);
      };
  }
  exports.collect_imports = collect_imports;
  function collect_deps(source) {
      function traverse(node) {
          if (is_require(node)) {
              const [arg] = node.arguments;
              if (ts.isStringLiteral(arg) && arg.text.length > 0)
                  deps.add(arg.text);
          }
          ts.forEachChild(node, traverse);
      }
      const deps = new Set();
      traverse(source);
      return [...deps];
  }
  exports.collect_deps = collect_deps;
  function rewrite_deps(resolve) {
      return (context) => (root) => {
          function visit(node) {
              if (is_require(node)) {
                  const [arg] = node.arguments;
                  if (ts.isStringLiteral(arg) && arg.text.length > 0) {
                      const dep = arg.text;
                      const val = resolve(dep);
                      if (val != null) {
                          node = ts.updateCall(node, node.expression, node.typeArguments, [ts.createLiteral(val)]);
                          ts.addSyntheticTrailingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, ` ${dep} `, false);
                      }
                      return node;
                  }
              }
              return ts.visitEachChild(node, visit, context);
          }
          return ts.visitNode(root, visit);
      };
  }
  exports.rewrite_deps = rewrite_deps;
  // XXX: this is pretty naive, but affects very litte code
  function rename_exports() {
      return (context) => (root) => {
          function is_exports(node) {
              return ts.isIdentifier(node) && node.text == "exports";
          }
          const has_exports = root.statements.some((stmt) => {
              return ts.isVariableStatement(stmt) && stmt.declarationList.declarations.some((decl) => is_exports(decl.name));
          });
          if (has_exports) {
              function visit(node) {
                  if (is_exports(node)) {
                      const updated = ts.createIdentifier("exports$1");
                      const original = node;
                      ts.setOriginalNode(updated, original);
                      ts.setTextRange(updated, original);
                      return updated;
                  }
                  return ts.visitEachChild(node, visit, context);
              }
              return ts.visitNode(root, visit);
          }
          else
              return root;
      };
  }
  exports.rename_exports = rename_exports;
  function add_json_export() {
      return (_context) => (root) => {
          if (root.statements.length == 1) {
              const [statement] = root.statements;
              if (ts.isExpressionStatement(statement)) {
                  const left = ts.createPropertyAccess(ts.createIdentifier("module"), "exports");
                  const right = statement.expression;
                  const assign = ts.createStatement(ts.createAssignment(left, right));
                  return ts.updateSourceFileNode(root, [assign]);
              }
          }
          return root;
      };
  }
  exports.add_json_export = add_json_export;
  function wrap_in_function(module_name) {
      return (_context) => (root) => {
          const p = (name) => ts.createParameter(undefined, undefined, undefined, name);
          const params = [p("require"), p("module"), p("exports")];
          const block = ts.createBlock(root.statements, true);
          const func = ts.createFunctionDeclaration(undefined, undefined, undefined, "_", undefined, params, undefined, block);
          ts.addSyntheticLeadingComment(func, ts.SyntaxKind.MultiLineCommentTrivia, ` ${module_name} `, false);
          return ts.updateSourceFileNode(root, [func]);
      };
  }
  exports.wrap_in_function = wrap_in_function;
  function parse_es(file, code, target = ts.ScriptTarget.ES2017) {
      return ts.createSourceFile(file, code != null ? code : ts.sys.readFile(file), target, true, ts.ScriptKind.JS);
  }
  exports.parse_es = parse_es;
  function print_es(source) {
      const printer = ts.createPrinter();
      return printer.printNode(ts.EmitHint.SourceFile, source, source);
  }
  exports.print_es = print_es;
  //# sourceMappingURL=transforms.js.map