xml-model 1.2.0 → 1.3.1

package/vite/dist/node_modules/typescript-rtti/dist.esm/transformer/type-literal.js

@@ -0,0 +1,499 @@
+import ts from "typescript";
+import "../common/index.js";
+import { findRelativePathToFile } from "./find-relative-path.js";
+import { getPreferredExportForImport } from "./get-exports-for-symbol.js";
+import { literalNode } from "./literal-node.js";
+import { serialize } from "./serialize.js";
+import { hasFlag, isFlagType, typeHasValue, getTypeLocality, serializeEntityNameAsExpression, isInterfaceType, propertyPrepend, optionalExportRef, isNodeJS, hasFilesystemAccess, fileExists } from "./utils.js";
+import { forwardRef } from "./forward-ref.js";
+import { encodeParameter } from "./encode-parameter.js";
+import { createRequire } from "node:module";
+import { T_VOID, T_ENUM, T_UNION, T_INTERSECTION, T_NULL, T_UNDEFINED, T_UNKNOWN, T_ANY, T_TRUE, T_FALSE, T_THIS, T_MAPPED, T_TUPLE, T_ARRAY, T_GENERIC, T_FUNCTION, T_OBJECT, F_OPTIONAL, T_STAND_IN } from "../common/format.js";
+const require$1 = createRequire(import.meta.url);
+function typeLiteral(encoder, type, typeNode, options) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+  let ctx = encoder.ctx;
+  let containingSourceFile = ctx.sourceFile;
+  let checker = ctx.checker;
+  let program = ctx.program;
+  if (!type)
+    return ts.factory.createIdentifier("Object");
+  if ((type.flags & ts.TypeFlags.String) !== 0) {
+    return ts.factory.createIdentifier("String");
+  } else if ((type.flags & ts.TypeFlags.Number) !== 0) {
+    return ts.factory.createIdentifier("Number");
+  } else if ((type.flags & ts.TypeFlags.Boolean) !== 0) {
+    return ts.factory.createIdentifier("Boolean");
+  } else if ((type.flags & ts.TypeFlags.Void) !== 0) {
+    return serialize({ TΦ: T_VOID });
+  } else if ((type.flags & ts.TypeFlags.BigInt) !== 0) {
+    return ts.factory.createIdentifier("BigInt");
+  } else if (hasFlag(type.flags, ts.TypeFlags.EnumLiteral)) {
+    if (type.symbol && hasFlag(type.symbol.flags, ts.SymbolFlags.ConstEnum)) {
+      let unionType = type;
+      return serialize({
+        TΦ: T_ENUM,
+        n: (_a = type.symbol.name) !== null && _a !== void 0 ? _a : type.aliasSymbol.name,
+        v: unionType.types.reduce((s, t) => (s[t.symbol.name] = t.value, s), {})
+      });
+    }
+    return serialize({
+      TΦ: T_ENUM,
+      n: (_c = (_b = type.symbol) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : (_d = type.aliasSymbol) === null || _d === void 0 ? void 0 : _d.name,
+      e: literalNode(referToTypeWithIdentifier(encoder, type, typeNode, options))
+    });
+  } else if (type.isUnion()) {
+    return serialize({
+      TΦ: T_UNION,
+      t: type.types.map((x) => literalNode(encoder.referToType(x)))
+    });
+  } else if (type.isIntersection()) {
+    return serialize({
+      TΦ: T_INTERSECTION,
+      t: type.types.map((x) => literalNode(encoder.referToType(x)))
+    });
+  } else if (hasFlag(type.flags, ts.TypeFlags.Null)) {
+    return serialize({ TΦ: T_NULL });
+  } else if (hasFlag(type.flags, ts.TypeFlags.Undefined)) {
+    return serialize({ TΦ: T_UNDEFINED });
+  } else if (hasFlag(type.flags, ts.TypeFlags.Unknown)) {
+    return serialize({ TΦ: T_UNKNOWN });
+  } else if (hasFlag(type.flags, ts.TypeFlags.Any)) {
+    return serialize({ TΦ: T_ANY });
+  } else if (isFlagType(type, ts.TypeFlags.Literal)) {
+    if (type["intrinsicName"] === "true")
+      return serialize({ TΦ: T_TRUE });
+    else if (type["intrinsicName"] === "false")
+      return serialize({ TΦ: T_FALSE });
+    return serialize(type.value);
+  } else if (hasFlag(type.flags, ts.TypeFlags.TypeVariable)) {
+    if (type["isThisType"])
+      return serialize({ TΦ: T_THIS });
+    return ts.factory.createIdentifier("Object");
+  } else if ((type.flags & ts.TypeFlags.Object) !== 0) {
+    let objectType = type;
+    let isMapped = hasFlag(objectType.objectFlags, ts.ObjectFlags.Mapped);
+    let isInstantiated = hasFlag(objectType.objectFlags, ts.ObjectFlags.Instantiated);
+    if (isMapped) {
+      if (isInstantiated) {
+        let typeRef = type;
+        return serialize({
+          TΦ: T_MAPPED,
+          t: literalNode(encoder.referToType(typeRef.typeParameter)),
+          p: (_f = (_e = typeRef.aliasTypeArguments) === null || _e === void 0 ? void 0 : _e.map((t) => literalNode(encoder.referToType(t)))) !== null && _f !== void 0 ? _f : [],
+          m: serializeObjectMembers(typeRef, typeNode, encoder)
+        });
+      }
+    } else if ((objectType.objectFlags & ts.ObjectFlags.Reference) !== 0) {
+      let typeRef = type;
+      if (typeRef.target !== typeRef) {
+        if ((typeRef.target.objectFlags & ts.ObjectFlags.Tuple) !== 0) {
+          let tupleTypeRef = typeRef;
+          let tupleType = tupleTypeRef.target;
+          return serialize({
+            TΦ: T_TUPLE,
+            e: typeRef.typeArguments.map((e, i) => {
+              if (tupleType.labeledElementDeclarations) {
+                return {
+                  n: tupleType.labeledElementDeclarations[i].name.getText(),
+                  t: literalNode(encoder.referToType(e))
+                };
+              } else {
+                return {
+                  t: literalNode(encoder.referToType(e))
+                };
+              }
+            })
+          });
+        }
+        if (!typeRef.symbol)
+          debugger;
+        if (!typeRef.target.symbol)
+          debugger;
+        if (typeRef.target.symbol.name === "Array" && typeRef.typeArguments.length === 1) {
+          return serialize({
+            TΦ: T_ARRAY,
+            e: literalNode(encoder.referToType(typeRef.typeArguments[0]))
+          });
+        }
+        try {
+          return serialize({
+            TΦ: T_GENERIC,
+            t: literalNode(encoder.referToType(typeRef.target)),
+            p: ((_g = typeRef.typeArguments) !== null && _g !== void 0 ? _g : []).map((x) => literalNode(encoder.referToType(x)))
+          });
+        } catch (e) {
+          console.error(`RTTI: Error while serializing type '${typeRef.symbol.name}': ${e.message}`);
+          console.error(e);
+          throw e;
+        }
+      }
+    }
+    if (!type.symbol && typeNode && ts.isArrayTypeNode(typeNode)) {
+      let typeRef = checker.getTypeAtLocation(typeNode.elementType);
+      return serialize({
+        TΦ: T_ARRAY,
+        e: literalNode(encoder.referToType(typeRef))
+      });
+    }
+    if (!type.symbol) {
+      if (typeNode) {
+        console.warn(`RTTI: Could not resolve symbol for type node '${typeNode.getText()}'.`);
+      } else {
+        if (program.getCompilerOptions().noLib) {
+          console.warn(`RTTI: ${containingSourceFile.fileName}: ${(_h = ctx.locationHint) !== null && _h !== void 0 ? _h : "unknown location"}: Missing symbol for type with flags=${type.flags} without type node! 'Object' will be emitted for the type instead.`);
+          if (!ctx["__warnedNoLib"]) {
+            console.warn(`RTTI: ^-- You are compiling with noLib enabled, which may interfere with inferred array types. You may be able to work around this issue by explicitly declaring the array type instead of relying on inference. This notice is shown only once.`);
+            ctx["__warnedNoLib"] = true;
+          }
+        } else {
+          console.warn(`RTTI: ${containingSourceFile.fileName}: ${(_j = ctx.locationHint) !== null && _j !== void 0 ? _j : "unknown location"}: Missing symbol for type with flags=${type.flags} without type node! 'Object' will be emitted as the type instead. [please report]`);
+        }
+      }
+    }
+    let isDeclaredFunctionType = typeNode && ts.isFunctionTypeNode(typeNode);
+    if (isDeclaredFunctionType || (((_k = type.symbol) === null || _k === void 0 ? void 0 : _k.flags) & ts.SymbolFlags.Function) !== 0) {
+      let signatures = type.getCallSignatures();
+      if (signatures.length > 1) {
+        console.warn(`RTTI: ${containingSourceFile.fileName}: ${(_l = ctx.locationHint) !== null && _l !== void 0 ? _l : "unknown location"}: Function type had multiple call signatures, emitted type will only include thefirst one. We could use an isolated reproduction of this [please report]`);
+      }
+      if (signatures.length >= 1) {
+        let signature = signatures[0];
+        let returnType = signature.getReturnType();
+        let parameters = signature.getParameters();
+        let flags = "";
+        let missingParamDecls = false;
+        return serialize({
+          TΦ: T_FUNCTION,
+          r: literalNode(encoder.referToType(returnType)),
+          p: parameters.map((p) => {
+            var _a2;
+            let decl = p.valueDeclaration;
+            if (decl && ts.isParameter(decl)) {
+              return encodeParameter(encoder, decl);
+            } else {
+              if (!missingParamDecls) {
+                missingParamDecls = true;
+                console.warn(`RTTI: ${containingSourceFile.fileName}: ${(_a2 = ctx.locationHint) !== null && _a2 !== void 0 ? _a2 : "unknown location"}: Could not resolve declaration of parameter for function type. Initializer and flags for these parameters will be unavailable. [please report]`);
+              }
+              return {
+                n: p.name,
+                t: literalNode(forwardRef(encoder.referToType(checker.getTypeOfSymbolAtLocation(p, typeNode !== null && typeNode !== void 0 ? typeNode : encoder.ctx.currentTopStatement)))),
+                v: void 0,
+                f: ""
+                // cannot determine flags without a ParameterDeclaration
+              };
+            }
+          }),
+          f: flags
+        });
+      }
+      return ts.factory.createIdentifier(`Function`);
+    } else if (type.isClassOrInterface()) {
+      return referToTypeWithIdentifier(encoder, type, typeNode, options);
+    }
+    if (hasFlag(type.flags, ts.TypeFlags.StructuredType)) {
+      return structuredTypeLiteral(encoder, type, typeNode);
+    }
+    return ts.factory.createIdentifier("Object");
+  }
+  return ts.factory.createIdentifier("Object");
+}
+function structuredTypeLiteral(encoder, type, typeNode, name) {
+  return serialize({
+    TΦ: T_OBJECT,
+    n: name,
+    m: serializeObjectMembers(type, typeNode, encoder)
+  });
+}
+function serializeObjectMembers(type, typeNode, encoder) {
+  let members = [];
+  let props = type.getProperties();
+  for (let prop of props) {
+    let memberType = encoder.ctx.checker.getTypeOfSymbolAtLocation(prop, typeNode !== null && typeNode !== void 0 ? typeNode : encoder.ctx.currentTopStatement);
+    members.push({
+      n: prop.name,
+      f: `${hasFlag(prop.flags, ts.SymbolFlags.Optional) ? F_OPTIONAL : ""}`,
+      t: literalNode(encoder.referToType(memberType))
+    });
+  }
+  return members;
+}
+function referToTypeWithIdentifier(encoder, type, typeNode, options) {
+  var _a, _b, _c;
+  let ctx = encoder.ctx;
+  let program = ctx.program;
+  let sourceFile = (_b = (_a = type.symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.getSourceFile();
+  if (!sourceFile) {
+    return ts.factory.createIdentifier("Object");
+  }
+  if (!type.symbol)
+    return ts.factory.createIdentifier("Object");
+  if (program.isSourceFileDefaultLibrary(sourceFile) && !typeHasValue(type))
+    return ts.factory.createIdentifier(`Object`);
+  if (getTypeLocality(ctx, type, typeNode) === "imported")
+    return referToImportedTypeWithIdentifier(encoder, type, typeNode, (_c = options === null || options === void 0 ? void 0 : options.hoistImportsInCommonJS) !== null && _c !== void 0 ? _c : false);
+  else
+    return referToLocalTypeWithIdentifier(encoder, type);
+}
+function referToLocalTypeWithIdentifier(encoder, type) {
+  const ctx = encoder.ctx;
+  const checker = ctx.checker;
+  const containingSourceFile = ctx.sourceFile;
+  let expr;
+  if (typeHasValue(type)) {
+    let entityName = checker.symbolToEntityName(type.symbol, ts.SymbolFlags.Class, void 0, void 0);
+    if (!entityName) {
+      return serialize({
+        TΦ: T_STAND_IN,
+        name: void 0,
+        note: `(anonymous class)`
+      });
+    }
+    expr = serializeEntityNameAsExpression(entityName, containingSourceFile);
+  } else {
+    let symbolName = `IΦ${type.symbol.name}`;
+    expr = ts.factory.createIdentifier(symbolName);
+  }
+  return expr;
+}
+function getImportedPathForSymbol(ctx, symbol, typeNode) {
+  var _a, _b, _c, _d, _e;
+  const checker = ctx.checker;
+  if (!typeNode)
+    return [void 0, symbol, void 0];
+  let localSymbol;
+  if (ts.isExpressionWithTypeArguments(typeNode)) {
+    localSymbol = checker.getSymbolAtLocation(typeNode.expression);
+  } else if (ts.isTypeReferenceNode(typeNode)) {
+    let typeName = typeNode.typeName;
+    while (ts.isQualifiedName(typeName))
+      typeName = typeName.left;
+    localSymbol = checker.getSymbolAtLocation(typeName);
+  } else {
+    return [void 0, symbol, void 0];
+  }
+  let localDecl = (_a = localSymbol === null || localSymbol === void 0 ? void 0 : localSymbol.declarations) === null || _a === void 0 ? void 0 : _a[0];
+  if (!localDecl)
+    return [void 0, symbol, void 0];
+  let specifier;
+  let typeOnly = false;
+  if (ts.isImportClause(localDecl)) {
+    specifier = (_b = localDecl.parent) === null || _b === void 0 ? void 0 : _b.moduleSpecifier;
+    symbol = localSymbol;
+    typeOnly = ts.isTypeOnlyImportOrExportDeclaration(localDecl);
+  } else if (ts.isImportSpecifier(localDecl)) {
+    specifier = (_e = (_d = (_c = localDecl.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.parent) === null || _e === void 0 ? void 0 : _e.moduleSpecifier;
+    symbol = localSymbol;
+    typeOnly = ts.isTypeOnlyImportOrExportDeclaration(localDecl);
+  } else if (ts.isNamespaceImport(localDecl)) {
+    specifier = localDecl.parent.parent.moduleSpecifier;
+    typeOnly = ts.isTypeOnlyImportOrExportDeclaration(localDecl);
+  }
+  if (specifier)
+    return [specifier.text, symbol, typeOnly];
+  return [void 0, symbol, void 0];
+}
+function referToImportedTypeWithIdentifier(encoder, type, typeNode, hoistImportsInCommonJS) {
+  const ctx = encoder.ctx;
+  const checker = ctx.checker;
+  const program = ctx.program;
+  const containingSourceFile = ctx.sourceFile;
+  const importMap = ctx.importMap;
+  const isCommonJS = program.getCompilerOptions().module === ts.ModuleKind.CommonJS;
+  let [importPath, symbol, typeOnly] = findImportableSymbolForType(ctx, type, typeNode);
+  if (typeOnly)
+    return structuredTypeLiteral(encoder, type, typeNode, symbol.name);
+  if (!importPath)
+    return ts.factory.createIdentifier(`Object`);
+  if (!symbol || isExportedAsDefault(checker, symbol)) {
+    let defaultName = isInterfaceType(type) ? `IΦdefault` : "default";
+    if (isCommonJS && !hoistImportsInCommonJS) {
+      return ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("require"), [], [
+        ts.factory.createStringLiteral(importPath)
+      ]), defaultName);
+    } else {
+      let impo = importMap.get(`*default:${importPath}`);
+      if (!impo) {
+        importMap.set(`*default:${importPath}`, impo = {
+          importDeclaration: ctx.currentTopStatement,
+          isDefault: defaultName === "default",
+          isNamespace: defaultName !== "default",
+          localName: `LΦ_${ctx.freeImportReference++}`,
+          modulePath: importPath,
+          name: `*${defaultName}:${importPath}`,
+          refName: "",
+          referenced: true
+        });
+      }
+      if (defaultName === "default") {
+        return ts.factory.createIdentifier(impo.localName);
+      } else {
+        return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(impo.localName), defaultName);
+      }
+    }
+  } else {
+    let expr;
+    let exportName;
+    if (typeHasValue(type)) {
+      let entityName = checker.symbolToEntityName(symbol, ts.SymbolFlags.Class, void 0, void 0);
+      expr = serializeEntityNameAsExpression(entityName, containingSourceFile);
+    } else {
+      exportName = `IΦ${type.symbol.name}`;
+      expr = ts.factory.createIdentifier(exportName);
+    }
+    if (isCommonJS && !hoistImportsInCommonJS) {
+      return propertyPrepend(ts.factory.createCallExpression(ts.factory.createIdentifier("require"), [], [ts.factory.createStringLiteral(importPath)]), expr);
+    } else {
+      let impo = ctx.importMap.get(`*:${importPath}`);
+      if (!impo) {
+        ctx.importMap.set(`*:${importPath}`, impo = {
+          importDeclaration: ctx.currentTopStatement,
+          isDefault: false,
+          isNamespace: true,
+          localName: `LΦ_${ctx.freeImportReference++}`,
+          modulePath: importPath,
+          name: `*:${importPath}`,
+          refName: "",
+          referenced: true
+        });
+      }
+      if (!isCommonJS) {
+        return optionalExportRef(ts.factory.createIdentifier(impo.localName), expr);
+      } else {
+        return propertyPrepend(ts.factory.createIdentifier(impo.localName), expr);
+      }
+    }
+  }
+}
+function findImportableSymbolForType(ctx, type, typeNode) {
+  let symbol = type.symbol;
+  let importPath;
+  let typeOnly = false;
+  [importPath, symbol, typeOnly] = getImportedPathForSymbol(ctx, symbol, typeNode);
+  if (!importPath) {
+    [importPath, symbol] = inferImportPath(ctx, type, symbol);
+    typeOnly = false;
+  }
+  return [importPath, symbol, typeOnly];
+}
+function inferImportPath(ctx, type, symbol) {
+  var _a, _b;
+  const program = ctx.program;
+  const containingSourceFile = ctx.sourceFile;
+  const sourceFile = (_b = (_a = type.symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.getSourceFile();
+  const isCommonJS = program.getCompilerOptions().module === ts.ModuleKind.CommonJS;
+  let destFile = sourceFile.fileName;
+  let preferredExport = getPreferredExportForImport(program, containingSourceFile, symbol);
+  if (preferredExport) {
+    destFile = preferredExport.sourceFile.fileName;
+    symbol = preferredExport.symbol;
+  }
+  if (isCommonJS && isNodeJS()) {
+    if (destFile.endsWith("/index.d.ts"))
+      destFile = destFile.replace(/\/index\.d\.ts$/, "");
+    else if (destFile.endsWith("/index.js"))
+      destFile = destFile.replace(/\/index\.js$/, "");
+    else if (destFile.endsWith("/index.ts"))
+      destFile = destFile.replace(/\/index\.ts$/, "");
+  }
+  if (destFile.endsWith(".d.ts") && hasFilesystemAccess()) {
+    if (!fileExists(destFile.replace(/\.d\.ts$/, ".js"))) {
+      console.warn(`RTTI: warning: Cannot import symbol '${symbol.name}' from declaration file '${destFile}' because there is no corresponding Javascript file alongside the declaration file! Refusing to emit type references for this symbol.`);
+      return [null, symbol];
+    }
+  }
+  if (destFile.endsWith(".d.ts"))
+    destFile = destFile.replace(/\.d\.ts$/, "");
+  else if (destFile.endsWith(".ts"))
+    destFile = destFile.replace(/\.ts$/, ".js");
+  let relativePath = findRelativePathToFile(ctx.sourceFile.fileName, destFile);
+  let pathParts = relativePath.split("/");
+  let nodeModulesIndex = pathParts.indexOf("node_modules");
+  if (nodeModulesIndex >= 0) {
+    let originalPath = relativePath;
+    let pathToNodeModules = pathParts.slice(0, nodeModulesIndex + 1).join("/");
+    let packagePath = pathParts.slice(nodeModulesIndex + 1);
+    relativePath = packagePath.join("/");
+    if (packagePath.length > 0) {
+      let pathIntoPackageParts = packagePath.slice();
+      let packageName = pathIntoPackageParts.shift();
+      if (packageName.startsWith("@")) {
+        packageName += "/" + pathIntoPackageParts.shift();
+      }
+      if (isNodeJS()) {
+        let requireX = function(path2) {
+          return requireN(path2);
+        };
+        let requireN = require$1;
+        const fs = requireX("fs");
+        const path = requireX("path");
+        let pkgJsonPath = path.resolve(path.dirname(ctx.sourceFile.fileName), pathToNodeModules, packageName, "package.json");
+        if (!pkgJsonPath) {
+          throw new Error(`Failed to resolve path for package.json [file='${ctx.sourceFile.fileName}', node_modules='${pathToNodeModules}', packageName='${packageName}']`);
+          debugger;
+        }
+        let pkgJson;
+        if (ctx.pkgJsonMap.has(pkgJsonPath)) {
+          pkgJson = ctx.pkgJsonMap.get(pkgJsonPath);
+        } else {
+          try {
+            if (fs.existsSync(pkgJsonPath)) {
+              let buf = fs.readFileSync(pkgJsonPath);
+              let json = JSON.parse(buf.toString("utf-8"));
+              pkgJson = json;
+              ctx.pkgJsonMap.set(pkgJsonPath, pkgJson);
+            }
+          } catch (e) {
+            console.error(`RTTI: Caught error while reading ${pkgJsonPath}: ${e.message}`);
+            console.error(e);
+            console.error(`RTTI: Proceeding with potentially non-optimal import path '${relativePath}'`);
+          }
+        }
+        if (pkgJson) {
+          let absPathToNodeModules = path.resolve(path.dirname(ctx.sourceFile.fileName), pathToNodeModules);
+          let entrypoints = [pkgJson.main, pkgJson.module, pkgJson.browser].filter((x) => x);
+          for (let entrypoint of entrypoints) {
+            if (typeof entrypoint !== "string") {
+              continue;
+            }
+            let entrypointFile = path.resolve(path.dirname(pkgJsonPath), entrypoint);
+            let absolutePath = path.resolve(absPathToNodeModules, relativePath);
+            if (entrypointFile === absolutePath) {
+              relativePath = packageName;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  let modulePath;
+  if (relativePath) {
+    modulePath = relativePath;
+  } else {
+    if (globalThis.RTTI_TRACE)
+      console.warn(`RTTI: Cannot determine relative path from '${ctx.sourceFile.fileName}' to '${sourceFile.fileName}'! Using absolute path!`);
+    modulePath = destFile;
+  }
+  if (modulePath.startsWith("@types/")) {
+    modulePath = modulePath.replace(/^@types\//, "").replace(/\/.*/, "");
+  }
+  return [modulePath, symbol];
+}
+function dealias(checker, symbol) {
+  if (!symbol)
+    return void 0;
+  if (hasFlag(symbol.flags, ts.SymbolFlags.Alias))
+    return checker.getImmediateAliasedSymbol(symbol);
+  return symbol;
+}
+function isExportedAsDefault(checker, symbol) {
+  var _a;
+  return ((_a = dealias(checker, symbol)) === null || _a === void 0 ? void 0 : _a.name) === "default";
+}
+export {
+  structuredTypeLiteral,
+  typeLiteral
+};
+//# sourceMappingURL=type-literal.js.map