582 lines
20 KiB
JavaScript
582 lines
20 KiB
JavaScript
/*!
|
|
* vue-router v5.2.0
|
|
* (c) 2026 Eduardo San Martin Morote
|
|
* @license MIT
|
|
*/
|
|
let scule = require("scule");
|
|
let nostics = require("nostics");
|
|
let pathe = require("pathe");
|
|
let local_pkg = require("local-pkg");
|
|
//#region src/unplugin/utils/index.ts
|
|
const ts = String.raw;
|
|
/**
|
|
* Pads a single-line string with spaces.
|
|
*
|
|
* @internal
|
|
*
|
|
* @param spaces The number of spaces to pad with.
|
|
* @param str The string to pad, none if omitted.
|
|
* @returns The padded string.
|
|
*/
|
|
function pad(spaces, str = "") {
|
|
return " ".repeat(spaces) + str;
|
|
}
|
|
/**
|
|
* Formats an array of union items as a multiline union type.
|
|
*
|
|
* @internal
|
|
*
|
|
* @param items The items to format.
|
|
* @param spaces The number of spaces to indent each line.
|
|
* @returns The formatted multiline union type.
|
|
*/
|
|
function formatMultilineUnion(items, spaces) {
|
|
return (items.length ? items : ["never"]).map((s) => `| ${s}`).join(`\n${pad(spaces)}`);
|
|
}
|
|
/**
|
|
* Converts a string value to a string literal, escaping as necessary.
|
|
*
|
|
* @internal
|
|
*
|
|
* @param str the string to convert to a string type
|
|
* @returns The string wrapped in single quotes and escaped.
|
|
* @example
|
|
* toStringLiteral('hello') // returns "'hello'"
|
|
* toStringLiteral("it's fine") // returns "'it\'s fine'"
|
|
*/
|
|
function toStringLiteral(str) {
|
|
return `'${str.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
|
|
}
|
|
//#endregion
|
|
//#region src/unplugin/core/utils.ts
|
|
function logTree(tree, log) {
|
|
log(printTree(tree));
|
|
}
|
|
const MAX_LEVEL = 1e3;
|
|
function printTree(tree, level = 0, parentPre = "", treeStr = "") {
|
|
if (typeof tree !== "object" || level >= MAX_LEVEL) return "";
|
|
if (tree instanceof Map) {
|
|
const total = tree.size;
|
|
let index = 0;
|
|
for (const [_key, child] of tree) {
|
|
const hasNext = index++ < total - 1;
|
|
const { children } = child;
|
|
treeStr += `${`${parentPre}${hasNext ? "├" : "└"}${"─" + (children.size > 0 ? "┬" : "")} `}${child}\n`;
|
|
if (children) treeStr += printTree(children, level + 1, `${parentPre}${hasNext ? "│" : " "} `);
|
|
}
|
|
} else {
|
|
const children = tree.children;
|
|
treeStr = `${tree}\n`;
|
|
if (children) treeStr += printTree(children, level + 1);
|
|
}
|
|
return treeStr;
|
|
}
|
|
/**
|
|
* Type safe alternative to Array.isArray
|
|
* https://github.com/microsoft/TypeScript/pull/48228
|
|
*/
|
|
const isArray = Array.isArray;
|
|
function trimExtension(path, extensions) {
|
|
for (const extension of extensions) {
|
|
const lastDot = path.endsWith(extension) ? -extension.length : 0;
|
|
if (lastDot < 0) return path.slice(0, lastDot);
|
|
}
|
|
return path;
|
|
}
|
|
function throttle(fn, wait, initialWait) {
|
|
let pendingExecutionTimeout = null;
|
|
let pendingExecution = false;
|
|
let executionTimeout = null;
|
|
return () => {
|
|
if (pendingExecutionTimeout == null) {
|
|
pendingExecutionTimeout = setTimeout(() => {
|
|
pendingExecutionTimeout = null;
|
|
if (pendingExecution) {
|
|
pendingExecution = false;
|
|
fn();
|
|
}
|
|
}, wait);
|
|
executionTimeout = setTimeout(() => {
|
|
executionTimeout = null;
|
|
fn();
|
|
}, initialWait);
|
|
} else if (executionTimeout == null) pendingExecution = true;
|
|
};
|
|
}
|
|
const LEADING_SLASH_RE = /^\//;
|
|
const TRAILING_SLASH_RE = /\/$/;
|
|
const ESCAPED_TRAILING_SLASH_RE = /\\\/$/;
|
|
function joinPath(...paths) {
|
|
let result = "";
|
|
for (const path of paths) result = result.replace(TRAILING_SLASH_RE, "") + (path && "/" + path.replace(LEADING_SLASH_RE, ""));
|
|
return result || "/";
|
|
}
|
|
function paramToName({ paramName, modifier, isSplat }) {
|
|
return `${isSplat ? "$" : ""}${paramName.charAt(0).toUpperCase() + paramName.slice(1)}${modifier}`;
|
|
}
|
|
/**
|
|
* Creates a name based of the node path segments.
|
|
*
|
|
* @param node - the node to get the path from
|
|
* @param parent - the parent node
|
|
* @returns a route name
|
|
*/
|
|
function getPascalCaseRouteName(node) {
|
|
if (node.parent?.isRoot() && node.value.pathSegment === "") return "Root";
|
|
let name = node.value.subSegments.map((segment) => {
|
|
if (typeof segment === "string") return (0, scule.pascalCase)(segment);
|
|
return paramToName(segment);
|
|
}).join("");
|
|
if (node.value.components.size && node.children.has("index")) name += "Parent";
|
|
const parent = node.parent;
|
|
return (parent && !parent.isRoot() ? getPascalCaseRouteName(parent).replace(/Parent$/, "") : "") + name;
|
|
}
|
|
/**
|
|
* Joins the path segments of a node into a name that corresponds to the filepath represented by the node.
|
|
*
|
|
* @param node - the node to get the path from
|
|
* @returns a route name
|
|
*/
|
|
function getFileBasedRouteName(node) {
|
|
if (!node.parent) return "";
|
|
return getFileBasedRouteName(node.parent) + "/" + (node.value.rawSegment === "index" ? "" : node.value.rawSegment);
|
|
}
|
|
function mergeRouteRecordOverride(a, b) {
|
|
const merged = {};
|
|
const keys = [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])];
|
|
for (const key of keys) if (key === "alias") merged[key] = [].concat(a.alias || [], b.alias || []);
|
|
else if (key === "meta") merged[key] = mergeDeep(a[key] || {}, b[key] || {});
|
|
else if (key === "params") merged[key] = {
|
|
path: {
|
|
...a[key]?.path,
|
|
...b[key]?.path
|
|
},
|
|
query: {
|
|
...a[key]?.query,
|
|
...b[key]?.query
|
|
}
|
|
};
|
|
else merged[key] = b[key] ?? a[key];
|
|
return merged;
|
|
}
|
|
function isObject(obj) {
|
|
return obj && typeof obj === "object";
|
|
}
|
|
function mergeDeep(...objects) {
|
|
return objects.reduce((prev, obj) => {
|
|
Object.keys(obj).forEach((key) => {
|
|
const pVal = prev[key];
|
|
const oVal = obj[key];
|
|
if (Array.isArray(pVal) && Array.isArray(oVal)) prev[key] = pVal.concat(...oVal);
|
|
else if (isObject(pVal) && isObject(oVal)) prev[key] = mergeDeep(pVal, oVal);
|
|
else prev[key] = oVal;
|
|
});
|
|
return prev;
|
|
}, {});
|
|
}
|
|
/**
|
|
* Returns a route path to be used by the router with any defined prefix from an absolute path to a file. Since it
|
|
* returns a route path, it will remove the extension from the file.
|
|
*
|
|
* @param options - RoutesFolderOption to apply
|
|
* @param filePath - absolute path to file
|
|
* @returns a route path to be used by the router with any defined prefix
|
|
*/
|
|
function asRoutePath({ src, path = "", extensions }, filePath) {
|
|
return trimExtension(typeof path === "string" ? path + filePath.slice(src.length + 1) : path(filePath), extensions);
|
|
}
|
|
function appendExtensionListToPattern(filePatterns, extensions) {
|
|
const extensionPattern = extensions.length === 1 ? extensions[0] : `.{${extensions.map((extension) => extension.replace(".", "")).join(",")}}`;
|
|
return Array.isArray(filePatterns) ? filePatterns.map((filePattern) => `${filePattern}${extensionPattern}`) : `${filePatterns}${extensionPattern}`;
|
|
}
|
|
var ImportsMap = class {
|
|
map = /* @__PURE__ */ new Map();
|
|
constructor() {}
|
|
add(path, importEntry) {
|
|
if (!this.map.has(path)) this.map.set(path, /* @__PURE__ */ new Map());
|
|
const imports = this.map.get(path);
|
|
if (typeof importEntry === "string") imports.set(importEntry, importEntry);
|
|
else imports.set(importEntry.as || importEntry.name, importEntry.name);
|
|
return this;
|
|
}
|
|
/**
|
|
* Check if the given path has the given import name.
|
|
*
|
|
* @param path - the path to check
|
|
* @param name - the import name to check
|
|
*/
|
|
has(path, name) {
|
|
return this.map.has(path) && this.map.get(path).has(name);
|
|
}
|
|
/**
|
|
* Add a default import. Alias for `add(path, { name: 'default', as })`.
|
|
*
|
|
* @param path - the path to import from
|
|
* @param as - the name to import as
|
|
*/
|
|
addDefault(path, as) {
|
|
return this.add(path, {
|
|
name: "default",
|
|
as
|
|
});
|
|
}
|
|
/**
|
|
* Get the list of imports for the given path.
|
|
*
|
|
* @param path - the path to get the import list for
|
|
* @returns the list of imports for the given path
|
|
*/
|
|
getImportList(path) {
|
|
if (!this.map.has(path)) return [];
|
|
return Array.from(this.map.get(path)).map(([as, name]) => ({
|
|
as: as || name,
|
|
name
|
|
}));
|
|
}
|
|
toString() {
|
|
let importStatements = "";
|
|
for (const [path, imports] of this.map) {
|
|
if (!imports.size) continue;
|
|
const fromImportPath = toStringLiteral(path);
|
|
if (imports.size === 1) {
|
|
const [[importName, maybeDefault]] = [...imports.entries()];
|
|
if (maybeDefault === "default") {
|
|
importStatements += `import ${importName} from ${fromImportPath}\n`;
|
|
continue;
|
|
}
|
|
}
|
|
importStatements += `import { ${Array.from(imports).map(([as, name]) => as === name ? name : `${name} as ${as}`).join(", ")} } from ${fromImportPath}\n`;
|
|
}
|
|
return importStatements;
|
|
}
|
|
get size() {
|
|
return this.map.size;
|
|
}
|
|
};
|
|
//#endregion
|
|
//#region src/unplugin/diagnostics.ts
|
|
/**
|
|
* Build-time diagnostics catalog for the Vue Router unplugin (file-based
|
|
* routing). These run in Node during the build, so they are not `__DEV__`
|
|
* guarded and are reported on every build.
|
|
*
|
|
* `why` keeps the original warning text (so existing substring assertions keep
|
|
* matching); the `VUE_ROUTER_B####` code identifies the source, so messages do not
|
|
* repeat a `[vue-router]` prefix. Codes are permanent: never rename or reuse.
|
|
*/
|
|
const diagnostics = /*#__PURE__*/ (0, nostics.defineDiagnostics)({
|
|
reporters: [/*#__PURE__*/ (0, nostics.createConsoleReporter)()],
|
|
codes: {
|
|
VUE_ROUTER_B0001: {
|
|
why: (p) => `In file "${p.filename}": Failed to process definePage: ${p.message}`,
|
|
fix: "Fix the syntax error in the definePage() macro of this file."
|
|
},
|
|
VUE_ROUTER_B0002: {
|
|
why: (p) => `In file "${p.filename}": ${p.message}`,
|
|
fix: "Avoid referencing <script setup> bindings inside definePage(); pass static values instead."
|
|
},
|
|
VUE_ROUTER_B0003: {
|
|
why: (p) => `In file "${p.filename}": Failed to extract definePage info: ${p.message}`,
|
|
fix: "Fix the syntax error in the definePage() macro of this file."
|
|
},
|
|
VUE_ROUTER_B0004: {
|
|
why: (p) => `route name must be a string literal or false. Found in file "${p.filename}".`,
|
|
fix: "Use a string literal or `false` for the route `name`."
|
|
},
|
|
VUE_ROUTER_B0005: {
|
|
why: (p) => `route path must be a string literal. Found in file "${p.filename}".`,
|
|
fix: "Use a string literal for the route `path`."
|
|
},
|
|
VUE_ROUTER_B0006: {
|
|
why: (p) => `Unrecognized default value in definePage() for query param "${p.paramName}". Typeof value: "${p.type}". This is a bug or a missing type of value, open an issue on https://github.com/vuejs/router and provide the definePage() code.`,
|
|
fix: "Report a reproduction at https://github.com/vuejs/router with the definePage() code."
|
|
},
|
|
VUE_ROUTER_B0007: {
|
|
why: (p) => `route alias must be a string literal or an array of string literals. Found in file "${p.filename}".`,
|
|
fix: "Use a string literal or an array of string literals for the route `alias`."
|
|
},
|
|
VUE_ROUTER_B0008: {
|
|
why: (p) => `route alias array must only contain string literals. Found "${p.found}" in file "${p.filename}".`,
|
|
fix: "Only use string literals inside the route `alias` array."
|
|
},
|
|
VUE_ROUTER_B0009: {
|
|
why: (p) => `Invalid extension "${p.ext}". Extensions must start with a dot.`,
|
|
fix: "Prefix the extension with a dot, e.g. \".vue\"."
|
|
},
|
|
VUE_ROUTER_B0010: {
|
|
why: (p) => `Segment "${p.segment}" is missing the closing ")". It will be treated as a static segment.`,
|
|
fix: "Add the closing \")\" to the dynamic segment."
|
|
},
|
|
VUE_ROUTER_B0011: {
|
|
why: (p) => `Invalid parameter in path "${p.segment}": parameter name cannot be empty. Using default name "pathMatch" for ':()'.`,
|
|
fix: "Give the parameter a name, e.g. \":id\"."
|
|
},
|
|
VUE_ROUTER_B0012: {
|
|
why: (p) => `Invalid JSON5 format of <${p.type}> content in ${p.filePath}\n${p.message}`,
|
|
fix: "Fix the JSON5 syntax in the route custom block."
|
|
},
|
|
VUE_ROUTER_B0013: {
|
|
why: (p) => `Invalid JSON format of <${p.type}> content in ${p.filePath}\n${p.message}`,
|
|
fix: "Fix the JSON syntax in the route custom block."
|
|
},
|
|
VUE_ROUTER_B0014: {
|
|
why: (p) => `Invalid YAML format of <${p.type}> content in ${p.filePath}\n${p.message}`,
|
|
fix: "Fix the YAML syntax in the route custom block."
|
|
},
|
|
VUE_ROUTER_B0015: {
|
|
why: (p) => `Language "${p.lang}" for <${p.type}> is not supported. Supported languages are: json5, json, yaml, yml. Found in ${p.filePath}.`,
|
|
fix: "Use one of the supported languages: json5, json, yaml, yml."
|
|
},
|
|
VUE_ROUTER_B0016: {
|
|
why: (p) => `Error decoding "${p.text}". Using original value`,
|
|
fix: "Ensure the value is correctly percent-encoded."
|
|
},
|
|
VUE_ROUTER_B0017: {
|
|
why: (p) => `A parameter without a name was found in the route "${p.fullPath}" in segment "${p.path}".`,
|
|
fix: "Report a reproduction at https://github.com/vuejs/router."
|
|
},
|
|
VUE_ROUTER_B0018: {
|
|
why: (p) => `Cannot statically determine if "parser" is raw in "${p.filename}" because it is re-exported from "${p.source}". The generated route param types may be incorrect. Define the parser inline in this file with \`defineParamParser\`/\`defineParamParserRaw\` instead of re-exporting it.`,
|
|
fix: "Define the parser inline with `defineParamParser`/`defineParamParserRaw` instead of re-exporting it."
|
|
},
|
|
VUE_ROUTER_B0019: {
|
|
why: (p) => `Parameter parser "${p.parser}" not found for route "${p.fullPath}".`,
|
|
fix: "Define the param parser or use one of the native parsers."
|
|
}
|
|
}
|
|
});
|
|
//#endregion
|
|
//#region src/unplugin/options.ts
|
|
/**
|
|
* Resolves an overridable option by calling the function with the existing
|
|
* value if it's a function, otherwise returning the passed `value`. If `value`
|
|
* is undefined, it returns the `defaultValue` instead.
|
|
*
|
|
* @param defaultValue default value for the option
|
|
* @param value and overridable option
|
|
*
|
|
* @internal
|
|
*/
|
|
function resolveOverridableOption(defaultValue, value) {
|
|
return typeof value === "function" ? value(defaultValue) : value ?? defaultValue;
|
|
}
|
|
/**
|
|
* Default options for experimental param parsers.
|
|
*/
|
|
const DEFAULT_PARAM_PARSERS_OPTIONS = {
|
|
dir: ["src/params"],
|
|
include: ["*.ts"],
|
|
exclude: ["*.test.{ts,js}", "*.spec.{ts,js}"]
|
|
};
|
|
/**
|
|
* Default plugin options.
|
|
*/
|
|
const DEFAULT_OPTIONS = {
|
|
extensions: [".vue"],
|
|
exclude: [],
|
|
routesFolder: "src/pages",
|
|
filePatterns: ["**/*"],
|
|
routeBlockLang: "json5",
|
|
getRouteName: getFileBasedRouteName,
|
|
importMode: "async",
|
|
root: process.cwd(),
|
|
dts: (0, local_pkg.isPackageExists)("typescript"),
|
|
logs: false,
|
|
_inspect: false,
|
|
pathParser: { dotNesting: true },
|
|
watch: !process.env.CI,
|
|
experimental: {}
|
|
};
|
|
function normalizeRoutesFolderOption(routesFolder) {
|
|
return (isArray(routesFolder) ? routesFolder : [routesFolder]).map((routeOption) => normalizeRouteOption(typeof routeOption === "string" ? { src: routeOption } : routeOption));
|
|
}
|
|
function normalizeRouteOption(routeOption) {
|
|
return {
|
|
...routeOption,
|
|
filePatterns: routeOption.filePatterns ? typeof routeOption.filePatterns === "function" ? routeOption.filePatterns : isArray(routeOption.filePatterns) ? routeOption.filePatterns : [routeOption.filePatterns] : void 0,
|
|
exclude: routeOption.exclude ? typeof routeOption.exclude === "function" ? routeOption.exclude : isArray(routeOption.exclude) ? routeOption.exclude : [routeOption.exclude] : void 0
|
|
};
|
|
}
|
|
/**
|
|
* Normalize user options with defaults and resolved paths.
|
|
*
|
|
* @param options - user provided options
|
|
* @returns normalized options
|
|
*/
|
|
function resolveOptions(options) {
|
|
const root = options.root || DEFAULT_OPTIONS.root;
|
|
const routesFolder = normalizeRoutesFolderOption(options.routesFolder || DEFAULT_OPTIONS.routesFolder).map((routeOption) => ({
|
|
...routeOption,
|
|
src: (0, pathe.resolve)(root, routeOption.src)
|
|
}));
|
|
const paramParsers = options.experimental?.paramParsers ? options.experimental.paramParsers === true ? DEFAULT_PARAM_PARSERS_OPTIONS : {
|
|
...DEFAULT_PARAM_PARSERS_OPTIONS,
|
|
...options.experimental.paramParsers
|
|
} : void 0;
|
|
const paramParsersDir = (paramParsers?.dir ? isArray(paramParsers.dir) ? paramParsers.dir : [paramParsers.dir] : []).map((dir) => (0, pathe.resolve)(root, dir));
|
|
const paramParsersInclude = paramParsers?.include ? isArray(paramParsers.include) ? paramParsers.include : [paramParsers.include] : DEFAULT_PARAM_PARSERS_OPTIONS.include;
|
|
const paramParsersExclude = paramParsers?.exclude ? isArray(paramParsers.exclude) ? paramParsers.exclude : [paramParsers.exclude] : DEFAULT_PARAM_PARSERS_OPTIONS.exclude;
|
|
const autoExportsDataLoaders = options.experimental?.autoExportsDataLoaders ? (isArray(options.experimental.autoExportsDataLoaders) ? options.experimental.autoExportsDataLoaders : [options.experimental.autoExportsDataLoaders]).map((path) => (0, pathe.resolve)(root, path)) : void 0;
|
|
const experimental = {
|
|
...options.experimental,
|
|
autoExportsDataLoaders,
|
|
paramParsers: paramParsers && {
|
|
...paramParsers,
|
|
dir: paramParsersDir,
|
|
include: paramParsersInclude,
|
|
exclude: paramParsersExclude
|
|
}
|
|
};
|
|
if (options.extensions) options.extensions = options.extensions.map((ext) => {
|
|
if (!ext.startsWith(".")) {
|
|
diagnostics.VUE_ROUTER_B0009({ ext });
|
|
return "." + ext;
|
|
}
|
|
return ext;
|
|
}).sort((a, b) => b.length - a.length);
|
|
const filePatterns = options.filePatterns ? isArray(options.filePatterns) ? options.filePatterns : [options.filePatterns] : DEFAULT_OPTIONS.filePatterns;
|
|
const exclude = options.exclude ? isArray(options.exclude) ? options.exclude : [options.exclude] : DEFAULT_OPTIONS.exclude;
|
|
return {
|
|
...DEFAULT_OPTIONS,
|
|
...options,
|
|
experimental,
|
|
routesFolder,
|
|
filePatterns,
|
|
exclude
|
|
};
|
|
}
|
|
/**
|
|
* Merge all the possible extensions as an array of unique values
|
|
* @param options - user provided options
|
|
* @internal
|
|
*/
|
|
function mergeAllExtensions(options) {
|
|
const allExtensions = new Set(options.extensions);
|
|
for (const routeOption of options.routesFolder) if (routeOption.extensions) {
|
|
const extensions = resolveOverridableOption(options.extensions, routeOption.extensions);
|
|
for (const ext of extensions) allExtensions.add(ext);
|
|
}
|
|
return Array.from(allExtensions.values());
|
|
}
|
|
//#endregion
|
|
Object.defineProperty(exports, "DEFAULT_OPTIONS", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return DEFAULT_OPTIONS;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "DEFAULT_PARAM_PARSERS_OPTIONS", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return DEFAULT_PARAM_PARSERS_OPTIONS;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "ESCAPED_TRAILING_SLASH_RE", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return ESCAPED_TRAILING_SLASH_RE;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "ImportsMap", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return ImportsMap;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "appendExtensionListToPattern", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return appendExtensionListToPattern;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "asRoutePath", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return asRoutePath;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "diagnostics", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return diagnostics;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "formatMultilineUnion", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return formatMultilineUnion;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "getFileBasedRouteName", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return getFileBasedRouteName;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "getPascalCaseRouteName", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return getPascalCaseRouteName;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "joinPath", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return joinPath;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "logTree", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return logTree;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "mergeAllExtensions", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return mergeAllExtensions;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "mergeRouteRecordOverride", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return mergeRouteRecordOverride;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "pad", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return pad;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "resolveOptions", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return resolveOptions;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "resolveOverridableOption", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return resolveOverridableOption;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "throttle", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return throttle;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "toStringLiteral", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return toStringLiteral;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "ts", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return ts;
|
|
}
|
|
});
|