Launch Week Day 3: Introducing Organization Notifications in Socket.Learn More →
Socket
Book a DemoSign in
Socket
Book a DemoSign in

@babel/template

Package Overview
Dependencies
Maintainers
4
Versions
106
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@babel/template - npm Package Compare versions

Comparing version
7.18.10
 to
7.20.7
+1
lib/builder.js.map
{"version":3,"names":["NO_PLACEHOLDER","validate","placeholderPattern","createTemplateBuilder","formatter","defaultOpts","templateFnCache","WeakMap","templateAstCache","cachedOpts","Object","assign","tpl","args","length","Error","extendedTrace","stringTemplate","merge","Array","isArray","builder","get","literalTemplate","set","ast","fn","rootStack","error","stack","split","slice","join","arg","err"],"sources":["../src/builder.ts"],"sourcesContent":["import { merge, validate } from \"./options\";\nimport type { TemplateOpts, PublicOpts, PublicReplacements } from \"./options\";\nimport type { Formatter } from \"./formatters\";\n\nimport stringTemplate from \"./string\";\nimport literalTemplate from \"./literal\";\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 (tpl: TemplateStringsArray, ...args: Array<unknown>): (\n replacements?: PublicReplacements,\n ) => 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: Array<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 | Array<string>, ...args: Array<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 let rootStack = \"\";\n try {\n // error stack gets populated in IE only on throw\n // (https://msdn.microsoft.com/en-us/library/hh699850(v=vs.94).aspx)\n throw new Error();\n } catch (error) {\n if (error.stack) {\n // error.stack does not exists in IE <= 9\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 rootStack = error.stack.split(\"\\n\").slice(3).join(\"\\n\");\n }\n }\n\n return (arg: Arg) => {\n try {\n return fn(arg);\n } catch (err) {\n err.stack += `\\n =============\\n${rootStack}`;\n throw err;\n }\n };\n}\n"],"mappings":"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"}
+1
lib/formatters.js.map
{"version":3,"names":["assertExpressionStatement","makeStatementFormatter","fn","code","str","validate","unwrap","ast","program","body","slice","smart","length","statements","statement","Error","expression","start","stmt"],"sources":["../src/formatters.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: Array<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"],"mappings":";;;;;;AAAA;AAAyD;EAAhDA;AAAyB;AASlC,SAASC,sBAAsB,CAC7BC,EAAyC,EAC3B;EACd,OAAO;IAMLC,IAAI,EAAEC,GAAG,IAAK,2BAA0BA,GAAI,EAAC;IAC7CC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAClBC,MAAM,EAAGC,GAAW,IAAQ;MAC1B,OAAOL,EAAE,CAACK,GAAG,CAACC,OAAO,CAACC,IAAI,CAACC,KAAK,CAAC,CAAC,CAAC,CAAC;IACtC;EACF,CAAC;AACH;AAEO,MAAMC,KAAK,GAAGV,sBAAsB,CAACQ,IAAI,IAAI;EAClD,IAAIA,IAAI,CAACG,MAAM,GAAG,CAAC,EAAE;IACnB,OAAOH,IAAI;EACb,CAAC,MAAM;IACL,OAAOA,IAAI,CAAC,CAAC,CAAC;EAChB;AACF,CAAC,CAAC;AAAC;AAEI,MAAMI,UAAU,GAAGZ,sBAAsB,CAACQ,IAAI,IAAIA,IAAI,CAAC;AAAC;AAExD,MAAMK,SAAS,GAAGb,sBAAsB,CAACQ,IAAI,IAAI;EAGtD,IAAIA,IAAI,CAACG,MAAM,KAAK,CAAC,EAAE;IACrB,MAAM,IAAIG,KAAK,CAAC,0BAA0B,CAAC;EAC7C;EACA,IAAIN,IAAI,CAACG,MAAM,GAAG,CAAC,EAAE;IACnB,MAAM,IAAIG,KAAK,CAAC,0CAA0C,CAAC;EAC7D;EAEA,OAAON,IAAI,CAAC,CAAC,CAAC;AAChB,CAAC,CAAC;AAAC;AAEI,MAAMO,UAAmC,GAAG;EACjDb,IAAI,EAAEC,GAAG,IAAK,MAAKA,GAAI,KAAI;EAC3BC,QAAQ,EAAEE,GAAG,IAAI;IACf,IAAIA,GAAG,CAACC,OAAO,CAACC,IAAI,CAACG,MAAM,GAAG,CAAC,EAAE;MAC/B,MAAM,IAAIG,KAAK,CAAC,0CAA0C,CAAC;IAC7D;IACA,IAAIC,UAAU,CAACV,MAAM,CAACC,GAAG,CAAC,CAACU,KAAK,KAAK,CAAC,EAAE;MACtC,MAAM,IAAIF,KAAK,CAAC,+BAA+B,CAAC;IAClD;EACF,CAAC;EACDT,MAAM,EAAE,CAAC;IAAEE;EAAQ,CAAC,KAAK;IACvB,MAAM,CAACU,IAAI,CAAC,GAAGV,OAAO,CAACC,IAAI;IAC3BT,yBAAyB,CAACkB,IAAI,CAAC;IAC/B,OAAOA,IAAI,CAACF,UAAU;EACxB;AACF,CAAC;AAAC;AAEK,MAAMR,OAA6B,GAAG;EAC3CL,IAAI,EAAEC,GAAG,IAAIA,GAAG;EAChBC,QAAQ,EAAE,MAAM,CAAC,CAAC;EAClBC,MAAM,EAAEC,GAAG,IAAIA,GAAG,CAACC;AACrB,CAAC;AAAC"}
+1
lib/index.js.map
{"version":3,"names":["smart","createTemplateBuilder","formatters","statement","statements","expression","program","Object","assign","bind","undefined","ast"],"sources":["../src/index.ts"],"sourcesContent":["import * as formatters from \"./formatters\";\nimport createTemplateBuilder from \"./builder\";\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"],"mappings":";;;;;;AAAA;AACA;AAEO,MAAMA,KAAK,GAAG,IAAAC,gBAAqB,EAACC,UAAU,CAACF,KAAK,CAAC;AAAC;AACtD,MAAMG,SAAS,GAAG,IAAAF,gBAAqB,EAACC,UAAU,CAACC,SAAS,CAAC;AAAC;AAC9D,MAAMC,UAAU,GAAG,IAAAH,gBAAqB,EAACC,UAAU,CAACE,UAAU,CAAC;AAAC;AAChE,MAAMC,UAAU,GAAG,IAAAJ,gBAAqB,EAACC,UAAU,CAACG,UAAU,CAAC;AAAC;AAChE,MAAMC,OAAO,GAAG,IAAAL,gBAAqB,EAACC,UAAU,CAACI,OAAO,CAAC;AAAC;AAAA,eAUlDC,MAAM,CAACC,MAAM,CAACR,KAAK,CAACS,IAAI,CAACC,SAAS,CAAC,EAA4B;EAC5EV,KAAK;EACLG,SAAS;EACTC,UAAU;EACVC,UAAU;EACVC,OAAO;EACPK,GAAG,EAAEX,KAAK,CAACW;AACb,CAAC,CAAC;AAAA"}
+1
lib/literal.js.map
{"version":3,"names":["literalTemplate","formatter","tpl","opts","metadata","names","buildLiteralData","arg","defaultReplacements","forEach","replacement","i","replacements","normalizeReplacements","Object","keys","key","prototype","hasOwnProperty","call","Error","unwrap","populatePlaceholders","assign","nameSet","prefix","result","buildTemplateCode","Set","parseAndBuildMetadata","code","parser","placeholderWhitelist","concat","Array","from","placeholderPattern","preserveComments","syntacticPlaceholders","placeholders","some","placeholder","isDuplicate","has","name","length","value","push"],"sources":["../src/literal.ts"],"sourcesContent":["import type { Formatter } from \"./formatters\";\nimport type { TemplateReplacements, TemplateOpts } from \"./options\";\nimport { normalizeReplacements } from \"./options\";\nimport parseAndBuildMetadata from \"./parse\";\nimport populatePlaceholders from \"./populate\";\n\nexport default function literalTemplate<T>(\n formatter: Formatter<T>,\n tpl: Array<string>,\n opts: TemplateOpts,\n): (_: Array<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.prototype.hasOwnProperty.call(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: Array<string>,\n opts: TemplateOpts,\n) {\n let names;\n let nameSet: Set<string>;\n let metadata;\n let prefix = \"\";\n\n do {\n // If there are cases where the template already contains $0 or any other\n // matching pattern, we keep adding \"$\" characters until a unique prefix\n // is found.\n prefix += \"$\";\n const result = buildTemplateCode(tpl, prefix);\n\n names = result.names;\n nameSet = new Set(names);\n metadata = parseAndBuildMetadata(formatter, formatter.code(result.code), {\n parser: opts.parser,\n\n // Explicitly include our generated names in the whitelist so users never\n // have to think about whether their placeholder pattern will match.\n placeholderWhitelist: new Set(\n result.names.concat(\n opts.placeholderWhitelist\n ? Array.from(opts.placeholderWhitelist)\n : [],\n ),\n ),\n placeholderPattern: opts.placeholderPattern,\n preserveComments: opts.preserveComments,\n syntacticPlaceholders: opts.syntacticPlaceholders,\n });\n } while (\n metadata.placeholders.some(\n placeholder => placeholder.isDuplicate && nameSet.has(placeholder.name),\n )\n );\n\n return { metadata, names };\n}\n\nfunction buildTemplateCode(\n tpl: Array<string>,\n prefix: string,\n): { names: Array<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"],"mappings":"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"}
+1
lib/options.js.map
{"version":3,"names":["merge","a","b","placeholderWhitelist","placeholderPattern","preserveComments","syntacticPlaceholders","parser","validate","opts","Error","Set","RegExp","undefined","normalizeReplacements","replacements","Array","isArray","reduce","acc","replacement","i"],"sources":["../src/options.ts"],"sourcesContent":["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 placeholderWhitelist?: 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 * 'placeholderWhitelist' 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 placeholderWhitelist.\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};\n\nexport type TemplateOpts = {\n parser: ParserOpts;\n placeholderWhitelist?: 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 placeholderWhitelist = a.placeholderWhitelist,\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 placeholderWhitelist,\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 const {\n placeholderWhitelist,\n placeholderPattern,\n preserveComments,\n syntacticPlaceholders,\n ...parser\n } = opts || ({} as any);\n\n if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) {\n throw new Error(\n \"'.placeholderWhitelist' 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 (placeholderWhitelist != null || placeholderPattern != null)\n ) {\n throw new Error(\n \"'.placeholderWhitelist' and '.placeholderPattern' aren't compatible\" +\n \" with '.syntacticPlaceholders: true'\",\n );\n }\n\n return {\n parser,\n placeholderWhitelist: placeholderWhitelist || 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 = { [x: string]: unknown } | Array<unknown>;\nexport type TemplateReplacements = { [x: 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"],"mappings":";;;;;;;;;;;AAkDO,SAASA,KAAK,CAACC,CAAe,EAAEC,CAAe,EAAgB;EACpE,MAAM;IACJC,oBAAoB,GAAGF,CAAC,CAACE,oBAAoB;IAC7CC,kBAAkB,GAAGH,CAAC,CAACG,kBAAkB;IACzCC,gBAAgB,GAAGJ,CAAC,CAACI,gBAAgB;IACrCC,qBAAqB,GAAGL,CAAC,CAACK;EAC5B,CAAC,GAAGJ,CAAC;EAEL,OAAO;IACLK,MAAM,oBACDN,CAAC,CAACM,MAAM,EACRL,CAAC,CAACK,MAAM,CACZ;IACDJ,oBAAoB;IACpBC,kBAAkB;IAClBC,gBAAgB;IAChBC;EACF,CAAC;AACH;AAEO,SAASE,QAAQ,CAACC,IAAa,EAAgB;EACpD,IAAIA,IAAI,IAAI,IAAI,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;IAC5C,MAAM,IAAIC,KAAK,CAAC,2BAA2B,CAAC;EAC9C;EAEA,aAMID,IAAI,IAAK,CAAC,CAAS;IANjB;MACJN,oBAAoB;MACpBC,kBAAkB;MAClBC,gBAAgB;MAChBC;IAEF,CAAC;IADIC,MAAM;EAGX,IAAIJ,oBAAoB,IAAI,IAAI,IAAI,EAAEA,oBAAoB,YAAYQ,GAAG,CAAC,EAAE;IAC1E,MAAM,IAAID,KAAK,CACb,2DAA2D,CAC5D;EACH;EAEA,IACEN,kBAAkB,IAAI,IAAI,IAC1B,EAAEA,kBAAkB,YAAYQ,MAAM,CAAC,IACvCR,kBAAkB,KAAK,KAAK,EAC5B;IACA,MAAM,IAAIM,KAAK,CACb,mEAAmE,CACpE;EACH;EAEA,IAAIL,gBAAgB,IAAI,IAAI,IAAI,OAAOA,gBAAgB,KAAK,SAAS,EAAE;IACrE,MAAM,IAAIK,KAAK,CACb,2DAA2D,CAC5D;EACH;EAEA,IACEJ,qBAAqB,IAAI,IAAI,IAC7B,OAAOA,qBAAqB,KAAK,SAAS,EAC1C;IACA,MAAM,IAAII,KAAK,CACb,gEAAgE,CACjE;EACH;EACA,IACEJ,qBAAqB,KAAK,IAAI,KAC7BH,oBAAoB,IAAI,IAAI,IAAIC,kBAAkB,IAAI,IAAI,CAAC,EAC5D;IACA,MAAM,IAAIM,KAAK,CACb,qEAAqE,GACnE,sCAAsC,CACzC;EACH;EAEA,OAAO;IACLH,MAAM;IACNJ,oBAAoB,EAAEA,oBAAoB,IAAIU,SAAS;IACvDT,kBAAkB,EAChBA,kBAAkB,IAAI,IAAI,GAAGS,SAAS,GAAGT,kBAAkB;IAC7DC,gBAAgB,EAAEA,gBAAgB,IAAI,IAAI,GAAGQ,SAAS,GAAGR,gBAAgB;IACzEC,qBAAqB,EACnBA,qBAAqB,IAAI,IAAI,GAAGO,SAAS,GAAGP;EAChD,CAAC;AACH;AAKO,SAASQ,qBAAqB,CACnCC,YAAqB,EACC;EACtB,IAAIC,KAAK,CAACC,OAAO,CAACF,YAAY,CAAC,EAAE;IAC/B,OAAOA,YAAY,CAACG,MAAM,CAAC,CAACC,GAAG,EAAEC,WAAW,EAAEC,CAAC,KAAK;MAClDF,GAAG,CAAC,GAAG,GAAGE,CAAC,CAAC,GAAGD,WAAW;MAC1B,OAAOD,GAAG;IACZ,CAAC,EAAE,CAAC,CAAC,CAAC;EACR,CAAC,MAAM,IAAI,OAAOJ,YAAY,KAAK,QAAQ,IAAIA,YAAY,IAAI,IAAI,EAAE;IACnE,OAAQA,YAAY,IAAYF,SAAS;EAC3C;EAEA,MAAM,IAAIH,KAAK,CACb,oEAAoE,CACrE;AACH"}
+1
lib/parse.js.map
{"version":3,"names":["isCallExpression","isExpressionStatement","isFunction","isIdentifier","isJSXIdentifier","isNewExpression","isPlaceholder","isStatement","isStringLiteral","removePropertiesDeep","traverse","PATTERN","parseAndBuildMetadata","formatter","code","opts","placeholderWhitelist","placeholderPattern","preserveComments","syntacticPlaceholders","ast","parseWithCodeFrame","parser","validate","syntactic","placeholders","placeholderNames","Set","legacy","isLegacyRef","value","undefined","placeholderVisitorHandler","node","ancestors","state","name","Error","test","has","slice","parent","key","length","type","expectedNode","push","resolve","resolveAncestors","isDuplicate","add","i","index","parserOpts","plugins","allowReturnOutsideFunction","allowSuperOutsideMethod","sourceType","parse","err","loc","message","codeFrameColumns","start"],"sources":["../src/parse.ts"],"sourcesContent":["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, TraversalHandler } from \"@babel/types\";\nimport { parse } from \"@babel/parser\";\nimport { codeFrameColumns } from \"@babel/code-frame\";\nimport type { TemplateOpts, ParserOpts } from \"./options\";\nimport type { Formatter } from \"./formatters\";\n\nexport type Metadata = {\n ast: t.File;\n placeholders: Array<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 placeholderWhitelist,\n placeholderPattern,\n preserveComments,\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 syntactic: MetadataState[\"syntactic\"] = {\n placeholders: [],\n placeholderNames: new Set(),\n };\n const legacy: MetadataState[\"legacy\"] = {\n placeholders: [],\n placeholderNames: new Set(),\n };\n const isLegacyRef: MetadataState[\"isLegacyRef\"] = { value: undefined };\n\n traverse(ast, placeholderVisitorHandler as TraversalHandler<any>, {\n syntactic,\n legacy,\n isLegacyRef,\n placeholderWhitelist,\n placeholderPattern,\n syntacticPlaceholders,\n });\n\n return {\n ast,\n ...(isLegacyRef.value ? legacy : syntactic),\n };\n}\n\nfunction placeholderVisitorHandler(\n node: t.Node,\n ancestors: TraversalAncestors,\n state: MetadataState,\n) {\n let name: string;\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 } else {\n name = node.name.name;\n state.isLegacyRef.value = false;\n }\n } else if (state.isLegacyRef.value === false || state.syntacticPlaceholders) {\n return;\n } else if (isIdentifier(node) || isJSXIdentifier(node)) {\n name = node.name;\n state.isLegacyRef.value = true;\n } else if (isStringLiteral(node)) {\n name = node.value;\n state.isLegacyRef.value = true;\n } else {\n return;\n }\n\n if (\n !state.isLegacyRef.value &&\n (state.placeholderPattern != null || state.placeholderWhitelist != 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 \"'.placeholderWhitelist' and '.placeholderPattern' aren't compatible\" +\n \" with '.syntacticPlaceholders: true'\",\n );\n }\n\n if (\n state.isLegacyRef.value &&\n (state.placeholderPattern === false ||\n !(state.placeholderPattern || PATTERN).test(name)) &&\n !state.placeholderWhitelist?.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 } = state.isLegacyRef.value\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: Array<Placeholder>;\n placeholderNames: Set<string>;\n };\n legacy: {\n placeholders: Array<Placeholder>;\n placeholderNames: Set<string>;\n };\n isLegacyRef: {\n value?: boolean;\n };\n placeholderWhitelist?: 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 allowReturnOutsideFunction: true,\n allowSuperOutsideMethod: true,\n sourceType: \"module\",\n ...parserOpts,\n plugins,\n };\n\n try {\n // @ts-expect-error todo: use babel-types ast typings in Babel parser\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"],"mappings":"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"}
+1
lib/populate.js.map
{"version":3,"names":["blockStatement","cloneNode","emptyStatement","expressionStatement","identifier","isStatement","isStringLiteral","stringLiteral","validate","populatePlaceholders","metadata","replacements","ast","placeholders","forEach","placeholder","Object","prototype","hasOwnProperty","call","name","placeholderName","Error","keys","key","placeholderNames","has","slice","reverse","applyReplacement","e","message","replacement","isDuplicate","Array","isArray","map","node","parent","index","resolve","type","undefined","items","splice"],"sources":["../src/populate.ts"],"sourcesContent":["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\";\nimport type { Metadata, Placeholder } from \"./parse\";\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 (\n !Object.prototype.hasOwnProperty.call(replacements, placeholder.name)\n ) {\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, placeholderWhitelist: 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 if (index === undefined) {\n validate(parent, key, replacement);\n\n (parent as any)[key] = replacement;\n } else {\n const items: Array<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 items[index] = replacement;\n }\n } else {\n items[index] = replacement;\n }\n\n validate(parent, key, items);\n (parent as any)[key] = items;\n }\n}\n"],"mappings":"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"}
+1
lib/string.js.map
{"version":3,"names":["stringTemplate","formatter","code","opts","metadata","arg","replacements","normalizeReplacements","parseAndBuildMetadata","unwrap","populatePlaceholders"],"sources":["../src/string.ts"],"sourcesContent":["import type { Formatter } from \"./formatters\";\nimport type { TemplateOpts } from \"./options\";\nimport type { Metadata } from \"./parse\";\nimport { normalizeReplacements } from \"./options\";\nimport parseAndBuildMetadata from \"./parse\";\nimport populatePlaceholders from \"./populate\";\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"],"mappings":";;;;;;AAGA;AACA;AACA;AAEe,SAASA,cAAc,CACpCC,SAAuB,EACvBC,IAAY,EACZC,IAAkB,EACI;EACtBD,IAAI,GAAGD,SAAS,CAACC,IAAI,CAACA,IAAI,CAAC;EAE3B,IAAIE,QAAkB;EAEtB,OAAQC,GAAa,IAAK;IACxB,MAAMC,YAAY,GAAG,IAAAC,8BAAqB,EAACF,GAAG,CAAC;IAE/C,IAAI,CAACD,QAAQ,EAAEA,QAAQ,GAAG,IAAAI,cAAqB,EAACP,SAAS,EAAEC,IAAI,EAAEC,IAAI,CAAC;IAEtE,OAAOF,SAAS,CAACQ,MAAM,CAAC,IAAAC,iBAAoB,EAACN,QAAQ,EAAEE,YAAY,CAAC,CAAC;EACvE,CAAC;AACH"}
+3
-15
lib/builder.js

@@ -7,13 +7,8 @@ "use strict";

exports.default = createTemplateBuilder;
var _options = require("./options");
var _string = require("./string");
var _literal = require("./literal");
const NO_PLACEHOLDER = (0, _options.validate)({
placeholderPattern: false
});
function createTemplateBuilder(formatter, defaultOpts) {

@@ -29,3 +24,2 @@ const templateFnCache = new WeakMap();

let builder = templateFnCache.get(tpl);
if (!builder) {

@@ -35,3 +29,2 @@ builder = (0, _literal.default)(formatter, tpl, cachedOpts);

}
return extendedTrace(builder(args));

@@ -42,3 +35,2 @@ } else if (typeof tpl === "object" && tpl) {

}
throw new Error(`Unexpected template param ${typeof tpl}`);

@@ -52,3 +44,2 @@ }, {

let builder = templateAstCache.get(tpl);
if (!builder) {

@@ -58,6 +49,4 @@ builder = (0, _literal.default)(formatter, tpl, (0, _options.merge)(cachedOpts, NO_PLACEHOLDER));

}
return builder(args)();
}
throw new Error(`Unexpected template param ${typeof tpl}`);

@@ -67,6 +56,4 @@ }

}
function extendedTrace(fn) {
let rootStack = "";
try {

@@ -79,3 +66,2 @@ throw new Error();

}
return arg => {

@@ -89,2 +75,4 @@ try {

};
}
}
//# sourceMappingURL=builder.js.map
+3
-8
lib/formatters.js

@@ -7,9 +7,6 @@ "use strict";

exports.statements = exports.statement = exports.smart = exports.program = exports.expression = void 0;
var _t = require("@babel/types");
const {
assertExpressionStatement
} = _t;
function makeStatementFormatter(fn) {

@@ -24,3 +21,2 @@ return {

}
const smart = makeStatementFormatter(body => {

@@ -40,7 +36,5 @@ if (body.length > 1) {

}
if (body.length > 1) {
throw new Error("Found multiple statements but wanted one");
}
return body[0];

@@ -55,3 +49,2 @@ });

}
if (expression.unwrap(ast).start === 0) {

@@ -75,2 +68,4 @@ throw new Error("Parse result included parens.");

};
exports.program = program;
exports.program = program;
//# sourceMappingURL=formatters.js.map
+2
-5
lib/index.js

@@ -7,7 +7,4 @@ "use strict";

exports.statements = exports.statement = exports.smart = exports.program = exports.expression = exports.default = void 0;
var formatters = require("./formatters");
var _builder = require("./builder");
const smart = (0, _builder.default)(formatters.smart);

@@ -23,3 +20,2 @@ exports.smart = smart;

exports.program = program;
var _default = Object.assign(smart.bind(undefined), {

@@ -33,3 +29,4 @@ smart,

});
exports.default = _default;
exports.default = _default;
//# sourceMappingURL=index.js.map
+3
-13
lib/literal.js

@@ -7,9 +7,5 @@ "use strict";

exports.default = literalTemplate;
var _options = require("./options");
var _parse = require("./parse");
var _populate = require("./populate");
function literalTemplate(formatter, tpl, opts) {

@@ -27,3 +23,2 @@ const {

const replacements = (0, _options.normalizeReplacements)(arg);
if (replacements) {

@@ -36,3 +31,2 @@ Object.keys(replacements).forEach(key => {

}
return formatter.unwrap((0, _populate.default)(metadata, replacements ? Object.assign(replacements, defaultReplacements) : defaultReplacements));

@@ -42,3 +36,2 @@ };

}
function buildLiteralData(formatter, tpl, opts) {

@@ -49,3 +42,2 @@ let names;

let prefix = "";
do {

@@ -64,3 +56,2 @@ prefix += "$";

} while (metadata.placeholders.some(placeholder => placeholder.isDuplicate && nameSet.has(placeholder.name)));
return {

@@ -71,7 +62,5 @@ metadata,

}
function buildTemplateCode(tpl, prefix) {
const names = [];
let code = tpl[0];
for (let i = 1; i < tpl.length; i++) {

@@ -82,3 +71,2 @@ const value = `${prefix}${i - 1}`;

}
return {

@@ -88,2 +76,4 @@ names,

};
}
}
//# sourceMappingURL=literal.js.map
+10
-19
lib/options.js

@@ -10,3 +10,2 @@ "use strict";

const _excluded = ["placeholderWhitelist", "placeholderPattern", "preserveComments", "syntacticPlaceholders"];
function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

@@ -29,3 +28,2 @@

}
function validate(opts) {

@@ -35,32 +33,25 @@ if (opts != null && typeof opts !== "object") {

}
const _ref = opts || {},
{
placeholderWhitelist,
placeholderPattern,
preserveComments,
syntacticPlaceholders
} = _ref,
parser = _objectWithoutPropertiesLoose(_ref, _excluded);
{
placeholderWhitelist,
placeholderPattern,
preserveComments,
syntacticPlaceholders
} = _ref,
parser = _objectWithoutPropertiesLoose(_ref, _excluded);
if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) {
throw new Error("'.placeholderWhitelist' must be a Set, null, or undefined");
}
if (placeholderPattern != null && !(placeholderPattern instanceof RegExp) && placeholderPattern !== false) {
throw new Error("'.placeholderPattern' must be a RegExp, false, null, or undefined");
}
if (preserveComments != null && typeof preserveComments !== "boolean") {
throw new Error("'.preserveComments' must be a boolean, null, or undefined");
}
if (syntacticPlaceholders != null && typeof syntacticPlaceholders !== "boolean") {
throw new Error("'.syntacticPlaceholders' must be a boolean, null, or undefined");
}
if (syntacticPlaceholders === true && (placeholderWhitelist != null || placeholderPattern != null)) {
throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'");
}
return {

@@ -74,3 +65,2 @@ parser,

}
function normalizeReplacements(replacements) {

@@ -85,4 +75,5 @@ if (Array.isArray(replacements)) {

}
throw new Error("Template replacements must be an array, object, null, or undefined");
}
throw new Error("Template replacements must be an array, object, null, or undefined");
}
//# sourceMappingURL=options.js.map
+3
-23
lib/parse.js

@@ -7,9 +7,5 @@ "use strict";

exports.default = parseAndBuildMetadata;
var _t = require("@babel/types");
var _parser = require("@babel/parser");
var _codeFrame = require("@babel/code-frame");
const {

@@ -29,3 +25,2 @@ isCallExpression,

const PATTERN = /^[_$A-Z0-9]+$/;
function parseAndBuildMetadata(formatter, code, opts) {

@@ -66,8 +61,5 @@ const {

}
function placeholderVisitorHandler(node, ancestors, state) {
var _state$placeholderWhi;
let name;
if (isPlaceholder(node)) {

@@ -91,7 +83,5 @@ if (state.syntacticPlaceholders === false) {

}
if (!state.isLegacyRef.value && (state.placeholderPattern != null || state.placeholderWhitelist != null)) {
throw new Error("'.placeholderWhitelist' and '.placeholderPattern' aren't compatible" + " with '.syntacticPlaceholders: true'");
}
if (state.isLegacyRef.value && (state.placeholderPattern === false || !(state.placeholderPattern || PATTERN).test(name)) && !((_state$placeholderWhi = state.placeholderWhitelist) != null && _state$placeholderWhi.has(name))) {

@@ -107,3 +97,2 @@ return;

let type;
if (isStringLiteral(node) || isPlaceholder(node, {

@@ -123,3 +112,2 @@ expectedNode: "StringLiteral"

}
const {

@@ -137,6 +125,4 @@ placeholders,

}
function resolveAncestors(ast, ancestors) {
let parent = ast;
for (let i = 0; i < ancestors.length - 1; i++) {

@@ -147,3 +133,2 @@ const {

} = ancestors[i];
if (index === undefined) {

@@ -155,3 +140,2 @@ parent = parent[key];

}
const {

@@ -167,10 +151,7 @@ key,

}
function parseWithCodeFrame(code, parserOpts, syntacticPlaceholders) {
const plugins = (parserOpts.plugins || []).slice();
if (syntacticPlaceholders !== false) {
plugins.push("placeholders");
}
parserOpts = Object.assign({

@@ -183,3 +164,2 @@ allowReturnOutsideFunction: true,

});
try {

@@ -189,3 +169,2 @@ return (0, _parser.parse)(code, parserOpts);

const loc = err.loc;
if (loc) {

@@ -197,5 +176,6 @@ err.message += "\n" + (0, _codeFrame.codeFrameColumns)(code, {

}
throw err;
}
}
}
//# sourceMappingURL=parse.js.map
+3
-15
lib/populate.js

@@ -7,5 +7,3 @@ "use strict";

exports.default = populatePlaceholders;
var _t = require("@babel/types");
const {

@@ -22,6 +20,4 @@ blockStatement,

} = _t;
function populatePlaceholders(metadata, replacements) {
const ast = cloneNode(metadata.ast);
if (replacements) {

@@ -54,3 +50,2 @@ metadata.placeholders.forEach(placeholder => {

}
function applyReplacement(placeholder, ast, replacement) {

@@ -64,3 +59,2 @@ if (placeholder.isDuplicate) {

}
const {

@@ -71,3 +65,2 @@ parent,

} = placeholder.resolve(ast);
if (placeholder.type === "string") {

@@ -77,3 +70,2 @@ if (typeof replacement === "string") {

}
if (!replacement || !isStringLiteral(replacement)) {

@@ -98,3 +90,2 @@ throw new Error("Expected string substitution");

}
if (!isStatement(replacement)) {

@@ -109,3 +100,2 @@ replacement = expressionStatement(replacement);

}
if (index === undefined) throw new Error("Assertion failure.");

@@ -116,3 +106,2 @@ } else {

}
if (Array.isArray(replacement)) {

@@ -122,3 +111,2 @@ throw new Error("Cannot replace single expression with an array.");

}
if (index === undefined) {

@@ -129,3 +117,2 @@ validate(parent, key, replacement);

const items = parent[key].slice();
if (placeholder.type === "statement" || placeholder.type === "param") {

@@ -142,6 +129,7 @@ if (replacement == null) {

}
validate(parent, key, items);
parent[key] = items;
}
}
}
//# sourceMappingURL=populate.js.map
+3
-5
lib/string.js

@@ -7,9 +7,5 @@ "use strict";

exports.default = stringTemplate;
var _options = require("./options");
var _parse = require("./parse");
var _populate = require("./populate");
function stringTemplate(formatter, code, opts) {

@@ -23,2 +19,4 @@ code = formatter.code(code);

};
}
}
//# sourceMappingURL=string.js.map
+3
-3
package.json
{
"name": "@babel/template",
"version": "7.18.10",
"version": "7.20.7",
"description": "Generate an AST from a string template.",

@@ -20,4 +20,4 @@ "author": "The Babel Team (https://babel.dev/team)",

"@babel/code-frame": "^7.18.6",
"@babel/parser": "^7.18.10",
"@babel/types": "^7.18.10"
"@babel/parser": "^7.20.7",
"@babel/types": "^7.20.7"
},

@@ -24,0 +24,0 @@ "engines": {