{"version":3,"file":"index.js","sources":["../src/formatters.ts","../src/options.ts","../src/parse.ts","../src/populate.ts","../src/string.ts","../src/literal.ts","../src/builder.ts","../src/index.ts"],"sourcesContent":["import { assertExpressionStatement } from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nexport type Formatter<T> = {\n  code: (source: string) => string;\n  validate: (ast: t.File) => void;\n  unwrap: (ast: t.File) => T;\n};\n\nfunction makeStatementFormatter<T>(\n  fn: (statements: t.Statement[]) => T,\n): Formatter<T> {\n  return {\n    // We need to prepend a \";\" to force statement parsing so that\n    // ExpressionStatement strings won't be parsed as directives.\n    // Alongside that, we also prepend a comment so that when a syntax error\n    // is encountered, the user will be less likely to get confused about\n    // where the random semicolon came from.\n    code: str => `/* @babel/template */;\\n${str}`,\n    validate: () => {},\n    unwrap: (ast: t.File): T => {\n      return fn(ast.program.body.slice(1));\n    },\n  };\n}\n\nexport const smart = makeStatementFormatter(body => {\n  if (body.length > 1) {\n    return body;\n  } else {\n    return body[0];\n  }\n});\n\nexport const statements = makeStatementFormatter(body => body);\n\nexport const statement = makeStatementFormatter(body => {\n  // We do this validation when unwrapping since the replacement process\n  // could have added or removed statements.\n  if (body.length === 0) {\n    throw new Error(\"Found nothing to return.\");\n  }\n  if (body.length > 1) {\n    throw new Error(\"Found multiple statements but wanted one\");\n  }\n\n  return body[0];\n});\n\nexport const expression: Formatter<t.Expression> = {\n  code: str => `(\\n${str}\\n)`,\n  validate: ast => {\n    if (ast.program.body.length > 1) {\n      throw new Error(\"Found multiple statements but wanted one\");\n    }\n    if (expression.unwrap(ast).start === 0) {\n      throw new Error(\"Parse result included parens.\");\n    }\n  },\n  unwrap: ({ program }) => {\n    const [stmt] = program.body;\n    assertExpressionStatement(stmt);\n    return stmt.expression;\n  },\n};\n\nexport const program: Formatter<t.Program> = {\n  code: str => str,\n  validate: () => {},\n  unwrap: ast => ast.program,\n};\n","import type { ParserOptions as ParserOpts } from \"@babel/parser\";\n\nexport type { ParserOpts };\n\n/**\n * These are the options that 'babel-template' actually accepts and typechecks\n * when called. All other options are passed through to the parser.\n */\nexport type PublicOpts = {\n  /**\n   * A set of placeholder names to automatically accept, ignoring the given\n   * pattern entirely.\n   *\n   * This option can be used when using %%foo%% style placeholders.\n   */\n  placeholderAllowlist?: Set<string>;\n  /**\n   * A pattern to search for when looking for Identifier and StringLiteral\n   * nodes that can be replaced.\n   *\n   * 'false' will disable placeholder searching entirely, leaving only the\n   * 'placeholderAllowlist' value to find replacements.\n   *\n   * Defaults to /^[_$A-Z0-9]+$/.\n   *\n   * This option can be used when using %%foo%% style placeholders.\n   */\n  placeholderPattern?: RegExp | false;\n  /**\n   * 'true' to pass through comments from the template into the resulting AST,\n   * or 'false' to automatically discard comments. Defaults to 'false'.\n   */\n  preserveComments?: boolean;\n  /**\n   * 'true' to use %%foo%% style placeholders, 'false' to use legacy placeholders\n   * described by placeholderPattern or placeholderAllowlist.\n   * When it is not set, it behaves as 'true' if there are syntactic placeholders,\n   * otherwise as 'false'.\n   */\n  syntacticPlaceholders?: boolean | null;\n} & ParserOpts;\n\nexport type TemplateOpts = {\n  parser: ParserOpts;\n  placeholderAllowlist?: Set<string>;\n  placeholderPattern?: RegExp | false;\n  preserveComments?: boolean;\n  syntacticPlaceholders?: boolean;\n};\n\nexport function merge(a: TemplateOpts, b: TemplateOpts): TemplateOpts {\n  const {\n    placeholderAllowlist = a.placeholderAllowlist,\n    placeholderPattern = a.placeholderPattern,\n    preserveComments = a.preserveComments,\n    syntacticPlaceholders = a.syntacticPlaceholders,\n  } = b;\n\n  return {\n    parser: {\n      ...a.parser,\n      ...b.parser,\n    },\n    placeholderAllowlist,\n    placeholderPattern,\n    preserveComments,\n    syntacticPlaceholders,\n  };\n}\n\nexport function validate(opts: unknown): TemplateOpts {\n  if (opts != null && typeof opts !== \"object\") {\n    throw new Error(\"Unknown template options.\");\n  }\n\n  if (opts != null && Object.hasOwn(opts, \"placeholderWhitelist\")) {\n    if (!Object.hasOwn(opts, \"placeholderAllowlist\")) {\n      throw new Error(\n        \"The 'placeholderWhitelist' option has been renamed to \" +\n          \"'placeholderAllowlist'. Please update your configuration.\",\n      );\n    }\n    // Both options provided: new option takes precedence (supports Babel 7/8 cross-version compat)\n  }\n\n  const {\n    placeholderAllowlist,\n    placeholderPattern,\n    preserveComments,\n    syntacticPlaceholders,\n    ...parser\n  } = opts || ({} as any);\n\n  if (placeholderAllowlist != null && !(placeholderAllowlist instanceof Set)) {\n    throw new Error(\n      \"'.placeholderAllowlist' must be a Set, null, or undefined\",\n    );\n  }\n\n  if (\n    placeholderPattern != null &&\n    !(placeholderPattern instanceof RegExp) &&\n    placeholderPattern !== false\n  ) {\n    throw new Error(\n      \"'.placeholderPattern' must be a RegExp, false, null, or undefined\",\n    );\n  }\n\n  if (preserveComments != null && typeof preserveComments !== \"boolean\") {\n    throw new Error(\n      \"'.preserveComments' must be a boolean, null, or undefined\",\n    );\n  }\n\n  if (\n    syntacticPlaceholders != null &&\n    typeof syntacticPlaceholders !== \"boolean\"\n  ) {\n    throw new Error(\n      \"'.syntacticPlaceholders' must be a boolean, null, or undefined\",\n    );\n  }\n  if (\n    syntacticPlaceholders === true &&\n    (placeholderAllowlist != null || placeholderPattern != null)\n  ) {\n    throw new Error(\n      \"'.placeholderAllowlist' and '.placeholderPattern' aren't compatible\" +\n        \" with '.syntacticPlaceholders: true'\",\n    );\n  }\n\n  return {\n    parser,\n    placeholderAllowlist: placeholderAllowlist || undefined,\n    placeholderPattern:\n      placeholderPattern == null ? undefined : placeholderPattern,\n    preserveComments: preserveComments == null ? undefined : preserveComments,\n    syntacticPlaceholders:\n      syntacticPlaceholders == null ? undefined : syntacticPlaceholders,\n  };\n}\n\nexport type PublicReplacements = Record<string, unknown> | unknown[];\nexport type TemplateReplacements = Record<string, unknown> | void;\n\nexport function normalizeReplacements(\n  replacements: unknown,\n): TemplateReplacements {\n  if (Array.isArray(replacements)) {\n    return replacements.reduce((acc, replacement, i) => {\n      acc[\"$\" + i] = replacement;\n      return acc;\n    }, {});\n  } else if (typeof replacements === \"object\" || replacements == null) {\n    return (replacements as any) || undefined;\n  }\n\n  throw new Error(\n    \"Template replacements must be an array, object, null, or undefined\",\n  );\n}\n","import {\n  isCallExpression,\n  isExpressionStatement,\n  isFunction,\n  isIdentifier,\n  isJSXIdentifier,\n  isNewExpression,\n  isPlaceholder,\n  isStatement,\n  isStringLiteral,\n  removePropertiesDeep,\n  traverse,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type { TraversalAncestors } from \"@babel/types\";\nimport { parse } from \"@babel/parser\";\nimport { codeFrameColumns } from \"@babel/code-frame\";\nimport type { TemplateOpts, ParserOpts } from \"./options.ts\";\nimport type { Formatter } from \"./formatters.ts\";\n\nexport type Metadata = {\n  ast: t.File;\n  placeholders: Placeholder[];\n  placeholderNames: Set<string>;\n};\n\ntype PlaceholderType = \"string\" | \"param\" | \"statement\" | \"other\";\nexport type Placeholder = {\n  name: string;\n  resolve: (a: t.File) => { parent: t.Node; key: string; index?: number };\n  type: PlaceholderType;\n  isDuplicate: boolean;\n};\n\nconst PATTERN = /^[_$A-Z0-9]+$/;\n\nexport default function parseAndBuildMetadata<T>(\n  formatter: Formatter<T>,\n  code: string,\n  opts: TemplateOpts,\n): Metadata {\n  const {\n    placeholderAllowlist,\n    placeholderPattern,\n    preserveComments = false,\n    syntacticPlaceholders,\n  } = opts;\n\n  const ast = parseWithCodeFrame(code, opts.parser, syntacticPlaceholders);\n\n  removePropertiesDeep(ast, {\n    preserveComments,\n  });\n\n  formatter.validate(ast);\n\n  const state: MetadataState = {\n    syntactic: { placeholders: [], placeholderNames: new Set() },\n    legacy: { placeholders: [], placeholderNames: new Set() },\n    placeholderAllowlist,\n    placeholderPattern,\n    syntacticPlaceholders,\n  };\n\n  traverse(ast, placeholderVisitorHandler, state);\n\n  return {\n    ast,\n    ...(state.syntactic.placeholders.length ? state.syntactic : state.legacy),\n  };\n}\n\nfunction placeholderVisitorHandler(\n  node: t.Node,\n  ancestors: TraversalAncestors,\n  state: MetadataState,\n) {\n  let name: string;\n\n  let hasSyntacticPlaceholders = state.syntactic.placeholders.length > 0;\n\n  if (isPlaceholder(node)) {\n    if (state.syntacticPlaceholders === false) {\n      throw new Error(\n        \"%%foo%%-style placeholders can't be used when \" +\n          \"'.syntacticPlaceholders' is false.\",\n      );\n    }\n    name = node.name.name;\n    hasSyntacticPlaceholders = true;\n  } else if (hasSyntacticPlaceholders || state.syntacticPlaceholders) {\n    return;\n  } else if (isIdentifier(node) || isJSXIdentifier(node)) {\n    name = node.name;\n  } else if (isStringLiteral(node)) {\n    name = node.value;\n  } else {\n    return;\n  }\n\n  if (\n    hasSyntacticPlaceholders &&\n    (state.placeholderPattern != null || state.placeholderAllowlist != null)\n  ) {\n    // This check is also in options.js. We need it there to handle the default\n    // .syntacticPlaceholders behavior.\n    throw new Error(\n      \"'.placeholderAllowlist' and '.placeholderPattern' aren't compatible\" +\n        \" with '.syntacticPlaceholders: true'\",\n    );\n  }\n\n  if (\n    !hasSyntacticPlaceholders &&\n    (state.placeholderPattern === false ||\n      !(state.placeholderPattern || PATTERN).test(name)) &&\n    !state.placeholderAllowlist?.has(name)\n  ) {\n    return;\n  }\n\n  // Keep our own copy of the ancestors so we can use it in .resolve().\n  ancestors = ancestors.slice();\n\n  const { node: parent, key } = ancestors[ancestors.length - 1];\n\n  let type: PlaceholderType;\n  if (\n    isStringLiteral(node) ||\n    isPlaceholder(node, { expectedNode: \"StringLiteral\" })\n  ) {\n    type = \"string\";\n  } else if (\n    (isNewExpression(parent) && key === \"arguments\") ||\n    (isCallExpression(parent) && key === \"arguments\") ||\n    (isFunction(parent) && key === \"params\")\n  ) {\n    type = \"param\";\n  } else if (isExpressionStatement(parent) && !isPlaceholder(node)) {\n    type = \"statement\";\n    ancestors = ancestors.slice(0, -1);\n  } else if (isStatement(node) && isPlaceholder(node)) {\n    type = \"statement\";\n  } else {\n    type = \"other\";\n  }\n\n  const { placeholders, placeholderNames } = !hasSyntacticPlaceholders\n    ? state.legacy\n    : state.syntactic;\n\n  placeholders.push({\n    name,\n    type,\n    resolve: ast => resolveAncestors(ast, ancestors),\n    isDuplicate: placeholderNames.has(name),\n  });\n  placeholderNames.add(name);\n}\n\nfunction resolveAncestors(ast: t.File, ancestors: TraversalAncestors) {\n  let parent: t.Node = ast;\n  for (let i = 0; i < ancestors.length - 1; i++) {\n    const { key, index } = ancestors[i];\n\n    if (index === undefined) {\n      parent = (parent as any)[key];\n    } else {\n      parent = (parent as any)[key][index];\n    }\n  }\n\n  const { key, index } = ancestors[ancestors.length - 1];\n\n  return { parent, key, index };\n}\n\ntype MetadataState = {\n  syntactic: {\n    placeholders: Placeholder[];\n    placeholderNames: Set<string>;\n  };\n  legacy: {\n    placeholders: Placeholder[];\n    placeholderNames: Set<string>;\n  };\n  placeholderAllowlist?: Set<string>;\n  placeholderPattern?: RegExp | false;\n  syntacticPlaceholders?: boolean;\n};\n\nfunction parseWithCodeFrame(\n  code: string,\n  parserOpts: ParserOpts,\n  syntacticPlaceholders?: boolean,\n): t.File {\n  const plugins = (parserOpts.plugins || []).slice();\n  if (syntacticPlaceholders !== false) {\n    plugins.push(\"placeholders\");\n  }\n\n  parserOpts = {\n    allowAwaitOutsideFunction: true,\n    allowReturnOutsideFunction: true,\n    allowNewTargetOutsideFunction: true,\n    allowSuperOutsideMethod: true,\n    allowYieldOutsideFunction: true,\n    sourceType: \"module\",\n    ...parserOpts,\n    plugins,\n  };\n\n  try {\n    return parse(code, parserOpts);\n  } catch (err) {\n    const loc = err.loc;\n    if (loc) {\n      err.message += \"\\n\" + codeFrameColumns(code, { start: loc });\n      err.code = \"BABEL_TEMPLATE_PARSE_ERROR\";\n    }\n    throw err;\n  }\n}\n","import {\n  blockStatement,\n  cloneNode,\n  emptyStatement,\n  expressionStatement,\n  identifier,\n  isStatement,\n  isStringLiteral,\n  stringLiteral,\n  validate,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nimport type { TemplateReplacements } from \"./options.ts\";\nimport type { Metadata, Placeholder } from \"./parse.ts\";\n\nexport default function populatePlaceholders(\n  metadata: Metadata,\n  replacements: TemplateReplacements,\n): t.File {\n  const ast = cloneNode(metadata.ast);\n\n  if (replacements) {\n    metadata.placeholders.forEach(placeholder => {\n      if (!Object.hasOwn(replacements, placeholder.name)) {\n        const placeholderName = placeholder.name;\n\n        throw new Error(\n          `Error: No substitution given for \"${placeholderName}\". If this is not meant to be a\n            placeholder you may want to consider passing one of the following options to @babel/template:\n            - { placeholderPattern: false, placeholderAllowlist: new Set(['${placeholderName}'])}\n            - { placeholderPattern: /^${placeholderName}$/ }`,\n        );\n      }\n    });\n    Object.keys(replacements).forEach(key => {\n      if (!metadata.placeholderNames.has(key)) {\n        throw new Error(`Unknown substitution \"${key}\" given`);\n      }\n    });\n  }\n\n  // Process in reverse order so AST mutation doesn't change indices that\n  // will be needed for later calls to `placeholder.resolve()`.\n  metadata.placeholders\n    .slice()\n    .reverse()\n    .forEach(placeholder => {\n      try {\n        applyReplacement(\n          placeholder,\n          ast,\n          (replacements && replacements[placeholder.name]) ?? null,\n        );\n      } catch (e) {\n        e.message = `@babel/template placeholder \"${placeholder.name}\": ${e.message}`;\n        throw e;\n      }\n    });\n\n  return ast;\n}\n\nfunction applyReplacement(\n  placeholder: Placeholder,\n  ast: t.File,\n  replacement: any,\n) {\n  // Track inserted nodes and clone them if they are inserted more than\n  // once to avoid injecting the same node multiple times.\n  if (placeholder.isDuplicate) {\n    if (Array.isArray(replacement)) {\n      replacement = replacement.map(node => cloneNode(node));\n    } else if (typeof replacement === \"object\") {\n      replacement = cloneNode(replacement);\n    }\n  }\n\n  const { parent, key, index } = placeholder.resolve(ast);\n\n  if (placeholder.type === \"string\") {\n    if (typeof replacement === \"string\") {\n      replacement = stringLiteral(replacement);\n    }\n    if (!replacement || !isStringLiteral(replacement)) {\n      throw new Error(\"Expected string substitution\");\n    }\n  } else if (placeholder.type === \"statement\") {\n    if (index === undefined) {\n      if (!replacement) {\n        replacement = emptyStatement();\n      } else if (Array.isArray(replacement)) {\n        replacement = blockStatement(replacement);\n      } else if (typeof replacement === \"string\") {\n        replacement = expressionStatement(identifier(replacement));\n      } else if (!isStatement(replacement)) {\n        replacement = expressionStatement(replacement);\n      }\n    } else {\n      if (replacement && !Array.isArray(replacement)) {\n        if (typeof replacement === \"string\") {\n          replacement = identifier(replacement);\n        }\n        if (!isStatement(replacement)) {\n          replacement = expressionStatement(replacement);\n        }\n      }\n    }\n  } else if (placeholder.type === \"param\") {\n    if (typeof replacement === \"string\") {\n      replacement = identifier(replacement);\n    }\n\n    if (index === undefined) throw new Error(\"Assertion failure.\");\n  } else {\n    if (typeof replacement === \"string\") {\n      replacement = identifier(replacement);\n    }\n    if (Array.isArray(replacement)) {\n      throw new Error(\"Cannot replace single expression with an array.\");\n    }\n  }\n\n  function set(parent: any, key: any, value: any) {\n    const node = parent[key] as t.Node;\n    parent[key] = value;\n    if (node.type === \"Identifier\" || node.type === \"Placeholder\") {\n      if (node.typeAnnotation) {\n        value.typeAnnotation = node.typeAnnotation;\n      }\n      if (node.optional) {\n        value.optional = node.optional;\n      }\n      if (node.decorators) {\n        value.decorators = node.decorators;\n      }\n    }\n  }\n\n  if (index === undefined) {\n    validate(parent, key, replacement);\n\n    set(parent, key, replacement);\n  } else {\n    const items: t.Node[] = (parent as any)[key].slice();\n\n    if (placeholder.type === \"statement\" || placeholder.type === \"param\") {\n      if (replacement == null) {\n        items.splice(index, 1);\n      } else if (Array.isArray(replacement)) {\n        items.splice(index, 1, ...replacement);\n      } else {\n        set(items, index, replacement);\n      }\n    } else {\n      set(items, index, replacement);\n    }\n\n    validate(parent, key, items);\n    (parent as any)[key] = items;\n  }\n}\n","import type { Formatter } from \"./formatters.ts\";\nimport type { TemplateOpts } from \"./options.ts\";\nimport type { Metadata } from \"./parse.ts\";\nimport { normalizeReplacements } from \"./options.ts\";\nimport parseAndBuildMetadata from \"./parse.ts\";\nimport populatePlaceholders from \"./populate.ts\";\n\nexport default function stringTemplate<T>(\n  formatter: Formatter<T>,\n  code: string,\n  opts: TemplateOpts,\n): (arg?: unknown) => T {\n  code = formatter.code(code);\n\n  let metadata: Metadata;\n\n  return (arg?: unknown) => {\n    const replacements = normalizeReplacements(arg);\n\n    if (!metadata) metadata = parseAndBuildMetadata(formatter, code, opts);\n\n    return formatter.unwrap(populatePlaceholders(metadata, replacements));\n  };\n}\n","import type { Formatter } from \"./formatters.ts\";\nimport type { TemplateReplacements, TemplateOpts } from \"./options.ts\";\nimport { normalizeReplacements } from \"./options.ts\";\nimport parseAndBuildMetadata from \"./parse.ts\";\nimport populatePlaceholders from \"./populate.ts\";\n\nexport default function literalTemplate<T>(\n  formatter: Formatter<T>,\n  tpl: string[],\n  opts: TemplateOpts,\n): (_: unknown[]) => (_: unknown) => T {\n  const { metadata, names } = buildLiteralData(formatter, tpl, opts);\n\n  return arg => {\n    const defaultReplacements: TemplateReplacements = {};\n    arg.forEach((replacement, i) => {\n      defaultReplacements[names[i]] = replacement;\n    });\n\n    return (arg: unknown) => {\n      const replacements = normalizeReplacements(arg);\n\n      if (replacements) {\n        Object.keys(replacements).forEach(key => {\n          if (Object.hasOwn(defaultReplacements, key)) {\n            throw new Error(\"Unexpected replacement overlap.\");\n          }\n        });\n      }\n\n      return formatter.unwrap(\n        populatePlaceholders(\n          metadata,\n          replacements\n            ? Object.assign(replacements, defaultReplacements)\n            : defaultReplacements,\n        ),\n      );\n    };\n  };\n}\n\nfunction buildLiteralData<T>(\n  formatter: Formatter<T>,\n  tpl: string[],\n  opts: TemplateOpts,\n) {\n  let prefix = \"BABEL_TPL$\";\n\n  const raw = tpl.join(\"\");\n\n  do {\n    // If there are cases where the template already contains $$BABEL_TPL$0 or any other\n    // matching pattern, we keep adding \"$$\" characters until a unique prefix\n    // is found.\n    prefix = \"$$\" + prefix;\n  } while (raw.includes(prefix));\n\n  const { names, code } = buildTemplateCode(tpl, prefix);\n\n  const metadata = parseAndBuildMetadata(formatter, formatter.code(code), {\n    parser: opts.parser,\n\n    // Explicitly include our generated names in the allowlist so users never\n    // have to think about whether their placeholder pattern will match.\n    placeholderAllowlist: new Set(\n      names.concat(\n        opts.placeholderAllowlist ? Array.from(opts.placeholderAllowlist) : [],\n      ),\n    ),\n    placeholderPattern: opts.placeholderPattern,\n    preserveComments: opts.preserveComments,\n    syntacticPlaceholders: opts.syntacticPlaceholders,\n  });\n\n  return { metadata, names };\n}\n\nfunction buildTemplateCode(\n  tpl: string[],\n  prefix: string,\n): { names: string[]; code: string } {\n  const names = [];\n\n  let code = tpl[0];\n\n  for (let i = 1; i < tpl.length; i++) {\n    const value = `${prefix}${i - 1}`;\n    names.push(value);\n\n    code += value + tpl[i];\n  }\n\n  return { names, code };\n}\n","import { merge, validate } from \"./options.ts\";\nimport type {\n  TemplateOpts,\n  PublicOpts,\n  PublicReplacements,\n} from \"./options.ts\";\nimport type { Formatter } from \"./formatters.ts\";\n\nimport stringTemplate from \"./string.ts\";\nimport literalTemplate from \"./literal.ts\";\n\nexport type TemplateBuilder<T> = {\n  // Build a new builder, merging the given options with the previous ones.\n  (opts: PublicOpts): TemplateBuilder<T>;\n\n  // Building from a string produces an AST builder function by default.\n  (tpl: string, opts?: PublicOpts): (replacements?: PublicReplacements) => T;\n\n  // Building from a template literal produces an AST builder function by default.\n  (\n    tpl: TemplateStringsArray,\n    ...args: unknown[]\n  ): (replacements?: PublicReplacements) => T;\n\n  // Allow users to explicitly create templates that produce ASTs, skipping\n  // the need for an intermediate function.\n  ast: {\n    (tpl: string, opts?: PublicOpts): T;\n    (tpl: TemplateStringsArray, ...args: unknown[]): T;\n  };\n};\n\n// Prebuild the options that will be used when parsing a `.ast` template.\n// These do not use a pattern because there is no way for users to pass in\n// replacement patterns to begin with, and disabling pattern matching means\n// users have more flexibility in what type of content they have in their\n// template JS.\nconst NO_PLACEHOLDER: TemplateOpts = validate({\n  placeholderPattern: false,\n});\n\nexport default function createTemplateBuilder<T>(\n  formatter: Formatter<T>,\n  defaultOpts?: TemplateOpts,\n): TemplateBuilder<T> {\n  const templateFnCache = new WeakMap();\n  const templateAstCache = new WeakMap();\n  const cachedOpts = defaultOpts || validate(null);\n\n  return Object.assign(\n    ((tpl, ...args) => {\n      if (typeof tpl === \"string\") {\n        if (args.length > 1) throw new Error(\"Unexpected extra params.\");\n        return extendedTrace(\n          stringTemplate(formatter, tpl, merge(cachedOpts, validate(args[0]))),\n        );\n      } else if (Array.isArray(tpl)) {\n        let builder = templateFnCache.get(tpl);\n        if (!builder) {\n          builder = literalTemplate(formatter, tpl, cachedOpts);\n          templateFnCache.set(tpl, builder);\n        }\n        return extendedTrace(builder(args));\n      } else if (typeof tpl === \"object\" && tpl) {\n        if (args.length > 0) throw new Error(\"Unexpected extra params.\");\n        return createTemplateBuilder(\n          formatter,\n          merge(cachedOpts, validate(tpl)),\n        );\n      }\n      throw new Error(`Unexpected template param ${typeof tpl}`);\n    }) as TemplateBuilder<T>,\n    {\n      ast: (tpl: string | string[], ...args: unknown[]) => {\n        if (typeof tpl === \"string\") {\n          if (args.length > 1) throw new Error(\"Unexpected extra params.\");\n          return stringTemplate(\n            formatter,\n            tpl,\n            merge(merge(cachedOpts, validate(args[0])), NO_PLACEHOLDER),\n          )();\n        } else if (Array.isArray(tpl)) {\n          let builder = templateAstCache.get(tpl);\n          if (!builder) {\n            builder = literalTemplate(\n              formatter,\n              tpl,\n              merge(cachedOpts, NO_PLACEHOLDER),\n            );\n            templateAstCache.set(tpl, builder);\n          }\n          return builder(args)();\n        }\n\n        throw new Error(`Unexpected template param ${typeof tpl}`);\n      },\n    },\n  );\n}\n\nfunction extendedTrace<Arg, Result>(\n  fn: (_: Arg) => Result,\n): (_: Arg) => Result {\n  // Since we lazy parse the template, we get the current stack so we have the\n  // original stack to append if it errors when parsing\n  const rootErr = new Error();\n\n  return (arg: Arg) => {\n    try {\n      return fn(arg);\n    } catch (err) {\n      // We slice off the top 3 items in the stack to remove the call to\n      // 'extendedTrace', and the anonymous builder function, with the final\n      // stripped line being the error message itself since we threw it\n      // in the first place and it doesn't matter.\n      err.stack += `\\n    =============\\n${rootErr.stack!.split(\"\\n\").slice(3).join(\"\\n\")}`;\n      throw err;\n    }\n  };\n}\n","import * as formatters from \"./formatters.ts\";\nimport createTemplateBuilder from \"./builder.ts\";\n\nexport const smart = createTemplateBuilder(formatters.smart);\nexport const statement = createTemplateBuilder(formatters.statement);\nexport const statements = createTemplateBuilder(formatters.statements);\nexport const expression = createTemplateBuilder(formatters.expression);\nexport const program = createTemplateBuilder(formatters.program);\n\ntype DefaultTemplateBuilder = typeof smart & {\n  smart: typeof smart;\n  statement: typeof statement;\n  statements: typeof statements;\n  expression: typeof expression;\n  program: typeof program;\n};\n\nexport default Object.assign(smart.bind(undefined) as DefaultTemplateBuilder, {\n  smart,\n  statement,\n  statements,\n  expression,\n  program,\n  ast: smart.ast,\n});\n\nexport type {\n  PublicOpts as Options,\n  PublicReplacements as Replacements,\n} from \"./options.ts\";\n"],"names":["smart","statements","statement","expression","program","validate","isStatement","isStringLiteral","formatters.smart","formatters.statement","formatters.statements","formatters.expression","formatters.program"],"mappings":"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"}