From b54d9c1f3c4f990a9040c46eecc88fb8a87b6618 Mon Sep 17 00:00:00 2001 From: Martin McKeaveney Date: Fri, 3 Apr 2020 16:15:53 +0100 Subject: [PATCH 1/9] restructure server routes --- packages/server/middleware/routes/apps.js | 35 +++++ .../server/middleware/routes/authenticated.js | 129 ++++++++++++++++++ .../server/middleware/routes/builderRouter.js | 116 ++++++++++++++++ .../server/middleware/routes/components.js | 47 +++++++ packages/server/middleware/routes/index.js | 14 ++ packages/server/middleware/routes/pages.js | 70 ++++++++++ packages/server/middleware/routes/user.js | 33 +++++ 7 files changed, 444 insertions(+) create mode 100644 packages/server/middleware/routes/apps.js create mode 100644 packages/server/middleware/routes/authenticated.js create mode 100644 packages/server/middleware/routes/builderRouter.js create mode 100644 packages/server/middleware/routes/components.js create mode 100644 packages/server/middleware/routes/index.js create mode 100644 packages/server/middleware/routes/pages.js create mode 100644 packages/server/middleware/routes/user.js diff --git a/packages/server/middleware/routes/apps.js b/packages/server/middleware/routes/apps.js new file mode 100644 index 0000000000..dd20d79ab5 --- /dev/null +++ b/packages/server/middleware/routes/apps.js @@ -0,0 +1,35 @@ +const Router = require("@koa/router"); +const { + getPackageForBuilder, + getApps, +} = require("../utilities/builder") + +const router = Router(); + +router.get("/_builder/api/apps", async ctx => { + ctx.body = await getApps(config, ctx.master) + ctx.response.status = StatusCodes.OK +}) + +router.get("/_builder/api/:appname/appPackage", async ctx => { + const application = await ctx.master.getApplicationWithInstances( + ctx.params.appname + ) + ctx.body = await getPackageForBuilder(config, application) + ctx.response.status = StatusCodes.OK +}) + +router + .post("/_builder/api/:appname/backend", async ctx => { + await saveBackend( + config, + ctx.params.appname, + ctx.request.body.appDefinition, + ctx.request.body.accessLevels + ) + ctx.master.deleteLatestPackageFromCache(ctx.params.appname) + ctx.response.status = StatusCodes.OK + }) + + +module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/authenticated.js b/packages/server/middleware/routes/authenticated.js new file mode 100644 index 0000000000..5931469d89 --- /dev/null +++ b/packages/server/middleware/routes/authenticated.js @@ -0,0 +1,129 @@ +const Router = require("koa-router"); +const routeHandlers = require("../routeHandlers") + +const router = Router(); + +router.use(async (ctx, next) => { + if (ctx.isAuthenticated) { + await next() + } else { + ctx.response.status = StatusCodes.UNAUTHORIZED + } +}) + +router.post( + "/_builder/instance/:appname/:instanceid/api/upgradeData", + routeHandlers.upgradeData +) + +router.post("/:appname/api/changeMyPassword", routeHandlers.changeMyPassword) + +router.post( + "/_builder/instance/:appname/:instanceid/api/changeMyPassword", + routeHandlers.changeMyPassword +) + +router.post( + "/:appname/api/executeAction/:actionname", + routeHandlers.executeAction +) + +router.post( + "/_builder/instance/:appname/:instanceid/api/executeAction/:actionname", + routeHandlers.executeAction +) + +router.post("/:appname/api/createUser", routeHandlers.createUser) + +router.post( + "/_builder/instance/:appname/:instanceid/api/createUser", + routeHandlers.createUser +) + +router.post("/:appname/api/enableUser", routeHandlers.enableUser) + +router.post( + "/_builder/instance/:appname/:instanceid/api/enableUser", + routeHandlers.enableUser +) + +router.post("/:appname/api/disableUser", routeHandlers.disableUser) + +router.post( + "/_builder/instance/:appname/:instanceid/api/disableUser", + routeHandlers.disableUser +) + +router.get("/:appname/api/users", routeHandlers.getUsers) + +router.get( + "/_builder/instance/:appname/:instanceid/api/users", + routeHandlers.getUsers +) + +router.get("/:appname/api/accessLevels", routeHandlers.getAccessLevels) + +router.get( + "/_builder/instance/:appname/:instanceid/api/accessLevels", + routeHandlers.getAccessLevels +) + +router.get("/:appname/api/listRecords/*", routeHandlers.listRecordsGet) + +router.get( + "/_builder/instance/:appname/:instanceid/api/listRecords/*", + routeHandlers.listRecordsGet +) + +router.post("/:appname/api/listRecords/*", routeHandlers.listRecordsPost) + +router.post( + "/_builder/instance/:appname/:instanceid/api/listRecords/*", + routeHandlers.listRecordsPost +) + +router.post("/:appname/api/aggregates/*", routeHandlers.aggregatesPost) + +router.post( + "/_builder/instance/:appname/:instanceid/api/aggregates/*", + routeHandlers.aggregatesPost +) + +router.post("/:appname/api/files/*", routeHandlers.postFiles) + +router.post( + "/_builder/instance/:appname/:instanceid/api/files/*", + routeHandlers.postFiles +) + +router.post("/:appname/api/record/*", routeHandlers.saveRecord) + +router.post( + "/_builder/instance/:appname/:instanceid/api/record/*", + routeHandlers.saveRecord +) + +router.get("/:appname/api/lookup_field/*", routeHandlers.lookupField) + +router.get( + "/_builder/instance/:appname/:instanceid/api/lookup_field/*", + routeHandlers.lookupField +) + +router.get("/:appname/api/record/*", routeHandlers.getRecord) + +router.get( + "/_builder/instance/:appname/:instanceid/api/record/*", + routeHandlers.getRecord +) + +router.del("/:appname/api/record/*", routeHandlers.deleteRecord) + +router.del( + "/_builder/instance/:appname/:instanceid/api/record/*", + routeHandlers.deleteRecord +) + +router.post("/:appname/api/apphierarchy", routeHandlers.saveAppHierarchy) + +module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/builderRouter.js b/packages/server/middleware/routes/builderRouter.js new file mode 100644 index 0000000000..a9960a0b26 --- /dev/null +++ b/packages/server/middleware/routes/builderRouter.js @@ -0,0 +1,116 @@ +const Router = require("@koa/router") +const session = require("./session") +const StatusCodes = require("../utilities/statusCodes") +const { resolve } = require("path") +const send = require("koa-send") +const routeHandlers = require("./routeHandlers") +const { + componentRoutes, + appsRoutes, + pageRoutes, + userRoutes, + authenticatedRoutes +} = require("./"); + +const builderPath = resolve(__dirname, "../builder") + +module.exports = (config, app) => { + const router = new Router() + + router + .use(session(config, app)) + .use(async (ctx, next) => { + ctx.sessionId = ctx.session._sessCtx.externalKey + ctx.session.accessed = true + + const pathParts = ctx.path.split("/") + + if (pathParts.length < 2) { + ctx.throw(StatusCodes.NOT_FOUND, "App Name not declared") + } + + const appname = pathParts[1] + ctx.set("x-bbappname", appname) + + if (appname === "_builder") { + if (!config.dev) { + ctx.response.status = StatusCodes.FORBIDDEN + ctx.body = "run in dev mode to access builder" + return + } + + if (ctx.path.startsWith("/_builder/instance/_master")) { + const { + instance, + publicPath, + sharedPath, + } = await ctx.master.getFullAccessApiForMaster() + ctx.instance = instance + ctx.publicPath = publicPath + ctx.sharedPath = sharedPath + ctx.isAuthenticated = !!ctx.instance + } else if (ctx.path.startsWith("/_builder/instance")) { + const builderAppName = pathParts[3] + const instanceId = pathParts[4] + const { + bbInstance, + publicPath, + sharedPath, + } = await ctx.master.getFullAccessApiForInstanceId( + builderAppName, + instanceId + ) + ctx.instance = bbInstance + ctx.publicPath = publicPath + ctx.sharedPath = sharedPath + ctx.isAuthenticated = !!ctx.instance + } + + await next() + } else { + const instance = await ctx.master.getInstanceApiForSession( + appname, + ctx.sessionId + ) + + ctx.instance = instance.instance + ctx.publicPath = instance.publicPath + ctx.sharedPath = instance.sharedPath + ctx.isAuthenticated = !!instance.instance + + await next() + } + }) + + router.get("/_builder", async ctx => { + await send(ctx, "/index.html", { root: builderPath }) + }) + router.get("/_builder/*", async (ctx, next) => { + const path = ctx.path.replace("/_builder", "") + + const isFile = new RegExp(/(.+\..{1,5})/g).test(path) + + if (path.startsWith("/api/") || path.startsWith("/instance/")) { + await next() + } else if (isFile) { + await send(ctx, path, { root: builderPath }) + } else { + await send(ctx, "/index.html", { root: builderPath }) + } + }) + + router.use(userRoutes.routes()); + router.use(appsRoutes.routes()) + router.use(componentRoutes.routes()); + router.use(pageRoutes.routes()); + + router.get("/:appname", async ctx => { + await send(ctx, "/index.html", { root: ctx.publicPath }) + }) + router.get("/:appname/*", routeHandlers.appDefault) + router.get("/_builder/instance/:appname/:instanceid/*", routeHandlers.appDefault) + + router.use(authenticatedRoutes.routes()); + + return router +} diff --git a/packages/server/middleware/routes/components.js b/packages/server/middleware/routes/components.js new file mode 100644 index 0000000000..bc52863966 --- /dev/null +++ b/packages/server/middleware/routes/components.js @@ -0,0 +1,47 @@ +const Router = require("koa-router"); +const send = require("koa-send") +const { + getComponentDefinitions, + componentLibraryInfo, +} = require("../../utilities/builder") + + +const router = Router(); + +router.get("/_builder/api/:appname/components", async ctx => { + try { + ctx.body = getComponentDefinitions( + config, + ctx.params.appname, + ctx.query.lib + ) + ctx.response.status = StatusCodes.OK + } catch (e) { + if (e.status) { + ctx.response.status = e.status + } else { + throw e + } + } +}) + +router.get("/_builder/api/:appname/componentlibrary", async ctx => { + const info = await componentLibraryInfo( + config, + ctx.params.appname, + ctx.query.lib ? decodeURI(ctx.query.lib) : "" + ) + ctx.body = info.components + ctx.response.status = StatusCodes.OK +}) + +router.get("/_builder/:appname/componentlibrary", async ctx => { + const info = await componentLibraryInfo( + config, + ctx.params.appname, + ctx.query.lib + ) + await send(ctx, info.components._lib || "index.js", { root: info.libDir }) +}) + +module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/index.js b/packages/server/middleware/routes/index.js new file mode 100644 index 0000000000..1efaadbaeb --- /dev/null +++ b/packages/server/middleware/routes/index.js @@ -0,0 +1,14 @@ +const screenRoutes = require("./screens"); +const pageRoutes = require("./pages"); +const componentRoutes = require("./components"); +const userRoutes = require("./user"); +const appsRoutes = require("./apps"); +const authenticatedRoutes = require("./authenticated"); + +module.exports = { + screenRoutes, + pageRoutes, + componentRoutes, + authRoutes, + appsRoutes +}; \ No newline at end of file diff --git a/packages/server/middleware/routes/pages.js b/packages/server/middleware/routes/pages.js new file mode 100644 index 0000000000..ee954b36ff --- /dev/null +++ b/packages/server/middleware/routes/pages.js @@ -0,0 +1,70 @@ +const Router = require("@koa/router"); +const { + listScreens, + saveScreen, + buildPage +} = require("../../utilities/builder") + + +const router = Router() + +router.get("/_builder/api/:appname/pages/:pagename/screens", async ctx => { + ctx.body = await listScreens( + config, + ctx.params.appname, + ctx.params.pagename + ) + ctx.response.status = StatusCodes.OK +}) + +router + .post("/_builder/api/:appname/pages/:pagename/screen", async ctx => { + ctx.body = await saveScreen( + config, + ctx.params.appname, + ctx.params.pagename, + ctx.request.body + ) + ctx.response.status = StatusCodes.OK + }) + +router + .patch("/_builder/api/:appname/pages/:pagename/screen", async ctx => { + await renameScreen( + config, + ctx.params.appname, + ctx.params.pagename, + ctx.request.body.oldname, + ctx.request.body.newname + ) + ctx.response.status = StatusCodes.OK + }) + +router + .delete("/_builder/api/:appname/pages/:pagename/screen/*", async ctx => { + const name = ctx.request.path.replace( + `/_builder/api/${ctx.params.appname}/pages/${ctx.params.pagename}/screen/`, + "" + ) + + await deleteScreen( + config, + ctx.params.appname, + ctx.params.pagename, + decodeURI(name) + ) + + ctx.response.status = StatusCodes.OK +}) + +router.post("/_builder/api/:appname/pages/:pageName", async ctx => { + await buildPage( + config, + ctx.params.appname, + ctx.params.pageName, + ctx.request.body + ) + ctx.response.status = StatusCodes.OK +}) + +module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/user.js b/packages/server/middleware/routes/user.js new file mode 100644 index 0000000000..72e8ac717b --- /dev/null +++ b/packages/server/middleware/routes/user.js @@ -0,0 +1,33 @@ +const Router = require("@koa/router") +const routeHandlers = require("../routeHandlers") + +const router = new Router() + +router.post("/:appname/api/authenticate", routeHandlers.authenticate) + +router.post( + "/_builder/instance/:appname/:instanceid/api/authenticate", + routeHandlers.authenticate +) + +router.post( + "/_builder/instance/:appname/:instanceid/api/setPasswordFromTemporaryCode", + routeHandlers.setPasswordFromTemporaryCode +) + +router.post( + "/_builder/instance/:appname/:instanceid/api/createTemporaryAccess", + routeHandlers.createTemporaryAccess +) + +router.post( + "/:appname/api/createTemporaryAccess", + routeHandlers.createTemporaryAccess +) + +router.post( + "/:appname/api/setPasswordFromTemporaryCode", + routeHandlers.setPasswordFromTemporaryCode +) + +module.exports = router \ No newline at end of file From 2c03ac761c0a59a2776e14e546ffc02f7c1bdc72 Mon Sep 17 00:00:00 2001 From: Martin McKeaveney Date: Fri, 3 Apr 2020 17:35:20 +0100 Subject: [PATCH 2/9] restructure server --- packages/server/app.js | 2 +- packages/server/middleware/routes/apps.js | 3 ++- packages/server/middleware/routes/authenticated.js | 2 +- packages/server/middleware/routes/builderRouter.js | 6 +++--- packages/server/middleware/routes/components.js | 2 +- packages/server/middleware/routes/index.js | 7 +++---- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/packages/server/app.js b/packages/server/app.js index f56d4c8541..3b95d2364f 100644 --- a/packages/server/app.js +++ b/packages/server/app.js @@ -1,5 +1,5 @@ const Koa = require("koa") -const router = require("./middleware/routers") +const router = require("./middleware/routes/builderRouter") const koaBody = require("koa-body") const initialiseRuntimePackages = require("./initialise/initialiseRuntimePackages") diff --git a/packages/server/middleware/routes/apps.js b/packages/server/middleware/routes/apps.js index dd20d79ab5..45ddceb96d 100644 --- a/packages/server/middleware/routes/apps.js +++ b/packages/server/middleware/routes/apps.js @@ -2,7 +2,8 @@ const Router = require("@koa/router"); const { getPackageForBuilder, getApps, -} = require("../utilities/builder") +} = require("../../utilities/builder") + const router = Router(); diff --git a/packages/server/middleware/routes/authenticated.js b/packages/server/middleware/routes/authenticated.js index 5931469d89..d6c791aedc 100644 --- a/packages/server/middleware/routes/authenticated.js +++ b/packages/server/middleware/routes/authenticated.js @@ -1,4 +1,4 @@ -const Router = require("koa-router"); +const Router = require("@koa/router"); const routeHandlers = require("../routeHandlers") const router = Router(); diff --git a/packages/server/middleware/routes/builderRouter.js b/packages/server/middleware/routes/builderRouter.js index a9960a0b26..e47e45ed09 100644 --- a/packages/server/middleware/routes/builderRouter.js +++ b/packages/server/middleware/routes/builderRouter.js @@ -1,9 +1,9 @@ const Router = require("@koa/router") -const session = require("./session") -const StatusCodes = require("../utilities/statusCodes") +const session = require("../session") +const StatusCodes = require("../../utilities/statusCodes") const { resolve } = require("path") const send = require("koa-send") -const routeHandlers = require("./routeHandlers") +const routeHandlers = require("../routeHandlers") const { componentRoutes, appsRoutes, diff --git a/packages/server/middleware/routes/components.js b/packages/server/middleware/routes/components.js index bc52863966..e89fec6b3b 100644 --- a/packages/server/middleware/routes/components.js +++ b/packages/server/middleware/routes/components.js @@ -1,4 +1,4 @@ -const Router = require("koa-router"); +const Router = require("@koa/router"); const send = require("koa-send") const { getComponentDefinitions, diff --git a/packages/server/middleware/routes/index.js b/packages/server/middleware/routes/index.js index 1efaadbaeb..5cac9f21ff 100644 --- a/packages/server/middleware/routes/index.js +++ b/packages/server/middleware/routes/index.js @@ -1,4 +1,3 @@ -const screenRoutes = require("./screens"); const pageRoutes = require("./pages"); const componentRoutes = require("./components"); const userRoutes = require("./user"); @@ -6,9 +5,9 @@ const appsRoutes = require("./apps"); const authenticatedRoutes = require("./authenticated"); module.exports = { - screenRoutes, pageRoutes, componentRoutes, - authRoutes, - appsRoutes + appsRoutes, + userRoutes, + authenticatedRoutes }; \ No newline at end of file From 19e5be19bf453ee9f8462d35b9a6d8962ccac18c Mon Sep 17 00:00:00 2001 From: Martin McKeaveney Date: Mon, 6 Apr 2020 09:09:48 +0100 Subject: [PATCH 3/9] config in context --- packages/server/middleware/routes/apps.js | 2 +- packages/server/middleware/routes/builderRouter.js | 1 + packages/server/middleware/routes/components.js | 6 +++--- packages/server/middleware/routes/pages.js | 2 +- 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/packages/server/middleware/routes/apps.js b/packages/server/middleware/routes/apps.js index 45ddceb96d..941be4eabc 100644 --- a/packages/server/middleware/routes/apps.js +++ b/packages/server/middleware/routes/apps.js @@ -23,7 +23,7 @@ router.get("/_builder/api/:appname/appPackage", async ctx => { router .post("/_builder/api/:appname/backend", async ctx => { await saveBackend( - config, + ctx.config, ctx.params.appname, ctx.request.body.appDefinition, ctx.request.body.accessLevels diff --git a/packages/server/middleware/routes/builderRouter.js b/packages/server/middleware/routes/builderRouter.js index e47e45ed09..0071db0a14 100644 --- a/packages/server/middleware/routes/builderRouter.js +++ b/packages/server/middleware/routes/builderRouter.js @@ -22,6 +22,7 @@ module.exports = (config, app) => { .use(async (ctx, next) => { ctx.sessionId = ctx.session._sessCtx.externalKey ctx.session.accessed = true + ctx.config = config const pathParts = ctx.path.split("/") diff --git a/packages/server/middleware/routes/components.js b/packages/server/middleware/routes/components.js index e89fec6b3b..8c770d57be 100644 --- a/packages/server/middleware/routes/components.js +++ b/packages/server/middleware/routes/components.js @@ -11,7 +11,7 @@ const router = Router(); router.get("/_builder/api/:appname/components", async ctx => { try { ctx.body = getComponentDefinitions( - config, + ctx.config, ctx.params.appname, ctx.query.lib ) @@ -27,7 +27,7 @@ router.get("/_builder/api/:appname/components", async ctx => { router.get("/_builder/api/:appname/componentlibrary", async ctx => { const info = await componentLibraryInfo( - config, + ctx.config, ctx.params.appname, ctx.query.lib ? decodeURI(ctx.query.lib) : "" ) @@ -37,7 +37,7 @@ router.get("/_builder/api/:appname/componentlibrary", async ctx => { router.get("/_builder/:appname/componentlibrary", async ctx => { const info = await componentLibraryInfo( - config, + ctx.config, ctx.params.appname, ctx.query.lib ) diff --git a/packages/server/middleware/routes/pages.js b/packages/server/middleware/routes/pages.js index ee954b36ff..08a9418c9d 100644 --- a/packages/server/middleware/routes/pages.js +++ b/packages/server/middleware/routes/pages.js @@ -59,7 +59,7 @@ router router.post("/_builder/api/:appname/pages/:pageName", async ctx => { await buildPage( - config, + ctx.config, ctx.params.appname, ctx.params.pageName, ctx.request.body From 35f461dbeb7bab4ce66c0e8ab2cf5ed9a3eb44ed Mon Sep 17 00:00:00 2001 From: Martin McKeaveney Date: Fri, 3 Apr 2020 16:15:53 +0100 Subject: [PATCH 4/9] restructure server routes --- packages/server/middleware/routes/apps.js | 35 +++++ .../server/middleware/routes/authenticated.js | 129 ++++++++++++++++++ .../server/middleware/routes/builderRouter.js | 116 ++++++++++++++++ .../server/middleware/routes/components.js | 47 +++++++ packages/server/middleware/routes/index.js | 14 ++ packages/server/middleware/routes/pages.js | 70 ++++++++++ packages/server/middleware/routes/user.js | 33 +++++ 7 files changed, 444 insertions(+) create mode 100644 packages/server/middleware/routes/apps.js create mode 100644 packages/server/middleware/routes/authenticated.js create mode 100644 packages/server/middleware/routes/builderRouter.js create mode 100644 packages/server/middleware/routes/components.js create mode 100644 packages/server/middleware/routes/index.js create mode 100644 packages/server/middleware/routes/pages.js create mode 100644 packages/server/middleware/routes/user.js diff --git a/packages/server/middleware/routes/apps.js b/packages/server/middleware/routes/apps.js new file mode 100644 index 0000000000..dd20d79ab5 --- /dev/null +++ b/packages/server/middleware/routes/apps.js @@ -0,0 +1,35 @@ +const Router = require("@koa/router"); +const { + getPackageForBuilder, + getApps, +} = require("../utilities/builder") + +const router = Router(); + +router.get("/_builder/api/apps", async ctx => { + ctx.body = await getApps(config, ctx.master) + ctx.response.status = StatusCodes.OK +}) + +router.get("/_builder/api/:appname/appPackage", async ctx => { + const application = await ctx.master.getApplicationWithInstances( + ctx.params.appname + ) + ctx.body = await getPackageForBuilder(config, application) + ctx.response.status = StatusCodes.OK +}) + +router + .post("/_builder/api/:appname/backend", async ctx => { + await saveBackend( + config, + ctx.params.appname, + ctx.request.body.appDefinition, + ctx.request.body.accessLevels + ) + ctx.master.deleteLatestPackageFromCache(ctx.params.appname) + ctx.response.status = StatusCodes.OK + }) + + +module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/authenticated.js b/packages/server/middleware/routes/authenticated.js new file mode 100644 index 0000000000..5931469d89 --- /dev/null +++ b/packages/server/middleware/routes/authenticated.js @@ -0,0 +1,129 @@ +const Router = require("koa-router"); +const routeHandlers = require("../routeHandlers") + +const router = Router(); + +router.use(async (ctx, next) => { + if (ctx.isAuthenticated) { + await next() + } else { + ctx.response.status = StatusCodes.UNAUTHORIZED + } +}) + +router.post( + "/_builder/instance/:appname/:instanceid/api/upgradeData", + routeHandlers.upgradeData +) + +router.post("/:appname/api/changeMyPassword", routeHandlers.changeMyPassword) + +router.post( + "/_builder/instance/:appname/:instanceid/api/changeMyPassword", + routeHandlers.changeMyPassword +) + +router.post( + "/:appname/api/executeAction/:actionname", + routeHandlers.executeAction +) + +router.post( + "/_builder/instance/:appname/:instanceid/api/executeAction/:actionname", + routeHandlers.executeAction +) + +router.post("/:appname/api/createUser", routeHandlers.createUser) + +router.post( + "/_builder/instance/:appname/:instanceid/api/createUser", + routeHandlers.createUser +) + +router.post("/:appname/api/enableUser", routeHandlers.enableUser) + +router.post( + "/_builder/instance/:appname/:instanceid/api/enableUser", + routeHandlers.enableUser +) + +router.post("/:appname/api/disableUser", routeHandlers.disableUser) + +router.post( + "/_builder/instance/:appname/:instanceid/api/disableUser", + routeHandlers.disableUser +) + +router.get("/:appname/api/users", routeHandlers.getUsers) + +router.get( + "/_builder/instance/:appname/:instanceid/api/users", + routeHandlers.getUsers +) + +router.get("/:appname/api/accessLevels", routeHandlers.getAccessLevels) + +router.get( + "/_builder/instance/:appname/:instanceid/api/accessLevels", + routeHandlers.getAccessLevels +) + +router.get("/:appname/api/listRecords/*", routeHandlers.listRecordsGet) + +router.get( + "/_builder/instance/:appname/:instanceid/api/listRecords/*", + routeHandlers.listRecordsGet +) + +router.post("/:appname/api/listRecords/*", routeHandlers.listRecordsPost) + +router.post( + "/_builder/instance/:appname/:instanceid/api/listRecords/*", + routeHandlers.listRecordsPost +) + +router.post("/:appname/api/aggregates/*", routeHandlers.aggregatesPost) + +router.post( + "/_builder/instance/:appname/:instanceid/api/aggregates/*", + routeHandlers.aggregatesPost +) + +router.post("/:appname/api/files/*", routeHandlers.postFiles) + +router.post( + "/_builder/instance/:appname/:instanceid/api/files/*", + routeHandlers.postFiles +) + +router.post("/:appname/api/record/*", routeHandlers.saveRecord) + +router.post( + "/_builder/instance/:appname/:instanceid/api/record/*", + routeHandlers.saveRecord +) + +router.get("/:appname/api/lookup_field/*", routeHandlers.lookupField) + +router.get( + "/_builder/instance/:appname/:instanceid/api/lookup_field/*", + routeHandlers.lookupField +) + +router.get("/:appname/api/record/*", routeHandlers.getRecord) + +router.get( + "/_builder/instance/:appname/:instanceid/api/record/*", + routeHandlers.getRecord +) + +router.del("/:appname/api/record/*", routeHandlers.deleteRecord) + +router.del( + "/_builder/instance/:appname/:instanceid/api/record/*", + routeHandlers.deleteRecord +) + +router.post("/:appname/api/apphierarchy", routeHandlers.saveAppHierarchy) + +module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/builderRouter.js b/packages/server/middleware/routes/builderRouter.js new file mode 100644 index 0000000000..a9960a0b26 --- /dev/null +++ b/packages/server/middleware/routes/builderRouter.js @@ -0,0 +1,116 @@ +const Router = require("@koa/router") +const session = require("./session") +const StatusCodes = require("../utilities/statusCodes") +const { resolve } = require("path") +const send = require("koa-send") +const routeHandlers = require("./routeHandlers") +const { + componentRoutes, + appsRoutes, + pageRoutes, + userRoutes, + authenticatedRoutes +} = require("./"); + +const builderPath = resolve(__dirname, "../builder") + +module.exports = (config, app) => { + const router = new Router() + + router + .use(session(config, app)) + .use(async (ctx, next) => { + ctx.sessionId = ctx.session._sessCtx.externalKey + ctx.session.accessed = true + + const pathParts = ctx.path.split("/") + + if (pathParts.length < 2) { + ctx.throw(StatusCodes.NOT_FOUND, "App Name not declared") + } + + const appname = pathParts[1] + ctx.set("x-bbappname", appname) + + if (appname === "_builder") { + if (!config.dev) { + ctx.response.status = StatusCodes.FORBIDDEN + ctx.body = "run in dev mode to access builder" + return + } + + if (ctx.path.startsWith("/_builder/instance/_master")) { + const { + instance, + publicPath, + sharedPath, + } = await ctx.master.getFullAccessApiForMaster() + ctx.instance = instance + ctx.publicPath = publicPath + ctx.sharedPath = sharedPath + ctx.isAuthenticated = !!ctx.instance + } else if (ctx.path.startsWith("/_builder/instance")) { + const builderAppName = pathParts[3] + const instanceId = pathParts[4] + const { + bbInstance, + publicPath, + sharedPath, + } = await ctx.master.getFullAccessApiForInstanceId( + builderAppName, + instanceId + ) + ctx.instance = bbInstance + ctx.publicPath = publicPath + ctx.sharedPath = sharedPath + ctx.isAuthenticated = !!ctx.instance + } + + await next() + } else { + const instance = await ctx.master.getInstanceApiForSession( + appname, + ctx.sessionId + ) + + ctx.instance = instance.instance + ctx.publicPath = instance.publicPath + ctx.sharedPath = instance.sharedPath + ctx.isAuthenticated = !!instance.instance + + await next() + } + }) + + router.get("/_builder", async ctx => { + await send(ctx, "/index.html", { root: builderPath }) + }) + router.get("/_builder/*", async (ctx, next) => { + const path = ctx.path.replace("/_builder", "") + + const isFile = new RegExp(/(.+\..{1,5})/g).test(path) + + if (path.startsWith("/api/") || path.startsWith("/instance/")) { + await next() + } else if (isFile) { + await send(ctx, path, { root: builderPath }) + } else { + await send(ctx, "/index.html", { root: builderPath }) + } + }) + + router.use(userRoutes.routes()); + router.use(appsRoutes.routes()) + router.use(componentRoutes.routes()); + router.use(pageRoutes.routes()); + + router.get("/:appname", async ctx => { + await send(ctx, "/index.html", { root: ctx.publicPath }) + }) + router.get("/:appname/*", routeHandlers.appDefault) + router.get("/_builder/instance/:appname/:instanceid/*", routeHandlers.appDefault) + + router.use(authenticatedRoutes.routes()); + + return router +} diff --git a/packages/server/middleware/routes/components.js b/packages/server/middleware/routes/components.js new file mode 100644 index 0000000000..bc52863966 --- /dev/null +++ b/packages/server/middleware/routes/components.js @@ -0,0 +1,47 @@ +const Router = require("koa-router"); +const send = require("koa-send") +const { + getComponentDefinitions, + componentLibraryInfo, +} = require("../../utilities/builder") + + +const router = Router(); + +router.get("/_builder/api/:appname/components", async ctx => { + try { + ctx.body = getComponentDefinitions( + config, + ctx.params.appname, + ctx.query.lib + ) + ctx.response.status = StatusCodes.OK + } catch (e) { + if (e.status) { + ctx.response.status = e.status + } else { + throw e + } + } +}) + +router.get("/_builder/api/:appname/componentlibrary", async ctx => { + const info = await componentLibraryInfo( + config, + ctx.params.appname, + ctx.query.lib ? decodeURI(ctx.query.lib) : "" + ) + ctx.body = info.components + ctx.response.status = StatusCodes.OK +}) + +router.get("/_builder/:appname/componentlibrary", async ctx => { + const info = await componentLibraryInfo( + config, + ctx.params.appname, + ctx.query.lib + ) + await send(ctx, info.components._lib || "index.js", { root: info.libDir }) +}) + +module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/index.js b/packages/server/middleware/routes/index.js new file mode 100644 index 0000000000..1efaadbaeb --- /dev/null +++ b/packages/server/middleware/routes/index.js @@ -0,0 +1,14 @@ +const screenRoutes = require("./screens"); +const pageRoutes = require("./pages"); +const componentRoutes = require("./components"); +const userRoutes = require("./user"); +const appsRoutes = require("./apps"); +const authenticatedRoutes = require("./authenticated"); + +module.exports = { + screenRoutes, + pageRoutes, + componentRoutes, + authRoutes, + appsRoutes +}; \ No newline at end of file diff --git a/packages/server/middleware/routes/pages.js b/packages/server/middleware/routes/pages.js new file mode 100644 index 0000000000..ee954b36ff --- /dev/null +++ b/packages/server/middleware/routes/pages.js @@ -0,0 +1,70 @@ +const Router = require("@koa/router"); +const { + listScreens, + saveScreen, + buildPage +} = require("../../utilities/builder") + + +const router = Router() + +router.get("/_builder/api/:appname/pages/:pagename/screens", async ctx => { + ctx.body = await listScreens( + config, + ctx.params.appname, + ctx.params.pagename + ) + ctx.response.status = StatusCodes.OK +}) + +router + .post("/_builder/api/:appname/pages/:pagename/screen", async ctx => { + ctx.body = await saveScreen( + config, + ctx.params.appname, + ctx.params.pagename, + ctx.request.body + ) + ctx.response.status = StatusCodes.OK + }) + +router + .patch("/_builder/api/:appname/pages/:pagename/screen", async ctx => { + await renameScreen( + config, + ctx.params.appname, + ctx.params.pagename, + ctx.request.body.oldname, + ctx.request.body.newname + ) + ctx.response.status = StatusCodes.OK + }) + +router + .delete("/_builder/api/:appname/pages/:pagename/screen/*", async ctx => { + const name = ctx.request.path.replace( + `/_builder/api/${ctx.params.appname}/pages/${ctx.params.pagename}/screen/`, + "" + ) + + await deleteScreen( + config, + ctx.params.appname, + ctx.params.pagename, + decodeURI(name) + ) + + ctx.response.status = StatusCodes.OK +}) + +router.post("/_builder/api/:appname/pages/:pageName", async ctx => { + await buildPage( + config, + ctx.params.appname, + ctx.params.pageName, + ctx.request.body + ) + ctx.response.status = StatusCodes.OK +}) + +module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/user.js b/packages/server/middleware/routes/user.js new file mode 100644 index 0000000000..72e8ac717b --- /dev/null +++ b/packages/server/middleware/routes/user.js @@ -0,0 +1,33 @@ +const Router = require("@koa/router") +const routeHandlers = require("../routeHandlers") + +const router = new Router() + +router.post("/:appname/api/authenticate", routeHandlers.authenticate) + +router.post( + "/_builder/instance/:appname/:instanceid/api/authenticate", + routeHandlers.authenticate +) + +router.post( + "/_builder/instance/:appname/:instanceid/api/setPasswordFromTemporaryCode", + routeHandlers.setPasswordFromTemporaryCode +) + +router.post( + "/_builder/instance/:appname/:instanceid/api/createTemporaryAccess", + routeHandlers.createTemporaryAccess +) + +router.post( + "/:appname/api/createTemporaryAccess", + routeHandlers.createTemporaryAccess +) + +router.post( + "/:appname/api/setPasswordFromTemporaryCode", + routeHandlers.setPasswordFromTemporaryCode +) + +module.exports = router \ No newline at end of file From a9ba145fcef0d918617e8da1f07a3506c585761c Mon Sep 17 00:00:00 2001 From: Martin McKeaveney Date: Fri, 3 Apr 2020 17:35:20 +0100 Subject: [PATCH 5/9] restructure server --- packages/server/app.js | 2 +- packages/server/middleware/routes/apps.js | 3 ++- packages/server/middleware/routes/authenticated.js | 2 +- packages/server/middleware/routes/builderRouter.js | 6 +++--- packages/server/middleware/routes/components.js | 2 +- packages/server/middleware/routes/index.js | 7 +++---- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/packages/server/app.js b/packages/server/app.js index f56d4c8541..3b95d2364f 100644 --- a/packages/server/app.js +++ b/packages/server/app.js @@ -1,5 +1,5 @@ const Koa = require("koa") -const router = require("./middleware/routers") +const router = require("./middleware/routes/builderRouter") const koaBody = require("koa-body") const initialiseRuntimePackages = require("./initialise/initialiseRuntimePackages") diff --git a/packages/server/middleware/routes/apps.js b/packages/server/middleware/routes/apps.js index dd20d79ab5..45ddceb96d 100644 --- a/packages/server/middleware/routes/apps.js +++ b/packages/server/middleware/routes/apps.js @@ -2,7 +2,8 @@ const Router = require("@koa/router"); const { getPackageForBuilder, getApps, -} = require("../utilities/builder") +} = require("../../utilities/builder") + const router = Router(); diff --git a/packages/server/middleware/routes/authenticated.js b/packages/server/middleware/routes/authenticated.js index 5931469d89..d6c791aedc 100644 --- a/packages/server/middleware/routes/authenticated.js +++ b/packages/server/middleware/routes/authenticated.js @@ -1,4 +1,4 @@ -const Router = require("koa-router"); +const Router = require("@koa/router"); const routeHandlers = require("../routeHandlers") const router = Router(); diff --git a/packages/server/middleware/routes/builderRouter.js b/packages/server/middleware/routes/builderRouter.js index a9960a0b26..e47e45ed09 100644 --- a/packages/server/middleware/routes/builderRouter.js +++ b/packages/server/middleware/routes/builderRouter.js @@ -1,9 +1,9 @@ const Router = require("@koa/router") -const session = require("./session") -const StatusCodes = require("../utilities/statusCodes") +const session = require("../session") +const StatusCodes = require("../../utilities/statusCodes") const { resolve } = require("path") const send = require("koa-send") -const routeHandlers = require("./routeHandlers") +const routeHandlers = require("../routeHandlers") const { componentRoutes, appsRoutes, diff --git a/packages/server/middleware/routes/components.js b/packages/server/middleware/routes/components.js index bc52863966..e89fec6b3b 100644 --- a/packages/server/middleware/routes/components.js +++ b/packages/server/middleware/routes/components.js @@ -1,4 +1,4 @@ -const Router = require("koa-router"); +const Router = require("@koa/router"); const send = require("koa-send") const { getComponentDefinitions, diff --git a/packages/server/middleware/routes/index.js b/packages/server/middleware/routes/index.js index 1efaadbaeb..5cac9f21ff 100644 --- a/packages/server/middleware/routes/index.js +++ b/packages/server/middleware/routes/index.js @@ -1,4 +1,3 @@ -const screenRoutes = require("./screens"); const pageRoutes = require("./pages"); const componentRoutes = require("./components"); const userRoutes = require("./user"); @@ -6,9 +5,9 @@ const appsRoutes = require("./apps"); const authenticatedRoutes = require("./authenticated"); module.exports = { - screenRoutes, pageRoutes, componentRoutes, - authRoutes, - appsRoutes + appsRoutes, + userRoutes, + authenticatedRoutes }; \ No newline at end of file From 72fcfd42bb92faf215d5af0a82e25f13daf8d011 Mon Sep 17 00:00:00 2001 From: Martin McKeaveney Date: Mon, 6 Apr 2020 09:09:48 +0100 Subject: [PATCH 6/9] config in context --- packages/server/middleware/routes/apps.js | 2 +- packages/server/middleware/routes/builderRouter.js | 1 + packages/server/middleware/routes/components.js | 6 +++--- packages/server/middleware/routes/pages.js | 2 +- 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/packages/server/middleware/routes/apps.js b/packages/server/middleware/routes/apps.js index 45ddceb96d..941be4eabc 100644 --- a/packages/server/middleware/routes/apps.js +++ b/packages/server/middleware/routes/apps.js @@ -23,7 +23,7 @@ router.get("/_builder/api/:appname/appPackage", async ctx => { router .post("/_builder/api/:appname/backend", async ctx => { await saveBackend( - config, + ctx.config, ctx.params.appname, ctx.request.body.appDefinition, ctx.request.body.accessLevels diff --git a/packages/server/middleware/routes/builderRouter.js b/packages/server/middleware/routes/builderRouter.js index e47e45ed09..0071db0a14 100644 --- a/packages/server/middleware/routes/builderRouter.js +++ b/packages/server/middleware/routes/builderRouter.js @@ -22,6 +22,7 @@ module.exports = (config, app) => { .use(async (ctx, next) => { ctx.sessionId = ctx.session._sessCtx.externalKey ctx.session.accessed = true + ctx.config = config const pathParts = ctx.path.split("/") diff --git a/packages/server/middleware/routes/components.js b/packages/server/middleware/routes/components.js index e89fec6b3b..8c770d57be 100644 --- a/packages/server/middleware/routes/components.js +++ b/packages/server/middleware/routes/components.js @@ -11,7 +11,7 @@ const router = Router(); router.get("/_builder/api/:appname/components", async ctx => { try { ctx.body = getComponentDefinitions( - config, + ctx.config, ctx.params.appname, ctx.query.lib ) @@ -27,7 +27,7 @@ router.get("/_builder/api/:appname/components", async ctx => { router.get("/_builder/api/:appname/componentlibrary", async ctx => { const info = await componentLibraryInfo( - config, + ctx.config, ctx.params.appname, ctx.query.lib ? decodeURI(ctx.query.lib) : "" ) @@ -37,7 +37,7 @@ router.get("/_builder/api/:appname/componentlibrary", async ctx => { router.get("/_builder/:appname/componentlibrary", async ctx => { const info = await componentLibraryInfo( - config, + ctx.config, ctx.params.appname, ctx.query.lib ) diff --git a/packages/server/middleware/routes/pages.js b/packages/server/middleware/routes/pages.js index ee954b36ff..08a9418c9d 100644 --- a/packages/server/middleware/routes/pages.js +++ b/packages/server/middleware/routes/pages.js @@ -59,7 +59,7 @@ router router.post("/_builder/api/:appname/pages/:pageName", async ctx => { await buildPage( - config, + ctx.config, ctx.params.appname, ctx.params.pageName, ctx.request.body From fea50bb56ef571245b0f8e5d3122242ec3e265e9 Mon Sep 17 00:00:00 2001 From: Martin McKeaveney Date: Mon, 6 Apr 2020 14:05:57 +0100 Subject: [PATCH 7/9] restructuring server routers --- packages/server/middleware/routers.js | 246 ++---------------- packages/server/middleware/routes/apps.js | 5 +- .../server/middleware/routes/authenticated.js | 7 +- .../server/middleware/routes/builderRouter.js | 117 --------- .../server/middleware/routes/components.js | 19 +- packages/server/middleware/routes/pages.js | 9 +- packages/server/yarn.lock | 16 +- 7 files changed, 56 insertions(+), 363 deletions(-) delete mode 100644 packages/server/middleware/routes/builderRouter.js diff --git a/packages/server/middleware/routers.js b/packages/server/middleware/routers.js index f0bdd8dd77..336df0b5c2 100644 --- a/packages/server/middleware/routers.js +++ b/packages/server/middleware/routers.js @@ -4,21 +4,18 @@ const StatusCodes = require("../utilities/statusCodes") const { resolve } = require("path") const send = require("koa-send") const routeHandlers = require("./routeHandlers") - const { - getPackageForBuilder, - getComponentDefinitions, - getApps, - saveScreen, - renameScreen, - deleteScreen, - buildPage, componentLibraryInfo, - listScreens, - saveBackend, -} = require("../utilities/builder") +} = require("../../utilities/builder") +const { + componentRoutes, + appsRoutes, + pageRoutes, + userRoutes, + authenticatedRoutes +} = require("./"); -const builderPath = resolve(__dirname, "../builder") +const builderPath = resolve(__dirname, "../../builder") module.exports = (config, app) => { const router = new Router() @@ -28,6 +25,7 @@ module.exports = (config, app) => { .use(async (ctx, next) => { ctx.sessionId = ctx.session._sessCtx.externalKey ctx.session.accessed = true + ctx.config = config const pathParts = ctx.path.split("/") @@ -45,6 +43,7 @@ module.exports = (config, app) => { return } + // Builder URLs should have admin access to the API if (ctx.path.startsWith("/_builder/instance/_master")) { const { instance, @@ -92,7 +91,7 @@ module.exports = (config, app) => { }) .get("/_builder/:appname/componentlibrary", async ctx => { const info = await componentLibraryInfo( - config, + ctx.config, ctx.params.appname, ctx.query.lib ) @@ -111,220 +110,25 @@ module.exports = (config, app) => { await send(ctx, "/index.html", { root: builderPath }) } }) - .post("/:appname/api/authenticate", routeHandlers.authenticate) - .post( - "/_builder/instance/:appname/:instanceid/api/authenticate", - routeHandlers.authenticate - ) - .post( - "/:appname/api/setPasswordFromTemporaryCode", - routeHandlers.setPasswordFromTemporaryCode - ) - .post( - "/_builder/instance/:appname/:instanceid/api/setPasswordFromTemporaryCode", - routeHandlers.setPasswordFromTemporaryCode - ) - .post( - "/:appname/api/createTemporaryAccess", - routeHandlers.createTemporaryAccess - ) - .post( - "/_builder/instance/:appname/:instanceid/api/createTemporaryAccess", - routeHandlers.createTemporaryAccess - ) - .get("/_builder/api/apps", async ctx => { - ctx.body = await getApps(config, ctx.master) - ctx.response.status = StatusCodes.OK - }) - .get("/_builder/api/:appname/appPackage", async ctx => { - const application = await ctx.master.getApplicationWithInstances( - ctx.params.appname - ) - ctx.body = await getPackageForBuilder(config, application) - ctx.response.status = StatusCodes.OK - }) - .get("/_builder/api/:appname/components", async ctx => { - try { - ctx.body = getComponentDefinitions( - config, - ctx.params.appname, - ctx.query.lib - ) - ctx.response.status = StatusCodes.OK - } catch (e) { - if (e.status) { - ctx.response.status = e.status - } else { - throw e - } - } - }) - .get("/_builder/api/:appname/componentlibrary", async ctx => { - const info = await componentLibraryInfo( - config, - ctx.params.appname, - ctx.query.lib ? decodeURI(ctx.query.lib) : "" - ) - ctx.body = info.components - ctx.response.status = StatusCodes.OK - }) - .post("/_builder/api/:appname/backend", async ctx => { - await saveBackend( - config, - ctx.params.appname, - ctx.request.body.appDefinition, - ctx.request.body.accessLevels - ) - ctx.master.deleteLatestPackageFromCache(ctx.params.appname) - ctx.response.status = StatusCodes.OK - }) - .post("/_builder/api/:appname/pages/:pageName", async ctx => { - await buildPage( - config, - ctx.params.appname, - ctx.params.pageName, - ctx.request.body - ) - ctx.response.status = StatusCodes.OK - }) - .get("/_builder/api/:appname/pages/:pagename/screens", async ctx => { - ctx.body = await listScreens( - config, - ctx.params.appname, - ctx.params.pagename - ) - ctx.response.status = StatusCodes.OK - }) - .post("/_builder/api/:appname/pages/:pagename/screen", async ctx => { - ctx.body = await saveScreen( - config, - ctx.params.appname, - ctx.params.pagename, - ctx.request.body - ) - ctx.response.status = StatusCodes.OK - }) - .patch("/_builder/api/:appname/pages/:pagename/screen", async ctx => { - await renameScreen( - config, - ctx.params.appname, - ctx.params.pagename, - ctx.request.body.oldname, - ctx.request.body.newname - ) - ctx.response.status = StatusCodes.OK - }) - .delete("/_builder/api/:appname/pages/:pagename/screen/*", async ctx => { - const name = ctx.request.path.replace( - `/_builder/api/${ctx.params.appname}/pages/${ctx.params.pagename}/screen/`, - "" - ) - await deleteScreen( - config, - ctx.params.appname, - ctx.params.pagename, - decodeURI(name) - ) + router.use(userRoutes.routes()); + router.use(userRoutes.allowedMethods()); + router.use(appsRoutes.routes()) + router.use(appsRoutes.allowedMethods()); + router.use(componentRoutes.routes()); + router.use(componentRoutes.allowedMethods()); + router.use(pageRoutes.routes()); + router.use(pageRoutes.allowedMethods()); - ctx.response.status = StatusCodes.OK - }) + router .get("/:appname", async ctx => { await send(ctx, "/index.html", { root: ctx.publicPath }) - }) + }) .get("/:appname/*", routeHandlers.appDefault) .get("/_builder/instance/:appname/:instanceid/*", routeHandlers.appDefault) - // EVERYTHING BELOW HERE REQUIRES AUTHENTICATION - .use(async (ctx, next) => { - if (ctx.isAuthenticated) { - await next() - } else { - ctx.response.status = StatusCodes.UNAUTHORIZED - } - }) - .post( - "/_builder/instance/:appname/:instanceid/api/upgradeData", - routeHandlers.upgradeData - ) - .post("/:appname/api/changeMyPassword", routeHandlers.changeMyPassword) - .post( - "/_builder/instance/:appname/:instanceid/api/changeMyPassword", - routeHandlers.changeMyPassword - ) - .post( - "/:appname/api/executeAction/:actionname", - routeHandlers.executeAction - ) - .post( - "/_builder/instance/:appname/:instanceid/api/executeAction/:actionname", - routeHandlers.executeAction - ) - .post("/:appname/api/createUser", routeHandlers.createUser) - .post( - "/_builder/instance/:appname/:instanceid/api/createUser", - routeHandlers.createUser - ) - .post("/:appname/api/enableUser", routeHandlers.enableUser) - .post( - "/_builder/instance/:appname/:instanceid/api/enableUser", - routeHandlers.enableUser - ) - .post("/:appname/api/disableUser", routeHandlers.disableUser) - .post( - "/_builder/instance/:appname/:instanceid/api/disableUser", - routeHandlers.disableUser - ) - .get("/:appname/api/users", routeHandlers.getUsers) - .get( - "/_builder/instance/:appname/:instanceid/api/users", - routeHandlers.getUsers - ) - .get("/:appname/api/accessLevels", routeHandlers.getAccessLevels) - .get( - "/_builder/instance/:appname/:instanceid/api/accessLevels", - routeHandlers.getAccessLevels - ) - .get("/:appname/api/listRecords/*", routeHandlers.listRecordsGet) - .get( - "/_builder/instance/:appname/:instanceid/api/listRecords/*", - routeHandlers.listRecordsGet - ) - .post("/:appname/api/listRecords/*", routeHandlers.listRecordsPost) - .post( - "/_builder/instance/:appname/:instanceid/api/listRecords/*", - routeHandlers.listRecordsPost - ) - .post("/:appname/api/aggregates/*", routeHandlers.aggregatesPost) - .post( - "/_builder/instance/:appname/:instanceid/api/aggregates/*", - routeHandlers.aggregatesPost - ) - .post("/:appname/api/files/*", routeHandlers.postFiles) - .post( - "/_builder/instance/:appname/:instanceid/api/files/*", - routeHandlers.postFiles - ) - .post("/:appname/api/record/*", routeHandlers.saveRecord) - .post( - "/_builder/instance/:appname/:instanceid/api/record/*", - routeHandlers.saveRecord - ) - .get("/:appname/api/lookup_field/*", routeHandlers.lookupField) - .get( - "/_builder/instance/:appname/:instanceid/api/lookup_field/*", - routeHandlers.lookupField - ) - .get("/:appname/api/record/*", routeHandlers.getRecord) - .get( - "/_builder/instance/:appname/:instanceid/api/record/*", - routeHandlers.getRecord - ) - .del("/:appname/api/record/*", routeHandlers.deleteRecord) - .del( - "/_builder/instance/:appname/:instanceid/api/record/*", - routeHandlers.deleteRecord - ) - .post("/:appname/api/apphierarchy", routeHandlers.saveAppHierarchy) + + router.use(authenticatedRoutes.routes()); + router.use(authenticatedRoutes.allowedMethods()); return router } diff --git a/packages/server/middleware/routes/apps.js b/packages/server/middleware/routes/apps.js index 941be4eabc..96ab556217 100644 --- a/packages/server/middleware/routes/apps.js +++ b/packages/server/middleware/routes/apps.js @@ -1,4 +1,5 @@ const Router = require("@koa/router"); +const StatusCodes = require("../../utilities/statusCodes") const { getPackageForBuilder, getApps, @@ -8,7 +9,7 @@ const { const router = Router(); router.get("/_builder/api/apps", async ctx => { - ctx.body = await getApps(config, ctx.master) + ctx.body = await getApps(ctx.config, ctx.master) ctx.response.status = StatusCodes.OK }) @@ -16,7 +17,7 @@ router.get("/_builder/api/:appname/appPackage", async ctx => { const application = await ctx.master.getApplicationWithInstances( ctx.params.appname ) - ctx.body = await getPackageForBuilder(config, application) + ctx.body = await getPackageForBuilder(ctx.config, application) ctx.response.status = StatusCodes.OK }) diff --git a/packages/server/middleware/routes/authenticated.js b/packages/server/middleware/routes/authenticated.js index d6c791aedc..505dec7e84 100644 --- a/packages/server/middleware/routes/authenticated.js +++ b/packages/server/middleware/routes/authenticated.js @@ -1,15 +1,18 @@ const Router = require("@koa/router"); +const StatusCodes = require("../../utilities/statusCodes") const routeHandlers = require("../routeHandlers") const router = Router(); -router.use(async (ctx, next) => { +async function isAuthenticated(ctx, next) { if (ctx.isAuthenticated) { await next() } else { ctx.response.status = StatusCodes.UNAUTHORIZED } -}) +} + +router.use(isAuthenticated) router.post( "/_builder/instance/:appname/:instanceid/api/upgradeData", diff --git a/packages/server/middleware/routes/builderRouter.js b/packages/server/middleware/routes/builderRouter.js deleted file mode 100644 index 0071db0a14..0000000000 --- a/packages/server/middleware/routes/builderRouter.js +++ /dev/null @@ -1,117 +0,0 @@ -const Router = require("@koa/router") -const session = require("../session") -const StatusCodes = require("../../utilities/statusCodes") -const { resolve } = require("path") -const send = require("koa-send") -const routeHandlers = require("../routeHandlers") -const { - componentRoutes, - appsRoutes, - pageRoutes, - userRoutes, - authenticatedRoutes -} = require("./"); - -const builderPath = resolve(__dirname, "../builder") - -module.exports = (config, app) => { - const router = new Router() - - router - .use(session(config, app)) - .use(async (ctx, next) => { - ctx.sessionId = ctx.session._sessCtx.externalKey - ctx.session.accessed = true - ctx.config = config - - const pathParts = ctx.path.split("/") - - if (pathParts.length < 2) { - ctx.throw(StatusCodes.NOT_FOUND, "App Name not declared") - } - - const appname = pathParts[1] - ctx.set("x-bbappname", appname) - - if (appname === "_builder") { - if (!config.dev) { - ctx.response.status = StatusCodes.FORBIDDEN - ctx.body = "run in dev mode to access builder" - return - } - - if (ctx.path.startsWith("/_builder/instance/_master")) { - const { - instance, - publicPath, - sharedPath, - } = await ctx.master.getFullAccessApiForMaster() - ctx.instance = instance - ctx.publicPath = publicPath - ctx.sharedPath = sharedPath - ctx.isAuthenticated = !!ctx.instance - } else if (ctx.path.startsWith("/_builder/instance")) { - const builderAppName = pathParts[3] - const instanceId = pathParts[4] - const { - bbInstance, - publicPath, - sharedPath, - } = await ctx.master.getFullAccessApiForInstanceId( - builderAppName, - instanceId - ) - ctx.instance = bbInstance - ctx.publicPath = publicPath - ctx.sharedPath = sharedPath - ctx.isAuthenticated = !!ctx.instance - } - - await next() - } else { - const instance = await ctx.master.getInstanceApiForSession( - appname, - ctx.sessionId - ) - - ctx.instance = instance.instance - ctx.publicPath = instance.publicPath - ctx.sharedPath = instance.sharedPath - ctx.isAuthenticated = !!instance.instance - - await next() - } - }) - - router.get("/_builder", async ctx => { - await send(ctx, "/index.html", { root: builderPath }) - }) - router.get("/_builder/*", async (ctx, next) => { - const path = ctx.path.replace("/_builder", "") - - const isFile = new RegExp(/(.+\..{1,5})/g).test(path) - - if (path.startsWith("/api/") || path.startsWith("/instance/")) { - await next() - } else if (isFile) { - await send(ctx, path, { root: builderPath }) - } else { - await send(ctx, "/index.html", { root: builderPath }) - } - }) - - router.use(userRoutes.routes()); - router.use(appsRoutes.routes()) - router.use(componentRoutes.routes()); - router.use(pageRoutes.routes()); - - router.get("/:appname", async ctx => { - await send(ctx, "/index.html", { root: ctx.publicPath }) - }) - router.get("/:appname/*", routeHandlers.appDefault) - router.get("/_builder/instance/:appname/:instanceid/*", routeHandlers.appDefault) - - router.use(authenticatedRoutes.routes()); - - return router -} diff --git a/packages/server/middleware/routes/components.js b/packages/server/middleware/routes/components.js index 8c770d57be..a72ebfccd4 100644 --- a/packages/server/middleware/routes/components.js +++ b/packages/server/middleware/routes/components.js @@ -1,5 +1,6 @@ const Router = require("@koa/router"); const send = require("koa-send") +const StatusCodes = require("../../utilities/statusCodes") const { getComponentDefinitions, componentLibraryInfo, @@ -8,6 +9,15 @@ const { const router = Router(); +router.get("/_builder/:appname/componentlibrary", async ctx => { + const info = await componentLibraryInfo( + ctx.config, + ctx.params.appname, + ctx.query.lib + ) + await send(ctx, info.components._lib || "index.js", { root: info.libDir }) +}) + router.get("/_builder/api/:appname/components", async ctx => { try { ctx.body = getComponentDefinitions( @@ -35,13 +45,4 @@ router.get("/_builder/api/:appname/componentlibrary", async ctx => { ctx.response.status = StatusCodes.OK }) -router.get("/_builder/:appname/componentlibrary", async ctx => { - const info = await componentLibraryInfo( - ctx.config, - ctx.params.appname, - ctx.query.lib - ) - await send(ctx, info.components._lib || "index.js", { root: info.libDir }) -}) - module.exports = router \ No newline at end of file diff --git a/packages/server/middleware/routes/pages.js b/packages/server/middleware/routes/pages.js index 08a9418c9d..bde3aeeb4c 100644 --- a/packages/server/middleware/routes/pages.js +++ b/packages/server/middleware/routes/pages.js @@ -1,4 +1,5 @@ const Router = require("@koa/router"); +const StatusCodes = require("../../utilities/statusCodes") const { listScreens, saveScreen, @@ -10,7 +11,7 @@ const router = Router() router.get("/_builder/api/:appname/pages/:pagename/screens", async ctx => { ctx.body = await listScreens( - config, + ctx.config, ctx.params.appname, ctx.params.pagename ) @@ -20,7 +21,7 @@ router.get("/_builder/api/:appname/pages/:pagename/screens", async ctx => { router .post("/_builder/api/:appname/pages/:pagename/screen", async ctx => { ctx.body = await saveScreen( - config, + ctx.config, ctx.params.appname, ctx.params.pagename, ctx.request.body @@ -31,7 +32,7 @@ router router .patch("/_builder/api/:appname/pages/:pagename/screen", async ctx => { await renameScreen( - config, + ctx.config, ctx.params.appname, ctx.params.pagename, ctx.request.body.oldname, @@ -48,7 +49,7 @@ router ) await deleteScreen( - config, + ctx.config, ctx.params.appname, ctx.params.pagename, decodeURI(name) diff --git a/packages/server/yarn.lock b/packages/server/yarn.lock index 7e65f2f2d4..de31b9e9fc 100644 --- a/packages/server/yarn.lock +++ b/packages/server/yarn.lock @@ -131,10 +131,10 @@ lodash "^4.17.13" to-fast-properties "^2.0.0" -"@budibase/client@^0.0.27": - version "0.0.27" - resolved "https://registry.yarnpkg.com/@budibase/client/-/client-0.0.27.tgz#d43a66202a23103ae5ac89d9fa69c3cd36b2a090" - integrity sha512-emS6L66fzfr/CdnpazlqveVKqcSQA9+sQRcbzLZ+sJLFk6FNIezRQcMjGHz+ooeYS91OVgOfleqXDCnvHO+MNg== +"@budibase/client@^0.0.32": + version "0.0.32" + resolved "https://registry.yarnpkg.com/@budibase/client/-/client-0.0.32.tgz#76d9f147563a0bf939eae7f32ce75b2a527ba496" + integrity sha512-jmCCLn0CUoQbL6h623S5IqK6+GYLqX3WzUTZInSb1SCBOM3pI0eLP5HwTR6s7r42SfD0v9jTWRdyTnHiElNj8A== dependencies: "@nx-js/compiler-util" "^2.0.0" bcryptjs "^2.4.3" @@ -145,10 +145,10 @@ shortid "^2.2.8" svelte "^3.9.2" -"@budibase/core@^0.0.27": - version "0.0.27" - resolved "https://registry.yarnpkg.com/@budibase/core/-/core-0.0.27.tgz#05bbacce692222089a1ae85b7ea4bb322e327f64" - integrity sha512-V8qGB9Lcwz8CFGzYct6i1oI+WiYgEOCsBBQ6DPPRLLVg07i2DHI9Ynwa35QXWTO3WeyWIxy//WSmVwSlYPAtOw== +"@budibase/core@^0.0.32": + version "0.0.32" + resolved "https://registry.yarnpkg.com/@budibase/core/-/core-0.0.32.tgz#c5d9ab869c5e9596a1ac337aaf041e795b1cc7fa" + integrity sha512-B6DHlz/C/m3jrxHbImT4bphdJlL7r2qmGrmcVBSc9mGHvwcRh1xfFGrsPCOU2IEJow+DWD63BIjyHzLPI3cerQ== dependencies: "@nx-js/compiler-util" "^2.0.0" bcryptjs "^2.4.3" From c37cff77127c458132cb4a1f068cacc0d8627964 Mon Sep 17 00:00:00 2001 From: Martin McKeaveney Date: Mon, 6 Apr 2020 14:16:21 +0100 Subject: [PATCH 8/9] tidy up --- packages/server/app.js | 2 +- .../testApp/pages/main/screens/newscreen.json | 7 + .../testApp/public/main/budibase-client.js | 56982 +++++++--------- .../public/main/budibase-client.js.map | 2 +- .../public/main/clientFrontendDefinition.js | 2 +- packages/server/middleware/routers.js | 50 +- 6 files changed, 24872 insertions(+), 32173 deletions(-) create mode 100644 packages/server/appPackages/testApp/pages/main/screens/newscreen.json diff --git a/packages/server/app.js b/packages/server/app.js index 3b95d2364f..f56d4c8541 100644 --- a/packages/server/app.js +++ b/packages/server/app.js @@ -1,5 +1,5 @@ const Koa = require("koa") -const router = require("./middleware/routes/builderRouter") +const router = require("./middleware/routers") const koaBody = require("koa-body") const initialiseRuntimePackages = require("./initialise/initialiseRuntimePackages") diff --git a/packages/server/appPackages/testApp/pages/main/screens/newscreen.json b/packages/server/appPackages/testApp/pages/main/screens/newscreen.json new file mode 100644 index 0000000000..73570595a7 --- /dev/null +++ b/packages/server/appPackages/testApp/pages/main/screens/newscreen.json @@ -0,0 +1,7 @@ +{ + "name": "newscreen", + "props": { + "_component": "@budibase/standard-component/div", + "className": "something else" + } +} diff --git a/packages/server/appPackages/testApp/public/main/budibase-client.js b/packages/server/appPackages/testApp/public/main/budibase-client.js index 7f539eb2af..c0a7cae3d5 100644 --- a/packages/server/appPackages/testApp/public/main/budibase-client.js +++ b/packages/server/appPackages/testApp/public/main/budibase-client.js @@ -1,25023 +1,19064 @@ -var app = (function(exports) { - "use strict" - - function noop() {} - function safe_not_equal(a, b) { - return a != a - ? b == b - : a !== b || (a && typeof a === "object") || typeof a === "function" - } - - const subscriber_queue = [] - /** - * Create a `Writable` store that allows both updating and reading by subscription. - * @param {*=}value initial value - * @param {StartStopNotifier=}start start and stop notifications for subscriptions - */ - function writable(value, start = noop) { - let stop - const subscribers = [] - function set(new_value) { - if (safe_not_equal(value, new_value)) { - value = new_value - if (stop) { - // store is ready - const run_queue = !subscriber_queue.length - for (let i = 0; i < subscribers.length; i += 1) { - const s = subscribers[i] - s[1]() - subscriber_queue.push(s, value) - } - if (run_queue) { - for (let i = 0; i < subscriber_queue.length; i += 2) { - subscriber_queue[i][0](subscriber_queue[i + 1]) - } - subscriber_queue.length = 0 - } - } - } - } - function update(fn) { - set(fn(value)) - } - function subscribe(run, invalidate = noop) { - const subscriber = [run, invalidate] - subscribers.push(subscriber) - if (subscribers.length === 1) { - stop = start(set) || noop - } - run(value) - return () => { - const index = subscribers.indexOf(subscriber) - if (index !== -1) { - subscribers.splice(index, 1) - } - if (subscribers.length === 0) { - stop() - stop = null - } - } - } - return { set, update, subscribe } - } - - const createCoreApp = (backendDefinition, user) => { - const app = { - datastore: null, - crypto: null, - publish: () => {}, - hierarchy: backendDefinition.hierarchy, - actions: backendDefinition.actions, - user, - } - - return app - } - - var commonjsGlobal = - typeof globalThis !== "undefined" - ? globalThis - : typeof window !== "undefined" - ? window - : typeof global !== "undefined" - ? global - : typeof self !== "undefined" - ? self - : {} - - function commonjsRequire() { - throw new Error( - "Dynamic requires are not currently supported by rollup-plugin-commonjs" - ) - } - - function createCommonjsModule(fn, module) { - return ( - (module = { exports: {} }), fn(module, module.exports), module.exports - ) - } - - function getCjsExportFromNamespace(n) { - return (n && n["default"]) || n - } - - var lodash_min = createCommonjsModule(function(module, exports) { - ;(function() { - function n(n, t, r) { - switch (r.length) { - case 0: - return n.call(t) - case 1: - return n.call(t, r[0]) - case 2: - return n.call(t, r[0], r[1]) - case 3: - return n.call(t, r[0], r[1], r[2]) - } - return n.apply(t, r) - } - function t(n, t, r, e) { - for (var u = -1, i = null == n ? 0 : n.length; ++u < i; ) { - var o = n[u] - t(e, o, r(o), n) - } - return e - } - function r(n, t) { - for ( - var r = -1, e = null == n ? 0 : n.length; - ++r < e && false !== t(n[r], r, n); - - ); - return n - } - function e(n, t) { - for ( - var r = null == n ? 0 : n.length; - r-- && false !== t(n[r], r, n); - - ); - return n - } - function u(n, t) { - for (var r = -1, e = null == n ? 0 : n.length; ++r < e; ) - if (!t(n[r], r, n)) return false - return true - } - function i(n, t) { - for ( - var r = -1, e = null == n ? 0 : n.length, u = 0, i = []; - ++r < e; - - ) { - var o = n[r] - t(o, r, n) && (i[u++] = o) - } - return i - } - function o(n, t) { - return !(null == n || !n.length) && -1 < v(n, t, 0) - } - function f(n, t, r) { - for (var e = -1, u = null == n ? 0 : n.length; ++e < u; ) - if (r(t, n[e])) return true - return false - } - function c(n, t) { - for (var r = -1, e = null == n ? 0 : n.length, u = Array(e); ++r < e; ) - u[r] = t(n[r], r, n) - return u - } - function a(n, t) { - for (var r = -1, e = t.length, u = n.length; ++r < e; ) n[u + r] = t[r] - return n - } - function l(n, t, r, e) { - var u = -1, - i = null == n ? 0 : n.length - for (e && i && (r = n[++u]); ++u < i; ) r = t(r, n[u], u, n) - return r - } - function s(n, t, r, e) { - var u = null == n ? 0 : n.length - for (e && u && (r = n[--u]); u--; ) r = t(r, n[u], u, n) - return r - } - function h(n, t) { - for (var r = -1, e = null == n ? 0 : n.length; ++r < e; ) - if (t(n[r], r, n)) return true - return false - } - function p(n, t, r) { - var e - return ( - r(n, function(n, r, u) { - if (t(n, r, u)) return (e = r), false - }), - e - ) - } - function _(n, t, r, e) { - var u = n.length - for (r += e ? 1 : -1; e ? r-- : ++r < u; ) if (t(n[r], r, n)) return r - return -1 - } - function v(n, t, r) { - if (t === t) - n: { - --r - for (var e = n.length; ++r < e; ) - if (n[r] === t) { - n = r - break n - } - n = -1 - } - else n = _(n, d, r) - return n - } - function g(n, t, r, e) { - --r - for (var u = n.length; ++r < u; ) if (e(n[r], t)) return r - return -1 - } - function d(n) { - return n !== n - } - function y(n, t) { - var r = null == n ? 0 : n.length - return r ? m(n, t) / r : F - } - function b(n) { - return function(t) { - return null == t ? T : t[n] - } - } - function x(n) { - return function(t) { - return null == n ? T : n[t] - } - } - function j(n, t, r, e, u) { - return ( - u(n, function(n, u, i) { - r = e ? ((e = false), n) : t(r, n, u, i) - }), - r - ) - } - function w(n, t) { - var r = n.length - for (n.sort(t); r--; ) n[r] = n[r].c - return n - } - function m(n, t) { - for (var r, e = -1, u = n.length; ++e < u; ) { - var i = t(n[e]) - i !== T && (r = r === T ? i : r + i) - } - return r - } - function A(n, t) { - for (var r = -1, e = Array(n); ++r < n; ) e[r] = t(r) - return e - } - function E(n, t) { - return c(t, function(t) { - return [t, n[t]] - }) - } - function k(n) { - return function(t) { - return n(t) - } - } - function S(n, t) { - return c(t, function(t) { - return n[t] - }) - } - function O(n, t) { - return n.has(t) - } - function I(n, t) { - for (var r = -1, e = n.length; ++r < e && -1 < v(t, n[r], 0); ); - return r - } - function R(n, t) { - for (var r = n.length; r-- && -1 < v(t, n[r], 0); ); - return r - } - function z(n) { - return "\\" + Un[n] - } - function W(n) { - var t = -1, - r = Array(n.size) - return ( - n.forEach(function(n, e) { - r[++t] = [e, n] - }), - r - ) - } - function B(n, t) { - return function(r) { - return n(t(r)) - } - } - function L(n, t) { - for (var r = -1, e = n.length, u = 0, i = []; ++r < e; ) { - var o = n[r] - ;(o !== t && "__lodash_placeholder__" !== o) || - ((n[r] = "__lodash_placeholder__"), (i[u++] = r)) - } - return i - } - function U(n) { - var t = -1, - r = Array(n.size) - return ( - n.forEach(function(n) { - r[++t] = n - }), - r - ) - } - function C(n) { - var t = -1, - r = Array(n.size) - return ( - n.forEach(function(n) { - r[++t] = [n, n] - }), - r - ) - } - function D(n) { - if (Rn.test(n)) { - for (var t = (On.lastIndex = 0); On.test(n); ) ++t - n = t - } else n = Qn(n) - return n - } - function M(n) { - return Rn.test(n) ? n.match(On) || [] : n.split("") - } - var T, - $ = 1 / 0, - F = NaN, - N = [ - ["ary", 128], - ["bind", 1], - ["bindKey", 2], - ["curry", 8], - ["curryRight", 16], - ["flip", 512], - ["partial", 32], - ["partialRight", 64], - ["rearg", 256], - ], - P = /\b__p\+='';/g, - Z = /\b(__p\+=)''\+/g, - q = /(__e\(.*?\)|\b__t\))\+'';/g, - V = /&(?:amp|lt|gt|quot|#39);/g, - K = /[&<>"']/g, - G = RegExp(V.source), - H = RegExp(K.source), - J = /<%-([\s\S]+?)%>/g, - Y = /<%([\s\S]+?)%>/g, - Q = /<%=([\s\S]+?)%>/g, - X = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, - nn = /^\w*$/, - tn = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, - rn = /[\\^$.*+?()[\]{}|]/g, - en = RegExp(rn.source), - un = /^\s+|\s+$/g, - on = /^\s+/, - fn = /\s+$/, - cn = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, - an = /\{\n\/\* \[wrapped with (.+)\] \*/, - ln = /,? & /, - sn = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g, - hn = /\\(\\)?/g, - pn = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g, - _n = /\w*$/, - vn = /^[-+]0x[0-9a-f]+$/i, - gn = /^0b[01]+$/i, - dn = /^\[object .+?Constructor\]$/, - yn = /^0o[0-7]+$/i, - bn = /^(?:0|[1-9]\d*)$/, - xn = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g, - jn = /($^)/, - wn = /['\n\r\u2028\u2029\\]/g, - mn = - "[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?(?:\\u200d(?:[^\\ud800-\\udfff]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?)*", - An = - "(?:[\\u2700-\\u27bf]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff])" + - mn, - En = - "(?:[^\\ud800-\\udfff][\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]?|[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff])", - kn = RegExp("['\u2019]", "g"), - Sn = RegExp("[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]", "g"), - On = RegExp( - "\\ud83c[\\udffb-\\udfff](?=\\ud83c[\\udffb-\\udfff])|" + En + mn, - "g" - ), - In = RegExp( - [ - "[A-Z\\xc0-\\xd6\\xd8-\\xde]?[a-z\\xdf-\\xf6\\xf8-\\xff]+(?:['\u2019](?:d|ll|m|re|s|t|ve))?(?=[\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000]|[A-Z\\xc0-\\xd6\\xd8-\\xde]|$)|(?:[A-Z\\xc0-\\xd6\\xd8-\\xde]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])+(?:['\u2019](?:D|LL|M|RE|S|T|VE))?(?=[\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000]|[A-Z\\xc0-\\xd6\\xd8-\\xde](?:[a-z\\xdf-\\xf6\\xf8-\\xff]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])|$)|[A-Z\\xc0-\\xd6\\xd8-\\xde]?(?:[a-z\\xdf-\\xf6\\xf8-\\xff]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])+(?:['\u2019](?:d|ll|m|re|s|t|ve))?|[A-Z\\xc0-\\xd6\\xd8-\\xde]+(?:['\u2019](?:D|LL|M|RE|S|T|VE))?|\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])|\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])|\\d+", - An, - ].join("|"), - "g" - ), - Rn = RegExp( - "[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]" - ), - zn = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/, - Wn = "Array Buffer DataView Date Error Float32Array Float64Array Function Int8Array Int16Array Int32Array Map Math Object Promise RegExp Set String Symbol TypeError Uint8Array Uint8ClampedArray Uint16Array Uint32Array WeakMap _ clearTimeout isFinite parseInt setTimeout".split( - " " - ), - Bn = {} - ;(Bn["[object Float32Array]"] = Bn["[object Float64Array]"] = Bn[ - "[object Int8Array]" - ] = Bn["[object Int16Array]"] = Bn["[object Int32Array]"] = Bn[ - "[object Uint8Array]" - ] = Bn["[object Uint8ClampedArray]"] = Bn["[object Uint16Array]"] = Bn[ - "[object Uint32Array]" - ] = true), - (Bn["[object Arguments]"] = Bn["[object Array]"] = Bn[ - "[object ArrayBuffer]" - ] = Bn["[object Boolean]"] = Bn["[object DataView]"] = Bn[ - "[object Date]" - ] = Bn["[object Error]"] = Bn["[object Function]"] = Bn[ - "[object Map]" - ] = Bn["[object Number]"] = Bn["[object Object]"] = Bn[ - "[object RegExp]" - ] = Bn["[object Set]"] = Bn["[object String]"] = Bn[ - "[object WeakMap]" - ] = false) - var Ln = {} - ;(Ln["[object Arguments]"] = Ln["[object Array]"] = Ln[ - "[object ArrayBuffer]" - ] = Ln["[object DataView]"] = Ln["[object Boolean]"] = Ln[ - "[object Date]" - ] = Ln["[object Float32Array]"] = Ln["[object Float64Array]"] = Ln[ - "[object Int8Array]" - ] = Ln["[object Int16Array]"] = Ln["[object Int32Array]"] = Ln[ - "[object Map]" - ] = Ln["[object Number]"] = Ln["[object Object]"] = Ln[ - "[object RegExp]" - ] = Ln["[object Set]"] = Ln["[object String]"] = Ln[ - "[object Symbol]" - ] = Ln["[object Uint8Array]"] = Ln["[object Uint8ClampedArray]"] = Ln[ - "[object Uint16Array]" - ] = Ln["[object Uint32Array]"] = true), - (Ln["[object Error]"] = Ln["[object Function]"] = Ln[ - "[object WeakMap]" - ] = false) - var Un = { - "\\": "\\", - "'": "'", - "\n": "n", - "\r": "r", - "\u2028": "u2028", - "\u2029": "u2029", - }, - Cn = parseFloat, - Dn = parseInt, - Mn = - typeof commonjsGlobal == "object" && - commonjsGlobal && - commonjsGlobal.Object === Object && - commonjsGlobal, - Tn = typeof self == "object" && self && self.Object === Object && self, - $n = Mn || Tn || Function("return this")(), - Fn = exports && !exports.nodeType && exports, - Nn = Fn && "object" == "object" && module && !module.nodeType && module, - Pn = Nn && Nn.exports === Fn, - Zn = Pn && Mn.process, - qn = (function() { - try { - var n = Nn && Nn.f && Nn.f("util").types - return n ? n : Zn && Zn.binding && Zn.binding("util") - } catch (n) {} - })(), - Vn = qn && qn.isArrayBuffer, - Kn = qn && qn.isDate, - Gn = qn && qn.isMap, - Hn = qn && qn.isRegExp, - Jn = qn && qn.isSet, - Yn = qn && qn.isTypedArray, - Qn = b("length"), - Xn = x({ - À: "A", - Á: "A", - Â: "A", - Ã: "A", - Ä: "A", - Å: "A", - à: "a", - á: "a", - â: "a", - ã: "a", - ä: "a", - å: "a", - Ç: "C", - ç: "c", - Ð: "D", - ð: "d", - È: "E", - É: "E", - Ê: "E", - Ë: "E", - è: "e", - é: "e", - ê: "e", - ë: "e", - Ì: "I", - Í: "I", - Î: "I", - Ï: "I", - ì: "i", - í: "i", - î: "i", - ï: "i", - Ñ: "N", - ñ: "n", - Ò: "O", - Ó: "O", - Ô: "O", - Õ: "O", - Ö: "O", - Ø: "O", - ò: "o", - ó: "o", - ô: "o", - õ: "o", - ö: "o", - ø: "o", - Ù: "U", - Ú: "U", - Û: "U", - Ü: "U", - ù: "u", - ú: "u", - û: "u", - ü: "u", - Ý: "Y", - ý: "y", - ÿ: "y", - Æ: "Ae", - æ: "ae", - Þ: "Th", - þ: "th", - ß: "ss", - Ā: "A", - Ă: "A", - Ą: "A", - ā: "a", - ă: "a", - ą: "a", - Ć: "C", - Ĉ: "C", - Ċ: "C", - Č: "C", - ć: "c", - ĉ: "c", - ċ: "c", - č: "c", - Ď: "D", - Đ: "D", - ď: "d", - đ: "d", - Ē: "E", - Ĕ: "E", - Ė: "E", - Ę: "E", - Ě: "E", - ē: "e", - ĕ: "e", - ė: "e", - ę: "e", - ě: "e", - Ĝ: "G", - Ğ: "G", - Ġ: "G", - Ģ: "G", - ĝ: "g", - ğ: "g", - ġ: "g", - ģ: "g", - Ĥ: "H", - Ħ: "H", - ĥ: "h", - ħ: "h", - Ĩ: "I", - Ī: "I", - Ĭ: "I", - Į: "I", - İ: "I", - ĩ: "i", - ī: "i", - ĭ: "i", - į: "i", - ı: "i", - Ĵ: "J", - ĵ: "j", - Ķ: "K", - ķ: "k", - ĸ: "k", - Ĺ: "L", - Ļ: "L", - Ľ: "L", - Ŀ: "L", - Ł: "L", - ĺ: "l", - ļ: "l", - ľ: "l", - ŀ: "l", - ł: "l", - Ń: "N", - Ņ: "N", - Ň: "N", - Ŋ: "N", - ń: "n", - ņ: "n", - ň: "n", - ŋ: "n", - Ō: "O", - Ŏ: "O", - Ő: "O", - ō: "o", - ŏ: "o", - ő: "o", - Ŕ: "R", - Ŗ: "R", - Ř: "R", - ŕ: "r", - ŗ: "r", - ř: "r", - Ś: "S", - Ŝ: "S", - Ş: "S", - Š: "S", - ś: "s", - ŝ: "s", - ş: "s", - š: "s", - Ţ: "T", - Ť: "T", - Ŧ: "T", - ţ: "t", - ť: "t", - ŧ: "t", - Ũ: "U", - Ū: "U", - Ŭ: "U", - Ů: "U", - Ű: "U", - Ų: "U", - ũ: "u", - ū: "u", - ŭ: "u", - ů: "u", - ű: "u", - ų: "u", - Ŵ: "W", - ŵ: "w", - Ŷ: "Y", - ŷ: "y", - Ÿ: "Y", - Ź: "Z", - Ż: "Z", - Ž: "Z", - ź: "z", - ż: "z", - ž: "z", - IJ: "IJ", - ij: "ij", - Œ: "Oe", - œ: "oe", - ʼn: "'n", - ſ: "s", - }), - nt = x({ - "&": "&", - "<": "<", - ">": ">", - '"': """, - "'": "'", - }), - tt = x({ - "&": "&", - "<": "<", - ">": ">", - """: '"', - "'": "'", - }), - rt = (function x(mn) { - function An(n) { - if (yu(n) && !ff(n) && !(n instanceof Un)) { - if (n instanceof On) return n - if (oi.call(n, "__wrapped__")) return Fe(n) - } - return new On(n) - } - function En() {} - function On(n, t) { - ;(this.__wrapped__ = n), - (this.__actions__ = []), - (this.__chain__ = !!t), - (this.__index__ = 0), - (this.__values__ = T) - } - function Un(n) { - ;(this.__wrapped__ = n), - (this.__actions__ = []), - (this.__dir__ = 1), - (this.__filtered__ = false), - (this.__iteratees__ = []), - (this.__takeCount__ = 4294967295), - (this.__views__ = []) - } - function Mn(n) { - var t = -1, - r = null == n ? 0 : n.length - for (this.clear(); ++t < r; ) { - var e = n[t] - this.set(e[0], e[1]) - } - } - function Tn(n) { - var t = -1, - r = null == n ? 0 : n.length - for (this.clear(); ++t < r; ) { - var e = n[t] - this.set(e[0], e[1]) - } - } - function Fn(n) { - var t = -1, - r = null == n ? 0 : n.length - for (this.clear(); ++t < r; ) { - var e = n[t] - this.set(e[0], e[1]) - } - } - function Nn(n) { - var t = -1, - r = null == n ? 0 : n.length - for (this.__data__ = new Fn(); ++t < r; ) this.add(n[t]) - } - function Zn(n) { - this.size = (this.__data__ = new Tn(n)).size - } - function qn(n, t) { - var r, - e = ff(n), - u = !e && of(n), - i = !e && !u && af(n), - o = !e && !u && !i && _f(n), - u = (e = e || u || i || o) ? A(n.length, ni) : [], - f = u.length - for (r in n) - (!t && !oi.call(n, r)) || - (e && - ("length" == r || - (i && ("offset" == r || "parent" == r)) || - (o && - ("buffer" == r || - "byteLength" == r || - "byteOffset" == r)) || - Se(r, f))) || - u.push(r) - return u - } - function Qn(n) { - var t = n.length - return t ? n[ir(0, t - 1)] : T - } - function et(n, t) { - return De(Ur(n), pt(t, 0, n.length)) - } - function ut(n) { - return De(Ur(n)) - } - function it(n, t, r) { - ;((r === T || lu(n[t], r)) && (r !== T || t in n)) || st(n, t, r) - } - function ot(n, t, r) { - var e = n[t] - ;(oi.call(n, t) && lu(e, r) && (r !== T || t in n)) || st(n, t, r) - } - function ft(n, t) { - for (var r = n.length; r--; ) if (lu(n[r][0], t)) return r - return -1 - } - function ct(n, t, r, e) { - return ( - uo(n, function(n, u, i) { - t(e, n, r(n), i) - }), - e - ) - } - function at(n, t) { - return n && Cr(t, Wu(t), n) - } - function lt(n, t) { - return n && Cr(t, Bu(t), n) - } - function st(n, t, r) { - "__proto__" == t && Ai - ? Ai(n, t, { - configurable: true, - enumerable: true, - value: r, - writable: true, - }) - : (n[t] = r) - } - function ht(n, t) { - for (var r = -1, e = t.length, u = Ku(e), i = null == n; ++r < e; ) - u[r] = i ? T : Ru(n, t[r]) - return u - } - function pt(n, t, r) { - return ( - n === n && - (r !== T && (n = n <= r ? n : r), - t !== T && (n = n >= t ? n : t)), - n - ) - } - function _t(n, t, e, u, i, o) { - var f, - c = 1 & t, - a = 2 & t, - l = 4 & t - if ((e && (f = i ? e(n, u, i, o) : e(n)), f !== T)) return f - if (!du(n)) return n - if ((u = ff(n))) { - if (((f = me(n)), !c)) return Ur(n, f) - } else { - var s = vo(n), - h = - "[object Function]" == s || "[object GeneratorFunction]" == s - if (af(n)) return Ir(n, c) - if ( - "[object Object]" == s || - "[object Arguments]" == s || - (h && !i) - ) { - if (((f = a || h ? {} : Ae(n)), !c)) - return a ? Mr(n, lt(f, n)) : Dr(n, at(f, n)) - } else { - if (!Ln[s]) return i ? n : {} - f = Ee(n, s, c) - } - } - if ((o || (o = new Zn()), (i = o.get(n)))) return i - o.set(n, f), - pf(n) - ? n.forEach(function(r) { - f.add(_t(r, t, e, r, n, o)) - }) - : sf(n) && - n.forEach(function(r, u) { - f.set(u, _t(r, t, e, u, n, o)) - }) - var a = l ? (a ? ve : _e) : a ? Bu : Wu, - p = u ? T : a(n) - return ( - r(p || n, function(r, u) { - p && ((u = r), (r = n[u])), ot(f, u, _t(r, t, e, u, n, o)) - }), - f - ) - } - function vt(n) { - var t = Wu(n) - return function(r) { - return gt(r, n, t) - } - } - function gt(n, t, r) { - var e = r.length - if (null == n) return !e - for (n = Qu(n); e--; ) { - var u = r[e], - i = t[u], - o = n[u] - if ((o === T && !(u in n)) || !i(o)) return false - } - return true - } - function dt(n, t, r) { - if (typeof n != "function") throw new ti("Expected a function") - return bo(function() { - n.apply(T, r) - }, t) - } - function yt(n, t, r, e) { - var u = -1, - i = o, - a = true, - l = n.length, - s = [], - h = t.length - if (!l) return s - r && (t = c(t, k(r))), - e - ? ((i = f), (a = false)) - : 200 <= t.length && ((i = O), (a = false), (t = new Nn(t))) - n: for (; ++u < l; ) { - var p = n[u], - _ = null == r ? p : r(p), - p = e || 0 !== p ? p : 0 - if (a && _ === _) { - for (var v = h; v--; ) if (t[v] === _) continue n - s.push(p) - } else i(t, _, e) || s.push(p) - } - return s - } - function bt(n, t) { - var r = true - return ( - uo(n, function(n, e, u) { - return (r = !!t(n, e, u)) - }), - r - ) - } - function xt(n, t, r) { - for (var e = -1, u = n.length; ++e < u; ) { - var i = n[e], - o = t(i) - if (null != o && (f === T ? o === o && !wu(o) : r(o, f))) - var f = o, - c = i - } - return c - } - function jt(n, t) { - var r = [] - return ( - uo(n, function(n, e, u) { - t(n, e, u) && r.push(n) - }), - r - ) - } - function wt(n, t, r, e, u) { - var i = -1, - o = n.length - for (r || (r = ke), u || (u = []); ++i < o; ) { - var f = n[i] - 0 < t && r(f) - ? 1 < t - ? wt(f, t - 1, r, e, u) - : a(u, f) - : e || (u[u.length] = f) - } - return u - } - function mt(n, t) { - return n && oo(n, t, Wu) - } - function At(n, t) { - return n && fo(n, t, Wu) - } - function Et(n, t) { - return i(t, function(t) { - return _u(n[t]) - }) - } - function kt(n, t) { - t = Sr(t, n) - for (var r = 0, e = t.length; null != n && r < e; ) - n = n[Me(t[r++])] - return r && r == e ? n : T - } - function St(n, t, r) { - return (t = t(n)), ff(n) ? t : a(t, r(n)) - } - function Ot(n) { - if (null == n) n = n === T ? "[object Undefined]" : "[object Null]" - else if (mi && mi in Qu(n)) { - var t = oi.call(n, mi), - r = n[mi] - try { - n[mi] = T - var e = true - } catch (n) {} - var u = ai.call(n) - e && (t ? (n[mi] = r) : delete n[mi]), (n = u) - } else n = ai.call(n) - return n - } - function It(n, t) { - return n > t - } - function Rt(n, t) { - return null != n && oi.call(n, t) - } - function zt(n, t) { - return null != n && t in Qu(n) - } - function Wt(n, t, r) { - for ( - var e = r ? f : o, - u = n[0].length, - i = n.length, - a = i, - l = Ku(i), - s = 1 / 0, - h = []; - a--; - - ) { - var p = n[a] - a && t && (p = c(p, k(t))), - (s = Ci(p.length, s)), - (l[a] = - !r && (t || (120 <= u && 120 <= p.length)) - ? new Nn(a && p) - : T) - } - var p = n[0], - _ = -1, - v = l[0] - n: for (; ++_ < u && h.length < s; ) { - var g = p[_], - d = t ? t(g) : g, - g = r || 0 !== g ? g : 0 - if (v ? !O(v, d) : !e(h, d, r)) { - for (a = i; --a; ) { - var y = l[a] - if (y ? !O(y, d) : !e(n[a], d, r)) continue n - } - v && v.push(d), h.push(g) - } - } - return h - } - function Bt(n, t, r) { - var e = {} - return ( - mt(n, function(n, u, i) { - t(e, r(n), u, i) - }), - e - ) - } - function Lt(t, r, e) { - return ( - (r = Sr(r, t)), - (t = 2 > r.length ? t : kt(t, hr(r, 0, -1))), - (r = null == t ? t : t[Me(Ve(r))]), - null == r ? T : n(r, t, e) - ) - } - function Ut(n) { - return yu(n) && "[object Arguments]" == Ot(n) - } - function Ct(n) { - return yu(n) && "[object ArrayBuffer]" == Ot(n) - } - function Dt(n) { - return yu(n) && "[object Date]" == Ot(n) - } - function Mt(n, t, r, e, u) { - if (n === t) t = true - else if (null == n || null == t || (!yu(n) && !yu(t))) - t = n !== n && t !== t - else - n: { - var i = ff(n), - o = ff(t), - f = i ? "[object Array]" : vo(n), - c = o ? "[object Array]" : vo(t), - f = "[object Arguments]" == f ? "[object Object]" : f, - c = "[object Arguments]" == c ? "[object Object]" : c, - a = "[object Object]" == f, - o = "[object Object]" == c - if ((c = f == c) && af(n)) { - if (!af(t)) { - t = false - break n - } - ;(i = true), (a = false) - } - if (c && !a) - u || (u = new Zn()), - (t = - i || _f(n) - ? se(n, t, r, e, Mt, u) - : he(n, t, f, r, e, Mt, u)) - else { - if ( - !(1 & r) && - ((i = a && oi.call(n, "__wrapped__")), - (f = o && oi.call(t, "__wrapped__")), - i || f) - ) { - ;(n = i ? n.value() : n), - (t = f ? t.value() : t), - u || (u = new Zn()), - (t = Mt(n, t, r, e, u)) - break n - } - if (c) - t: if ( - (u || (u = new Zn()), - (i = 1 & r), - (f = _e(n)), - (o = f.length), - (c = _e(t).length), - o == c || i) - ) { - for (a = o; a--; ) { - var l = f[a] - if (!(i ? l in t : oi.call(t, l))) { - t = false - break t - } - } - if ((c = u.get(n)) && u.get(t)) t = c == t - else { - ;(c = true), u.set(n, t), u.set(t, n) - for (var s = i; ++a < o; ) { - var l = f[a], - h = n[l], - p = t[l] - if (e) - var _ = i - ? e(p, h, l, t, n, u) - : e(h, p, l, n, t, u) - if (_ === T ? h !== p && !Mt(h, p, r, e, u) : !_) { - c = false - break - } - s || (s = "constructor" == l) - } - c && - !s && - ((r = n.constructor), - (e = t.constructor), - r != e && - "constructor" in n && - "constructor" in t && - !( - typeof r == "function" && - r instanceof r && - typeof e == "function" && - e instanceof e - ) && - (c = false)), - u.delete(n), - u.delete(t), - (t = c) - } - } else t = false - else t = false - } - } - return t - } - function Tt(n) { - return yu(n) && "[object Map]" == vo(n) - } - function $t(n, t, r, e) { - var u = r.length, - i = u, - o = !e - if (null == n) return !i - for (n = Qu(n); u--; ) { - var f = r[u] - if (o && f[2] ? f[1] !== n[f[0]] : !(f[0] in n)) return false - } - for (; ++u < i; ) { - var f = r[u], - c = f[0], - a = n[c], - l = f[1] - if (o && f[2]) { - if (a === T && !(c in n)) return false - } else { - if (((f = new Zn()), e)) var s = e(a, l, c, n, t, f) - if (s === T ? !Mt(l, a, 3, e, f) : !s) return false - } - } - return true - } - function Ft(n) { - return !(!du(n) || (ci && ci in n)) && (_u(n) ? hi : dn).test(Te(n)) - } - function Nt(n) { - return yu(n) && "[object RegExp]" == Ot(n) - } - function Pt(n) { - return yu(n) && "[object Set]" == vo(n) - } - function Zt(n) { - return yu(n) && gu(n.length) && !!Bn[Ot(n)] - } - function qt(n) { - return typeof n == "function" - ? n - : null == n - ? $u - : typeof n == "object" - ? ff(n) - ? Jt(n[0], n[1]) - : Ht(n) - : Zu(n) - } - function Vt(n) { - if (!ze(n)) return Li(n) - var t, - r = [] - for (t in Qu(n)) oi.call(n, t) && "constructor" != t && r.push(t) - return r - } - function Kt(n, t) { - return n < t - } - function Gt(n, t) { - var r = -1, - e = su(n) ? Ku(n.length) : [] - return ( - uo(n, function(n, u, i) { - e[++r] = t(n, u, i) - }), - e - ) - } - function Ht(n) { - var t = xe(n) - return 1 == t.length && t[0][2] - ? We(t[0][0], t[0][1]) - : function(r) { - return r === n || $t(r, n, t) - } - } - function Jt(n, t) { - return Ie(n) && t === t && !du(t) - ? We(Me(n), t) - : function(r) { - var e = Ru(r, n) - return e === T && e === t ? zu(r, n) : Mt(t, e, 3) - } - } - function Yt(n, t, r, e, u) { - n !== t && - oo( - t, - function(i, o) { - if ((u || (u = new Zn()), du(i))) { - var f = u, - c = Le(n, o), - a = Le(t, o), - l = f.get(a) - if (l) it(n, o, l) - else { - var l = e ? e(c, a, o + "", n, t, f) : T, - s = l === T - if (s) { - var h = ff(a), - p = !h && af(a), - _ = !h && !p && _f(a), - l = a - h || p || _ - ? ff(c) - ? (l = c) - : hu(c) - ? (l = Ur(c)) - : p - ? ((s = false), (l = Ir(a, true))) - : _ - ? ((s = false), (l = zr(a, true))) - : (l = []) - : xu(a) || of(a) - ? ((l = c), - of(c) - ? (l = Ou(c)) - : (du(c) && !_u(c)) || (l = Ae(a))) - : (s = false) - } - s && (f.set(a, l), Yt(l, a, r, e, f), f.delete(a)), - it(n, o, l) - } - } else - (f = e ? e(Le(n, o), i, o + "", n, t, u) : T), - f === T && (f = i), - it(n, o, f) - }, - Bu - ) - } - function Qt(n, t) { - var r = n.length - if (r) return (t += 0 > t ? r : 0), Se(t, r) ? n[t] : T - } - function Xt(n, t, r) { - var e = -1 - return ( - (t = c(t.length ? t : [$u], k(ye()))), - (n = Gt(n, function(n) { - return { - a: c(t, function(t) { - return t(n) - }), - b: ++e, - c: n, - } - })), - w(n, function(n, t) { - var e - n: { - e = -1 - for ( - var u = n.a, i = t.a, o = u.length, f = r.length; - ++e < o; - - ) { - var c = Wr(u[e], i[e]) - if (c) { - e = e >= f ? c : c * ("desc" == r[e] ? -1 : 1) - break n - } - } - e = n.b - t.b - } - return e - }) - ) - } - function nr(n, t) { - return tr(n, t, function(t, r) { - return zu(n, r) - }) - } - function tr(n, t, r) { - for (var e = -1, u = t.length, i = {}; ++e < u; ) { - var o = t[e], - f = kt(n, o) - r(f, o) && lr(i, Sr(o, n), f) - } - return i - } - function rr(n) { - return function(t) { - return kt(t, n) - } - } - function er(n, t, r, e) { - var u = e ? g : v, - i = -1, - o = t.length, - f = n - for (n === t && (t = Ur(t)), r && (f = c(n, k(r))); ++i < o; ) - for ( - var a = 0, l = t[i], l = r ? r(l) : l; - -1 < (a = u(f, l, a, e)); - - ) - f !== n && xi.call(f, a, 1), xi.call(n, a, 1) - return n - } - function ur(n, t) { - for (var r = n ? t.length : 0, e = r - 1; r--; ) { - var u = t[r] - if (r == e || u !== i) { - var i = u - Se(u) ? xi.call(n, u, 1) : xr(n, u) - } - } - } - function ir(n, t) { - return n + Ii(Ti() * (t - n + 1)) - } - function or(n, t) { - var r = "" - if (!n || 1 > t || 9007199254740991 < t) return r - do t % 2 && (r += n), (t = Ii(t / 2)) && (n += n) - while (t) - return r - } - function fr(n, t) { - return xo(Be(n, t, $u), n + "") - } - function cr(n) { - return Qn(Uu(n)) - } - function ar(n, t) { - var r = Uu(n) - return De(r, pt(t, 0, r.length)) - } - function lr(n, t, r, e) { - if (!du(n)) return n - t = Sr(t, n) - for ( - var u = -1, i = t.length, o = i - 1, f = n; - null != f && ++u < i; - - ) { - var c = Me(t[u]), - a = r - if (u != o) { - var l = f[c], - a = e ? e(l, c, f) : T - a === T && (a = du(l) ? l : Se(t[u + 1]) ? [] : {}) - } - ot(f, c, a), (f = f[c]) - } - return n - } - function sr(n) { - return De(Uu(n)) - } - function hr(n, t, r) { - var e = -1, - u = n.length - for ( - 0 > t && (t = -t > u ? 0 : u + t), - r = r > u ? u : r, - 0 > r && (r += u), - u = t > r ? 0 : (r - t) >>> 0, - t >>>= 0, - r = Ku(u); - ++e < u; - - ) - r[e] = n[e + t] - return r - } - function pr(n, t) { - var r - return ( - uo(n, function(n, e, u) { - return (r = t(n, e, u)), !r - }), - !!r - ) - } - function _r(n, t, r) { - var e = 0, - u = null == n ? e : n.length - if (typeof t == "number" && t === t && 2147483647 >= u) { - for (; e < u; ) { - var i = (e + u) >>> 1, - o = n[i] - null !== o && !wu(o) && (r ? o <= t : o < t) - ? (e = i + 1) - : (u = i) - } - return u - } - return vr(n, t, $u, r) - } - function vr(n, t, r, e) { - t = r(t) - for ( - var u = 0, - i = null == n ? 0 : n.length, - o = t !== t, - f = null === t, - c = wu(t), - a = t === T; - u < i; - - ) { - var l = Ii((u + i) / 2), - s = r(n[l]), - h = s !== T, - p = null === s, - _ = s === s, - v = wu(s) - ;(o - ? e || _ - : a - ? _ && (e || h) - : f - ? _ && h && (e || !p) - : c - ? _ && h && !p && (e || !v) - : p || v - ? 0 - : e - ? s <= t - : s < t) - ? (u = l + 1) - : (i = l) - } - return Ci(i, 4294967294) - } - function gr(n, t) { - for (var r = -1, e = n.length, u = 0, i = []; ++r < e; ) { - var o = n[r], - f = t ? t(o) : o - if (!r || !lu(f, c)) { - var c = f - i[u++] = 0 === o ? 0 : o - } - } - return i - } - function dr(n) { - return typeof n == "number" ? n : wu(n) ? F : +n - } - function yr(n) { - if (typeof n == "string") return n - if (ff(n)) return c(n, yr) + "" - if (wu(n)) return ro ? ro.call(n) : "" - var t = n + "" - return "0" == t && 1 / n == -$ ? "-0" : t - } - function br(n, t, r) { - var e = -1, - u = o, - i = n.length, - c = true, - a = [], - l = a - if (r) (c = false), (u = f) - else if (200 <= i) { - if ((u = t ? null : so(n))) return U(u) - ;(c = false), (u = O), (l = new Nn()) - } else l = t ? [] : a - n: for (; ++e < i; ) { - var s = n[e], - h = t ? t(s) : s, - s = r || 0 !== s ? s : 0 - if (c && h === h) { - for (var p = l.length; p--; ) if (l[p] === h) continue n - t && l.push(h), a.push(s) - } else u(l, h, r) || (l !== a && l.push(h), a.push(s)) - } - return a - } - function xr(n, t) { - return ( - (t = Sr(t, n)), - (n = 2 > t.length ? n : kt(n, hr(t, 0, -1))), - null == n || delete n[Me(Ve(t))] - ) - } - function jr(n, t, r, e) { - for ( - var u = n.length, i = e ? u : -1; - (e ? i-- : ++i < u) && t(n[i], i, n); - - ); - return r - ? hr(n, e ? 0 : i, e ? i + 1 : u) - : hr(n, e ? i + 1 : 0, e ? u : i) - } - function wr(n, t) { - var r = n - return ( - r instanceof Un && (r = r.value()), - l( - t, - function(n, t) { - return t.func.apply(t.thisArg, a([n], t.args)) - }, - r - ) - ) - } - function mr(n, t, r) { - var e = n.length - if (2 > e) return e ? br(n[0]) : [] - for (var u = -1, i = Ku(e); ++u < e; ) - for (var o = n[u], f = -1; ++f < e; ) - f != u && (i[u] = yt(i[u] || o, n[f], t, r)) - return br(wt(i, 1), t, r) - } - function Ar(n, t, r) { - for (var e = -1, u = n.length, i = t.length, o = {}; ++e < u; ) - r(o, n[e], e < i ? t[e] : T) - return o - } - function Er(n) { - return hu(n) ? n : [] - } - function kr(n) { - return typeof n == "function" ? n : $u - } - function Sr(n, t) { - return ff(n) ? n : Ie(n, t) ? [n] : jo(Iu(n)) - } - function Or(n, t, r) { - var e = n.length - return (r = r === T ? e : r), !t && r >= e ? n : hr(n, t, r) - } - function Ir(n, t) { - if (t) return n.slice() - var r = n.length, - r = gi ? gi(r) : new n.constructor(r) - return n.copy(r), r - } - function Rr(n) { - var t = new n.constructor(n.byteLength) - return new vi(t).set(new vi(n)), t - } - function zr(n, t) { - return new n.constructor( - t ? Rr(n.buffer) : n.buffer, - n.byteOffset, - n.length - ) - } - function Wr(n, t) { - if (n !== t) { - var r = n !== T, - e = null === n, - u = n === n, - i = wu(n), - o = t !== T, - f = null === t, - c = t === t, - a = wu(t) - if ( - (!f && !a && !i && n > t) || - (i && o && c && !f && !a) || - (e && o && c) || - (!r && c) || - !u - ) - return 1 - if ( - (!e && !i && !a && n < t) || - (a && r && u && !e && !i) || - (f && r && u) || - (!o && u) || - !c - ) - return -1 - } - return 0 - } - function Br(n, t, r, e) { - var u = -1, - i = n.length, - o = r.length, - f = -1, - c = t.length, - a = Ui(i - o, 0), - l = Ku(c + a) - for (e = !e; ++f < c; ) l[f] = t[f] - for (; ++u < o; ) (e || u < i) && (l[r[u]] = n[u]) - for (; a--; ) l[f++] = n[u++] - return l - } - function Lr(n, t, r, e) { - var u = -1, - i = n.length, - o = -1, - f = r.length, - c = -1, - a = t.length, - l = Ui(i - f, 0), - s = Ku(l + a) - for (e = !e; ++u < l; ) s[u] = n[u] - for (l = u; ++c < a; ) s[l + c] = t[c] - for (; ++o < f; ) (e || u < i) && (s[l + r[o]] = n[u++]) - return s - } - function Ur(n, t) { - var r = -1, - e = n.length - for (t || (t = Ku(e)); ++r < e; ) t[r] = n[r] - return t - } - function Cr(n, t, r, e) { - var u = !r - r || (r = {}) - for (var i = -1, o = t.length; ++i < o; ) { - var f = t[i], - c = e ? e(r[f], n[f], f, r, n) : T - c === T && (c = n[f]), u ? st(r, f, c) : ot(r, f, c) - } - return r - } - function Dr(n, t) { - return Cr(n, po(n), t) - } - function Mr(n, t) { - return Cr(n, _o(n), t) - } - function Tr(n, r) { - return function(e, u) { - var i = ff(e) ? t : ct, - o = r ? r() : {} - return i(e, n, ye(u, 2), o) - } - } - function $r(n) { - return fr(function(t, r) { - var e = -1, - u = r.length, - i = 1 < u ? r[u - 1] : T, - o = 2 < u ? r[2] : T, - i = 3 < n.length && typeof i == "function" ? (u--, i) : T - for ( - o && Oe(r[0], r[1], o) && ((i = 3 > u ? T : i), (u = 1)), - t = Qu(t); - ++e < u; - - ) - (o = r[e]) && n(t, o, e, i) - return t - }) - } - function Fr(n, t) { - return function(r, e) { - if (null == r) return r - if (!su(r)) return n(r, e) - for ( - var u = r.length, i = t ? u : -1, o = Qu(r); - (t ? i-- : ++i < u) && false !== e(o[i], i, o); - - ); - return r - } - } - function Nr(n) { - return function(t, r, e) { - var u = -1, - i = Qu(t) - e = e(t) - for (var o = e.length; o--; ) { - var f = e[n ? o : ++u] - if (false === r(i[f], f, i)) break - } - return t - } - } - function Pr(n, t, r) { - function e() { - return (this && this !== $n && this instanceof e ? i : n).apply( - u ? r : this, - arguments - ) - } - var u = 1 & t, - i = Vr(n) - return e - } - function Zr(n) { - return function(t) { - t = Iu(t) - var r = Rn.test(t) ? M(t) : T, - e = r ? r[0] : t.charAt(0) - return (t = r ? Or(r, 1).join("") : t.slice(1)), e[n]() + t - } - } - function qr(n) { - return function(t) { - return l(Mu(Du(t).replace(kn, "")), n, "") - } - } - function Vr(n) { - return function() { - var t = arguments - switch (t.length) { - case 0: - return new n() - case 1: - return new n(t[0]) - case 2: - return new n(t[0], t[1]) - case 3: - return new n(t[0], t[1], t[2]) - case 4: - return new n(t[0], t[1], t[2], t[3]) - case 5: - return new n(t[0], t[1], t[2], t[3], t[4]) - case 6: - return new n(t[0], t[1], t[2], t[3], t[4], t[5]) - case 7: - return new n(t[0], t[1], t[2], t[3], t[4], t[5], t[6]) - } - var r = eo(n.prototype), - t = n.apply(r, t) - return du(t) ? t : r - } - } - function Kr(t, r, e) { - function u() { - for (var o = arguments.length, f = Ku(o), c = o, a = de(u); c--; ) - f[c] = arguments[c] - return ( - (c = 3 > o && f[0] !== a && f[o - 1] !== a ? [] : L(f, a)), - (o -= c.length), - o < e - ? ue(t, r, Jr, u.placeholder, T, f, c, T, T, e - o) - : n(this && this !== $n && this instanceof u ? i : t, this, f) - ) - } - var i = Vr(t) - return u - } - function Gr(n) { - return function(t, r, e) { - var u = Qu(t) - if (!su(t)) { - var i = ye(r, 3) - ;(t = Wu(t)), - (r = function(n) { - return i(u[n], n, u) - }) - } - return (r = n(t, r, e)), -1 < r ? u[i ? t[r] : r] : T - } - } - function Hr(n) { - return pe(function(t) { - var r = t.length, - e = r, - u = On.prototype.thru - for (n && t.reverse(); e--; ) { - var i = t[e] - if (typeof i != "function") throw new ti("Expected a function") - if (u && !o && "wrapper" == ge(i)) var o = new On([], true) - } - for (e = o ? e : r; ++e < r; ) - var i = t[e], - u = ge(i), - f = "wrapper" == u ? ho(i) : T, - o = - f && Re(f[0]) && 424 == f[1] && !f[4].length && 1 == f[9] - ? o[ge(f[0])].apply(o, f[3]) - : 1 == i.length && Re(i) - ? o[u]() - : o.thru(i) - return function() { - var n = arguments, - e = n[0] - if (o && 1 == n.length && ff(e)) return o.plant(e).value() - for (var u = 0, n = r ? t[u].apply(this, n) : e; ++u < r; ) - n = t[u].call(this, n) - return n - } - }) - } - function Jr(n, t, r, e, u, i, o, f, c, a) { - function l() { - for (var d = arguments.length, y = Ku(d), b = d; b--; ) - y[b] = arguments[b] - if (_) { - var x, - j = de(l), - b = y.length - for (x = 0; b--; ) y[b] === j && ++x - } - if ( - (e && (y = Br(y, e, u, _)), - i && (y = Lr(y, i, o, _)), - (d -= x), - _ && d < a) - ) - return ( - (j = L(y, j)), - ue(n, t, Jr, l.placeholder, r, y, j, f, c, a - d) - ) - if (((j = h ? r : this), (b = p ? j[n] : n), (d = y.length), f)) { - x = y.length - for (var w = Ci(f.length, x), m = Ur(y); w--; ) { - var A = f[w] - y[w] = Se(A, x) ? m[A] : T - } - } else v && 1 < d && y.reverse() - return ( - s && c < d && (y.length = c), - this && this !== $n && this instanceof l && (b = g || Vr(b)), - b.apply(j, y) - ) - } - var s = 128 & t, - h = 1 & t, - p = 2 & t, - _ = 24 & t, - v = 512 & t, - g = p ? T : Vr(n) - return l - } - function Yr(n, t) { - return function(r, e) { - return Bt(r, n, t(e)) - } - } - function Qr(n, t) { - return function(r, e) { - var u - if (r === T && e === T) return t - if ((r !== T && (u = r), e !== T)) { - if (u === T) return e - typeof r == "string" || typeof e == "string" - ? ((r = yr(r)), (e = yr(e))) - : ((r = dr(r)), (e = dr(e))), - (u = n(r, e)) - } - return u - } - } - function Xr(t) { - return pe(function(r) { - return ( - (r = c(r, k(ye()))), - fr(function(e) { - var u = this - return t(r, function(t) { - return n(t, u, e) - }) - }) - ) - }) - } - function ne(n, t) { - t = t === T ? " " : yr(t) - var r = t.length - return 2 > r - ? r - ? or(t, n) - : t - : ((r = or(t, Oi(n / D(t)))), - Rn.test(t) ? Or(M(r), 0, n).join("") : r.slice(0, n)) - } - function te(t, r, e, u) { - function i() { - for ( - var r = -1, - c = arguments.length, - a = -1, - l = u.length, - s = Ku(l + c), - h = this && this !== $n && this instanceof i ? f : t; - ++a < l; - - ) - s[a] = u[a] - for (; c--; ) s[a++] = arguments[++r] - return n(h, o ? e : this, s) - } - var o = 1 & r, - f = Vr(t) - return i - } - function re(n) { - return function(t, r, e) { - e && typeof e != "number" && Oe(t, r, e) && (r = e = T), - (t = Au(t)), - r === T ? ((r = t), (t = 0)) : (r = Au(r)), - (e = e === T ? (t < r ? 1 : -1) : Au(e)) - var u = -1 - r = Ui(Oi((r - t) / (e || 1)), 0) - for (var i = Ku(r); r--; ) (i[n ? r : ++u] = t), (t += e) - return i - } - } - function ee(n) { - return function(t, r) { - return ( - (typeof t == "string" && typeof r == "string") || - ((t = Su(t)), (r = Su(r))), - n(t, r) - ) - } - } - function ue(n, t, r, e, u, i, o, f, c, a) { - var l = 8 & t, - s = l ? o : T - o = l ? T : o - var h = l ? i : T - return ( - (i = l ? T : i), - (t = (t | (l ? 32 : 64)) & ~(l ? 64 : 32)), - 4 & t || (t &= -4), - (u = [n, t, u, h, s, i, o, f, c, a]), - (r = r.apply(T, u)), - Re(n) && yo(r, u), - (r.placeholder = e), - Ue(r, n, t) - ) - } - function ie(n) { - var t = Yu[n] - return function(n, r) { - if ( - ((n = Su(n)), (r = null == r ? 0 : Ci(Eu(r), 292)) && Wi(n)) - ) { - var e = (Iu(n) + "e").split("e"), - e = t(e[0] + "e" + (+e[1] + r)), - e = (Iu(e) + "e").split("e") - return +(e[0] + "e" + (+e[1] - r)) - } - return t(n) - } - } - function oe(n) { - return function(t) { - var r = vo(t) - return "[object Map]" == r - ? W(t) - : "[object Set]" == r - ? C(t) - : E(t, n(t)) - } - } - function fe(n, t, r, e, u, i, o, f) { - var c = 2 & t - if (!c && typeof n != "function") - throw new ti("Expected a function") - var a = e ? e.length : 0 - if ( - (a || ((t &= -97), (e = u = T)), - (o = o === T ? o : Ui(Eu(o), 0)), - (f = f === T ? f : Eu(f)), - (a -= u ? u.length : 0), - 64 & t) - ) { - var l = e, - s = u - e = u = T - } - var h = c ? T : ho(n) - return ( - (i = [n, t, r, e, u, l, s, i, o, f]), - h && - ((r = i[1]), - (n = h[1]), - (t = r | n), - (e = - (128 == n && 8 == r) || - (128 == n && 256 == r && i[7].length <= h[8]) || - (384 == n && h[7].length <= h[8] && 8 == r)), - 131 > t || e) && - (1 & n && ((i[2] = h[2]), (t |= 1 & r ? 0 : 4)), - (r = h[3]) && - ((e = i[3]), - (i[3] = e ? Br(e, r, h[4]) : r), - (i[4] = e ? L(i[3], "__lodash_placeholder__") : h[4])), - (r = h[5]) && - ((e = i[5]), - (i[5] = e ? Lr(e, r, h[6]) : r), - (i[6] = e ? L(i[5], "__lodash_placeholder__") : h[6])), - (r = h[7]) && (i[7] = r), - 128 & n && (i[8] = null == i[8] ? h[8] : Ci(i[8], h[8])), - null == i[9] && (i[9] = h[9]), - (i[0] = h[0]), - (i[1] = t)), - (n = i[0]), - (t = i[1]), - (r = i[2]), - (e = i[3]), - (u = i[4]), - (f = i[9] = i[9] === T ? (c ? 0 : n.length) : Ui(i[9] - a, 0)), - !f && 24 & t && (t &= -25), - Ue( - (h ? co : yo)( - t && 1 != t - ? 8 == t || 16 == t - ? Kr(n, t, f) - : (32 != t && 33 != t) || u.length - ? Jr.apply(T, i) - : te(n, t, r, e) - : Pr(n, t, r), - i - ), - n, - t - ) - ) - } - function ce(n, t, r, e) { - return n === T || (lu(n, ei[r]) && !oi.call(e, r)) ? t : n - } - function ae(n, t, r, e, u, i) { - return ( - du(n) && du(t) && (i.set(t, n), Yt(n, t, T, ae, i), i.delete(t)), - n - ) - } - function le(n) { - return xu(n) ? T : n - } - function se(n, t, r, e, u, i) { - var o = 1 & r, - f = n.length, - c = t.length - if (f != c && !(o && c > f)) return false - if ((c = i.get(n)) && i.get(t)) return c == t - var c = -1, - a = true, - l = 2 & r ? new Nn() : T - for (i.set(n, t), i.set(t, n); ++c < f; ) { - var s = n[c], - p = t[c] - if (e) var _ = o ? e(p, s, c, t, n, i) : e(s, p, c, n, t, i) - if (_ !== T) { - if (_) continue - a = false - break - } - if (l) { - if ( - !h(t, function(n, t) { - if (!O(l, t) && (s === n || u(s, n, r, e, i))) - return l.push(t) - }) - ) { - a = false - break - } - } else if (s !== p && !u(s, p, r, e, i)) { - a = false - break - } - } - return i.delete(n), i.delete(t), a - } - function he(n, t, r, e, u, i, o) { - switch (r) { - case "[object DataView]": - if ( - n.byteLength != t.byteLength || - n.byteOffset != t.byteOffset - ) - break - ;(n = n.buffer), (t = t.buffer) - case "[object ArrayBuffer]": - if (n.byteLength != t.byteLength || !i(new vi(n), new vi(t))) - break - return true - case "[object Boolean]": - case "[object Date]": - case "[object Number]": - return lu(+n, +t) - case "[object Error]": - return n.name == t.name && n.message == t.message - case "[object RegExp]": - case "[object String]": - return n == t + "" - case "[object Map]": - var f = W - case "[object Set]": - if ((f || (f = U), n.size != t.size && !(1 & e))) break - return (r = o.get(n)) - ? r == t - : ((e |= 2), - o.set(n, t), - (t = se(f(n), f(t), e, u, i, o)), - o.delete(n), - t) - case "[object Symbol]": - if (to) return to.call(n) == to.call(t) - } - return false - } - function pe(n) { - return xo(Be(n, T, Ze), n + "") - } - function _e(n) { - return St(n, Wu, po) - } - function ve(n) { - return St(n, Bu, _o) - } - function ge(n) { - for ( - var t = n.name + "", r = Gi[t], e = oi.call(Gi, t) ? r.length : 0; - e--; - - ) { - var u = r[e], - i = u.func - if (null == i || i == n) return u.name - } - return t - } - function de(n) { - return (oi.call(An, "placeholder") ? An : n).placeholder - } - function ye() { - var n = An.iteratee || Fu, - n = n === Fu ? qt : n - return arguments.length ? n(arguments[0], arguments[1]) : n - } - function be(n, t) { - var r = n.__data__, - e = typeof t - return ("string" == e || - "number" == e || - "symbol" == e || - "boolean" == e - ? "__proto__" !== t - : null === t) - ? r[typeof t == "string" ? "string" : "hash"] - : r.map - } - function xe(n) { - for (var t = Wu(n), r = t.length; r--; ) { - var e = t[r], - u = n[e] - t[r] = [e, u, u === u && !du(u)] - } - return t - } - function je(n, t) { - var r = null == n ? T : n[t] - return Ft(r) ? r : T - } - function we(n, t, r) { - t = Sr(t, n) - for (var e = -1, u = t.length, i = false; ++e < u; ) { - var o = Me(t[e]) - if (!(i = null != n && r(n, o))) break - n = n[o] - } - return i || ++e != u - ? i - : ((u = null == n ? 0 : n.length), - !!u && gu(u) && Se(o, u) && (ff(n) || of(n))) - } - function me(n) { - var t = n.length, - r = new n.constructor(t) - return ( - t && - "string" == typeof n[0] && - oi.call(n, "index") && - ((r.index = n.index), (r.input = n.input)), - r - ) - } - function Ae(n) { - return typeof n.constructor != "function" || ze(n) ? {} : eo(di(n)) - } - function Ee(n, t, r) { - var e = n.constructor - switch (t) { - case "[object ArrayBuffer]": - return Rr(n) - case "[object Boolean]": - case "[object Date]": - return new e(+n) - case "[object DataView]": - return ( - (t = r ? Rr(n.buffer) : n.buffer), - new n.constructor(t, n.byteOffset, n.byteLength) - ) - case "[object Float32Array]": - case "[object Float64Array]": - case "[object Int8Array]": - case "[object Int16Array]": - case "[object Int32Array]": - case "[object Uint8Array]": - case "[object Uint8ClampedArray]": - case "[object Uint16Array]": - case "[object Uint32Array]": - return zr(n, r) - case "[object Map]": - return new e() - case "[object Number]": - case "[object String]": - return new e(n) - case "[object RegExp]": - return ( - (t = new n.constructor(n.source, _n.exec(n))), - (t.lastIndex = n.lastIndex), - t - ) - case "[object Set]": - return new e() - case "[object Symbol]": - return to ? Qu(to.call(n)) : {} - } - } - function ke(n) { - return ff(n) || of(n) || !!(ji && n && n[ji]) - } - function Se(n, t) { - var r = typeof n - return ( - (t = null == t ? 9007199254740991 : t), - !!t && - ("number" == r || ("symbol" != r && bn.test(n))) && - -1 < n && - 0 == n % 1 && - n < t - ) - } - function Oe(n, t, r) { - if (!du(r)) return false - var e = typeof t - return ( - !!("number" == e - ? su(r) && Se(t, r.length) - : "string" == e && t in r) && lu(r[t], n) - ) - } - function Ie(n, t) { - if (ff(n)) return false - var r = typeof n - return ( - !( - "number" != r && - "symbol" != r && - "boolean" != r && - null != n && - !wu(n) - ) || - nn.test(n) || !X.test(n) || (null != t && n in Qu(t)) - ) - } - function Re(n) { - var t = ge(n), - r = An[t] - return ( - typeof r == "function" && - t in Un.prototype && - (n === r || ((t = ho(r)), !!t && n === t[0])) - ) - } - function ze(n) { - var t = n && n.constructor - return n === ((typeof t == "function" && t.prototype) || ei) - } - function We(n, t) { - return function(r) { - return null != r && r[n] === t && (t !== T || n in Qu(r)) - } - } - function Be(t, r, e) { - return ( - (r = Ui(r === T ? t.length - 1 : r, 0)), - function() { - for ( - var u = arguments, i = -1, o = Ui(u.length - r, 0), f = Ku(o); - ++i < o; - - ) - f[i] = u[r + i] - for (i = -1, o = Ku(r + 1); ++i < r; ) o[i] = u[i] - return (o[r] = e(f)), n(t, this, o) - } - ) - } - function Le(n, t) { - if ( - ("constructor" !== t || "function" != typeof n[t]) && - "__proto__" != t - ) - return n[t] - } - function Ue(n, t, r) { - var e = t + "" - t = xo - var u, - i = $e - return ( - (u = (u = e.match(an)) ? u[1].split(ln) : []), - (r = i(u, r)), - (i = r.length) && - ((u = i - 1), - (r[u] = (1 < i ? "& " : "") + r[u]), - (r = r.join(2 < i ? ", " : " ")), - (e = e.replace(cn, "{\n/* [wrapped with " + r + "] */\n"))), - t(n, e) - ) - } - function Ce(n) { - var t = 0, - r = 0 - return function() { - var e = Di(), - u = 16 - (e - r) - if (((r = e), 0 < u)) { - if (800 <= ++t) return arguments[0] - } else t = 0 - return n.apply(T, arguments) - } - } - function De(n, t) { - var r = -1, - e = n.length, - u = e - 1 - for (t = t === T ? e : t; ++r < t; ) { - var e = ir(r, u), - i = n[e] - ;(n[e] = n[r]), (n[r] = i) - } - return (n.length = t), n - } - function Me(n) { - if (typeof n == "string" || wu(n)) return n - var t = n + "" - return "0" == t && 1 / n == -$ ? "-0" : t - } - function Te(n) { - if (null != n) { - try { - return ii.call(n) - } catch (n) {} - return n + "" - } - return "" - } - function $e(n, t) { - return ( - r(N, function(r) { - var e = "_." + r[0] - t & r[1] && !o(n, e) && n.push(e) - }), - n.sort() - ) - } - function Fe(n) { - if (n instanceof Un) return n.clone() - var t = new On(n.__wrapped__, n.__chain__) - return ( - (t.__actions__ = Ur(n.__actions__)), - (t.__index__ = n.__index__), - (t.__values__ = n.__values__), - t - ) - } - function Ne(n, t, r) { - var e = null == n ? 0 : n.length - return e - ? ((r = null == r ? 0 : Eu(r)), - 0 > r && (r = Ui(e + r, 0)), - _(n, ye(t, 3), r)) - : -1 - } - function Pe(n, t, r) { - var e = null == n ? 0 : n.length - if (!e) return -1 - var u = e - 1 - return ( - r !== T && - ((u = Eu(r)), (u = 0 > r ? Ui(e + u, 0) : Ci(u, e - 1))), - _(n, ye(t, 3), u, true) - ) - } - function Ze(n) { - return (null == n ? 0 : n.length) ? wt(n, 1) : [] - } - function qe(n) { - return n && n.length ? n[0] : T - } - function Ve(n) { - var t = null == n ? 0 : n.length - return t ? n[t - 1] : T - } - function Ke(n, t) { - return n && n.length && t && t.length ? er(n, t) : n - } - function Ge(n) { - return null == n ? n : $i.call(n) - } - function He(n) { - if (!n || !n.length) return [] - var t = 0 - return ( - (n = i(n, function(n) { - if (hu(n)) return (t = Ui(n.length, t)), true - })), - A(t, function(t) { - return c(n, b(t)) - }) - ) - } - function Je(t, r) { - if (!t || !t.length) return [] - var e = He(t) - return null == r - ? e - : c(e, function(t) { - return n(r, T, t) - }) - } - function Ye(n) { - return (n = An(n)), (n.__chain__ = true), n - } - function Qe(n, t) { - return t(n) - } - function Xe() { - return this - } - function nu(n, t) { - return (ff(n) ? r : uo)(n, ye(t, 3)) - } - function tu(n, t) { - return (ff(n) ? e : io)(n, ye(t, 3)) - } - function ru(n, t) { - return (ff(n) ? c : Gt)(n, ye(t, 3)) - } - function eu(n, t, r) { - return ( - (t = r ? T : t), - (t = n && null == t ? n.length : t), - fe(n, 128, T, T, T, T, t) - ) - } - function uu(n, t) { - var r - if (typeof t != "function") throw new ti("Expected a function") - return ( - (n = Eu(n)), - function() { - return ( - 0 < --n && (r = t.apply(this, arguments)), - 1 >= n && (t = T), - r - ) - } - ) - } - function iu(n, t, r) { - return ( - (t = r ? T : t), - (n = fe(n, 8, T, T, T, T, T, t)), - (n.placeholder = iu.placeholder), - n - ) - } - function ou(n, t, r) { - return ( - (t = r ? T : t), - (n = fe(n, 16, T, T, T, T, T, t)), - (n.placeholder = ou.placeholder), - n - ) - } - function fu(n, t, r) { - function e(t) { - var r = c, - e = a - return (c = a = T), (_ = t), (s = n.apply(e, r)) - } - function u(n) { - var r = n - p - return (n -= _), p === T || r >= t || 0 > r || (g && n >= l) - } - function i() { - var n = Go() - if (u(n)) return o(n) - var r, - e = bo - ;(r = n - _), - (n = t - (n - p)), - (r = g ? Ci(n, l - r) : n), - (h = e(i, r)) - } - function o(n) { - return (h = T), d && c ? e(n) : ((c = a = T), s) - } - function f() { - var n = Go(), - r = u(n) - if (((c = arguments), (a = this), (p = n), r)) { - if (h === T) return (_ = n = p), (h = bo(i, t)), v ? e(n) : s - if (g) return lo(h), (h = bo(i, t)), e(p) - } - return h === T && (h = bo(i, t)), s - } - var c, - a, - l, - s, - h, - p, - _ = 0, - v = false, - g = false, - d = true - if (typeof n != "function") throw new ti("Expected a function") - return ( - (t = Su(t) || 0), - du(r) && - ((v = !!r.leading), - (l = (g = "maxWait" in r) ? Ui(Su(r.maxWait) || 0, t) : l), - (d = "trailing" in r ? !!r.trailing : d)), - (f.cancel = function() { - h !== T && lo(h), (_ = 0), (c = p = a = h = T) - }), - (f.flush = function() { - return h === T ? s : o(Go()) - }), - f - ) - } - function cu(n, t) { - function r() { - var e = arguments, - u = t ? t.apply(this, e) : e[0], - i = r.cache - return i.has(u) - ? i.get(u) - : ((e = n.apply(this, e)), (r.cache = i.set(u, e) || i), e) - } - if (typeof n != "function" || (null != t && typeof t != "function")) - throw new ti("Expected a function") - return (r.cache = new (cu.Cache || Fn)()), r - } - function au(n) { - if (typeof n != "function") throw new ti("Expected a function") - return function() { - var t = arguments - switch (t.length) { - case 0: - return !n.call(this) - case 1: - return !n.call(this, t[0]) - case 2: - return !n.call(this, t[0], t[1]) - case 3: - return !n.call(this, t[0], t[1], t[2]) - } - return !n.apply(this, t) - } - } - function lu(n, t) { - return n === t || (n !== n && t !== t) - } - function su(n) { - return null != n && gu(n.length) && !_u(n) - } - function hu(n) { - return yu(n) && su(n) - } - function pu(n) { - if (!yu(n)) return false - var t = Ot(n) - return ( - "[object Error]" == t || - "[object DOMException]" == t || - (typeof n.message == "string" && - typeof n.name == "string" && - !xu(n)) - ) - } - function _u(n) { - return ( - !!du(n) && - ((n = Ot(n)), - "[object Function]" == n || - "[object GeneratorFunction]" == n || - "[object AsyncFunction]" == n || - "[object Proxy]" == n) - ) - } - function vu(n) { - return typeof n == "number" && n == Eu(n) - } - function gu(n) { - return ( - typeof n == "number" && - -1 < n && - 0 == n % 1 && - 9007199254740991 >= n - ) - } - function du(n) { - var t = typeof n - return null != n && ("object" == t || "function" == t) - } - function yu(n) { - return null != n && typeof n == "object" - } - function bu(n) { - return typeof n == "number" || (yu(n) && "[object Number]" == Ot(n)) - } - function xu(n) { - return ( - !(!yu(n) || "[object Object]" != Ot(n)) && - ((n = di(n)), - null === n || - ((n = oi.call(n, "constructor") && n.constructor), - typeof n == "function" && n instanceof n && ii.call(n) == li)) - ) - } - function ju(n) { - return ( - typeof n == "string" || - (!ff(n) && yu(n) && "[object String]" == Ot(n)) - ) - } - function wu(n) { - return typeof n == "symbol" || (yu(n) && "[object Symbol]" == Ot(n)) - } - function mu(n) { - if (!n) return [] - if (su(n)) return ju(n) ? M(n) : Ur(n) - if (wi && n[wi]) { - n = n[wi]() - for (var t, r = []; !(t = n.next()).done; ) r.push(t.value) - return r - } - return ( - (t = vo(n)), - ("[object Map]" == t ? W : "[object Set]" == t ? U : Uu)(n) - ) - } - function Au(n) { - return n - ? ((n = Su(n)), - n === $ || n === -$ - ? 1.7976931348623157e308 * (0 > n ? -1 : 1) - : n === n - ? n - : 0) - : 0 === n - ? n - : 0 - } - function Eu(n) { - n = Au(n) - var t = n % 1 - return n === n ? (t ? n - t : n) : 0 - } - function ku(n) { - return n ? pt(Eu(n), 0, 4294967295) : 0 - } - function Su(n) { - if (typeof n == "number") return n - if (wu(n)) return F - if ( - (du(n) && - ((n = typeof n.valueOf == "function" ? n.valueOf() : n), - (n = du(n) ? n + "" : n)), - typeof n != "string") - ) - return 0 === n ? n : +n - n = n.replace(un, "") - var t = gn.test(n) - return t || yn.test(n) - ? Dn(n.slice(2), t ? 2 : 8) - : vn.test(n) - ? F - : +n - } - function Ou(n) { - return Cr(n, Bu(n)) - } - function Iu(n) { - return null == n ? "" : yr(n) - } - function Ru(n, t, r) { - return (n = null == n ? T : kt(n, t)), n === T ? r : n - } - function zu(n, t) { - return null != n && we(n, t, zt) - } - function Wu(n) { - return su(n) ? qn(n) : Vt(n) - } - function Bu(n) { - if (su(n)) n = qn(n, true) - else if (du(n)) { - var t, - r = ze(n), - e = [] - for (t in n) - ("constructor" != t || (!r && oi.call(n, t))) && e.push(t) - n = e - } else { - if (((t = []), null != n)) for (r in Qu(n)) t.push(r) - n = t - } - return n - } - function Lu(n, t) { - if (null == n) return {} - var r = c(ve(n), function(n) { - return [n] - }) - return ( - (t = ye(t)), - tr(n, r, function(n, r) { - return t(n, r[0]) - }) - ) - } - function Uu(n) { - return null == n ? [] : S(n, Wu(n)) - } - function Cu(n) { - return $f(Iu(n).toLowerCase()) - } - function Du(n) { - return (n = Iu(n)) && n.replace(xn, Xn).replace(Sn, "") - } - function Mu(n, t, r) { - return ( - (n = Iu(n)), - (t = r ? T : t), - t === T - ? zn.test(n) - ? n.match(In) || [] - : n.match(sn) || [] - : n.match(t) || [] - ) - } - function Tu(n) { - return function() { - return n - } - } - function $u(n) { - return n - } - function Fu(n) { - return qt(typeof n == "function" ? n : _t(n, 1)) - } - function Nu(n, t, e) { - var u = Wu(t), - i = Et(t, u) - null != e || - (du(t) && (i.length || !u.length)) || - ((e = t), (t = n), (n = this), (i = Et(t, Wu(t)))) - var o = !(du(e) && "chain" in e && !e.chain), - f = _u(n) - return ( - r(i, function(r) { - var e = t[r] - ;(n[r] = e), - f && - (n.prototype[r] = function() { - var t = this.__chain__ - if (o || t) { - var r = n(this.__wrapped__) - return ( - (r.__actions__ = Ur(this.__actions__)).push({ - func: e, - args: arguments, - thisArg: n, - }), - (r.__chain__ = t), - r - ) - } - return e.apply(n, a([this.value()], arguments)) - }) - }), - n - ) - } - function Pu() {} - function Zu(n) { - return Ie(n) ? b(Me(n)) : rr(n) - } - function qu() { - return [] - } - function Vu() { - return false - } - mn = null == mn ? $n : rt.defaults($n.Object(), mn, rt.pick($n, Wn)) - var Ku = mn.Array, - Gu = mn.Date, - Hu = mn.Error, - Ju = mn.Function, - Yu = mn.Math, - Qu = mn.Object, - Xu = mn.RegExp, - ni = mn.String, - ti = mn.TypeError, - ri = Ku.prototype, - ei = Qu.prototype, - ui = mn["__core-js_shared__"], - ii = Ju.prototype.toString, - oi = ei.hasOwnProperty, - fi = 0, - ci = (function() { - var n = /[^.]+$/.exec((ui && ui.keys && ui.keys.IE_PROTO) || "") - return n ? "Symbol(src)_1." + n : "" - })(), - ai = ei.toString, - li = ii.call(Qu), - si = $n._, - hi = Xu( - "^" + - ii - .call(oi) - .replace(rn, "\\$&") - .replace( - /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, - "$1.*?" - ) + - "$" - ), - pi = Pn ? mn.Buffer : T, - _i = mn.Symbol, - vi = mn.Uint8Array, - gi = pi ? pi.g : T, - di = B(Qu.getPrototypeOf, Qu), - yi = Qu.create, - bi = ei.propertyIsEnumerable, - xi = ri.splice, - ji = _i ? _i.isConcatSpreadable : T, - wi = _i ? _i.iterator : T, - mi = _i ? _i.toStringTag : T, - Ai = (function() { - try { - var n = je(Qu, "defineProperty") - return n({}, "", {}), n - } catch (n) {} - })(), - Ei = mn.clearTimeout !== $n.clearTimeout && mn.clearTimeout, - ki = Gu && Gu.now !== $n.Date.now && Gu.now, - Si = mn.setTimeout !== $n.setTimeout && mn.setTimeout, - Oi = Yu.ceil, - Ii = Yu.floor, - Ri = Qu.getOwnPropertySymbols, - zi = pi ? pi.isBuffer : T, - Wi = mn.isFinite, - Bi = ri.join, - Li = B(Qu.keys, Qu), - Ui = Yu.max, - Ci = Yu.min, - Di = Gu.now, - Mi = mn.parseInt, - Ti = Yu.random, - $i = ri.reverse, - Fi = je(mn, "DataView"), - Ni = je(mn, "Map"), - Pi = je(mn, "Promise"), - Zi = je(mn, "Set"), - qi = je(mn, "WeakMap"), - Vi = je(Qu, "create"), - Ki = qi && new qi(), - Gi = {}, - Hi = Te(Fi), - Ji = Te(Ni), - Yi = Te(Pi), - Qi = Te(Zi), - Xi = Te(qi), - no = _i ? _i.prototype : T, - to = no ? no.valueOf : T, - ro = no ? no.toString : T, - eo = (function() { - function n() {} - return function(t) { - return du(t) - ? yi - ? yi(t) - : ((n.prototype = t), (t = new n()), (n.prototype = T), t) - : {} - } - })() - ;(An.templateSettings = { - escape: J, - evaluate: Y, - interpolate: Q, - variable: "", - imports: { _: An }, - }), - (An.prototype = En.prototype), - (An.prototype.constructor = An), - (On.prototype = eo(En.prototype)), - (On.prototype.constructor = On), - (Un.prototype = eo(En.prototype)), - (Un.prototype.constructor = Un), - (Mn.prototype.clear = function() { - ;(this.__data__ = Vi ? Vi(null) : {}), (this.size = 0) - }), - (Mn.prototype.delete = function(n) { - return ( - (n = this.has(n) && delete this.__data__[n]), - (this.size -= n ? 1 : 0), - n - ) - }), - (Mn.prototype.get = function(n) { - var t = this.__data__ - return Vi - ? ((n = t[n]), "__lodash_hash_undefined__" === n ? T : n) - : oi.call(t, n) - ? t[n] - : T - }), - (Mn.prototype.has = function(n) { - var t = this.__data__ - return Vi ? t[n] !== T : oi.call(t, n) - }), - (Mn.prototype.set = function(n, t) { - var r = this.__data__ - return ( - (this.size += this.has(n) ? 0 : 1), - (r[n] = Vi && t === T ? "__lodash_hash_undefined__" : t), - this - ) - }), - (Tn.prototype.clear = function() { - ;(this.__data__ = []), (this.size = 0) - }), - (Tn.prototype.delete = function(n) { - var t = this.__data__ - return ( - (n = ft(t, n)), - !(0 > n) && - (n == t.length - 1 ? t.pop() : xi.call(t, n, 1), - --this.size, - true) - ) - }), - (Tn.prototype.get = function(n) { - var t = this.__data__ - return (n = ft(t, n)), 0 > n ? T : t[n][1] - }), - (Tn.prototype.has = function(n) { - return -1 < ft(this.__data__, n) - }), - (Tn.prototype.set = function(n, t) { - var r = this.__data__, - e = ft(r, n) - return 0 > e ? (++this.size, r.push([n, t])) : (r[e][1] = t), this - }), - (Fn.prototype.clear = function() { - ;(this.size = 0), - (this.__data__ = { - hash: new Mn(), - map: new (Ni || Tn)(), - string: new Mn(), - }) - }), - (Fn.prototype.delete = function(n) { - return (n = be(this, n).delete(n)), (this.size -= n ? 1 : 0), n - }), - (Fn.prototype.get = function(n) { - return be(this, n).get(n) - }), - (Fn.prototype.has = function(n) { - return be(this, n).has(n) - }), - (Fn.prototype.set = function(n, t) { - var r = be(this, n), - e = r.size - return r.set(n, t), (this.size += r.size == e ? 0 : 1), this - }), - (Nn.prototype.add = Nn.prototype.push = function(n) { - return this.__data__.set(n, "__lodash_hash_undefined__"), this - }), - (Nn.prototype.has = function(n) { - return this.__data__.has(n) - }), - (Zn.prototype.clear = function() { - ;(this.__data__ = new Tn()), (this.size = 0) - }), - (Zn.prototype.delete = function(n) { - var t = this.__data__ - return (n = t.delete(n)), (this.size = t.size), n - }), - (Zn.prototype.get = function(n) { - return this.__data__.get(n) - }), - (Zn.prototype.has = function(n) { - return this.__data__.has(n) - }), - (Zn.prototype.set = function(n, t) { - var r = this.__data__ - if (r instanceof Tn) { - var e = r.__data__ - if (!Ni || 199 > e.length) - return e.push([n, t]), (this.size = ++r.size), this - r = this.__data__ = new Fn(e) - } - return r.set(n, t), (this.size = r.size), this - }) - var uo = Fr(mt), - io = Fr(At, true), - oo = Nr(), - fo = Nr(true), - co = Ki - ? function(n, t) { - return Ki.set(n, t), n - } - : $u, - ao = Ai - ? function(n, t) { - return Ai(n, "toString", { - configurable: true, - enumerable: false, - value: Tu(t), - writable: true, - }) - } - : $u, - lo = - Ei || - function(n) { - return $n.clearTimeout(n) - }, - so = - Zi && 1 / U(new Zi([, -0]))[1] == $ - ? function(n) { - return new Zi(n) - } - : Pu, - ho = Ki - ? function(n) { - return Ki.get(n) - } - : Pu, - po = Ri - ? function(n) { - return null == n - ? [] - : ((n = Qu(n)), - i(Ri(n), function(t) { - return bi.call(n, t) - })) - } - : qu, - _o = Ri - ? function(n) { - for (var t = []; n; ) a(t, po(n)), (n = di(n)) - return t - } - : qu, - vo = Ot - ;((Fi && "[object DataView]" != vo(new Fi(new ArrayBuffer(1)))) || - (Ni && "[object Map]" != vo(new Ni())) || - (Pi && "[object Promise]" != vo(Pi.resolve())) || - (Zi && "[object Set]" != vo(new Zi())) || - (qi && "[object WeakMap]" != vo(new qi()))) && - (vo = function(n) { - var t = Ot(n) - if ( - (n = (n = "[object Object]" == t ? n.constructor : T) - ? Te(n) - : "") - ) - switch (n) { - case Hi: - return "[object DataView]" - case Ji: - return "[object Map]" - case Yi: - return "[object Promise]" - case Qi: - return "[object Set]" - case Xi: - return "[object WeakMap]" - } - return t - }) - var go = ui ? _u : Vu, - yo = Ce(co), - bo = - Si || - function(n, t) { - return $n.setTimeout(n, t) - }, - xo = Ce(ao), - jo = (function(n) { - n = cu(n, function(n) { - return 500 === t.size && t.clear(), n - }) - var t = n.cache - return n - })(function(n) { - var t = [] - return ( - 46 === n.charCodeAt(0) && t.push(""), - n.replace(tn, function(n, r, e, u) { - t.push(e ? u.replace(hn, "$1") : r || n) - }), - t - ) - }), - wo = fr(function(n, t) { - return hu(n) ? yt(n, wt(t, 1, hu, true)) : [] - }), - mo = fr(function(n, t) { - var r = Ve(t) - return ( - hu(r) && (r = T), - hu(n) ? yt(n, wt(t, 1, hu, true), ye(r, 2)) : [] - ) - }), - Ao = fr(function(n, t) { - var r = Ve(t) - return ( - hu(r) && (r = T), hu(n) ? yt(n, wt(t, 1, hu, true), T, r) : [] - ) - }), - Eo = fr(function(n) { - var t = c(n, Er) - return t.length && t[0] === n[0] ? Wt(t) : [] - }), - ko = fr(function(n) { - var t = Ve(n), - r = c(n, Er) - return ( - t === Ve(r) ? (t = T) : r.pop(), - r.length && r[0] === n[0] ? Wt(r, ye(t, 2)) : [] - ) - }), - So = fr(function(n) { - var t = Ve(n), - r = c(n, Er) - return ( - (t = typeof t == "function" ? t : T) && r.pop(), - r.length && r[0] === n[0] ? Wt(r, T, t) : [] - ) - }), - Oo = fr(Ke), - Io = pe(function(n, t) { - var r = null == n ? 0 : n.length, - e = ht(n, t) - return ( - ur( - n, - c(t, function(n) { - return Se(n, r) ? +n : n - }).sort(Wr) - ), - e - ) - }), - Ro = fr(function(n) { - return br(wt(n, 1, hu, true)) - }), - zo = fr(function(n) { - var t = Ve(n) - return hu(t) && (t = T), br(wt(n, 1, hu, true), ye(t, 2)) - }), - Wo = fr(function(n) { - var t = Ve(n), - t = typeof t == "function" ? t : T - return br(wt(n, 1, hu, true), T, t) - }), - Bo = fr(function(n, t) { - return hu(n) ? yt(n, t) : [] - }), - Lo = fr(function(n) { - return mr(i(n, hu)) - }), - Uo = fr(function(n) { - var t = Ve(n) - return hu(t) && (t = T), mr(i(n, hu), ye(t, 2)) - }), - Co = fr(function(n) { - var t = Ve(n), - t = typeof t == "function" ? t : T - return mr(i(n, hu), T, t) - }), - Do = fr(He), - Mo = fr(function(n) { - var t = n.length, - t = 1 < t ? n[t - 1] : T, - t = typeof t == "function" ? (n.pop(), t) : T - return Je(n, t) - }), - To = pe(function(n) { - function t(t) { - return ht(t, n) - } - var r = n.length, - e = r ? n[0] : 0, - u = this.__wrapped__ - return !(1 < r || this.__actions__.length) && - u instanceof Un && - Se(e) - ? ((u = u.slice(e, +e + (r ? 1 : 0))), - u.__actions__.push({ func: Qe, args: [t], thisArg: T }), - new On(u, this.__chain__).thru(function(n) { - return r && !n.length && n.push(T), n - })) - : this.thru(t) - }), - $o = Tr(function(n, t, r) { - oi.call(n, r) ? ++n[r] : st(n, r, 1) - }), - Fo = Gr(Ne), - No = Gr(Pe), - Po = Tr(function(n, t, r) { - oi.call(n, r) ? n[r].push(t) : st(n, r, [t]) - }), - Zo = fr(function(t, r, e) { - var u = -1, - i = typeof r == "function", - o = su(t) ? Ku(t.length) : [] - return ( - uo(t, function(t) { - o[++u] = i ? n(r, t, e) : Lt(t, r, e) - }), - o - ) - }), - qo = Tr(function(n, t, r) { - st(n, r, t) - }), - Vo = Tr( - function(n, t, r) { - n[r ? 0 : 1].push(t) - }, - function() { - return [[], []] - } - ), - Ko = fr(function(n, t) { - if (null == n) return [] - var r = t.length - return ( - 1 < r && Oe(n, t[0], t[1]) - ? (t = []) - : 2 < r && Oe(t[0], t[1], t[2]) && (t = [t[0]]), - Xt(n, wt(t, 1), []) - ) - }), - Go = - ki || - function() { - return $n.Date.now() - }, - Ho = fr(function(n, t, r) { - var e = 1 - if (r.length) - var u = L(r, de(Ho)), - e = 32 | e - return fe(n, e, t, r, u) - }), - Jo = fr(function(n, t, r) { - var e = 3 - if (r.length) - var u = L(r, de(Jo)), - e = 32 | e - return fe(t, e, n, r, u) - }), - Yo = fr(function(n, t) { - return dt(n, 1, t) - }), - Qo = fr(function(n, t, r) { - return dt(n, Su(t) || 0, r) - }) - cu.Cache = Fn - var Xo = fr(function(t, r) { - r = - 1 == r.length && ff(r[0]) - ? c(r[0], k(ye())) - : c(wt(r, 1), k(ye())) - var e = r.length - return fr(function(u) { - for (var i = -1, o = Ci(u.length, e); ++i < o; ) - u[i] = r[i].call(this, u[i]) - return n(t, this, u) - }) - }), - nf = fr(function(n, t) { - return fe(n, 32, T, t, L(t, de(nf))) - }), - tf = fr(function(n, t) { - return fe(n, 64, T, t, L(t, de(tf))) - }), - rf = pe(function(n, t) { - return fe(n, 256, T, T, T, t) - }), - ef = ee(It), - uf = ee(function(n, t) { - return n >= t - }), - of = Ut( - (function() { - return arguments - })() - ) - ? Ut - : function(n) { - return yu(n) && oi.call(n, "callee") && !bi.call(n, "callee") - }, - ff = Ku.isArray, - cf = Vn ? k(Vn) : Ct, - af = zi || Vu, - lf = Kn ? k(Kn) : Dt, - sf = Gn ? k(Gn) : Tt, - hf = Hn ? k(Hn) : Nt, - pf = Jn ? k(Jn) : Pt, - _f = Yn ? k(Yn) : Zt, - vf = ee(Kt), - gf = ee(function(n, t) { - return n <= t - }), - df = $r(function(n, t) { - if (ze(t) || su(t)) Cr(t, Wu(t), n) - else for (var r in t) oi.call(t, r) && ot(n, r, t[r]) - }), - yf = $r(function(n, t) { - Cr(t, Bu(t), n) - }), - bf = $r(function(n, t, r, e) { - Cr(t, Bu(t), n, e) - }), - xf = $r(function(n, t, r, e) { - Cr(t, Wu(t), n, e) - }), - jf = pe(ht), - wf = fr(function(n, t) { - n = Qu(n) - var r = -1, - e = t.length, - u = 2 < e ? t[2] : T - for (u && Oe(t[0], t[1], u) && (e = 1); ++r < e; ) - for (var u = t[r], i = Bu(u), o = -1, f = i.length; ++o < f; ) { - var c = i[o], - a = n[c] - ;(a === T || (lu(a, ei[c]) && !oi.call(n, c))) && - (n[c] = u[c]) - } - return n - }), - mf = fr(function(t) { - return t.push(T, ae), n(Of, T, t) - }), - Af = Yr(function(n, t, r) { - null != t && typeof t.toString != "function" && (t = ai.call(t)), - (n[t] = r) - }, Tu($u)), - Ef = Yr(function(n, t, r) { - null != t && typeof t.toString != "function" && (t = ai.call(t)), - oi.call(n, t) ? n[t].push(r) : (n[t] = [r]) - }, ye), - kf = fr(Lt), - Sf = $r(function(n, t, r) { - Yt(n, t, r) - }), - Of = $r(function(n, t, r, e) { - Yt(n, t, r, e) - }), - If = pe(function(n, t) { - var r = {} - if (null == n) return r - var e = false - ;(t = c(t, function(t) { - return (t = Sr(t, n)), e || (e = 1 < t.length), t - })), - Cr(n, ve(n), r), - e && (r = _t(r, 7, le)) - for (var u = t.length; u--; ) xr(r, t[u]) - return r - }), - Rf = pe(function(n, t) { - return null == n ? {} : nr(n, t) - }), - zf = oe(Wu), - Wf = oe(Bu), - Bf = qr(function(n, t, r) { - return (t = t.toLowerCase()), n + (r ? Cu(t) : t) - }), - Lf = qr(function(n, t, r) { - return n + (r ? "-" : "") + t.toLowerCase() - }), - Uf = qr(function(n, t, r) { - return n + (r ? " " : "") + t.toLowerCase() - }), - Cf = Zr("toLowerCase"), - Df = qr(function(n, t, r) { - return n + (r ? "_" : "") + t.toLowerCase() - }), - Mf = qr(function(n, t, r) { - return n + (r ? " " : "") + $f(t) - }), - Tf = qr(function(n, t, r) { - return n + (r ? " " : "") + t.toUpperCase() - }), - $f = Zr("toUpperCase"), - Ff = fr(function(t, r) { - try { - return n(t, T, r) - } catch (n) { - return pu(n) ? n : new Hu(n) - } - }), - Nf = pe(function(n, t) { - return ( - r(t, function(t) { - ;(t = Me(t)), st(n, t, Ho(n[t], n)) - }), - n - ) - }), - Pf = Hr(), - Zf = Hr(true), - qf = fr(function(n, t) { - return function(r) { - return Lt(r, n, t) - } - }), - Vf = fr(function(n, t) { - return function(r) { - return Lt(n, r, t) - } - }), - Kf = Xr(c), - Gf = Xr(u), - Hf = Xr(h), - Jf = re(), - Yf = re(true), - Qf = Qr(function(n, t) { - return n + t - }, 0), - Xf = ie("ceil"), - nc = Qr(function(n, t) { - return n / t - }, 1), - tc = ie("floor"), - rc = Qr(function(n, t) { - return n * t - }, 1), - ec = ie("round"), - uc = Qr(function(n, t) { - return n - t - }, 0) - return ( - (An.after = function(n, t) { - if (typeof t != "function") throw new ti("Expected a function") - return ( - (n = Eu(n)), - function() { - if (1 > --n) return t.apply(this, arguments) - } - ) - }), - (An.ary = eu), - (An.assign = df), - (An.assignIn = yf), - (An.assignInWith = bf), - (An.assignWith = xf), - (An.at = jf), - (An.before = uu), - (An.bind = Ho), - (An.bindAll = Nf), - (An.bindKey = Jo), - (An.castArray = function() { - if (!arguments.length) return [] - var n = arguments[0] - return ff(n) ? n : [n] - }), - (An.chain = Ye), - (An.chunk = function(n, t, r) { - if ( - ((t = (r ? Oe(n, t, r) : t === T) ? 1 : Ui(Eu(t), 0)), - (r = null == n ? 0 : n.length), - !r || 1 > t) - ) - return [] - for (var e = 0, u = 0, i = Ku(Oi(r / t)); e < r; ) - i[u++] = hr(n, e, (e += t)) - return i - }), - (An.compact = function(n) { - for ( - var t = -1, r = null == n ? 0 : n.length, e = 0, u = []; - ++t < r; - - ) { - var i = n[t] - i && (u[e++] = i) - } - return u - }), - (An.concat = function() { - var n = arguments.length - if (!n) return [] - for (var t = Ku(n - 1), r = arguments[0]; n--; ) - t[n - 1] = arguments[n] - return a(ff(r) ? Ur(r) : [r], wt(t, 1)) - }), - (An.cond = function(t) { - var r = null == t ? 0 : t.length, - e = ye() - return ( - (t = r - ? c(t, function(n) { - if ("function" != typeof n[1]) - throw new ti("Expected a function") - return [e(n[0]), n[1]] - }) - : []), - fr(function(e) { - for (var u = -1; ++u < r; ) { - var i = t[u] - if (n(i[0], this, e)) return n(i[1], this, e) - } - }) - ) - }), - (An.conforms = function(n) { - return vt(_t(n, 1)) - }), - (An.constant = Tu), - (An.countBy = $o), - (An.create = function(n, t) { - var r = eo(n) - return null == t ? r : at(r, t) - }), - (An.curry = iu), - (An.curryRight = ou), - (An.debounce = fu), - (An.defaults = wf), - (An.defaultsDeep = mf), - (An.defer = Yo), - (An.delay = Qo), - (An.difference = wo), - (An.differenceBy = mo), - (An.differenceWith = Ao), - (An.drop = function(n, t, r) { - var e = null == n ? 0 : n.length - return e - ? ((t = r || t === T ? 1 : Eu(t)), hr(n, 0 > t ? 0 : t, e)) - : [] - }), - (An.dropRight = function(n, t, r) { - var e = null == n ? 0 : n.length - return e - ? ((t = r || t === T ? 1 : Eu(t)), - (t = e - t), - hr(n, 0, 0 > t ? 0 : t)) - : [] - }), - (An.dropRightWhile = function(n, t) { - return n && n.length ? jr(n, ye(t, 3), true, true) : [] - }), - (An.dropWhile = function(n, t) { - return n && n.length ? jr(n, ye(t, 3), true) : [] - }), - (An.fill = function(n, t, r, e) { - var u = null == n ? 0 : n.length - if (!u) return [] - for ( - r && typeof r != "number" && Oe(n, t, r) && ((r = 0), (e = u)), - u = n.length, - r = Eu(r), - 0 > r && (r = -r > u ? 0 : u + r), - e = e === T || e > u ? u : Eu(e), - 0 > e && (e += u), - e = r > e ? 0 : ku(e); - r < e; - - ) - n[r++] = t - return n - }), - (An.filter = function(n, t) { - return (ff(n) ? i : jt)(n, ye(t, 3)) - }), - (An.flatMap = function(n, t) { - return wt(ru(n, t), 1) - }), - (An.flatMapDeep = function(n, t) { - return wt(ru(n, t), $) - }), - (An.flatMapDepth = function(n, t, r) { - return (r = r === T ? 1 : Eu(r)), wt(ru(n, t), r) - }), - (An.flatten = Ze), - (An.flattenDeep = function(n) { - return (null == n ? 0 : n.length) ? wt(n, $) : [] - }), - (An.flattenDepth = function(n, t) { - return null != n && n.length - ? ((t = t === T ? 1 : Eu(t)), wt(n, t)) - : [] - }), - (An.flip = function(n) { - return fe(n, 512) - }), - (An.flow = Pf), - (An.flowRight = Zf), - (An.fromPairs = function(n) { - for ( - var t = -1, r = null == n ? 0 : n.length, e = {}; - ++t < r; - - ) { - var u = n[t] - e[u[0]] = u[1] - } - return e - }), - (An.functions = function(n) { - return null == n ? [] : Et(n, Wu(n)) - }), - (An.functionsIn = function(n) { - return null == n ? [] : Et(n, Bu(n)) - }), - (An.groupBy = Po), - (An.initial = function(n) { - return (null == n ? 0 : n.length) ? hr(n, 0, -1) : [] - }), - (An.intersection = Eo), - (An.intersectionBy = ko), - (An.intersectionWith = So), - (An.invert = Af), - (An.invertBy = Ef), - (An.invokeMap = Zo), - (An.iteratee = Fu), - (An.keyBy = qo), - (An.keys = Wu), - (An.keysIn = Bu), - (An.map = ru), - (An.mapKeys = function(n, t) { - var r = {} - return ( - (t = ye(t, 3)), - mt(n, function(n, e, u) { - st(r, t(n, e, u), n) - }), - r - ) - }), - (An.mapValues = function(n, t) { - var r = {} - return ( - (t = ye(t, 3)), - mt(n, function(n, e, u) { - st(r, e, t(n, e, u)) - }), - r - ) - }), - (An.matches = function(n) { - return Ht(_t(n, 1)) - }), - (An.matchesProperty = function(n, t) { - return Jt(n, _t(t, 1)) - }), - (An.memoize = cu), - (An.merge = Sf), - (An.mergeWith = Of), - (An.method = qf), - (An.methodOf = Vf), - (An.mixin = Nu), - (An.negate = au), - (An.nthArg = function(n) { - return ( - (n = Eu(n)), - fr(function(t) { - return Qt(t, n) - }) - ) - }), - (An.omit = If), - (An.omitBy = function(n, t) { - return Lu(n, au(ye(t))) - }), - (An.once = function(n) { - return uu(2, n) - }), - (An.orderBy = function(n, t, r, e) { - return null == n - ? [] - : (ff(t) || (t = null == t ? [] : [t]), - (r = e ? T : r), - ff(r) || (r = null == r ? [] : [r]), - Xt(n, t, r)) - }), - (An.over = Kf), - (An.overArgs = Xo), - (An.overEvery = Gf), - (An.overSome = Hf), - (An.partial = nf), - (An.partialRight = tf), - (An.partition = Vo), - (An.pick = Rf), - (An.pickBy = Lu), - (An.property = Zu), - (An.propertyOf = function(n) { - return function(t) { - return null == n ? T : kt(n, t) - } - }), - (An.pull = Oo), - (An.pullAll = Ke), - (An.pullAllBy = function(n, t, r) { - return n && n.length && t && t.length ? er(n, t, ye(r, 2)) : n - }), - (An.pullAllWith = function(n, t, r) { - return n && n.length && t && t.length ? er(n, t, T, r) : n - }), - (An.pullAt = Io), - (An.range = Jf), - (An.rangeRight = Yf), - (An.rearg = rf), - (An.reject = function(n, t) { - return (ff(n) ? i : jt)(n, au(ye(t, 3))) - }), - (An.remove = function(n, t) { - var r = [] - if (!n || !n.length) return r - var e = -1, - u = [], - i = n.length - for (t = ye(t, 3); ++e < i; ) { - var o = n[e] - t(o, e, n) && (r.push(o), u.push(e)) - } - return ur(n, u), r - }), - (An.rest = function(n, t) { - if (typeof n != "function") throw new ti("Expected a function") - return (t = t === T ? t : Eu(t)), fr(n, t) - }), - (An.reverse = Ge), - (An.sampleSize = function(n, t, r) { - return ( - (t = (r ? Oe(n, t, r) : t === T) ? 1 : Eu(t)), - (ff(n) ? et : ar)(n, t) - ) - }), - (An.set = function(n, t, r) { - return null == n ? n : lr(n, t, r) - }), - (An.setWith = function(n, t, r, e) { - return ( - (e = typeof e == "function" ? e : T), - null == n ? n : lr(n, t, r, e) - ) - }), - (An.shuffle = function(n) { - return (ff(n) ? ut : sr)(n) - }), - (An.slice = function(n, t, r) { - var e = null == n ? 0 : n.length - return e - ? (r && typeof r != "number" && Oe(n, t, r) - ? ((t = 0), (r = e)) - : ((t = null == t ? 0 : Eu(t)), (r = r === T ? e : Eu(r))), - hr(n, t, r)) - : [] - }), - (An.sortBy = Ko), - (An.sortedUniq = function(n) { - return n && n.length ? gr(n) : [] - }), - (An.sortedUniqBy = function(n, t) { - return n && n.length ? gr(n, ye(t, 2)) : [] - }), - (An.split = function(n, t, r) { - return ( - r && typeof r != "number" && Oe(n, t, r) && (t = r = T), - (r = r === T ? 4294967295 : r >>> 0), - r - ? (n = Iu(n)) && - (typeof t == "string" || (null != t && !hf(t))) && - ((t = yr(t)), !t && Rn.test(n)) - ? Or(M(n), 0, r) - : n.split(t, r) - : [] - ) - }), - (An.spread = function(t, r) { - if (typeof t != "function") throw new ti("Expected a function") - return ( - (r = null == r ? 0 : Ui(Eu(r), 0)), - fr(function(e) { - var u = e[r] - return (e = Or(e, 0, r)), u && a(e, u), n(t, this, e) - }) - ) - }), - (An.tail = function(n) { - var t = null == n ? 0 : n.length - return t ? hr(n, 1, t) : [] - }), - (An.take = function(n, t, r) { - return n && n.length - ? ((t = r || t === T ? 1 : Eu(t)), hr(n, 0, 0 > t ? 0 : t)) - : [] - }), - (An.takeRight = function(n, t, r) { - var e = null == n ? 0 : n.length - return e - ? ((t = r || t === T ? 1 : Eu(t)), - (t = e - t), - hr(n, 0 > t ? 0 : t, e)) - : [] - }), - (An.takeRightWhile = function(n, t) { - return n && n.length ? jr(n, ye(t, 3), false, true) : [] - }), - (An.takeWhile = function(n, t) { - return n && n.length ? jr(n, ye(t, 3)) : [] - }), - (An.tap = function(n, t) { - return t(n), n - }), - (An.throttle = function(n, t, r) { - var e = true, - u = true - if (typeof n != "function") throw new ti("Expected a function") - return ( - du(r) && - ((e = "leading" in r ? !!r.leading : e), - (u = "trailing" in r ? !!r.trailing : u)), - fu(n, t, { leading: e, maxWait: t, trailing: u }) - ) - }), - (An.thru = Qe), - (An.toArray = mu), - (An.toPairs = zf), - (An.toPairsIn = Wf), - (An.toPath = function(n) { - return ff(n) ? c(n, Me) : wu(n) ? [n] : Ur(jo(Iu(n))) - }), - (An.toPlainObject = Ou), - (An.transform = function(n, t, e) { - var u = ff(n), - i = u || af(n) || _f(n) - if (((t = ye(t, 4)), null == e)) { - var o = n && n.constructor - e = i ? (u ? new o() : []) : du(n) && _u(o) ? eo(di(n)) : {} - } - return ( - (i ? r : mt)(n, function(n, r, u) { - return t(e, n, r, u) - }), - e - ) - }), - (An.unary = function(n) { - return eu(n, 1) - }), - (An.union = Ro), - (An.unionBy = zo), - (An.unionWith = Wo), - (An.uniq = function(n) { - return n && n.length ? br(n) : [] - }), - (An.uniqBy = function(n, t) { - return n && n.length ? br(n, ye(t, 2)) : [] - }), - (An.uniqWith = function(n, t) { - return ( - (t = typeof t == "function" ? t : T), - n && n.length ? br(n, T, t) : [] - ) - }), - (An.unset = function(n, t) { - return null == n || xr(n, t) - }), - (An.unzip = He), - (An.unzipWith = Je), - (An.update = function(n, t, r) { - return null == n ? n : lr(n, t, kr(r)(kt(n, t)), void 0) - }), - (An.updateWith = function(n, t, r, e) { - return ( - (e = typeof e == "function" ? e : T), - null != n && (n = lr(n, t, kr(r)(kt(n, t)), e)), - n - ) - }), - (An.values = Uu), - (An.valuesIn = function(n) { - return null == n ? [] : S(n, Bu(n)) - }), - (An.without = Bo), - (An.words = Mu), - (An.wrap = function(n, t) { - return nf(kr(t), n) - }), - (An.xor = Lo), - (An.xorBy = Uo), - (An.xorWith = Co), - (An.zip = Do), - (An.zipObject = function(n, t) { - return Ar(n || [], t || [], ot) - }), - (An.zipObjectDeep = function(n, t) { - return Ar(n || [], t || [], lr) - }), - (An.zipWith = Mo), - (An.entries = zf), - (An.entriesIn = Wf), - (An.extend = yf), - (An.extendWith = bf), - Nu(An, An), - (An.add = Qf), - (An.attempt = Ff), - (An.camelCase = Bf), - (An.capitalize = Cu), - (An.ceil = Xf), - (An.clamp = function(n, t, r) { - return ( - r === T && ((r = t), (t = T)), - r !== T && ((r = Su(r)), (r = r === r ? r : 0)), - t !== T && ((t = Su(t)), (t = t === t ? t : 0)), - pt(Su(n), t, r) - ) - }), - (An.clone = function(n) { - return _t(n, 4) - }), - (An.cloneDeep = function(n) { - return _t(n, 5) - }), - (An.cloneDeepWith = function(n, t) { - return (t = typeof t == "function" ? t : T), _t(n, 5, t) - }), - (An.cloneWith = function(n, t) { - return (t = typeof t == "function" ? t : T), _t(n, 4, t) - }), - (An.conformsTo = function(n, t) { - return null == t || gt(n, t, Wu(t)) - }), - (An.deburr = Du), - (An.defaultTo = function(n, t) { - return null == n || n !== n ? t : n - }), - (An.divide = nc), - (An.endsWith = function(n, t, r) { - ;(n = Iu(n)), (t = yr(t)) - var e = n.length, - e = (r = r === T ? e : pt(Eu(r), 0, e)) - return (r -= t.length), 0 <= r && n.slice(r, e) == t - }), - (An.eq = lu), - (An.escape = function(n) { - return (n = Iu(n)) && H.test(n) ? n.replace(K, nt) : n - }), - (An.escapeRegExp = function(n) { - return (n = Iu(n)) && en.test(n) ? n.replace(rn, "\\$&") : n - }), - (An.every = function(n, t, r) { - var e = ff(n) ? u : bt - return r && Oe(n, t, r) && (t = T), e(n, ye(t, 3)) - }), - (An.find = Fo), - (An.findIndex = Ne), - (An.findKey = function(n, t) { - return p(n, ye(t, 3), mt) - }), - (An.findLast = No), - (An.findLastIndex = Pe), - (An.findLastKey = function(n, t) { - return p(n, ye(t, 3), At) - }), - (An.floor = tc), - (An.forEach = nu), - (An.forEachRight = tu), - (An.forIn = function(n, t) { - return null == n ? n : oo(n, ye(t, 3), Bu) - }), - (An.forInRight = function(n, t) { - return null == n ? n : fo(n, ye(t, 3), Bu) - }), - (An.forOwn = function(n, t) { - return n && mt(n, ye(t, 3)) - }), - (An.forOwnRight = function(n, t) { - return n && At(n, ye(t, 3)) - }), - (An.get = Ru), - (An.gt = ef), - (An.gte = uf), - (An.has = function(n, t) { - return null != n && we(n, t, Rt) - }), - (An.hasIn = zu), - (An.head = qe), - (An.identity = $u), - (An.includes = function(n, t, r, e) { - return ( - (n = su(n) ? n : Uu(n)), - (r = r && !e ? Eu(r) : 0), - (e = n.length), - 0 > r && (r = Ui(e + r, 0)), - ju(n) ? r <= e && -1 < n.indexOf(t, r) : !!e && -1 < v(n, t, r) - ) - }), - (An.indexOf = function(n, t, r) { - var e = null == n ? 0 : n.length - return e - ? ((r = null == r ? 0 : Eu(r)), - 0 > r && (r = Ui(e + r, 0)), - v(n, t, r)) - : -1 - }), - (An.inRange = function(n, t, r) { - return ( - (t = Au(t)), - r === T ? ((r = t), (t = 0)) : (r = Au(r)), - (n = Su(n)), - n >= Ci(t, r) && n < Ui(t, r) - ) - }), - (An.invoke = kf), - (An.isArguments = of), - (An.isArray = ff), - (An.isArrayBuffer = cf), - (An.isArrayLike = su), - (An.isArrayLikeObject = hu), - (An.isBoolean = function(n) { - return ( - true === n || - false === n || - (yu(n) && "[object Boolean]" == Ot(n)) - ) - }), - (An.isBuffer = af), - (An.isDate = lf), - (An.isElement = function(n) { - return yu(n) && 1 === n.nodeType && !xu(n) - }), - (An.isEmpty = function(n) { - if (null == n) return true - if ( - su(n) && - (ff(n) || - typeof n == "string" || - typeof n.splice == "function" || - af(n) || - _f(n) || - of(n)) - ) - return !n.length - var t = vo(n) - if ("[object Map]" == t || "[object Set]" == t) return !n.size - if (ze(n)) return !Vt(n).length - for (var r in n) if (oi.call(n, r)) return false - return true - }), - (An.isEqual = function(n, t) { - return Mt(n, t) - }), - (An.isEqualWith = function(n, t, r) { - var e = (r = typeof r == "function" ? r : T) ? r(n, t) : T - return e === T ? Mt(n, t, T, r) : !!e - }), - (An.isError = pu), - (An.isFinite = function(n) { - return typeof n == "number" && Wi(n) - }), - (An.isFunction = _u), - (An.isInteger = vu), - (An.isLength = gu), - (An.isMap = sf), - (An.isMatch = function(n, t) { - return n === t || $t(n, t, xe(t)) - }), - (An.isMatchWith = function(n, t, r) { - return (r = typeof r == "function" ? r : T), $t(n, t, xe(t), r) - }), - (An.isNaN = function(n) { - return bu(n) && n != +n - }), - (An.isNative = function(n) { - if (go(n)) - throw new Hu( - "Unsupported core-js use. Try https://npms.io/search?q=ponyfill." - ) - return Ft(n) - }), - (An.isNil = function(n) { - return null == n - }), - (An.isNull = function(n) { - return null === n - }), - (An.isNumber = bu), - (An.isObject = du), - (An.isObjectLike = yu), - (An.isPlainObject = xu), - (An.isRegExp = hf), - (An.isSafeInteger = function(n) { - return vu(n) && -9007199254740991 <= n && 9007199254740991 >= n - }), - (An.isSet = pf), - (An.isString = ju), - (An.isSymbol = wu), - (An.isTypedArray = _f), - (An.isUndefined = function(n) { - return n === T - }), - (An.isWeakMap = function(n) { - return yu(n) && "[object WeakMap]" == vo(n) - }), - (An.isWeakSet = function(n) { - return yu(n) && "[object WeakSet]" == Ot(n) - }), - (An.join = function(n, t) { - return null == n ? "" : Bi.call(n, t) - }), - (An.kebabCase = Lf), - (An.last = Ve), - (An.lastIndexOf = function(n, t, r) { - var e = null == n ? 0 : n.length - if (!e) return -1 - var u = e - if ( - (r !== T && - ((u = Eu(r)), (u = 0 > u ? Ui(e + u, 0) : Ci(u, e - 1))), - t === t) - ) { - for (r = u + 1; r-- && n[r] !== t; ); - n = r - } else n = _(n, d, u, true) - return n - }), - (An.lowerCase = Uf), - (An.lowerFirst = Cf), - (An.lt = vf), - (An.lte = gf), - (An.max = function(n) { - return n && n.length ? xt(n, $u, It) : T - }), - (An.maxBy = function(n, t) { - return n && n.length ? xt(n, ye(t, 2), It) : T - }), - (An.mean = function(n) { - return y(n, $u) - }), - (An.meanBy = function(n, t) { - return y(n, ye(t, 2)) - }), - (An.min = function(n) { - return n && n.length ? xt(n, $u, Kt) : T - }), - (An.minBy = function(n, t) { - return n && n.length ? xt(n, ye(t, 2), Kt) : T - }), - (An.stubArray = qu), - (An.stubFalse = Vu), - (An.stubObject = function() { - return {} - }), - (An.stubString = function() { - return "" - }), - (An.stubTrue = function() { - return true - }), - (An.multiply = rc), - (An.nth = function(n, t) { - return n && n.length ? Qt(n, Eu(t)) : T - }), - (An.noConflict = function() { - return $n._ === this && ($n._ = si), this - }), - (An.noop = Pu), - (An.now = Go), - (An.pad = function(n, t, r) { - n = Iu(n) - var e = (t = Eu(t)) ? D(n) : 0 - return !t || e >= t - ? n - : ((t = (t - e) / 2), ne(Ii(t), r) + n + ne(Oi(t), r)) - }), - (An.padEnd = function(n, t, r) { - n = Iu(n) - var e = (t = Eu(t)) ? D(n) : 0 - return t && e < t ? n + ne(t - e, r) : n - }), - (An.padStart = function(n, t, r) { - n = Iu(n) - var e = (t = Eu(t)) ? D(n) : 0 - return t && e < t ? ne(t - e, r) + n : n - }), - (An.parseInt = function(n, t, r) { - return ( - r || null == t ? (t = 0) : t && (t = +t), - Mi(Iu(n).replace(on, ""), t || 0) - ) - }), - (An.random = function(n, t, r) { - if ( - (r && typeof r != "boolean" && Oe(n, t, r) && (t = r = T), - r === T && - (typeof t == "boolean" - ? ((r = t), (t = T)) - : typeof n == "boolean" && ((r = n), (n = T))), - n === T && t === T - ? ((n = 0), (t = 1)) - : ((n = Au(n)), t === T ? ((t = n), (n = 0)) : (t = Au(t))), - n > t) - ) { - var e = n - ;(n = t), (t = e) - } - return r || n % 1 || t % 1 - ? ((r = Ti()), - Ci(n + r * (t - n + Cn("1e-" + ((r + "").length - 1))), t)) - : ir(n, t) - }), - (An.reduce = function(n, t, r) { - var e = ff(n) ? l : j, - u = 3 > arguments.length - return e(n, ye(t, 4), r, u, uo) - }), - (An.reduceRight = function(n, t, r) { - var e = ff(n) ? s : j, - u = 3 > arguments.length - return e(n, ye(t, 4), r, u, io) - }), - (An.repeat = function(n, t, r) { - return (t = (r ? Oe(n, t, r) : t === T) ? 1 : Eu(t)), or(Iu(n), t) - }), - (An.replace = function() { - var n = arguments, - t = Iu(n[0]) - return 3 > n.length ? t : t.replace(n[1], n[2]) - }), - (An.result = function(n, t, r) { - t = Sr(t, n) - var e = -1, - u = t.length - for (u || ((u = 1), (n = T)); ++e < u; ) { - var i = null == n ? T : n[Me(t[e])] - i === T && ((e = u), (i = r)), (n = _u(i) ? i.call(n) : i) - } - return n - }), - (An.round = ec), - (An.runInContext = x), - (An.sample = function(n) { - return (ff(n) ? Qn : cr)(n) - }), - (An.size = function(n) { - if (null == n) return 0 - if (su(n)) return ju(n) ? D(n) : n.length - var t = vo(n) - return "[object Map]" == t || "[object Set]" == t - ? n.size - : Vt(n).length - }), - (An.snakeCase = Df), - (An.some = function(n, t, r) { - var e = ff(n) ? h : pr - return r && Oe(n, t, r) && (t = T), e(n, ye(t, 3)) - }), - (An.sortedIndex = function(n, t) { - return _r(n, t) - }), - (An.sortedIndexBy = function(n, t, r) { - return vr(n, t, ye(r, 2)) - }), - (An.sortedIndexOf = function(n, t) { - var r = null == n ? 0 : n.length - if (r) { - var e = _r(n, t) - if (e < r && lu(n[e], t)) return e - } - return -1 - }), - (An.sortedLastIndex = function(n, t) { - return _r(n, t, true) - }), - (An.sortedLastIndexBy = function(n, t, r) { - return vr(n, t, ye(r, 2), true) - }), - (An.sortedLastIndexOf = function(n, t) { - if (null == n ? 0 : n.length) { - var r = _r(n, t, true) - 1 - if (lu(n[r], t)) return r - } - return -1 - }), - (An.startCase = Mf), - (An.startsWith = function(n, t, r) { - return ( - (n = Iu(n)), - (r = null == r ? 0 : pt(Eu(r), 0, n.length)), - (t = yr(t)), - n.slice(r, r + t.length) == t - ) - }), - (An.subtract = uc), - (An.sum = function(n) { - return n && n.length ? m(n, $u) : 0 - }), - (An.sumBy = function(n, t) { - return n && n.length ? m(n, ye(t, 2)) : 0 - }), - (An.template = function(n, t, r) { - var e = An.templateSettings - r && Oe(n, t, r) && (t = T), - (n = Iu(n)), - (t = bf({}, t, e, ce)), - (r = bf({}, t.imports, e.imports, ce)) - var u, - i, - o = Wu(r), - f = S(r, o), - c = 0 - r = t.interpolate || jn - var a = "__p+='" - r = Xu( - (t.escape || jn).source + - "|" + - r.source + - "|" + - (r === Q ? pn : jn).source + - "|" + - (t.evaluate || jn).source + - "|$", - "g" - ) - var l = oi.call(t, "sourceURL") - ? "//# sourceURL=" + - (t.sourceURL + "").replace(/[\r\n]/g, " ") + - "\n" - : "" - if ( - (n.replace(r, function(t, r, e, o, f, l) { - return ( - e || (e = o), - (a += n.slice(c, l).replace(wn, z)), - r && ((u = true), (a += "'+__e(" + r + ")+'")), - f && ((i = true), (a += "';" + f + ";\n__p+='")), - e && (a += "'+((__t=(" + e + "))==null?'':__t)+'"), - (c = l + t.length), - t - ) - }), - (a += "';"), - (t = oi.call(t, "variable") && t.variable) || - (a = "with(obj){" + a + "}"), - (a = (i ? a.replace(P, "") : a) - .replace(Z, "$1") - .replace(q, "$1;")), - (a = - "function(" + - (t || "obj") + - "){" + - (t ? "" : "obj||(obj={});") + - "var __t,__p=''" + - (u ? ",__e=_.escape" : "") + - (i - ? ",__j=Array.prototype.join;function print(){__p+=__j.call(arguments,'')}" - : ";") + - a + - "return __p}"), - (t = Ff(function() { - return Ju(o, l + "return " + a).apply(T, f) - })), - (t.source = a), - pu(t)) - ) - throw t - return t - }), - (An.times = function(n, t) { - if (((n = Eu(n)), 1 > n || 9007199254740991 < n)) return [] - var r = 4294967295, - e = Ci(n, 4294967295) - for (t = ye(t), n -= 4294967295, e = A(e, t); ++r < n; ) t(r) - return e - }), - (An.toFinite = Au), - (An.toInteger = Eu), - (An.toLength = ku), - (An.toLower = function(n) { - return Iu(n).toLowerCase() - }), - (An.toNumber = Su), - (An.toSafeInteger = function(n) { - return n - ? pt(Eu(n), -9007199254740991, 9007199254740991) - : 0 === n - ? n - : 0 - }), - (An.toString = Iu), - (An.toUpper = function(n) { - return Iu(n).toUpperCase() - }), - (An.trim = function(n, t, r) { - return (n = Iu(n)) && (r || t === T) - ? n.replace(un, "") - : n && (t = yr(t)) - ? ((n = M(n)), - (r = M(t)), - (t = I(n, r)), - (r = R(n, r) + 1), - Or(n, t, r).join("")) - : n - }), - (An.trimEnd = function(n, t, r) { - return (n = Iu(n)) && (r || t === T) - ? n.replace(fn, "") - : n && (t = yr(t)) - ? ((n = M(n)), (t = R(n, M(t)) + 1), Or(n, 0, t).join("")) - : n - }), - (An.trimStart = function(n, t, r) { - return (n = Iu(n)) && (r || t === T) - ? n.replace(on, "") - : n && (t = yr(t)) - ? ((n = M(n)), (t = I(n, M(t))), Or(n, t).join("")) - : n - }), - (An.truncate = function(n, t) { - var r = 30, - e = "..." - if (du(t)) - var u = "separator" in t ? t.separator : u, - r = "length" in t ? Eu(t.length) : r, - e = "omission" in t ? yr(t.omission) : e - n = Iu(n) - var i = n.length - if (Rn.test(n)) - var o = M(n), - i = o.length - if (r >= i) return n - if (((i = r - D(e)), 1 > i)) return e - if (((r = o ? Or(o, 0, i).join("") : n.slice(0, i)), u === T)) - return r + e - if ((o && (i += r.length - i), hf(u))) { - if (n.slice(i).search(u)) { - var f = r - for ( - u.global || (u = Xu(u.source, Iu(_n.exec(u)) + "g")), - u.lastIndex = 0; - (o = u.exec(f)); - - ) - var c = o.index - r = r.slice(0, c === T ? i : c) - } - } else - n.indexOf(yr(u), i) != i && - ((u = r.lastIndexOf(u)), -1 < u && (r = r.slice(0, u))) - return r + e - }), - (An.unescape = function(n) { - return (n = Iu(n)) && G.test(n) ? n.replace(V, tt) : n - }), - (An.uniqueId = function(n) { - var t = ++fi - return Iu(n) + t - }), - (An.upperCase = Tf), - (An.upperFirst = $f), - (An.each = nu), - (An.eachRight = tu), - (An.first = qe), - Nu( - An, - (function() { - var n = {} - return ( - mt(An, function(t, r) { - oi.call(An.prototype, r) || (n[r] = t) - }), - n - ) - })(), - { chain: false } - ), - (An.VERSION = "4.17.15"), - r( - "bind bindKey curry curryRight partial partialRight".split(" "), - function(n) { - An[n].placeholder = An - } - ), - r(["drop", "take"], function(n, t) { - ;(Un.prototype[n] = function(r) { - r = r === T ? 1 : Ui(Eu(r), 0) - var e = this.__filtered__ && !t ? new Un(this) : this.clone() - return ( - e.__filtered__ - ? (e.__takeCount__ = Ci(r, e.__takeCount__)) - : e.__views__.push({ - size: Ci(r, 4294967295), - type: n + (0 > e.__dir__ ? "Right" : ""), - }), - e - ) - }), - (Un.prototype[n + "Right"] = function(t) { - return this.reverse() - [n](t) - .reverse() - }) - }), - r(["filter", "map", "takeWhile"], function(n, t) { - var r = t + 1, - e = 1 == r || 3 == r - Un.prototype[n] = function(n) { - var t = this.clone() - return ( - t.__iteratees__.push({ iteratee: ye(n, 3), type: r }), - (t.__filtered__ = t.__filtered__ || e), - t - ) - } - }), - r(["head", "last"], function(n, t) { - var r = "take" + (t ? "Right" : "") - Un.prototype[n] = function() { - return this[r](1).value()[0] - } - }), - r(["initial", "tail"], function(n, t) { - var r = "drop" + (t ? "" : "Right") - Un.prototype[n] = function() { - return this.__filtered__ ? new Un(this) : this[r](1) - } - }), - (Un.prototype.compact = function() { - return this.filter($u) - }), - (Un.prototype.find = function(n) { - return this.filter(n).head() - }), - (Un.prototype.findLast = function(n) { - return this.reverse().find(n) - }), - (Un.prototype.invokeMap = fr(function(n, t) { - return typeof n == "function" - ? new Un(this) - : this.map(function(r) { - return Lt(r, n, t) - }) - })), - (Un.prototype.reject = function(n) { - return this.filter(au(ye(n))) - }), - (Un.prototype.slice = function(n, t) { - n = Eu(n) - var r = this - return r.__filtered__ && (0 < n || 0 > t) - ? new Un(r) - : (0 > n ? (r = r.takeRight(-n)) : n && (r = r.drop(n)), - t !== T && - ((t = Eu(t)), - (r = 0 > t ? r.dropRight(-t) : r.take(t - n))), - r) - }), - (Un.prototype.takeRightWhile = function(n) { - return this.reverse() - .takeWhile(n) - .reverse() - }), - (Un.prototype.toArray = function() { - return this.take(4294967295) - }), - mt(Un.prototype, function(n, t) { - var r = /^(?:filter|find|map|reject)|While$/.test(t), - e = /^(?:head|last)$/.test(t), - u = An[e ? "take" + ("last" == t ? "Right" : "") : t], - i = e || /^find/.test(t) - u && - (An.prototype[t] = function() { - function t(n) { - return (n = u.apply(An, a([n], f))), e && h ? n[0] : n - } - var o = this.__wrapped__, - f = e ? [1] : arguments, - c = o instanceof Un, - l = f[0], - s = c || ff(o) - s && - r && - typeof l == "function" && - 1 != l.length && - (c = s = false) - var h = this.__chain__, - p = !!this.__actions__.length, - l = i && !h, - c = c && !p - return !i && s - ? ((o = c ? o : new Un(this)), - (o = n.apply(o, f)), - o.__actions__.push({ func: Qe, args: [t], thisArg: T }), - new On(o, h)) - : l && c - ? n.apply(this, f) - : ((o = this.thru(t)), - l ? (e ? o.value()[0] : o.value()) : o) - }) - }), - r("pop push shift sort splice unshift".split(" "), function(n) { - var t = ri[n], - r = /^(?:push|sort|unshift)$/.test(n) ? "tap" : "thru", - e = /^(?:pop|shift)$/.test(n) - An.prototype[n] = function() { - var n = arguments - if (e && !this.__chain__) { - var u = this.value() - return t.apply(ff(u) ? u : [], n) - } - return this[r](function(r) { - return t.apply(ff(r) ? r : [], n) - }) - } - }), - mt(Un.prototype, function(n, t) { - var r = An[t] - if (r) { - var e = r.name + "" - oi.call(Gi, e) || (Gi[e] = []), Gi[e].push({ name: t, func: r }) - } - }), - (Gi[Jr(T, 2).name] = [{ name: "wrapper", func: T }]), - (Un.prototype.clone = function() { - var n = new Un(this.__wrapped__) - return ( - (n.__actions__ = Ur(this.__actions__)), - (n.__dir__ = this.__dir__), - (n.__filtered__ = this.__filtered__), - (n.__iteratees__ = Ur(this.__iteratees__)), - (n.__takeCount__ = this.__takeCount__), - (n.__views__ = Ur(this.__views__)), - n - ) - }), - (Un.prototype.reverse = function() { - if (this.__filtered__) { - var n = new Un(this) - ;(n.__dir__ = -1), (n.__filtered__ = true) - } else (n = this.clone()), (n.__dir__ *= -1) - return n - }), - (Un.prototype.value = function() { - var n, - t = this.__wrapped__.value(), - r = this.__dir__, - e = ff(t), - u = 0 > r, - i = e ? t.length : 0 - n = i - for ( - var o = this.__views__, f = 0, c = -1, a = o.length; - ++c < a; - - ) { - var l = o[c], - s = l.size - switch (l.type) { - case "drop": - f += s - break - case "dropRight": - n -= s - break - case "take": - n = Ci(n, f + s) - break - case "takeRight": - f = Ui(f, n - s) - } - } - if ( - ((n = { start: f, end: n }), - (o = n.start), - (f = n.end), - (n = f - o), - (o = u ? f : o - 1), - (f = this.__iteratees__), - (c = f.length), - (a = 0), - (l = Ci(n, this.__takeCount__)), - !e || (!u && i == n && l == n)) - ) - return wr(t, this.__actions__) - e = [] - n: for (; n-- && a < l; ) { - for (o += r, u = -1, i = t[o]; ++u < c; ) { - var h = f[u], - s = h.type, - h = (0, h.iteratee)(i) - if (2 == s) i = h - else if (!h) { - if (1 == s) continue n - break n - } - } - e[a++] = i - } - return e - }), - (An.prototype.at = To), - (An.prototype.chain = function() { - return Ye(this) - }), - (An.prototype.commit = function() { - return new On(this.value(), this.__chain__) - }), - (An.prototype.next = function() { - this.__values__ === T && (this.__values__ = mu(this.value())) - var n = this.__index__ >= this.__values__.length - return { - done: n, - value: n ? T : this.__values__[this.__index__++], - } - }), - (An.prototype.plant = function(n) { - for (var t, r = this; r instanceof En; ) { - var e = Fe(r) - ;(e.__index__ = 0), - (e.__values__ = T), - t ? (u.__wrapped__ = e) : (t = e) - var u = e, - r = r.__wrapped__ - } - return (u.__wrapped__ = n), t - }), - (An.prototype.reverse = function() { - var n = this.__wrapped__ - return n instanceof Un - ? (this.__actions__.length && (n = new Un(this)), - (n = n.reverse()), - n.__actions__.push({ func: Qe, args: [Ge], thisArg: T }), - new On(n, this.__chain__)) - : this.thru(Ge) - }), - (An.prototype.toJSON = An.prototype.valueOf = An.prototype.value = function() { - return wr(this.__wrapped__, this.__actions__) - }), - (An.prototype.first = An.prototype.head), - wi && (An.prototype[wi] = Xe), - An - ) - })() - Nn ? (((Nn.exports = rt)._ = rt), (Fn._ = rt)) : ($n._ = rt) - }.call(commonjsGlobal)) - }) - - var _mapping = createCommonjsModule(function(module, exports) { - /** Used to map aliases to their real names. */ - exports.aliasToReal = { - // Lodash aliases. - each: "forEach", - eachRight: "forEachRight", - entries: "toPairs", - entriesIn: "toPairsIn", - extend: "assignIn", - extendAll: "assignInAll", - extendAllWith: "assignInAllWith", - extendWith: "assignInWith", - first: "head", - - // Methods that are curried variants of others. - conforms: "conformsTo", - matches: "isMatch", - property: "get", - - // Ramda aliases. - __: "placeholder", - F: "stubFalse", - T: "stubTrue", - all: "every", - allPass: "overEvery", - always: "constant", - any: "some", - anyPass: "overSome", - apply: "spread", - assoc: "set", - assocPath: "set", - complement: "negate", - compose: "flowRight", - contains: "includes", - dissoc: "unset", - dissocPath: "unset", - dropLast: "dropRight", - dropLastWhile: "dropRightWhile", - equals: "isEqual", - identical: "eq", - indexBy: "keyBy", - init: "initial", - invertObj: "invert", - juxt: "over", - omitAll: "omit", - nAry: "ary", - path: "get", - pathEq: "matchesProperty", - pathOr: "getOr", - paths: "at", - pickAll: "pick", - pipe: "flow", - pluck: "map", - prop: "get", - propEq: "matchesProperty", - propOr: "getOr", - props: "at", - symmetricDifference: "xor", - symmetricDifferenceBy: "xorBy", - symmetricDifferenceWith: "xorWith", - takeLast: "takeRight", - takeLastWhile: "takeRightWhile", - unapply: "rest", - unnest: "flatten", - useWith: "overArgs", - where: "conformsTo", - whereEq: "isMatch", - zipObj: "zipObject", - } - - /** Used to map ary to method names. */ - exports.aryMethod = { - "1": [ - "assignAll", - "assignInAll", - "attempt", - "castArray", - "ceil", - "create", - "curry", - "curryRight", - "defaultsAll", - "defaultsDeepAll", - "floor", - "flow", - "flowRight", - "fromPairs", - "invert", - "iteratee", - "memoize", - "method", - "mergeAll", - "methodOf", - "mixin", - "nthArg", - "over", - "overEvery", - "overSome", - "rest", - "reverse", - "round", - "runInContext", - "spread", - "template", - "trim", - "trimEnd", - "trimStart", - "uniqueId", - "words", - "zipAll", - ], - "2": [ - "add", - "after", - "ary", - "assign", - "assignAllWith", - "assignIn", - "assignInAllWith", - "at", - "before", - "bind", - "bindAll", - "bindKey", - "chunk", - "cloneDeepWith", - "cloneWith", - "concat", - "conformsTo", - "countBy", - "curryN", - "curryRightN", - "debounce", - "defaults", - "defaultsDeep", - "defaultTo", - "delay", - "difference", - "divide", - "drop", - "dropRight", - "dropRightWhile", - "dropWhile", - "endsWith", - "eq", - "every", - "filter", - "find", - "findIndex", - "findKey", - "findLast", - "findLastIndex", - "findLastKey", - "flatMap", - "flatMapDeep", - "flattenDepth", - "forEach", - "forEachRight", - "forIn", - "forInRight", - "forOwn", - "forOwnRight", - "get", - "groupBy", - "gt", - "gte", - "has", - "hasIn", - "includes", - "indexOf", - "intersection", - "invertBy", - "invoke", - "invokeMap", - "isEqual", - "isMatch", - "join", - "keyBy", - "lastIndexOf", - "lt", - "lte", - "map", - "mapKeys", - "mapValues", - "matchesProperty", - "maxBy", - "meanBy", - "merge", - "mergeAllWith", - "minBy", - "multiply", - "nth", - "omit", - "omitBy", - "overArgs", - "pad", - "padEnd", - "padStart", - "parseInt", - "partial", - "partialRight", - "partition", - "pick", - "pickBy", - "propertyOf", - "pull", - "pullAll", - "pullAt", - "random", - "range", - "rangeRight", - "rearg", - "reject", - "remove", - "repeat", - "restFrom", - "result", - "sampleSize", - "some", - "sortBy", - "sortedIndex", - "sortedIndexOf", - "sortedLastIndex", - "sortedLastIndexOf", - "sortedUniqBy", - "split", - "spreadFrom", - "startsWith", - "subtract", - "sumBy", - "take", - "takeRight", - "takeRightWhile", - "takeWhile", - "tap", - "throttle", - "thru", - "times", - "trimChars", - "trimCharsEnd", - "trimCharsStart", - "truncate", - "union", - "uniqBy", - "uniqWith", - "unset", - "unzipWith", - "without", - "wrap", - "xor", - "zip", - "zipObject", - "zipObjectDeep", - ], - "3": [ - "assignInWith", - "assignWith", - "clamp", - "differenceBy", - "differenceWith", - "findFrom", - "findIndexFrom", - "findLastFrom", - "findLastIndexFrom", - "getOr", - "includesFrom", - "indexOfFrom", - "inRange", - "intersectionBy", - "intersectionWith", - "invokeArgs", - "invokeArgsMap", - "isEqualWith", - "isMatchWith", - "flatMapDepth", - "lastIndexOfFrom", - "mergeWith", - "orderBy", - "padChars", - "padCharsEnd", - "padCharsStart", - "pullAllBy", - "pullAllWith", - "rangeStep", - "rangeStepRight", - "reduce", - "reduceRight", - "replace", - "set", - "slice", - "sortedIndexBy", - "sortedLastIndexBy", - "transform", - "unionBy", - "unionWith", - "update", - "xorBy", - "xorWith", - "zipWith", - ], - "4": ["fill", "setWith", "updateWith"], - } - - /** Used to map ary to rearg configs. */ - exports.aryRearg = { - "2": [1, 0], - "3": [2, 0, 1], - "4": [3, 2, 0, 1], - } - - /** Used to map method names to their iteratee ary. */ - exports.iterateeAry = { - dropRightWhile: 1, - dropWhile: 1, - every: 1, - filter: 1, - find: 1, - findFrom: 1, - findIndex: 1, - findIndexFrom: 1, - findKey: 1, - findLast: 1, - findLastFrom: 1, - findLastIndex: 1, - findLastIndexFrom: 1, - findLastKey: 1, - flatMap: 1, - flatMapDeep: 1, - flatMapDepth: 1, - forEach: 1, - forEachRight: 1, - forIn: 1, - forInRight: 1, - forOwn: 1, - forOwnRight: 1, - map: 1, - mapKeys: 1, - mapValues: 1, - partition: 1, - reduce: 2, - reduceRight: 2, - reject: 1, - remove: 1, - some: 1, - takeRightWhile: 1, - takeWhile: 1, - times: 1, - transform: 2, - } - - /** Used to map method names to iteratee rearg configs. */ - exports.iterateeRearg = { - mapKeys: [1], - reduceRight: [1, 0], - } - - /** Used to map method names to rearg configs. */ - exports.methodRearg = { - assignInAllWith: [1, 0], - assignInWith: [1, 2, 0], - assignAllWith: [1, 0], - assignWith: [1, 2, 0], - differenceBy: [1, 2, 0], - differenceWith: [1, 2, 0], - getOr: [2, 1, 0], - intersectionBy: [1, 2, 0], - intersectionWith: [1, 2, 0], - isEqualWith: [1, 2, 0], - isMatchWith: [2, 1, 0], - mergeAllWith: [1, 0], - mergeWith: [1, 2, 0], - padChars: [2, 1, 0], - padCharsEnd: [2, 1, 0], - padCharsStart: [2, 1, 0], - pullAllBy: [2, 1, 0], - pullAllWith: [2, 1, 0], - rangeStep: [1, 2, 0], - rangeStepRight: [1, 2, 0], - setWith: [3, 1, 2, 0], - sortedIndexBy: [2, 1, 0], - sortedLastIndexBy: [2, 1, 0], - unionBy: [1, 2, 0], - unionWith: [1, 2, 0], - updateWith: [3, 1, 2, 0], - xorBy: [1, 2, 0], - xorWith: [1, 2, 0], - zipWith: [1, 2, 0], - } - - /** Used to map method names to spread configs. */ - exports.methodSpread = { - assignAll: { start: 0 }, - assignAllWith: { start: 0 }, - assignInAll: { start: 0 }, - assignInAllWith: { start: 0 }, - defaultsAll: { start: 0 }, - defaultsDeepAll: { start: 0 }, - invokeArgs: { start: 2 }, - invokeArgsMap: { start: 2 }, - mergeAll: { start: 0 }, - mergeAllWith: { start: 0 }, - partial: { start: 1 }, - partialRight: { start: 1 }, - without: { start: 1 }, - zipAll: { start: 0 }, - } - - /** Used to identify methods which mutate arrays or objects. */ - exports.mutate = { - array: { - fill: true, - pull: true, - pullAll: true, - pullAllBy: true, - pullAllWith: true, - pullAt: true, - remove: true, - reverse: true, - }, - object: { - assign: true, - assignAll: true, - assignAllWith: true, - assignIn: true, - assignInAll: true, - assignInAllWith: true, - assignInWith: true, - assignWith: true, - defaults: true, - defaultsAll: true, - defaultsDeep: true, - defaultsDeepAll: true, - merge: true, - mergeAll: true, - mergeAllWith: true, - mergeWith: true, - }, - set: { - set: true, - setWith: true, - unset: true, - update: true, - updateWith: true, - }, - } - - /** Used to map real names to their aliases. */ - exports.realToAlias = (function() { - var hasOwnProperty = Object.prototype.hasOwnProperty, - object = exports.aliasToReal, - result = {} - - for (var key in object) { - var value = object[key] - if (hasOwnProperty.call(result, value)) { - result[value].push(key) - } else { - result[value] = [key] - } - } - return result - })() - - /** Used to map method names to other names. */ - exports.remap = { - assignAll: "assign", - assignAllWith: "assignWith", - assignInAll: "assignIn", - assignInAllWith: "assignInWith", - curryN: "curry", - curryRightN: "curryRight", - defaultsAll: "defaults", - defaultsDeepAll: "defaultsDeep", - findFrom: "find", - findIndexFrom: "findIndex", - findLastFrom: "findLast", - findLastIndexFrom: "findLastIndex", - getOr: "get", - includesFrom: "includes", - indexOfFrom: "indexOf", - invokeArgs: "invoke", - invokeArgsMap: "invokeMap", - lastIndexOfFrom: "lastIndexOf", - mergeAll: "merge", - mergeAllWith: "mergeWith", - padChars: "pad", - padCharsEnd: "padEnd", - padCharsStart: "padStart", - propertyOf: "get", - rangeStep: "range", - rangeStepRight: "rangeRight", - restFrom: "rest", - spreadFrom: "spread", - trimChars: "trim", - trimCharsEnd: "trimEnd", - trimCharsStart: "trimStart", - zipAll: "zip", - } - - /** Used to track methods that skip fixing their arity. */ - exports.skipFixed = { - castArray: true, - flow: true, - flowRight: true, - iteratee: true, - mixin: true, - rearg: true, - runInContext: true, - } - - /** Used to track methods that skip rearranging arguments. */ - exports.skipRearg = { - add: true, - assign: true, - assignIn: true, - bind: true, - bindKey: true, - concat: true, - difference: true, - divide: true, - eq: true, - gt: true, - gte: true, - isEqual: true, - lt: true, - lte: true, - matchesProperty: true, - merge: true, - multiply: true, - overArgs: true, - partial: true, - partialRight: true, - propertyOf: true, - random: true, - range: true, - rangeRight: true, - subtract: true, - zip: true, - zipObject: true, - zipObjectDeep: true, - } - }) - var _mapping_1 = _mapping.aliasToReal - var _mapping_2 = _mapping.aryMethod - var _mapping_3 = _mapping.aryRearg - var _mapping_4 = _mapping.iterateeAry - var _mapping_5 = _mapping.iterateeRearg - var _mapping_6 = _mapping.methodRearg - var _mapping_7 = _mapping.methodSpread - var _mapping_8 = _mapping.mutate - var _mapping_9 = _mapping.realToAlias - var _mapping_10 = _mapping.remap - var _mapping_11 = _mapping.skipFixed - var _mapping_12 = _mapping.skipRearg - - /** - * The default argument placeholder value for methods. - * - * @type {Object} - */ - var placeholder = {} - - /** Built-in value reference. */ - var push = Array.prototype.push - - /** - * Creates a function, with an arity of `n`, that invokes `func` with the - * arguments it receives. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} n The arity of the new function. - * @returns {Function} Returns the new function. - */ - function baseArity(func, n) { - return n == 2 - ? function(a, b) { - return func.apply(undefined, arguments) - } - : function(a) { - return func.apply(undefined, arguments) - } - } - - /** - * Creates a function that invokes `func`, with up to `n` arguments, ignoring - * any additional arguments. - * - * @private - * @param {Function} func The function to cap arguments for. - * @param {number} n The arity cap. - * @returns {Function} Returns the new function. - */ - function baseAry(func, n) { - return n == 2 - ? function(a, b) { - return func(a, b) - } - : function(a) { - return func(a) - } - } - - /** - * Creates a clone of `array`. - * - * @private - * @param {Array} array The array to clone. - * @returns {Array} Returns the cloned array. - */ - function cloneArray(array) { - var length = array ? array.length : 0, - result = Array(length) - - while (length--) { - result[length] = array[length] - } - return result - } - - /** - * Creates a function that clones a given object using the assignment `func`. - * - * @private - * @param {Function} func The assignment function. - * @returns {Function} Returns the new cloner function. - */ - function createCloner(func) { - return function(object) { - return func({}, object) - } - } - - /** - * A specialized version of `_.spread` which flattens the spread array into - * the arguments of the invoked `func`. - * - * @private - * @param {Function} func The function to spread arguments over. - * @param {number} start The start position of the spread. - * @returns {Function} Returns the new function. - */ - function flatSpread(func, start) { - return function() { - var length = arguments.length, - lastIndex = length - 1, - args = Array(length) - - while (length--) { - args[length] = arguments[length] - } - var array = args[start], - otherArgs = args.slice(0, start) - - if (array) { - push.apply(otherArgs, array) - } - if (start != lastIndex) { - push.apply(otherArgs, args.slice(start + 1)) - } - return func.apply(this, otherArgs) - } - } - - /** - * Creates a function that wraps `func` and uses `cloner` to clone the first - * argument it receives. - * - * @private - * @param {Function} func The function to wrap. - * @param {Function} cloner The function to clone arguments. - * @returns {Function} Returns the new immutable function. - */ - function wrapImmutable(func, cloner) { - return function() { - var length = arguments.length - if (!length) { - return - } - var args = Array(length) - while (length--) { - args[length] = arguments[length] - } - var result = (args[0] = cloner.apply(undefined, args)) - func.apply(undefined, args) - return result - } - } - - /** - * The base implementation of `convert` which accepts a `util` object of methods - * required to perform conversions. - * - * @param {Object} util The util object. - * @param {string} name The name of the function to convert. - * @param {Function} func The function to convert. - * @param {Object} [options] The options object. - * @param {boolean} [options.cap=true] Specify capping iteratee arguments. - * @param {boolean} [options.curry=true] Specify currying. - * @param {boolean} [options.fixed=true] Specify fixed arity. - * @param {boolean} [options.immutable=true] Specify immutable operations. - * @param {boolean} [options.rearg=true] Specify rearranging arguments. - * @returns {Function|Object} Returns the converted function or object. - */ - function baseConvert(util, name, func, options) { - var isLib = typeof name == "function", - isObj = name === Object(name) - - if (isObj) { - options = func - func = name - name = undefined - } - if (func == null) { - throw new TypeError() - } - options || (options = {}) - - var config = { - cap: "cap" in options ? options.cap : true, - curry: "curry" in options ? options.curry : true, - fixed: "fixed" in options ? options.fixed : true, - immutable: "immutable" in options ? options.immutable : true, - rearg: "rearg" in options ? options.rearg : true, - } - - var defaultHolder = isLib ? func : placeholder, - forceCurry = "curry" in options && options.curry, - forceFixed = "fixed" in options && options.fixed, - forceRearg = "rearg" in options && options.rearg, - pristine = isLib ? func.runInContext() : undefined - - var helpers = isLib - ? func - : { - ary: util.ary, - assign: util.assign, - clone: util.clone, - curry: util.curry, - forEach: util.forEach, - isArray: util.isArray, - isError: util.isError, - isFunction: util.isFunction, - isWeakMap: util.isWeakMap, - iteratee: util.iteratee, - keys: util.keys, - rearg: util.rearg, - toInteger: util.toInteger, - toPath: util.toPath, - } - - var ary = helpers.ary, - assign = helpers.assign, - clone = helpers.clone, - curry = helpers.curry, - each = helpers.forEach, - isArray = helpers.isArray, - isError = helpers.isError, - isFunction = helpers.isFunction, - isWeakMap = helpers.isWeakMap, - keys = helpers.keys, - rearg = helpers.rearg, - toInteger = helpers.toInteger, - toPath = helpers.toPath - - var aryMethodKeys = keys(_mapping.aryMethod) - - var wrappers = { - castArray: function(castArray) { - return function() { - var value = arguments[0] - return isArray(value) - ? castArray(cloneArray(value)) - : castArray.apply(undefined, arguments) - } - }, - iteratee: function(iteratee) { - return function() { - var func = arguments[0], - arity = arguments[1], - result = iteratee(func, arity), - length = result.length - - if (config.cap && typeof arity == "number") { - arity = arity > 2 ? arity - 2 : 1 - return length && length <= arity ? result : baseAry(result, arity) - } - return result - } - }, - mixin: function(mixin) { - return function(source) { - var func = this - if (!isFunction(func)) { - return mixin(func, Object(source)) - } - var pairs = [] - each(keys(source), function(key) { - if (isFunction(source[key])) { - pairs.push([key, func.prototype[key]]) - } - }) - - mixin(func, Object(source)) - - each(pairs, function(pair) { - var value = pair[1] - if (isFunction(value)) { - func.prototype[pair[0]] = value - } else { - delete func.prototype[pair[0]] - } - }) - return func - } - }, - nthArg: function(nthArg) { - return function(n) { - var arity = n < 0 ? 1 : toInteger(n) + 1 - return curry(nthArg(n), arity) - } - }, - rearg: function(rearg) { - return function(func, indexes) { - var arity = indexes ? indexes.length : 0 - return curry(rearg(func, indexes), arity) - } - }, - runInContext: function(runInContext) { - return function(context) { - return baseConvert(util, runInContext(context), options) - } - }, - } - - /*--------------------------------------------------------------------------*/ - - /** - * Casts `func` to a function with an arity capped iteratee if needed. - * - * @private - * @param {string} name The name of the function to inspect. - * @param {Function} func The function to inspect. - * @returns {Function} Returns the cast function. - */ - function castCap(name, func) { - if (config.cap) { - var indexes = _mapping.iterateeRearg[name] - if (indexes) { - return iterateeRearg(func, indexes) - } - var n = !isLib && _mapping.iterateeAry[name] - if (n) { - return iterateeAry(func, n) - } - } - return func - } - - /** - * Casts `func` to a curried function if needed. - * - * @private - * @param {string} name The name of the function to inspect. - * @param {Function} func The function to inspect. - * @param {number} n The arity of `func`. - * @returns {Function} Returns the cast function. - */ - function castCurry(name, func, n) { - return forceCurry || (config.curry && n > 1) ? curry(func, n) : func - } - - /** - * Casts `func` to a fixed arity function if needed. - * - * @private - * @param {string} name The name of the function to inspect. - * @param {Function} func The function to inspect. - * @param {number} n The arity cap. - * @returns {Function} Returns the cast function. - */ - function castFixed(name, func, n) { - if (config.fixed && (forceFixed || !_mapping.skipFixed[name])) { - var data = _mapping.methodSpread[name], - start = data && data.start - - return start === undefined ? ary(func, n) : flatSpread(func, start) - } - return func - } - - /** - * Casts `func` to an rearged function if needed. - * - * @private - * @param {string} name The name of the function to inspect. - * @param {Function} func The function to inspect. - * @param {number} n The arity of `func`. - * @returns {Function} Returns the cast function. - */ - function castRearg(name, func, n) { - return config.rearg && n > 1 && (forceRearg || !_mapping.skipRearg[name]) - ? rearg(func, _mapping.methodRearg[name] || _mapping.aryRearg[n]) - : func - } - - /** - * Creates a clone of `object` by `path`. - * - * @private - * @param {Object} object The object to clone. - * @param {Array|string} path The path to clone by. - * @returns {Object} Returns the cloned object. - */ - function cloneByPath(object, path) { - path = toPath(path) - - var index = -1, - length = path.length, - lastIndex = length - 1, - result = clone(Object(object)), - nested = result - - while (nested != null && ++index < length) { - var key = path[index], - value = nested[key] - - if ( - value != null && - !(isFunction(value) || isError(value) || isWeakMap(value)) - ) { - nested[key] = clone(index == lastIndex ? value : Object(value)) - } - nested = nested[key] - } - return result - } - - /** - * Converts `lodash` to an immutable auto-curried iteratee-first data-last - * version with conversion `options` applied. - * - * @param {Object} [options] The options object. See `baseConvert` for more details. - * @returns {Function} Returns the converted `lodash`. - */ - function convertLib(options) { - return _.runInContext.convert(options)(undefined) - } - - /** - * Create a converter function for `func` of `name`. - * - * @param {string} name The name of the function to convert. - * @param {Function} func The function to convert. - * @returns {Function} Returns the new converter function. - */ - function createConverter(name, func) { - var realName = _mapping.aliasToReal[name] || name, - methodName = _mapping.remap[realName] || realName, - oldOptions = options - - return function(options) { - var newUtil = isLib ? pristine : helpers, - newFunc = isLib ? pristine[methodName] : func, - newOptions = assign(assign({}, oldOptions), options) - - return baseConvert(newUtil, realName, newFunc, newOptions) - } - } - - /** - * Creates a function that wraps `func` to invoke its iteratee, with up to `n` - * arguments, ignoring any additional arguments. - * - * @private - * @param {Function} func The function to cap iteratee arguments for. - * @param {number} n The arity cap. - * @returns {Function} Returns the new function. - */ - function iterateeAry(func, n) { - return overArg(func, function(func) { - return typeof func == "function" ? baseAry(func, n) : func - }) - } - - /** - * Creates a function that wraps `func` to invoke its iteratee with arguments - * arranged according to the specified `indexes` where the argument value at - * the first index is provided as the first argument, the argument value at - * the second index is provided as the second argument, and so on. - * - * @private - * @param {Function} func The function to rearrange iteratee arguments for. - * @param {number[]} indexes The arranged argument indexes. - * @returns {Function} Returns the new function. - */ - function iterateeRearg(func, indexes) { - return overArg(func, function(func) { - var n = indexes.length - return baseArity(rearg(baseAry(func, n), indexes), n) - }) - } - - /** - * Creates a function that invokes `func` with its first argument transformed. - * - * @private - * @param {Function} func The function to wrap. - * @param {Function} transform The argument transform. - * @returns {Function} Returns the new function. - */ - function overArg(func, transform) { - return function() { - var length = arguments.length - if (!length) { - return func() - } - var args = Array(length) - while (length--) { - args[length] = arguments[length] - } - var index = config.rearg ? 0 : length - 1 - args[index] = transform(args[index]) - return func.apply(undefined, args) - } - } - - /** - * Creates a function that wraps `func` and applys the conversions - * rules by `name`. - * - * @private - * @param {string} name The name of the function to wrap. - * @param {Function} func The function to wrap. - * @returns {Function} Returns the converted function. - */ - function wrap(name, func, placeholder) { - var result, - realName = _mapping.aliasToReal[name] || name, - wrapped = func, - wrapper = wrappers[realName] - - if (wrapper) { - wrapped = wrapper(func) - } else if (config.immutable) { - if (_mapping.mutate.array[realName]) { - wrapped = wrapImmutable(func, cloneArray) - } else if (_mapping.mutate.object[realName]) { - wrapped = wrapImmutable(func, createCloner(func)) - } else if (_mapping.mutate.set[realName]) { - wrapped = wrapImmutable(func, cloneByPath) - } - } - each(aryMethodKeys, function(aryKey) { - each(_mapping.aryMethod[aryKey], function(otherName) { - if (realName == otherName) { - var data = _mapping.methodSpread[realName], - afterRearg = data && data.afterRearg - - result = afterRearg - ? castFixed( - realName, - castRearg(realName, wrapped, aryKey), - aryKey - ) - : castRearg( - realName, - castFixed(realName, wrapped, aryKey), - aryKey - ) - - result = castCap(realName, result) - result = castCurry(realName, result, aryKey) - return false - } - }) - return !result - }) - - result || (result = wrapped) - if (result == func) { - result = forceCurry - ? curry(result, 1) - : function() { - return func.apply(this, arguments) - } - } - result.convert = createConverter(realName, func) - result.placeholder = func.placeholder = placeholder - - return result - } - - /*--------------------------------------------------------------------------*/ - - if (!isObj) { - return wrap(name, func, defaultHolder) - } - var _ = func - - // Convert methods by ary cap. - var pairs = [] - each(aryMethodKeys, function(aryKey) { - each(_mapping.aryMethod[aryKey], function(key) { - var func = _[_mapping.remap[key] || key] - if (func) { - pairs.push([key, wrap(key, func, _)]) - } - }) - }) - - // Convert remaining methods. - each(keys(_), function(key) { - var func = _[key] - if (typeof func == "function") { - var length = pairs.length - while (length--) { - if (pairs[length][0] == key) { - return - } - } - func.convert = createConverter(key, func) - pairs.push([key, func]) - } - }) - - // Assign to `_` leaving `_.prototype` unchanged to allow chaining. - each(pairs, function(pair) { - _[pair[0]] = pair[1] - }) - - _.convert = convertLib - _.placeholder = _ - - // Assign aliases. - each(keys(_), function(key) { - each(_mapping.realToAlias[key] || [], function(alias) { - _[alias] = _[key] - }) - }) - - return _ - } - - var _baseConvert = baseConvert - - var _ = lodash_min.runInContext() - var fp = _baseConvert(_, _) - var fp_1 = fp.find - var fp_2 = fp.isUndefined - var fp_3 = fp.split - var fp_4 = fp.max - var fp_5 = fp.last - var fp_6 = fp.union - var fp_7 = fp.reduce - var fp_8 = fp.isObject - var fp_9 = fp.cloneDeep - var fp_10 = fp.some - var fp_11 = fp.isArray - var fp_12 = fp.map - var fp_13 = fp.filter - var fp_14 = fp.keys - var fp_15 = fp.isFunction - var fp_16 = fp.isEmpty - var fp_17 = fp.countBy - var fp_18 = fp.join - var fp_19 = fp.includes - var fp_20 = fp.flatten - var fp_21 = fp.constant - var fp_22 = fp.first - var fp_23 = fp.intersection - var fp_24 = fp.take - var fp_25 = fp.has - var fp_26 = fp.mapValues - var fp_27 = fp.isString - var fp_28 = fp.isBoolean - var fp_29 = fp.isNull - var fp_30 = fp.isNumber - var fp_31 = fp.isObjectLike - var fp_32 = fp.isDate - var fp_33 = fp.clone - var fp_34 = fp.values - var fp_35 = fp.keyBy - var fp_36 = fp.isNaN - var fp_37 = fp.isInteger - var fp_38 = fp.toNumber - - // Found this seed-based random generator somewhere - // Based on The Central Randomizer 1.3 (C) 1997 by Paul Houle (houle@msc.cornell.edu) - - var seed = 1 - - /** - * return a random number based on a seed - * @param seed - * @returns {number} - */ - function getNextValue() { - seed = (seed * 9301 + 49297) % 233280 - return seed / 233280.0 - } - - function setSeed(_seed_) { - seed = _seed_ - } - - var randomFromSeed = { - nextValue: getNextValue, - seed: setSeed, - } - - var ORIGINAL = - "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-" - var alphabet - var previousSeed - - var shuffled - - function reset() { - shuffled = false - } - - function setCharacters(_alphabet_) { - if (!_alphabet_) { - if (alphabet !== ORIGINAL) { - alphabet = ORIGINAL - reset() - } - return - } - - if (_alphabet_ === alphabet) { - return - } - - if (_alphabet_.length !== ORIGINAL.length) { - throw new Error( - "Custom alphabet for shortid must be " + - ORIGINAL.length + - " unique characters. You submitted " + - _alphabet_.length + - " characters: " + - _alphabet_ - ) - } - - var unique = _alphabet_.split("").filter(function(item, ind, arr) { - return ind !== arr.lastIndexOf(item) - }) - - if (unique.length) { - throw new Error( - "Custom alphabet for shortid must be " + - ORIGINAL.length + - " unique characters. These characters were not unique: " + - unique.join(", ") - ) - } - - alphabet = _alphabet_ - reset() - } - - function characters(_alphabet_) { - setCharacters(_alphabet_) - return alphabet - } - - function setSeed$1(seed) { - randomFromSeed.seed(seed) - if (previousSeed !== seed) { - reset() - previousSeed = seed - } - } - - function shuffle() { - if (!alphabet) { - setCharacters(ORIGINAL) - } - - var sourceArray = alphabet.split("") - var targetArray = [] - var r = randomFromSeed.nextValue() - var characterIndex - - while (sourceArray.length > 0) { - r = randomFromSeed.nextValue() - characterIndex = Math.floor(r * sourceArray.length) - targetArray.push(sourceArray.splice(characterIndex, 1)[0]) - } - return targetArray.join("") - } - - function getShuffled() { - if (shuffled) { - return shuffled - } - shuffled = shuffle() - return shuffled - } - - /** - * lookup shuffled letter - * @param index - * @returns {string} - */ - function lookup(index) { - var alphabetShuffled = getShuffled() - return alphabetShuffled[index] - } - - function get() { - return alphabet || ORIGINAL - } - - var alphabet_1 = { - get: get, - characters: characters, - seed: setSeed$1, - lookup: lookup, - shuffled: getShuffled, - } - - var crypto = typeof window === "object" && (window.crypto || window.msCrypto) // IE 11 uses window.msCrypto - - var randomByte - - if (!crypto || !crypto.getRandomValues) { - randomByte = function(size) { - var bytes = [] - for (var i = 0; i < size; i++) { - bytes.push(Math.floor(Math.random() * 256)) - } - return bytes - } - } else { - randomByte = function(size) { - return crypto.getRandomValues(new Uint8Array(size)) - } - } - - var randomByteBrowser = randomByte - - // This file replaces `format.js` in bundlers like webpack or Rollup, - // according to `browser` config in `package.json`. - - var format_browser = function(random, alphabet, size) { - // We can’t use bytes bigger than the alphabet. To make bytes values closer - // to the alphabet, we apply bitmask on them. We look for the closest - // `2 ** x - 1` number, which will be bigger than alphabet size. If we have - // 30 symbols in the alphabet, we will take 31 (00011111). - // We do not use faster Math.clz32, because it is not available in browsers. - var mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1 - // Bitmask is not a perfect solution (in our example it will pass 31 bytes, - // which is bigger than the alphabet). As a result, we will need more bytes, - // than ID size, because we will refuse bytes bigger than the alphabet. - - // Every hardware random generator call is costly, - // because we need to wait for entropy collection. This is why often it will - // be faster to ask for few extra bytes in advance, to avoid additional calls. - - // Here we calculate how many random bytes should we call in advance. - // It depends on ID length, mask / alphabet size and magic number 1.6 - // (which was selected according benchmarks). - - // -~f => Math.ceil(f) if n is float number - // -~i => i + 1 if n is integer number - var step = -~((1.6 * mask * size) / alphabet.length) - var id = "" - - while (true) { - var bytes = random(step) - // Compact alternative for `for (var i = 0; i < step; i++)` - var i = step - while (i--) { - // If random byte is bigger than alphabet even after bitmask, - // we refuse it by `|| ''`. - id += alphabet[bytes[i] & mask] || "" - // More compact than `id.length + 1 === size` - if (id.length === +size) return id - } - } - } - - function generate(number) { - var loopCounter = 0 - var done - - var str = "" - - while (!done) { - str = str + format_browser(randomByteBrowser, alphabet_1.get(), 1) - done = number < Math.pow(16, loopCounter + 1) - loopCounter++ - } - return str - } - - var generate_1 = generate - - // Ignore all milliseconds before a certain time to reduce the size of the date entropy without sacrificing uniqueness. - // This number should be updated every year or so to keep the generated id short. - // To regenerate `new Date() - 0` and bump the version. Always bump the version! - var REDUCE_TIME = 1567752802062 - - // don't change unless we change the algos or REDUCE_TIME - // must be an integer and less than 16 - var version = 7 - - // Counter is used when shortid is called multiple times in one second. - var counter - - // Remember the last time shortid was called in case counter is needed. - var previousSeconds - - /** - * Generate unique id - * Returns string id - */ - function build(clusterWorkerId) { - var str = "" - - var seconds = Math.floor((Date.now() - REDUCE_TIME) * 0.001) - - if (seconds === previousSeconds) { - counter++ - } else { - counter = 0 - previousSeconds = seconds - } - - str = str + generate_1(version) - str = str + generate_1(clusterWorkerId) - if (counter > 0) { - str = str + generate_1(counter) - } - str = str + generate_1(seconds) - return str - } - - var build_1 = build - - function isShortId(id) { - if (!id || typeof id !== "string" || id.length < 6) { - return false - } - - var nonAlphabetic = new RegExp( - "[^" + alphabet_1.get().replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&") + "]" - ) - return !nonAlphabetic.test(id) - } - - var isValid = isShortId - - var lib = createCommonjsModule(function(module) { - // if you are using cluster or multiple servers use this to make each instance - // has a unique value for worker - // Note: I don't know if this is automatically set when using third - // party cluster solutions such as pm2. - var clusterWorkerId = 0 - - /** - * Set the seed. - * Highly recommended if you don't want people to try to figure out your id schema. - * exposed as shortid.seed(int) - * @param seed Integer value to seed the random alphabet. ALWAYS USE THE SAME SEED or you might get overlaps. - */ - function seed(seedValue) { - alphabet_1.seed(seedValue) - return module.exports - } - - /** - * Set the cluster worker or machine id - * exposed as shortid.worker(int) - * @param workerId worker must be positive integer. Number less than 16 is recommended. - * returns shortid module so it can be chained. - */ - function worker(workerId) { - clusterWorkerId = workerId - return module.exports - } - - /** - * - * sets new characters to use in the alphabet - * returns the shuffled alphabet - */ - function characters(newCharacters) { - if (newCharacters !== undefined) { - alphabet_1.characters(newCharacters) - } - - return alphabet_1.shuffled() - } - - /** - * Generate unique id - * Returns string id - */ - function generate() { - return build_1(clusterWorkerId) - } - - // Export all other functions as properties of the generate function - module.exports = generate - module.exports.generate = generate - module.exports.seed = seed - module.exports.worker = worker - module.exports.characters = characters - module.exports.isValid = isValid - }) - var lib_1 = lib.generate - var lib_2 = lib.seed - var lib_3 = lib.worker - var lib_4 = lib.characters - var lib_5 = lib.isValid - - var shortid = lib - var shortid_1 = shortid.generate - - var lodash = createCommonjsModule(function(module, exports) { - ;(function() { - /** Used as a safe reference for `undefined` in pre-ES5 environments. */ - var undefined$1 - - /** Used as the semantic version number. */ - var VERSION = "4.17.15" - - /** Used as the size to enable large array optimizations. */ - var LARGE_ARRAY_SIZE = 200 - - /** Error message constants. */ - var CORE_ERROR_TEXT = - "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", - FUNC_ERROR_TEXT = "Expected a function" - - /** Used to stand-in for `undefined` hash values. */ - var HASH_UNDEFINED = "__lodash_hash_undefined__" - - /** Used as the maximum memoize cache size. */ - var MAX_MEMOIZE_SIZE = 500 - - /** Used as the internal argument placeholder. */ - var PLACEHOLDER = "__lodash_placeholder__" - - /** Used to compose bitmasks for cloning. */ - var CLONE_DEEP_FLAG = 1, - CLONE_FLAT_FLAG = 2, - CLONE_SYMBOLS_FLAG = 4 - - /** Used to compose bitmasks for value comparisons. */ - var COMPARE_PARTIAL_FLAG = 1, - COMPARE_UNORDERED_FLAG = 2 - - /** Used to compose bitmasks for function metadata. */ - var WRAP_BIND_FLAG = 1, - WRAP_BIND_KEY_FLAG = 2, - WRAP_CURRY_BOUND_FLAG = 4, - WRAP_CURRY_FLAG = 8, - WRAP_CURRY_RIGHT_FLAG = 16, - WRAP_PARTIAL_FLAG = 32, - WRAP_PARTIAL_RIGHT_FLAG = 64, - WRAP_ARY_FLAG = 128, - WRAP_REARG_FLAG = 256, - WRAP_FLIP_FLAG = 512 - - /** Used as default options for `_.truncate`. */ - var DEFAULT_TRUNC_LENGTH = 30, - DEFAULT_TRUNC_OMISSION = "..." - - /** Used to detect hot functions by number of calls within a span of milliseconds. */ - var HOT_COUNT = 800, - HOT_SPAN = 16 - - /** Used to indicate the type of lazy iteratees. */ - var LAZY_FILTER_FLAG = 1, - LAZY_MAP_FLAG = 2, - LAZY_WHILE_FLAG = 3 - - /** Used as references for various `Number` constants. */ - var INFINITY = 1 / 0, - MAX_SAFE_INTEGER = 9007199254740991, - MAX_INTEGER = 1.7976931348623157e308, - NAN = 0 / 0 - - /** Used as references for the maximum length and index of an array. */ - var MAX_ARRAY_LENGTH = 4294967295, - MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, - HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1 - - /** Used to associate wrap methods with their bit flags. */ - var wrapFlags = [ - ["ary", WRAP_ARY_FLAG], - ["bind", WRAP_BIND_FLAG], - ["bindKey", WRAP_BIND_KEY_FLAG], - ["curry", WRAP_CURRY_FLAG], - ["curryRight", WRAP_CURRY_RIGHT_FLAG], - ["flip", WRAP_FLIP_FLAG], - ["partial", WRAP_PARTIAL_FLAG], - ["partialRight", WRAP_PARTIAL_RIGHT_FLAG], - ["rearg", WRAP_REARG_FLAG], - ] - - /** `Object#toString` result references. */ - var argsTag = "[object Arguments]", - arrayTag = "[object Array]", - asyncTag = "[object AsyncFunction]", - boolTag = "[object Boolean]", - dateTag = "[object Date]", - domExcTag = "[object DOMException]", - errorTag = "[object Error]", - funcTag = "[object Function]", - genTag = "[object GeneratorFunction]", - mapTag = "[object Map]", - numberTag = "[object Number]", - nullTag = "[object Null]", - objectTag = "[object Object]", - promiseTag = "[object Promise]", - proxyTag = "[object Proxy]", - regexpTag = "[object RegExp]", - setTag = "[object Set]", - stringTag = "[object String]", - symbolTag = "[object Symbol]", - undefinedTag = "[object Undefined]", - weakMapTag = "[object WeakMap]", - weakSetTag = "[object WeakSet]" - - var arrayBufferTag = "[object ArrayBuffer]", - dataViewTag = "[object DataView]", - float32Tag = "[object Float32Array]", - float64Tag = "[object Float64Array]", - int8Tag = "[object Int8Array]", - int16Tag = "[object Int16Array]", - int32Tag = "[object Int32Array]", - uint8Tag = "[object Uint8Array]", - uint8ClampedTag = "[object Uint8ClampedArray]", - uint16Tag = "[object Uint16Array]", - uint32Tag = "[object Uint32Array]" - - /** Used to match empty string literals in compiled template source. */ - var reEmptyStringLeading = /\b__p \+= '';/g, - reEmptyStringMiddle = /\b(__p \+=) '' \+/g, - reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g - - /** Used to match HTML entities and HTML characters. */ - var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, - reUnescapedHtml = /[&<>"']/g, - reHasEscapedHtml = RegExp(reEscapedHtml.source), - reHasUnescapedHtml = RegExp(reUnescapedHtml.source) - - /** Used to match template delimiters. */ - var reEscape = /<%-([\s\S]+?)%>/g, - reEvaluate = /<%([\s\S]+?)%>/g, - reInterpolate = /<%=([\s\S]+?)%>/g - - /** Used to match property names within property paths. */ - var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, - reIsPlainProp = /^\w*$/, - rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g - - /** - * Used to match `RegExp` - * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). - */ - var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, - reHasRegExpChar = RegExp(reRegExpChar.source) - - /** Used to match leading and trailing whitespace. */ - var reTrim = /^\s+|\s+$/g, - reTrimStart = /^\s+/, - reTrimEnd = /\s+$/ - - /** Used to match wrap detail comments. */ - var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, - reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, - reSplitDetails = /,? & / - - /** Used to match words composed of alphanumeric characters. */ - var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g - - /** Used to match backslashes in property paths. */ - var reEscapeChar = /\\(\\)?/g - - /** - * Used to match - * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components). - */ - var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g - - /** Used to match `RegExp` flags from their coerced string values. */ - var reFlags = /\w*$/ - - /** Used to detect bad signed hexadecimal string values. */ - var reIsBadHex = /^[-+]0x[0-9a-f]+$/i - - /** Used to detect binary string values. */ - var reIsBinary = /^0b[01]+$/i - - /** Used to detect host constructors (Safari). */ - var reIsHostCtor = /^\[object .+?Constructor\]$/ - - /** Used to detect octal string values. */ - var reIsOctal = /^0o[0-7]+$/i - - /** Used to detect unsigned integer values. */ - var reIsUint = /^(?:0|[1-9]\d*)$/ - - /** Used to match Latin Unicode letters (excluding mathematical operators). */ - var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g - - /** Used to ensure capturing order of template delimiters. */ - var reNoMatch = /($^)/ - - /** Used to match unescaped characters in compiled string literals. */ - var reUnescapedString = /['\n\r\u2028\u2029\\]/g - - /** Used to compose unicode character classes. */ - var rsAstralRange = "\\ud800-\\udfff", - rsComboMarksRange = "\\u0300-\\u036f", - reComboHalfMarksRange = "\\ufe20-\\ufe2f", - rsComboSymbolsRange = "\\u20d0-\\u20ff", - rsComboRange = - rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, - rsDingbatRange = "\\u2700-\\u27bf", - rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", - rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", - rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", - rsPunctuationRange = "\\u2000-\\u206f", - rsSpaceRange = - " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", - rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", - rsVarRange = "\\ufe0e\\ufe0f", - rsBreakRange = - rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange - - /** Used to compose unicode capture groups. */ - var rsApos = "['\u2019]", - rsAstral = "[" + rsAstralRange + "]", - rsBreak = "[" + rsBreakRange + "]", - rsCombo = "[" + rsComboRange + "]", - rsDigits = "\\d+", - rsDingbat = "[" + rsDingbatRange + "]", - rsLower = "[" + rsLowerRange + "]", - rsMisc = - "[^" + - rsAstralRange + - rsBreakRange + - rsDigits + - rsDingbatRange + - rsLowerRange + - rsUpperRange + - "]", - rsFitz = "\\ud83c[\\udffb-\\udfff]", - rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", - rsNonAstral = "[^" + rsAstralRange + "]", - rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", - rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", - rsUpper = "[" + rsUpperRange + "]", - rsZWJ = "\\u200d" - - /** Used to compose unicode regexes. */ - var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", - rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", - rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", - rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", - reOptMod = rsModifier + "?", - rsOptVar = "[" + rsVarRange + "]?", - rsOptJoin = - "(?:" + - rsZWJ + - "(?:" + - [rsNonAstral, rsRegional, rsSurrPair].join("|") + - ")" + - rsOptVar + - reOptMod + - ")*", - rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", - rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", - rsSeq = rsOptVar + reOptMod + rsOptJoin, - rsEmoji = - "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq, - rsSymbol = - "(?:" + - [ - rsNonAstral + rsCombo + "?", - rsCombo, - rsRegional, - rsSurrPair, - rsAstral, - ].join("|") + - ")" - - /** Used to match apostrophes. */ - var reApos = RegExp(rsApos, "g") - - /** - * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and - * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). - */ - var reComboMark = RegExp(rsCombo, "g") - - /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ - var reUnicode = RegExp( - rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, - "g" - ) - - /** Used to match complex or compound words. */ - var reUnicodeWord = RegExp( - [ - rsUpper + - "?" + - rsLower + - "+" + - rsOptContrLower + - "(?=" + - [rsBreak, rsUpper, "$"].join("|") + - ")", - rsMiscUpper + - "+" + - rsOptContrUpper + - "(?=" + - [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + - ")", - rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower, - rsUpper + "+" + rsOptContrUpper, - rsOrdUpper, - rsOrdLower, - rsDigits, - rsEmoji, - ].join("|"), - "g" - ) - - /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ - var reHasUnicode = RegExp( - "[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]" - ) - - /** Used to detect strings that need a more robust regexp to match words. */ - var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/ - - /** Used to assign default `context` object properties. */ - var contextProps = [ - "Array", - "Buffer", - "DataView", - "Date", - "Error", - "Float32Array", - "Float64Array", - "Function", - "Int8Array", - "Int16Array", - "Int32Array", - "Map", - "Math", - "Object", - "Promise", - "RegExp", - "Set", - "String", - "Symbol", - "TypeError", - "Uint8Array", - "Uint8ClampedArray", - "Uint16Array", - "Uint32Array", - "WeakMap", - "_", - "clearTimeout", - "isFinite", - "parseInt", - "setTimeout", - ] - - /** Used to make template sourceURLs easier to identify. */ - var templateCounter = -1 - - /** Used to identify `toStringTag` values of typed arrays. */ - var typedArrayTags = {} - typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[ - int8Tag - ] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[ - uint8Tag - ] = typedArrayTags[uint8ClampedTag] = typedArrayTags[ - uint16Tag - ] = typedArrayTags[uint32Tag] = true - typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[ - arrayBufferTag - ] = typedArrayTags[boolTag] = typedArrayTags[ - dataViewTag - ] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[ - funcTag - ] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[ - objectTag - ] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[ - stringTag - ] = typedArrayTags[weakMapTag] = false - - /** Used to identify `toStringTag` values supported by `_.clone`. */ - var cloneableTags = {} - cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[ - arrayBufferTag - ] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[ - dateTag - ] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[ - int8Tag - ] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[ - mapTag - ] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[ - regexpTag - ] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[ - symbolTag - ] = cloneableTags[uint8Tag] = cloneableTags[ - uint8ClampedTag - ] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true - cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[ - weakMapTag - ] = false - - /** Used to map Latin Unicode letters to basic Latin letters. */ - var deburredLetters = { - // Latin-1 Supplement block. - À: "A", - Á: "A", - Â: "A", - Ã: "A", - Ä: "A", - Å: "A", - à: "a", - á: "a", - â: "a", - ã: "a", - ä: "a", - å: "a", - Ç: "C", - ç: "c", - Ð: "D", - ð: "d", - È: "E", - É: "E", - Ê: "E", - Ë: "E", - è: "e", - é: "e", - ê: "e", - ë: "e", - Ì: "I", - Í: "I", - Î: "I", - Ï: "I", - ì: "i", - í: "i", - î: "i", - ï: "i", - Ñ: "N", - ñ: "n", - Ò: "O", - Ó: "O", - Ô: "O", - Õ: "O", - Ö: "O", - Ø: "O", - ò: "o", - ó: "o", - ô: "o", - õ: "o", - ö: "o", - ø: "o", - Ù: "U", - Ú: "U", - Û: "U", - Ü: "U", - ù: "u", - ú: "u", - û: "u", - ü: "u", - Ý: "Y", - ý: "y", - ÿ: "y", - Æ: "Ae", - æ: "ae", - Þ: "Th", - þ: "th", - ß: "ss", - // Latin Extended-A block. - Ā: "A", - Ă: "A", - Ą: "A", - ā: "a", - ă: "a", - ą: "a", - Ć: "C", - Ĉ: "C", - Ċ: "C", - Č: "C", - ć: "c", - ĉ: "c", - ċ: "c", - č: "c", - Ď: "D", - Đ: "D", - ď: "d", - đ: "d", - Ē: "E", - Ĕ: "E", - Ė: "E", - Ę: "E", - Ě: "E", - ē: "e", - ĕ: "e", - ė: "e", - ę: "e", - ě: "e", - Ĝ: "G", - Ğ: "G", - Ġ: "G", - Ģ: "G", - ĝ: "g", - ğ: "g", - ġ: "g", - ģ: "g", - Ĥ: "H", - Ħ: "H", - ĥ: "h", - ħ: "h", - Ĩ: "I", - Ī: "I", - Ĭ: "I", - Į: "I", - İ: "I", - ĩ: "i", - ī: "i", - ĭ: "i", - į: "i", - ı: "i", - Ĵ: "J", - ĵ: "j", - Ķ: "K", - ķ: "k", - ĸ: "k", - Ĺ: "L", - Ļ: "L", - Ľ: "L", - Ŀ: "L", - Ł: "L", - ĺ: "l", - ļ: "l", - ľ: "l", - ŀ: "l", - ł: "l", - Ń: "N", - Ņ: "N", - Ň: "N", - Ŋ: "N", - ń: "n", - ņ: "n", - ň: "n", - ŋ: "n", - Ō: "O", - Ŏ: "O", - Ő: "O", - ō: "o", - ŏ: "o", - ő: "o", - Ŕ: "R", - Ŗ: "R", - Ř: "R", - ŕ: "r", - ŗ: "r", - ř: "r", - Ś: "S", - Ŝ: "S", - Ş: "S", - Š: "S", - ś: "s", - ŝ: "s", - ş: "s", - š: "s", - Ţ: "T", - Ť: "T", - Ŧ: "T", - ţ: "t", - ť: "t", - ŧ: "t", - Ũ: "U", - Ū: "U", - Ŭ: "U", - Ů: "U", - Ű: "U", - Ų: "U", - ũ: "u", - ū: "u", - ŭ: "u", - ů: "u", - ű: "u", - ų: "u", - Ŵ: "W", - ŵ: "w", - Ŷ: "Y", - ŷ: "y", - Ÿ: "Y", - Ź: "Z", - Ż: "Z", - Ž: "Z", - ź: "z", - ż: "z", - ž: "z", - IJ: "IJ", - ij: "ij", - Œ: "Oe", - œ: "oe", - ʼn: "'n", - ſ: "s", - } - - /** Used to map characters to HTML entities. */ - var htmlEscapes = { - "&": "&", - "<": "<", - ">": ">", - '"': """, - "'": "'", - } - - /** Used to map HTML entities to characters. */ - var htmlUnescapes = { - "&": "&", - "<": "<", - ">": ">", - """: '"', - "'": "'", - } - - /** Used to escape characters for inclusion in compiled string literals. */ - var stringEscapes = { - "\\": "\\", - "'": "'", - "\n": "n", - "\r": "r", - "\u2028": "u2028", - "\u2029": "u2029", - } - - /** Built-in method references without a dependency on `root`. */ - var freeParseFloat = parseFloat, - freeParseInt = parseInt - - /** Detect free variable `global` from Node.js. */ - var freeGlobal = - typeof commonjsGlobal == "object" && - commonjsGlobal && - commonjsGlobal.Object === Object && - commonjsGlobal - - /** Detect free variable `self`. */ - var freeSelf = - typeof self == "object" && self && self.Object === Object && self - - /** Used as a reference to the global object. */ - var root = freeGlobal || freeSelf || Function("return this")() - - /** Detect free variable `exports`. */ - var freeExports = exports && !exports.nodeType && exports - - /** Detect free variable `module`. */ - var freeModule = - freeExports && - "object" == "object" && - module && - !module.nodeType && - module - - /** Detect the popular CommonJS extension `module.exports`. */ - var moduleExports = freeModule && freeModule.exports === freeExports - - /** Detect free variable `process` from Node.js. */ - var freeProcess = moduleExports && freeGlobal.process - - /** Used to access faster Node.js helpers. */ - var nodeUtil = (function() { - try { - // Use `util.types` for Node.js 10+. - var types = - freeModule && freeModule.require && freeModule.require("util").types - - if (types) { - return types - } - - // Legacy `process.binding('util')` for Node.js < 10. - return ( - freeProcess && freeProcess.binding && freeProcess.binding("util") - ) - } catch (e) {} - })() - - /* Node.js helper references. */ - var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, - nodeIsDate = nodeUtil && nodeUtil.isDate, - nodeIsMap = nodeUtil && nodeUtil.isMap, - nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, - nodeIsSet = nodeUtil && nodeUtil.isSet, - nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray - - /*--------------------------------------------------------------------------*/ - - /** - * A faster alternative to `Function#apply`, this function invokes `func` - * with the `this` binding of `thisArg` and the arguments of `args`. - * - * @private - * @param {Function} func The function to invoke. - * @param {*} thisArg The `this` binding of `func`. - * @param {Array} args The arguments to invoke `func` with. - * @returns {*} Returns the result of `func`. - */ - function apply(func, thisArg, args) { - switch (args.length) { - case 0: - return func.call(thisArg) - case 1: - return func.call(thisArg, args[0]) - case 2: - return func.call(thisArg, args[0], args[1]) - case 3: - return func.call(thisArg, args[0], args[1], args[2]) - } - return func.apply(thisArg, args) - } - - /** - * A specialized version of `baseAggregator` for arrays. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform keys. - * @param {Object} accumulator The initial aggregated object. - * @returns {Function} Returns `accumulator`. - */ - function arrayAggregator(array, setter, iteratee, accumulator) { - var index = -1, - length = array == null ? 0 : array.length - - while (++index < length) { - var value = array[index] - setter(accumulator, value, iteratee(value), array) - } - return accumulator - } - - /** - * A specialized version of `_.forEach` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns `array`. - */ - function arrayEach(array, iteratee) { - var index = -1, - length = array == null ? 0 : array.length - - while (++index < length) { - if (iteratee(array[index], index, array) === false) { - break - } - } - return array - } - - /** - * A specialized version of `_.forEachRight` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns `array`. - */ - function arrayEachRight(array, iteratee) { - var length = array == null ? 0 : array.length - - while (length--) { - if (iteratee(array[length], length, array) === false) { - break - } - } - return array - } - - /** - * A specialized version of `_.every` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false`. - */ - function arrayEvery(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length - - while (++index < length) { - if (!predicate(array[index], index, array)) { - return false - } - } - return true - } - - /** - * A specialized version of `_.filter` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - */ - function arrayFilter(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length, - resIndex = 0, - result = [] - - while (++index < length) { - var value = array[index] - if (predicate(value, index, array)) { - result[resIndex++] = value - } - } - return result - } - - /** - * A specialized version of `_.includes` for arrays without support for - * specifying an index to search from. - * - * @private - * @param {Array} [array] The array to inspect. - * @param {*} target The value to search for. - * @returns {boolean} Returns `true` if `target` is found, else `false`. - */ - function arrayIncludes(array, value) { - var length = array == null ? 0 : array.length - return !!length && baseIndexOf(array, value, 0) > -1 - } - - /** - * This function is like `arrayIncludes` except that it accepts a comparator. - * - * @private - * @param {Array} [array] The array to inspect. - * @param {*} target The value to search for. - * @param {Function} comparator The comparator invoked per element. - * @returns {boolean} Returns `true` if `target` is found, else `false`. - */ - function arrayIncludesWith(array, value, comparator) { - var index = -1, - length = array == null ? 0 : array.length - - while (++index < length) { - if (comparator(value, array[index])) { - return true - } - } - return false - } - - /** - * A specialized version of `_.map` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ - function arrayMap(array, iteratee) { - var index = -1, - length = array == null ? 0 : array.length, - result = Array(length) - - while (++index < length) { - result[index] = iteratee(array[index], index, array) - } - return result - } - - /** - * Appends the elements of `values` to `array`. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to append. - * @returns {Array} Returns `array`. - */ - function arrayPush(array, values) { - var index = -1, - length = values.length, - offset = array.length - - while (++index < length) { - array[offset + index] = values[index] - } - return array - } - - /** - * A specialized version of `_.reduce` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @param {boolean} [initAccum] Specify using the first element of `array` as - * the initial value. - * @returns {*} Returns the accumulated value. - */ - function arrayReduce(array, iteratee, accumulator, initAccum) { - var index = -1, - length = array == null ? 0 : array.length - - if (initAccum && length) { - accumulator = array[++index] - } - while (++index < length) { - accumulator = iteratee(accumulator, array[index], index, array) - } - return accumulator - } - - /** - * A specialized version of `_.reduceRight` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @param {boolean} [initAccum] Specify using the last element of `array` as - * the initial value. - * @returns {*} Returns the accumulated value. - */ - function arrayReduceRight(array, iteratee, accumulator, initAccum) { - var length = array == null ? 0 : array.length - if (initAccum && length) { - accumulator = array[--length] - } - while (length--) { - accumulator = iteratee(accumulator, array[length], length, array) - } - return accumulator - } - - /** - * A specialized version of `_.some` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - */ - function arraySome(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length - - while (++index < length) { - if (predicate(array[index], index, array)) { - return true - } - } - return false - } - - /** - * Gets the size of an ASCII `string`. - * - * @private - * @param {string} string The string inspect. - * @returns {number} Returns the string size. - */ - var asciiSize = baseProperty("length") - - /** - * Converts an ASCII `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function asciiToArray(string) { - return string.split("") - } - - /** - * Splits an ASCII `string` into an array of its words. - * - * @private - * @param {string} The string to inspect. - * @returns {Array} Returns the words of `string`. - */ - function asciiWords(string) { - return string.match(reAsciiWord) || [] - } - - /** - * The base implementation of methods like `_.findKey` and `_.findLastKey`, - * without support for iteratee shorthands, which iterates over `collection` - * using `eachFunc`. - * - * @private - * @param {Array|Object} collection The collection to inspect. - * @param {Function} predicate The function invoked per iteration. - * @param {Function} eachFunc The function to iterate over `collection`. - * @returns {*} Returns the found element or its key, else `undefined`. - */ - function baseFindKey(collection, predicate, eachFunc) { - var result - eachFunc(collection, function(value, key, collection) { - if (predicate(value, key, collection)) { - result = key - return false - } - }) - return result - } - - /** - * The base implementation of `_.findIndex` and `_.findLastIndex` without - * support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} predicate The function invoked per iteration. - * @param {number} fromIndex The index to search from. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseFindIndex(array, predicate, fromIndex, fromRight) { - var length = array.length, - index = fromIndex + (fromRight ? 1 : -1) - - while (fromRight ? index-- : ++index < length) { - if (predicate(array[index], index, array)) { - return index - } - } - return -1 - } - - /** - * The base implementation of `_.indexOf` without `fromIndex` bounds checks. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseIndexOf(array, value, fromIndex) { - return value === value - ? strictIndexOf(array, value, fromIndex) - : baseFindIndex(array, baseIsNaN, fromIndex) - } - - /** - * This function is like `baseIndexOf` except that it accepts a comparator. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @param {Function} comparator The comparator invoked per element. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseIndexOfWith(array, value, fromIndex, comparator) { - var index = fromIndex - 1, - length = array.length - - while (++index < length) { - if (comparator(array[index], value)) { - return index - } - } - return -1 - } - - /** - * The base implementation of `_.isNaN` without support for number objects. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. - */ - function baseIsNaN(value) { - return value !== value - } - - /** - * The base implementation of `_.mean` and `_.meanBy` without support for - * iteratee shorthands. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {number} Returns the mean. - */ - function baseMean(array, iteratee) { - var length = array == null ? 0 : array.length - return length ? baseSum(array, iteratee) / length : NAN - } - - /** - * The base implementation of `_.property` without support for deep paths. - * - * @private - * @param {string} key The key of the property to get. - * @returns {Function} Returns the new accessor function. - */ - function baseProperty(key) { - return function(object) { - return object == null ? undefined$1 : object[key] - } - } - - /** - * The base implementation of `_.propertyOf` without support for deep paths. - * - * @private - * @param {Object} object The object to query. - * @returns {Function} Returns the new accessor function. - */ - function basePropertyOf(object) { - return function(key) { - return object == null ? undefined$1 : object[key] - } - } - - /** - * The base implementation of `_.reduce` and `_.reduceRight`, without support - * for iteratee shorthands, which iterates over `collection` using `eachFunc`. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} accumulator The initial value. - * @param {boolean} initAccum Specify using the first or last element of - * `collection` as the initial value. - * @param {Function} eachFunc The function to iterate over `collection`. - * @returns {*} Returns the accumulated value. - */ - function baseReduce( - collection, - iteratee, - accumulator, - initAccum, - eachFunc - ) { - eachFunc(collection, function(value, index, collection) { - accumulator = initAccum - ? ((initAccum = false), value) - : iteratee(accumulator, value, index, collection) - }) - return accumulator - } - - /** - * The base implementation of `_.sortBy` which uses `comparer` to define the - * sort order of `array` and replaces criteria objects with their corresponding - * values. - * - * @private - * @param {Array} array The array to sort. - * @param {Function} comparer The function to define sort order. - * @returns {Array} Returns `array`. - */ - function baseSortBy(array, comparer) { - var length = array.length - - array.sort(comparer) - while (length--) { - array[length] = array[length].value - } - return array - } - - /** - * The base implementation of `_.sum` and `_.sumBy` without support for - * iteratee shorthands. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {number} Returns the sum. - */ - function baseSum(array, iteratee) { - var result, - index = -1, - length = array.length - - while (++index < length) { - var current = iteratee(array[index]) - if (current !== undefined$1) { - result = result === undefined$1 ? current : result + current - } - } - return result - } - - /** - * The base implementation of `_.times` without support for iteratee shorthands - * or max array length checks. - * - * @private - * @param {number} n The number of times to invoke `iteratee`. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the array of results. - */ - function baseTimes(n, iteratee) { - var index = -1, - result = Array(n) - - while (++index < n) { - result[index] = iteratee(index) - } - return result - } - - /** - * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array - * of key-value pairs for `object` corresponding to the property names of `props`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} props The property names to get values for. - * @returns {Object} Returns the key-value pairs. - */ - function baseToPairs(object, props) { - return arrayMap(props, function(key) { - return [key, object[key]] - }) - } - - /** - * The base implementation of `_.unary` without support for storing metadata. - * - * @private - * @param {Function} func The function to cap arguments for. - * @returns {Function} Returns the new capped function. - */ - function baseUnary(func) { - return function(value) { - return func(value) - } - } - - /** - * The base implementation of `_.values` and `_.valuesIn` which creates an - * array of `object` property values corresponding to the property names - * of `props`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} props The property names to get values for. - * @returns {Object} Returns the array of property values. - */ - function baseValues(object, props) { - return arrayMap(props, function(key) { - return object[key] - }) - } - - /** - * Checks if a `cache` value for `key` exists. - * - * @private - * @param {Object} cache The cache to query. - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function cacheHas(cache, key) { - return cache.has(key) - } - - /** - * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol - * that is not found in the character symbols. - * - * @private - * @param {Array} strSymbols The string symbols to inspect. - * @param {Array} chrSymbols The character symbols to find. - * @returns {number} Returns the index of the first unmatched string symbol. - */ - function charsStartIndex(strSymbols, chrSymbols) { - var index = -1, - length = strSymbols.length - - while ( - ++index < length && - baseIndexOf(chrSymbols, strSymbols[index], 0) > -1 - ) {} - return index - } - - /** - * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol - * that is not found in the character symbols. - * - * @private - * @param {Array} strSymbols The string symbols to inspect. - * @param {Array} chrSymbols The character symbols to find. - * @returns {number} Returns the index of the last unmatched string symbol. - */ - function charsEndIndex(strSymbols, chrSymbols) { - var index = strSymbols.length - - while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} - return index - } - - /** - * Gets the number of `placeholder` occurrences in `array`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} placeholder The placeholder to search for. - * @returns {number} Returns the placeholder count. - */ - function countHolders(array, placeholder) { - var length = array.length, - result = 0 - - while (length--) { - if (array[length] === placeholder) { - ++result - } - } - return result - } - - /** - * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A - * letters to basic Latin letters. - * - * @private - * @param {string} letter The matched letter to deburr. - * @returns {string} Returns the deburred letter. - */ - var deburrLetter = basePropertyOf(deburredLetters) - - /** - * Used by `_.escape` to convert characters to HTML entities. - * - * @private - * @param {string} chr The matched character to escape. - * @returns {string} Returns the escaped character. - */ - var escapeHtmlChar = basePropertyOf(htmlEscapes) - - /** - * Used by `_.template` to escape characters for inclusion in compiled string literals. - * - * @private - * @param {string} chr The matched character to escape. - * @returns {string} Returns the escaped character. - */ - function escapeStringChar(chr) { - return "\\" + stringEscapes[chr] - } - - /** - * Gets the value at `key` of `object`. - * - * @private - * @param {Object} [object] The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ - function getValue(object, key) { - return object == null ? undefined$1 : object[key] - } - - /** - * Checks if `string` contains Unicode symbols. - * - * @private - * @param {string} string The string to inspect. - * @returns {boolean} Returns `true` if a symbol is found, else `false`. - */ - function hasUnicode(string) { - return reHasUnicode.test(string) - } - - /** - * Checks if `string` contains a word composed of Unicode symbols. - * - * @private - * @param {string} string The string to inspect. - * @returns {boolean} Returns `true` if a word is found, else `false`. - */ - function hasUnicodeWord(string) { - return reHasUnicodeWord.test(string) - } - - /** - * Converts `iterator` to an array. - * - * @private - * @param {Object} iterator The iterator to convert. - * @returns {Array} Returns the converted array. - */ - function iteratorToArray(iterator) { - var data, - result = [] - - while (!(data = iterator.next()).done) { - result.push(data.value) - } - return result - } - - /** - * Converts `map` to its key-value pairs. - * - * @private - * @param {Object} map The map to convert. - * @returns {Array} Returns the key-value pairs. - */ - function mapToArray(map) { - var index = -1, - result = Array(map.size) - - map.forEach(function(value, key) { - result[++index] = [key, value] - }) - return result - } - - /** - * Creates a unary function that invokes `func` with its argument transformed. - * - * @private - * @param {Function} func The function to wrap. - * @param {Function} transform The argument transform. - * @returns {Function} Returns the new function. - */ - function overArg(func, transform) { - return function(arg) { - return func(transform(arg)) - } - } - - /** - * Replaces all `placeholder` elements in `array` with an internal placeholder - * and returns an array of their indexes. - * - * @private - * @param {Array} array The array to modify. - * @param {*} placeholder The placeholder to replace. - * @returns {Array} Returns the new array of placeholder indexes. - */ - function replaceHolders(array, placeholder) { - var index = -1, - length = array.length, - resIndex = 0, - result = [] - - while (++index < length) { - var value = array[index] - if (value === placeholder || value === PLACEHOLDER) { - array[index] = PLACEHOLDER - result[resIndex++] = index - } - } - return result - } - - /** - * Converts `set` to an array of its values. - * - * @private - * @param {Object} set The set to convert. - * @returns {Array} Returns the values. - */ - function setToArray(set) { - var index = -1, - result = Array(set.size) - - set.forEach(function(value) { - result[++index] = value - }) - return result - } - - /** - * Converts `set` to its value-value pairs. - * - * @private - * @param {Object} set The set to convert. - * @returns {Array} Returns the value-value pairs. - */ - function setToPairs(set) { - var index = -1, - result = Array(set.size) - - set.forEach(function(value) { - result[++index] = [value, value] - }) - return result - } - - /** - * A specialized version of `_.indexOf` which performs strict equality - * comparisons of values, i.e. `===`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function strictIndexOf(array, value, fromIndex) { - var index = fromIndex - 1, - length = array.length - - while (++index < length) { - if (array[index] === value) { - return index - } - } - return -1 - } - - /** - * A specialized version of `_.lastIndexOf` which performs strict equality - * comparisons of values, i.e. `===`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function strictLastIndexOf(array, value, fromIndex) { - var index = fromIndex + 1 - while (index--) { - if (array[index] === value) { - return index - } - } - return index - } - - /** - * Gets the number of symbols in `string`. - * - * @private - * @param {string} string The string to inspect. - * @returns {number} Returns the string size. - */ - function stringSize(string) { - return hasUnicode(string) ? unicodeSize(string) : asciiSize(string) - } - - /** - * Converts `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function stringToArray(string) { - return hasUnicode(string) - ? unicodeToArray(string) - : asciiToArray(string) - } - - /** - * Used by `_.unescape` to convert HTML entities to characters. - * - * @private - * @param {string} chr The matched character to unescape. - * @returns {string} Returns the unescaped character. - */ - var unescapeHtmlChar = basePropertyOf(htmlUnescapes) - - /** - * Gets the size of a Unicode `string`. - * - * @private - * @param {string} string The string inspect. - * @returns {number} Returns the string size. - */ - function unicodeSize(string) { - var result = (reUnicode.lastIndex = 0) - while (reUnicode.test(string)) { - ++result - } - return result - } - - /** - * Converts a Unicode `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function unicodeToArray(string) { - return string.match(reUnicode) || [] - } - - /** - * Splits a Unicode `string` into an array of its words. - * - * @private - * @param {string} The string to inspect. - * @returns {Array} Returns the words of `string`. - */ - function unicodeWords(string) { - return string.match(reUnicodeWord) || [] - } - - /*--------------------------------------------------------------------------*/ - - /** - * Create a new pristine `lodash` function using the `context` object. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Util - * @param {Object} [context=root] The context object. - * @returns {Function} Returns a new `lodash` function. - * @example - * - * _.mixin({ 'foo': _.constant('foo') }); - * - * var lodash = _.runInContext(); - * lodash.mixin({ 'bar': lodash.constant('bar') }); - * - * _.isFunction(_.foo); - * // => true - * _.isFunction(_.bar); - * // => false - * - * lodash.isFunction(lodash.foo); - * // => false - * lodash.isFunction(lodash.bar); - * // => true - * - * // Create a suped-up `defer` in Node.js. - * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; - */ - var runInContext = function runInContext(context) { - context = - context == null - ? root - : _.defaults(root.Object(), context, _.pick(root, contextProps)) - - /** Built-in constructor references. */ - var Array = context.Array, - Date = context.Date, - Error = context.Error, - Function = context.Function, - Math = context.Math, - Object = context.Object, - RegExp = context.RegExp, - String = context.String, - TypeError = context.TypeError - - /** Used for built-in method references. */ - var arrayProto = Array.prototype, - funcProto = Function.prototype, - objectProto = Object.prototype - - /** Used to detect overreaching core-js shims. */ - var coreJsData = context["__core-js_shared__"] - - /** Used to resolve the decompiled source of functions. */ - var funcToString = funcProto.toString - - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty - - /** Used to generate unique IDs. */ - var idCounter = 0 - - /** Used to detect methods masquerading as native. */ - var maskSrcKey = (function() { - var uid = /[^.]+$/.exec( - (coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO) || "" - ) - return uid ? "Symbol(src)_1." + uid : "" - })() - - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ - var nativeObjectToString = objectProto.toString - - /** Used to infer the `Object` constructor. */ - var objectCtorString = funcToString.call(Object) - - /** Used to restore the original `_` reference in `_.noConflict`. */ - var oldDash = root._ - - /** Used to detect if a method is native. */ - var reIsNative = RegExp( - "^" + - funcToString - .call(hasOwnProperty) - .replace(reRegExpChar, "\\$&") - .replace( - /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, - "$1.*?" - ) + - "$" - ) - - /** Built-in value references. */ - var Buffer = moduleExports ? context.Buffer : undefined$1, - Symbol = context.Symbol, - Uint8Array = context.Uint8Array, - allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined$1, - getPrototype = overArg(Object.getPrototypeOf, Object), - objectCreate = Object.create, - propertyIsEnumerable = objectProto.propertyIsEnumerable, - splice = arrayProto.splice, - spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined$1, - symIterator = Symbol ? Symbol.iterator : undefined$1, - symToStringTag = Symbol ? Symbol.toStringTag : undefined$1 - - var defineProperty = (function() { - try { - var func = getNative(Object, "defineProperty") - func({}, "", {}) - return func - } catch (e) {} - })() - - /** Mocked built-ins. */ - var ctxClearTimeout = - context.clearTimeout !== root.clearTimeout && context.clearTimeout, - ctxNow = Date && Date.now !== root.Date.now && Date.now, - ctxSetTimeout = - context.setTimeout !== root.setTimeout && context.setTimeout - - /* Built-in method references for those with the same name as other `lodash` methods. */ - var nativeCeil = Math.ceil, - nativeFloor = Math.floor, - nativeGetSymbols = Object.getOwnPropertySymbols, - nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined$1, - nativeIsFinite = context.isFinite, - nativeJoin = arrayProto.join, - nativeKeys = overArg(Object.keys, Object), - nativeMax = Math.max, - nativeMin = Math.min, - nativeNow = Date.now, - nativeParseInt = context.parseInt, - nativeRandom = Math.random, - nativeReverse = arrayProto.reverse - - /* Built-in method references that are verified to be native. */ - var DataView = getNative(context, "DataView"), - Map = getNative(context, "Map"), - Promise = getNative(context, "Promise"), - Set = getNative(context, "Set"), - WeakMap = getNative(context, "WeakMap"), - nativeCreate = getNative(Object, "create") - - /** Used to store function metadata. */ - var metaMap = WeakMap && new WeakMap() - - /** Used to lookup unminified function names. */ - var realNames = {} - - /** Used to detect maps, sets, and weakmaps. */ - var dataViewCtorString = toSource(DataView), - mapCtorString = toSource(Map), - promiseCtorString = toSource(Promise), - setCtorString = toSource(Set), - weakMapCtorString = toSource(WeakMap) - - /** Used to convert symbols to primitives and strings. */ - var symbolProto = Symbol ? Symbol.prototype : undefined$1, - symbolValueOf = symbolProto ? symbolProto.valueOf : undefined$1, - symbolToString = symbolProto ? symbolProto.toString : undefined$1 - - /*------------------------------------------------------------------------*/ - - /** - * Creates a `lodash` object which wraps `value` to enable implicit method - * chain sequences. Methods that operate on and return arrays, collections, - * and functions can be chained together. Methods that retrieve a single value - * or may return a primitive value will automatically end the chain sequence - * and return the unwrapped value. Otherwise, the value must be unwrapped - * with `_#value`. - * - * Explicit chain sequences, which must be unwrapped with `_#value`, may be - * enabled using `_.chain`. - * - * The execution of chained methods is lazy, that is, it's deferred until - * `_#value` is implicitly or explicitly called. - * - * Lazy evaluation allows several methods to support shortcut fusion. - * Shortcut fusion is an optimization to merge iteratee calls; this avoids - * the creation of intermediate arrays and can greatly reduce the number of - * iteratee executions. Sections of a chain sequence qualify for shortcut - * fusion if the section is applied to an array and iteratees accept only - * one argument. The heuristic for whether a section qualifies for shortcut - * fusion is subject to change. - * - * Chaining is supported in custom builds as long as the `_#value` method is - * directly or indirectly included in the build. - * - * In addition to lodash methods, wrappers have `Array` and `String` methods. - * - * The wrapper `Array` methods are: - * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` - * - * The wrapper `String` methods are: - * `replace` and `split` - * - * The wrapper methods that support shortcut fusion are: - * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, - * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, - * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` - * - * The chainable wrapper methods are: - * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, - * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, - * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, - * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, - * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, - * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, - * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, - * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, - * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, - * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, - * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, - * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, - * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, - * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, - * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, - * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, - * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, - * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, - * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, - * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, - * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, - * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, - * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, - * `zipObject`, `zipObjectDeep`, and `zipWith` - * - * The wrapper methods that are **not** chainable by default are: - * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, - * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`, - * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`, - * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`, - * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`, - * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`, - * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`, - * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, - * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`, - * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`, - * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, - * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, - * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`, - * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`, - * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, - * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`, - * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, - * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`, - * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`, - * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`, - * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`, - * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`, - * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`, - * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`, - * `upperFirst`, `value`, and `words` - * - * @name _ - * @constructor - * @category Seq - * @param {*} value The value to wrap in a `lodash` instance. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * function square(n) { - * return n * n; - * } - * - * var wrapped = _([1, 2, 3]); - * - * // Returns an unwrapped value. - * wrapped.reduce(_.add); - * // => 6 - * - * // Returns a wrapped value. - * var squares = wrapped.map(square); - * - * _.isArray(squares); - * // => false - * - * _.isArray(squares.value()); - * // => true - */ - function lodash(value) { - if ( - isObjectLike(value) && - !isArray(value) && - !(value instanceof LazyWrapper) - ) { - if (value instanceof LodashWrapper) { - return value - } - if (hasOwnProperty.call(value, "__wrapped__")) { - return wrapperClone(value) - } - } - return new LodashWrapper(value) - } - - /** - * The base implementation of `_.create` without support for assigning - * properties to the created object. - * - * @private - * @param {Object} proto The object to inherit from. - * @returns {Object} Returns the new object. - */ - var baseCreate = (function() { - function object() {} - return function(proto) { - if (!isObject(proto)) { - return {} - } - if (objectCreate) { - return objectCreate(proto) - } - object.prototype = proto - var result = new object() - object.prototype = undefined$1 - return result - } - })() - - /** - * The function whose prototype chain sequence wrappers inherit from. - * - * @private - */ - function baseLodash() { - // No operation performed. - } - - /** - * The base constructor for creating `lodash` wrapper objects. - * - * @private - * @param {*} value The value to wrap. - * @param {boolean} [chainAll] Enable explicit method chain sequences. - */ - function LodashWrapper(value, chainAll) { - this.__wrapped__ = value - this.__actions__ = [] - this.__chain__ = !!chainAll - this.__index__ = 0 - this.__values__ = undefined$1 - } - - /** - * By default, the template delimiters used by lodash are like those in - * embedded Ruby (ERB) as well as ES2015 template strings. Change the - * following template settings to use alternative delimiters. - * - * @static - * @memberOf _ - * @type {Object} - */ - lodash.templateSettings = { - /** - * Used to detect `data` property values to be HTML-escaped. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - escape: reEscape, - - /** - * Used to detect code to be evaluated. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - evaluate: reEvaluate, - - /** - * Used to detect `data` property values to inject. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - interpolate: reInterpolate, - - /** - * Used to reference the data object in the template text. - * - * @memberOf _.templateSettings - * @type {string} - */ - variable: "", - - /** - * Used to import variables into the compiled template. - * - * @memberOf _.templateSettings - * @type {Object} - */ - imports: { - /** - * A reference to the `lodash` function. - * - * @memberOf _.templateSettings.imports - * @type {Function} - */ - _: lodash, - }, - } - - // Ensure wrappers are instances of `baseLodash`. - lodash.prototype = baseLodash.prototype - lodash.prototype.constructor = lodash - - LodashWrapper.prototype = baseCreate(baseLodash.prototype) - LodashWrapper.prototype.constructor = LodashWrapper - - /*------------------------------------------------------------------------*/ - - /** - * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. - * - * @private - * @constructor - * @param {*} value The value to wrap. - */ - function LazyWrapper(value) { - this.__wrapped__ = value - this.__actions__ = [] - this.__dir__ = 1 - this.__filtered__ = false - this.__iteratees__ = [] - this.__takeCount__ = MAX_ARRAY_LENGTH - this.__views__ = [] - } - - /** - * Creates a clone of the lazy wrapper object. - * - * @private - * @name clone - * @memberOf LazyWrapper - * @returns {Object} Returns the cloned `LazyWrapper` object. - */ - function lazyClone() { - var result = new LazyWrapper(this.__wrapped__) - result.__actions__ = copyArray(this.__actions__) - result.__dir__ = this.__dir__ - result.__filtered__ = this.__filtered__ - result.__iteratees__ = copyArray(this.__iteratees__) - result.__takeCount__ = this.__takeCount__ - result.__views__ = copyArray(this.__views__) - return result - } - - /** - * Reverses the direction of lazy iteration. - * - * @private - * @name reverse - * @memberOf LazyWrapper - * @returns {Object} Returns the new reversed `LazyWrapper` object. - */ - function lazyReverse() { - if (this.__filtered__) { - var result = new LazyWrapper(this) - result.__dir__ = -1 - result.__filtered__ = true - } else { - result = this.clone() - result.__dir__ *= -1 - } - return result - } - - /** - * Extracts the unwrapped value from its lazy wrapper. - * - * @private - * @name value - * @memberOf LazyWrapper - * @returns {*} Returns the unwrapped value. - */ - function lazyValue() { - var array = this.__wrapped__.value(), - dir = this.__dir__, - isArr = isArray(array), - isRight = dir < 0, - arrLength = isArr ? array.length : 0, - view = getView(0, arrLength, this.__views__), - start = view.start, - end = view.end, - length = end - start, - index = isRight ? end : start - 1, - iteratees = this.__iteratees__, - iterLength = iteratees.length, - resIndex = 0, - takeCount = nativeMin(length, this.__takeCount__) - - if ( - !isArr || - (!isRight && arrLength == length && takeCount == length) - ) { - return baseWrapperValue(array, this.__actions__) - } - var result = [] - - outer: while (length-- && resIndex < takeCount) { - index += dir - - var iterIndex = -1, - value = array[index] - - while (++iterIndex < iterLength) { - var data = iteratees[iterIndex], - iteratee = data.iteratee, - type = data.type, - computed = iteratee(value) - - if (type == LAZY_MAP_FLAG) { - value = computed - } else if (!computed) { - if (type == LAZY_FILTER_FLAG) { - continue outer - } else { - break outer - } - } - } - result[resIndex++] = value - } - return result - } - - // Ensure `LazyWrapper` is an instance of `baseLodash`. - LazyWrapper.prototype = baseCreate(baseLodash.prototype) - LazyWrapper.prototype.constructor = LazyWrapper - - /*------------------------------------------------------------------------*/ - - /** - * Creates a hash object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function Hash(entries) { - var index = -1, - length = entries == null ? 0 : entries.length - - this.clear() - while (++index < length) { - var entry = entries[index] - this.set(entry[0], entry[1]) - } - } - - /** - * Removes all key-value entries from the hash. - * - * @private - * @name clear - * @memberOf Hash - */ - function hashClear() { - this.__data__ = nativeCreate ? nativeCreate(null) : {} - this.size = 0 - } - - /** - * Removes `key` and its value from the hash. - * - * @private - * @name delete - * @memberOf Hash - * @param {Object} hash The hash to modify. - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function hashDelete(key) { - var result = this.has(key) && delete this.__data__[key] - this.size -= result ? 1 : 0 - return result - } - - /** - * Gets the hash value for `key`. - * - * @private - * @name get - * @memberOf Hash - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function hashGet(key) { - var data = this.__data__ - if (nativeCreate) { - var result = data[key] - return result === HASH_UNDEFINED ? undefined$1 : result - } - return hasOwnProperty.call(data, key) ? data[key] : undefined$1 - } - - /** - * Checks if a hash value for `key` exists. - * - * @private - * @name has - * @memberOf Hash - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function hashHas(key) { - var data = this.__data__ - return nativeCreate - ? data[key] !== undefined$1 - : hasOwnProperty.call(data, key) - } - - /** - * Sets the hash `key` to `value`. - * - * @private - * @name set - * @memberOf Hash - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the hash instance. - */ - function hashSet(key, value) { - var data = this.__data__ - this.size += this.has(key) ? 0 : 1 - data[key] = - nativeCreate && value === undefined$1 ? HASH_UNDEFINED : value - return this - } - - // Add methods to `Hash`. - Hash.prototype.clear = hashClear - Hash.prototype["delete"] = hashDelete - Hash.prototype.get = hashGet - Hash.prototype.has = hashHas - Hash.prototype.set = hashSet - - /*------------------------------------------------------------------------*/ - - /** - * Creates an list cache object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function ListCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length - - this.clear() - while (++index < length) { - var entry = entries[index] - this.set(entry[0], entry[1]) - } - } - - /** - * Removes all key-value entries from the list cache. - * - * @private - * @name clear - * @memberOf ListCache - */ - function listCacheClear() { - this.__data__ = [] - this.size = 0 - } - - /** - * Removes `key` and its value from the list cache. - * - * @private - * @name delete - * @memberOf ListCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function listCacheDelete(key) { - var data = this.__data__, - index = assocIndexOf(data, key) - - if (index < 0) { - return false - } - var lastIndex = data.length - 1 - if (index == lastIndex) { - data.pop() - } else { - splice.call(data, index, 1) - } - --this.size - return true - } - - /** - * Gets the list cache value for `key`. - * - * @private - * @name get - * @memberOf ListCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function listCacheGet(key) { - var data = this.__data__, - index = assocIndexOf(data, key) - - return index < 0 ? undefined$1 : data[index][1] - } - - /** - * Checks if a list cache value for `key` exists. - * - * @private - * @name has - * @memberOf ListCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function listCacheHas(key) { - return assocIndexOf(this.__data__, key) > -1 - } - - /** - * Sets the list cache `key` to `value`. - * - * @private - * @name set - * @memberOf ListCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the list cache instance. - */ - function listCacheSet(key, value) { - var data = this.__data__, - index = assocIndexOf(data, key) - - if (index < 0) { - ++this.size - data.push([key, value]) - } else { - data[index][1] = value - } - return this - } - - // Add methods to `ListCache`. - ListCache.prototype.clear = listCacheClear - ListCache.prototype["delete"] = listCacheDelete - ListCache.prototype.get = listCacheGet - ListCache.prototype.has = listCacheHas - ListCache.prototype.set = listCacheSet - - /*------------------------------------------------------------------------*/ - - /** - * Creates a map cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function MapCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length - - this.clear() - while (++index < length) { - var entry = entries[index] - this.set(entry[0], entry[1]) - } - } - - /** - * Removes all key-value entries from the map. - * - * @private - * @name clear - * @memberOf MapCache - */ - function mapCacheClear() { - this.size = 0 - this.__data__ = { - hash: new Hash(), - map: new (Map || ListCache)(), - string: new Hash(), - } - } - - /** - * Removes `key` and its value from the map. - * - * @private - * @name delete - * @memberOf MapCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function mapCacheDelete(key) { - var result = getMapData(this, key)["delete"](key) - this.size -= result ? 1 : 0 - return result - } - - /** - * Gets the map value for `key`. - * - * @private - * @name get - * @memberOf MapCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function mapCacheGet(key) { - return getMapData(this, key).get(key) - } - - /** - * Checks if a map value for `key` exists. - * - * @private - * @name has - * @memberOf MapCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function mapCacheHas(key) { - return getMapData(this, key).has(key) - } - - /** - * Sets the map `key` to `value`. - * - * @private - * @name set - * @memberOf MapCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the map cache instance. - */ - function mapCacheSet(key, value) { - var data = getMapData(this, key), - size = data.size - - data.set(key, value) - this.size += data.size == size ? 0 : 1 - return this - } - - // Add methods to `MapCache`. - MapCache.prototype.clear = mapCacheClear - MapCache.prototype["delete"] = mapCacheDelete - MapCache.prototype.get = mapCacheGet - MapCache.prototype.has = mapCacheHas - MapCache.prototype.set = mapCacheSet - - /*------------------------------------------------------------------------*/ - - /** - * - * Creates an array cache object to store unique values. - * - * @private - * @constructor - * @param {Array} [values] The values to cache. - */ - function SetCache(values) { - var index = -1, - length = values == null ? 0 : values.length - - this.__data__ = new MapCache() - while (++index < length) { - this.add(values[index]) - } - } - - /** - * Adds `value` to the array cache. - * - * @private - * @name add - * @memberOf SetCache - * @alias push - * @param {*} value The value to cache. - * @returns {Object} Returns the cache instance. - */ - function setCacheAdd(value) { - this.__data__.set(value, HASH_UNDEFINED) - return this - } - - /** - * Checks if `value` is in the array cache. - * - * @private - * @name has - * @memberOf SetCache - * @param {*} value The value to search for. - * @returns {number} Returns `true` if `value` is found, else `false`. - */ - function setCacheHas(value) { - return this.__data__.has(value) - } - - // Add methods to `SetCache`. - SetCache.prototype.add = SetCache.prototype.push = setCacheAdd - SetCache.prototype.has = setCacheHas - - /*------------------------------------------------------------------------*/ - - /** - * Creates a stack cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function Stack(entries) { - var data = (this.__data__ = new ListCache(entries)) - this.size = data.size - } - - /** - * Removes all key-value entries from the stack. - * - * @private - * @name clear - * @memberOf Stack - */ - function stackClear() { - this.__data__ = new ListCache() - this.size = 0 - } - - /** - * Removes `key` and its value from the stack. - * - * @private - * @name delete - * @memberOf Stack - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function stackDelete(key) { - var data = this.__data__, - result = data["delete"](key) - - this.size = data.size - return result - } - - /** - * Gets the stack value for `key`. - * - * @private - * @name get - * @memberOf Stack - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function stackGet(key) { - return this.__data__.get(key) - } - - /** - * Checks if a stack value for `key` exists. - * - * @private - * @name has - * @memberOf Stack - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function stackHas(key) { - return this.__data__.has(key) - } - - /** - * Sets the stack `key` to `value`. - * - * @private - * @name set - * @memberOf Stack - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the stack cache instance. - */ - function stackSet(key, value) { - var data = this.__data__ - if (data instanceof ListCache) { - var pairs = data.__data__ - if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) { - pairs.push([key, value]) - this.size = ++data.size - return this - } - data = this.__data__ = new MapCache(pairs) - } - data.set(key, value) - this.size = data.size - return this - } - - // Add methods to `Stack`. - Stack.prototype.clear = stackClear - Stack.prototype["delete"] = stackDelete - Stack.prototype.get = stackGet - Stack.prototype.has = stackHas - Stack.prototype.set = stackSet - - /*------------------------------------------------------------------------*/ - - /** - * Creates an array of the enumerable property names of the array-like `value`. - * - * @private - * @param {*} value The value to query. - * @param {boolean} inherited Specify returning inherited property names. - * @returns {Array} Returns the array of property names. - */ - function arrayLikeKeys(value, inherited) { - var isArr = isArray(value), - isArg = !isArr && isArguments(value), - isBuff = !isArr && !isArg && isBuffer(value), - isType = !isArr && !isArg && !isBuff && isTypedArray(value), - skipIndexes = isArr || isArg || isBuff || isType, - result = skipIndexes ? baseTimes(value.length, String) : [], - length = result.length - - for (var key in value) { - if ( - (inherited || hasOwnProperty.call(value, key)) && - !( - skipIndexes && - // Safari 9 has enumerable `arguments.length` in strict mode. - (key == "length" || - // Node.js 0.10 has enumerable non-index properties on buffers. - (isBuff && (key == "offset" || key == "parent")) || - // PhantomJS 2 has enumerable non-index properties on typed arrays. - (isType && - (key == "buffer" || - key == "byteLength" || - key == "byteOffset")) || - // Skip index properties. - isIndex(key, length)) - ) - ) { - result.push(key) - } - } - return result - } - - /** - * A specialized version of `_.sample` for arrays. - * - * @private - * @param {Array} array The array to sample. - * @returns {*} Returns the random element. - */ - function arraySample(array) { - var length = array.length - return length ? array[baseRandom(0, length - 1)] : undefined$1 - } - - /** - * A specialized version of `_.sampleSize` for arrays. - * - * @private - * @param {Array} array The array to sample. - * @param {number} n The number of elements to sample. - * @returns {Array} Returns the random elements. - */ - function arraySampleSize(array, n) { - return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)) - } - - /** - * A specialized version of `_.shuffle` for arrays. - * - * @private - * @param {Array} array The array to shuffle. - * @returns {Array} Returns the new shuffled array. - */ - function arrayShuffle(array) { - return shuffleSelf(copyArray(array)) - } - - /** - * This function is like `assignValue` except that it doesn't assign - * `undefined` values. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function assignMergeValue(object, key, value) { - if ( - (value !== undefined$1 && !eq(object[key], value)) || - (value === undefined$1 && !(key in object)) - ) { - baseAssignValue(object, key, value) - } - } - - /** - * Assigns `value` to `key` of `object` if the existing value is not equivalent - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function assignValue(object, key, value) { - var objValue = object[key] - if ( - !(hasOwnProperty.call(object, key) && eq(objValue, value)) || - (value === undefined$1 && !(key in object)) - ) { - baseAssignValue(object, key, value) - } - } - - /** - * Gets the index at which the `key` is found in `array` of key-value pairs. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} key The key to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function assocIndexOf(array, key) { - var length = array.length - while (length--) { - if (eq(array[length][0], key)) { - return length - } - } - return -1 - } - - /** - * Aggregates elements of `collection` on `accumulator` with keys transformed - * by `iteratee` and values set by `setter`. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform keys. - * @param {Object} accumulator The initial aggregated object. - * @returns {Function} Returns `accumulator`. - */ - function baseAggregator(collection, setter, iteratee, accumulator) { - baseEach(collection, function(value, key, collection) { - setter(accumulator, value, iteratee(value), collection) - }) - return accumulator - } - - /** - * The base implementation of `_.assign` without support for multiple sources - * or `customizer` functions. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @returns {Object} Returns `object`. - */ - function baseAssign(object, source) { - return object && copyObject(source, keys(source), object) - } - - /** - * The base implementation of `_.assignIn` without support for multiple sources - * or `customizer` functions. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @returns {Object} Returns `object`. - */ - function baseAssignIn(object, source) { - return object && copyObject(source, keysIn(source), object) - } - - /** - * The base implementation of `assignValue` and `assignMergeValue` without - * value checks. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function baseAssignValue(object, key, value) { - if (key == "__proto__" && defineProperty) { - defineProperty(object, key, { - configurable: true, - enumerable: true, - value: value, - writable: true, - }) - } else { - object[key] = value - } - } - - /** - * The base implementation of `_.at` without support for individual paths. - * - * @private - * @param {Object} object The object to iterate over. - * @param {string[]} paths The property paths to pick. - * @returns {Array} Returns the picked elements. - */ - function baseAt(object, paths) { - var index = -1, - length = paths.length, - result = Array(length), - skip = object == null - - while (++index < length) { - result[index] = skip ? undefined$1 : get(object, paths[index]) - } - return result - } - - /** - * The base implementation of `_.clamp` which doesn't coerce arguments. - * - * @private - * @param {number} number The number to clamp. - * @param {number} [lower] The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the clamped number. - */ - function baseClamp(number, lower, upper) { - if (number === number) { - if (upper !== undefined$1) { - number = number <= upper ? number : upper - } - if (lower !== undefined$1) { - number = number >= lower ? number : lower - } - } - return number - } - - /** - * The base implementation of `_.clone` and `_.cloneDeep` which tracks - * traversed objects. - * - * @private - * @param {*} value The value to clone. - * @param {boolean} bitmask The bitmask flags. - * 1 - Deep clone - * 2 - Flatten inherited properties - * 4 - Clone symbols - * @param {Function} [customizer] The function to customize cloning. - * @param {string} [key] The key of `value`. - * @param {Object} [object] The parent object of `value`. - * @param {Object} [stack] Tracks traversed objects and their clone counterparts. - * @returns {*} Returns the cloned value. - */ - function baseClone(value, bitmask, customizer, key, object, stack) { - var result, - isDeep = bitmask & CLONE_DEEP_FLAG, - isFlat = bitmask & CLONE_FLAT_FLAG, - isFull = bitmask & CLONE_SYMBOLS_FLAG - - if (customizer) { - result = object - ? customizer(value, key, object, stack) - : customizer(value) - } - if (result !== undefined$1) { - return result - } - if (!isObject(value)) { - return value - } - var isArr = isArray(value) - if (isArr) { - result = initCloneArray(value) - if (!isDeep) { - return copyArray(value, result) - } - } else { - var tag = getTag(value), - isFunc = tag == funcTag || tag == genTag - - if (isBuffer(value)) { - return cloneBuffer(value, isDeep) - } - if (tag == objectTag || tag == argsTag || (isFunc && !object)) { - result = isFlat || isFunc ? {} : initCloneObject(value) - if (!isDeep) { - return isFlat - ? copySymbolsIn(value, baseAssignIn(result, value)) - : copySymbols(value, baseAssign(result, value)) - } - } else { - if (!cloneableTags[tag]) { - return object ? value : {} - } - result = initCloneByTag(value, tag, isDeep) - } - } - // Check for circular references and return its corresponding clone. - stack || (stack = new Stack()) - var stacked = stack.get(value) - if (stacked) { - return stacked - } - stack.set(value, result) - - if (isSet(value)) { - value.forEach(function(subValue) { - result.add( - baseClone(subValue, bitmask, customizer, subValue, value, stack) - ) - }) - } else if (isMap(value)) { - value.forEach(function(subValue, key) { - result.set( - key, - baseClone(subValue, bitmask, customizer, key, value, stack) - ) - }) - } - - var keysFunc = isFull - ? isFlat - ? getAllKeysIn - : getAllKeys - : isFlat - ? keysIn - : keys - - var props = isArr ? undefined$1 : keysFunc(value) - arrayEach(props || value, function(subValue, key) { - if (props) { - key = subValue - subValue = value[key] - } - // Recursively populate clone (susceptible to call stack limits). - assignValue( - result, - key, - baseClone(subValue, bitmask, customizer, key, value, stack) - ) - }) - return result - } - - /** - * The base implementation of `_.conforms` which doesn't clone `source`. - * - * @private - * @param {Object} source The object of property predicates to conform to. - * @returns {Function} Returns the new spec function. - */ - function baseConforms(source) { - var props = keys(source) - return function(object) { - return baseConformsTo(object, source, props) - } - } - - /** - * The base implementation of `_.conformsTo` which accepts `props` to check. - * - * @private - * @param {Object} object The object to inspect. - * @param {Object} source The object of property predicates to conform to. - * @returns {boolean} Returns `true` if `object` conforms, else `false`. - */ - function baseConformsTo(object, source, props) { - var length = props.length - if (object == null) { - return !length - } - object = Object(object) - while (length--) { - var key = props[length], - predicate = source[key], - value = object[key] - - if ( - (value === undefined$1 && !(key in object)) || - !predicate(value) - ) { - return false - } - } - return true - } - - /** - * The base implementation of `_.delay` and `_.defer` which accepts `args` - * to provide to `func`. - * - * @private - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @param {Array} args The arguments to provide to `func`. - * @returns {number|Object} Returns the timer id or timeout object. - */ - function baseDelay(func, wait, args) { - if (typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - return setTimeout(function() { - func.apply(undefined$1, args) - }, wait) - } - - /** - * The base implementation of methods like `_.difference` without support - * for excluding multiple arrays or iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Array} values The values to exclude. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - */ - function baseDifference(array, values, iteratee, comparator) { - var index = -1, - includes = arrayIncludes, - isCommon = true, - length = array.length, - result = [], - valuesLength = values.length - - if (!length) { - return result - } - if (iteratee) { - values = arrayMap(values, baseUnary(iteratee)) - } - if (comparator) { - includes = arrayIncludesWith - isCommon = false - } else if (values.length >= LARGE_ARRAY_SIZE) { - includes = cacheHas - isCommon = false - values = new SetCache(values) - } - outer: while (++index < length) { - var value = array[index], - computed = iteratee == null ? value : iteratee(value) - - value = comparator || value !== 0 ? value : 0 - if (isCommon && computed === computed) { - var valuesIndex = valuesLength - while (valuesIndex--) { - if (values[valuesIndex] === computed) { - continue outer - } - } - result.push(value) - } else if (!includes(values, computed, comparator)) { - result.push(value) - } - } - return result - } - - /** - * The base implementation of `_.forEach` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - */ - var baseEach = createBaseEach(baseForOwn) - - /** - * The base implementation of `_.forEachRight` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - */ - var baseEachRight = createBaseEach(baseForOwnRight, true) - - /** - * The base implementation of `_.every` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false` - */ - function baseEvery(collection, predicate) { - var result = true - baseEach(collection, function(value, index, collection) { - result = !!predicate(value, index, collection) - return result - }) - return result - } - - /** - * The base implementation of methods like `_.max` and `_.min` which accepts a - * `comparator` to determine the extremum value. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The iteratee invoked per iteration. - * @param {Function} comparator The comparator used to compare values. - * @returns {*} Returns the extremum value. - */ - function baseExtremum(array, iteratee, comparator) { - var index = -1, - length = array.length - - while (++index < length) { - var value = array[index], - current = iteratee(value) - - if ( - current != null && - (computed === undefined$1 - ? current === current && !isSymbol(current) - : comparator(current, computed)) - ) { - var computed = current, - result = value - } - } - return result - } - - /** - * The base implementation of `_.fill` without an iteratee call guard. - * - * @private - * @param {Array} array The array to fill. - * @param {*} value The value to fill `array` with. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns `array`. - */ - function baseFill(array, value, start, end) { - var length = array.length - - start = toInteger(start) - if (start < 0) { - start = -start > length ? 0 : length + start - } - end = end === undefined$1 || end > length ? length : toInteger(end) - if (end < 0) { - end += length - } - end = start > end ? 0 : toLength(end) - while (start < end) { - array[start++] = value - } - return array - } - - /** - * The base implementation of `_.filter` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - */ - function baseFilter(collection, predicate) { - var result = [] - baseEach(collection, function(value, index, collection) { - if (predicate(value, index, collection)) { - result.push(value) - } - }) - return result - } - - /** - * The base implementation of `_.flatten` with support for restricting flattening. - * - * @private - * @param {Array} array The array to flatten. - * @param {number} depth The maximum recursion depth. - * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. - * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. - * @param {Array} [result=[]] The initial result value. - * @returns {Array} Returns the new flattened array. - */ - function baseFlatten(array, depth, predicate, isStrict, result) { - var index = -1, - length = array.length - - predicate || (predicate = isFlattenable) - result || (result = []) - - while (++index < length) { - var value = array[index] - if (depth > 0 && predicate(value)) { - if (depth > 1) { - // Recursively flatten arrays (susceptible to call stack limits). - baseFlatten(value, depth - 1, predicate, isStrict, result) - } else { - arrayPush(result, value) - } - } else if (!isStrict) { - result[result.length] = value - } - } - return result - } - - /** - * The base implementation of `baseForOwn` which iterates over `object` - * properties returned by `keysFunc` and invokes `iteratee` for each property. - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {Function} keysFunc The function to get the keys of `object`. - * @returns {Object} Returns `object`. - */ - var baseFor = createBaseFor() - - /** - * This function is like `baseFor` except that it iterates over properties - * in the opposite order. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {Function} keysFunc The function to get the keys of `object`. - * @returns {Object} Returns `object`. - */ - var baseForRight = createBaseFor(true) - - /** - * The base implementation of `_.forOwn` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Object} Returns `object`. - */ - function baseForOwn(object, iteratee) { - return object && baseFor(object, iteratee, keys) - } - - /** - * The base implementation of `_.forOwnRight` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Object} Returns `object`. - */ - function baseForOwnRight(object, iteratee) { - return object && baseForRight(object, iteratee, keys) - } - - /** - * The base implementation of `_.functions` which creates an array of - * `object` function property names filtered from `props`. - * - * @private - * @param {Object} object The object to inspect. - * @param {Array} props The property names to filter. - * @returns {Array} Returns the function names. - */ - function baseFunctions(object, props) { - return arrayFilter(props, function(key) { - return isFunction(object[key]) - }) - } - - /** - * The base implementation of `_.get` without support for default values. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @returns {*} Returns the resolved value. - */ - function baseGet(object, path) { - path = castPath(path, object) - - var index = 0, - length = path.length - - while (object != null && index < length) { - object = object[toKey(path[index++])] - } - return index && index == length ? object : undefined$1 - } - - /** - * The base implementation of `getAllKeys` and `getAllKeysIn` which uses - * `keysFunc` and `symbolsFunc` to get the enumerable property names and - * symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Function} keysFunc The function to get the keys of `object`. - * @param {Function} symbolsFunc The function to get the symbols of `object`. - * @returns {Array} Returns the array of property names and symbols. - */ - function baseGetAllKeys(object, keysFunc, symbolsFunc) { - var result = keysFunc(object) - return isArray(object) - ? result - : arrayPush(result, symbolsFunc(object)) - } - - /** - * The base implementation of `getTag` without fallbacks for buggy environments. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ - function baseGetTag(value) { - if (value == null) { - return value === undefined$1 ? undefinedTag : nullTag - } - return symToStringTag && symToStringTag in Object(value) - ? getRawTag(value) - : objectToString(value) - } - - /** - * The base implementation of `_.gt` which doesn't coerce arguments. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than `other`, - * else `false`. - */ - function baseGt(value, other) { - return value > other - } - - /** - * The base implementation of `_.has` without support for deep paths. - * - * @private - * @param {Object} [object] The object to query. - * @param {Array|string} key The key to check. - * @returns {boolean} Returns `true` if `key` exists, else `false`. - */ - function baseHas(object, key) { - return object != null && hasOwnProperty.call(object, key) - } - - /** - * The base implementation of `_.hasIn` without support for deep paths. - * - * @private - * @param {Object} [object] The object to query. - * @param {Array|string} key The key to check. - * @returns {boolean} Returns `true` if `key` exists, else `false`. - */ - function baseHasIn(object, key) { - return object != null && key in Object(object) - } - - /** - * The base implementation of `_.inRange` which doesn't coerce arguments. - * - * @private - * @param {number} number The number to check. - * @param {number} start The start of the range. - * @param {number} end The end of the range. - * @returns {boolean} Returns `true` if `number` is in the range, else `false`. - */ - function baseInRange(number, start, end) { - return ( - number >= nativeMin(start, end) && number < nativeMax(start, end) - ) - } - - /** - * The base implementation of methods like `_.intersection`, without support - * for iteratee shorthands, that accepts an array of arrays to inspect. - * - * @private - * @param {Array} arrays The arrays to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of shared values. - */ - function baseIntersection(arrays, iteratee, comparator) { - var includes = comparator ? arrayIncludesWith : arrayIncludes, - length = arrays[0].length, - othLength = arrays.length, - othIndex = othLength, - caches = Array(othLength), - maxLength = Infinity, - result = [] - - while (othIndex--) { - var array = arrays[othIndex] - if (othIndex && iteratee) { - array = arrayMap(array, baseUnary(iteratee)) - } - maxLength = nativeMin(array.length, maxLength) - caches[othIndex] = - !comparator && - (iteratee || (length >= 120 && array.length >= 120)) - ? new SetCache(othIndex && array) - : undefined$1 - } - array = arrays[0] - - var index = -1, - seen = caches[0] - - outer: while (++index < length && result.length < maxLength) { - var value = array[index], - computed = iteratee ? iteratee(value) : value - - value = comparator || value !== 0 ? value : 0 - if ( - !(seen - ? cacheHas(seen, computed) - : includes(result, computed, comparator)) - ) { - othIndex = othLength - while (--othIndex) { - var cache = caches[othIndex] - if ( - !(cache - ? cacheHas(cache, computed) - : includes(arrays[othIndex], computed, comparator)) - ) { - continue outer - } - } - if (seen) { - seen.push(computed) - } - result.push(value) - } - } - return result - } - - /** - * The base implementation of `_.invert` and `_.invertBy` which inverts - * `object` with values transformed by `iteratee` and set by `setter`. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform values. - * @param {Object} accumulator The initial inverted object. - * @returns {Function} Returns `accumulator`. - */ - function baseInverter(object, setter, iteratee, accumulator) { - baseForOwn(object, function(value, key, object) { - setter(accumulator, iteratee(value), key, object) - }) - return accumulator - } - - /** - * The base implementation of `_.invoke` without support for individual - * method arguments. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the method to invoke. - * @param {Array} args The arguments to invoke the method with. - * @returns {*} Returns the result of the invoked method. - */ - function baseInvoke(object, path, args) { - path = castPath(path, object) - object = parent(object, path) - var func = object == null ? object : object[toKey(last(path))] - return func == null ? undefined$1 : apply(func, object, args) - } - - /** - * The base implementation of `_.isArguments`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - */ - function baseIsArguments(value) { - return isObjectLike(value) && baseGetTag(value) == argsTag - } - - /** - * The base implementation of `_.isArrayBuffer` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. - */ - function baseIsArrayBuffer(value) { - return isObjectLike(value) && baseGetTag(value) == arrayBufferTag - } - - /** - * The base implementation of `_.isDate` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a date object, else `false`. - */ - function baseIsDate(value) { - return isObjectLike(value) && baseGetTag(value) == dateTag - } - - /** - * The base implementation of `_.isEqual` which supports partial comparisons - * and tracks traversed objects. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @param {boolean} bitmask The bitmask flags. - * 1 - Unordered comparison - * 2 - Partial comparison - * @param {Function} [customizer] The function to customize comparisons. - * @param {Object} [stack] Tracks traversed `value` and `other` objects. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - */ - function baseIsEqual(value, other, bitmask, customizer, stack) { - if (value === other) { - return true - } - if ( - value == null || - other == null || - (!isObjectLike(value) && !isObjectLike(other)) - ) { - return value !== value && other !== other - } - return baseIsEqualDeep( - value, - other, - bitmask, - customizer, - baseIsEqual, - stack - ) - } - - /** - * A specialized version of `baseIsEqual` for arrays and objects which performs - * deep comparisons and tracks traversed objects enabling objects with circular - * references to be compared. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} [stack] Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function baseIsEqualDeep( - object, - other, - bitmask, - customizer, - equalFunc, - stack - ) { - var objIsArr = isArray(object), - othIsArr = isArray(other), - objTag = objIsArr ? arrayTag : getTag(object), - othTag = othIsArr ? arrayTag : getTag(other) - - objTag = objTag == argsTag ? objectTag : objTag - othTag = othTag == argsTag ? objectTag : othTag - - var objIsObj = objTag == objectTag, - othIsObj = othTag == objectTag, - isSameTag = objTag == othTag - - if (isSameTag && isBuffer(object)) { - if (!isBuffer(other)) { - return false - } - objIsArr = true - objIsObj = false - } - if (isSameTag && !objIsObj) { - stack || (stack = new Stack()) - return objIsArr || isTypedArray(object) - ? equalArrays( - object, - other, - bitmask, - customizer, - equalFunc, - stack - ) - : equalByTag( - object, - other, - objTag, - bitmask, - customizer, - equalFunc, - stack - ) - } - if (!(bitmask & COMPARE_PARTIAL_FLAG)) { - var objIsWrapped = - objIsObj && hasOwnProperty.call(object, "__wrapped__"), - othIsWrapped = - othIsObj && hasOwnProperty.call(other, "__wrapped__") - - if (objIsWrapped || othIsWrapped) { - var objUnwrapped = objIsWrapped ? object.value() : object, - othUnwrapped = othIsWrapped ? other.value() : other - - stack || (stack = new Stack()) - return equalFunc( - objUnwrapped, - othUnwrapped, - bitmask, - customizer, - stack - ) - } - } - if (!isSameTag) { - return false - } - stack || (stack = new Stack()) - return equalObjects( - object, - other, - bitmask, - customizer, - equalFunc, - stack - ) - } - - /** - * The base implementation of `_.isMap` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a map, else `false`. - */ - function baseIsMap(value) { - return isObjectLike(value) && getTag(value) == mapTag - } - - /** - * The base implementation of `_.isMatch` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @param {Array} matchData The property names, values, and compare flags to match. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - */ - function baseIsMatch(object, source, matchData, customizer) { - var index = matchData.length, - length = index, - noCustomizer = !customizer - - if (object == null) { - return !length - } - object = Object(object) - while (index--) { - var data = matchData[index] - if ( - noCustomizer && data[2] - ? data[1] !== object[data[0]] - : !(data[0] in object) - ) { - return false - } - } - while (++index < length) { - data = matchData[index] - var key = data[0], - objValue = object[key], - srcValue = data[1] - - if (noCustomizer && data[2]) { - if (objValue === undefined$1 && !(key in object)) { - return false - } - } else { - var stack = new Stack() - if (customizer) { - var result = customizer( - objValue, - srcValue, - key, - object, - source, - stack - ) - } - if ( - !(result === undefined$1 - ? baseIsEqual( - srcValue, - objValue, - COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, - customizer, - stack - ) - : result) - ) { - return false - } - } - } - return true - } - - /** - * The base implementation of `_.isNative` without bad shim checks. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - */ - function baseIsNative(value) { - if (!isObject(value) || isMasked(value)) { - return false - } - var pattern = isFunction(value) ? reIsNative : reIsHostCtor - return pattern.test(toSource(value)) - } - - /** - * The base implementation of `_.isRegExp` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. - */ - function baseIsRegExp(value) { - return isObjectLike(value) && baseGetTag(value) == regexpTag - } - - /** - * The base implementation of `_.isSet` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a set, else `false`. - */ - function baseIsSet(value) { - return isObjectLike(value) && getTag(value) == setTag - } - - /** - * The base implementation of `_.isTypedArray` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - */ - function baseIsTypedArray(value) { - return ( - isObjectLike(value) && - isLength(value.length) && - !!typedArrayTags[baseGetTag(value)] - ) - } - - /** - * The base implementation of `_.iteratee`. - * - * @private - * @param {*} [value=_.identity] The value to convert to an iteratee. - * @returns {Function} Returns the iteratee. - */ - function baseIteratee(value) { - // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. - // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. - if (typeof value == "function") { - return value - } - if (value == null) { - return identity - } - if (typeof value == "object") { - return isArray(value) - ? baseMatchesProperty(value[0], value[1]) - : baseMatches(value) - } - return property(value) - } - - /** - * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function baseKeys(object) { - if (!isPrototype(object)) { - return nativeKeys(object) - } - var result = [] - for (var key in Object(object)) { - if (hasOwnProperty.call(object, key) && key != "constructor") { - result.push(key) - } - } - return result - } - - /** - * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function baseKeysIn(object) { - if (!isObject(object)) { - return nativeKeysIn(object) - } - var isProto = isPrototype(object), - result = [] - - for (var key in object) { - if ( - !( - key == "constructor" && - (isProto || !hasOwnProperty.call(object, key)) - ) - ) { - result.push(key) - } - } - return result - } - - /** - * The base implementation of `_.lt` which doesn't coerce arguments. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than `other`, - * else `false`. - */ - function baseLt(value, other) { - return value < other - } - - /** - * The base implementation of `_.map` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ - function baseMap(collection, iteratee) { - var index = -1, - result = isArrayLike(collection) ? Array(collection.length) : [] - - baseEach(collection, function(value, key, collection) { - result[++index] = iteratee(value, key, collection) - }) - return result - } - - /** - * The base implementation of `_.matches` which doesn't clone `source`. - * - * @private - * @param {Object} source The object of property values to match. - * @returns {Function} Returns the new spec function. - */ - function baseMatches(source) { - var matchData = getMatchData(source) - if (matchData.length == 1 && matchData[0][2]) { - return matchesStrictComparable(matchData[0][0], matchData[0][1]) - } - return function(object) { - return object === source || baseIsMatch(object, source, matchData) - } - } - - /** - * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. - * - * @private - * @param {string} path The path of the property to get. - * @param {*} srcValue The value to match. - * @returns {Function} Returns the new spec function. - */ - function baseMatchesProperty(path, srcValue) { - if (isKey(path) && isStrictComparable(srcValue)) { - return matchesStrictComparable(toKey(path), srcValue) - } - return function(object) { - var objValue = get(object, path) - return objValue === undefined$1 && objValue === srcValue - ? hasIn(object, path) - : baseIsEqual( - srcValue, - objValue, - COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG - ) - } - } - - /** - * The base implementation of `_.merge` without support for multiple sources. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @param {number} srcIndex The index of `source`. - * @param {Function} [customizer] The function to customize merged values. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - */ - function baseMerge(object, source, srcIndex, customizer, stack) { - if (object === source) { - return - } - baseFor( - source, - function(srcValue, key) { - stack || (stack = new Stack()) - if (isObject(srcValue)) { - baseMergeDeep( - object, - source, - key, - srcIndex, - baseMerge, - customizer, - stack - ) - } else { - var newValue = customizer - ? customizer( - safeGet(object, key), - srcValue, - key + "", - object, - source, - stack - ) - : undefined$1 - - if (newValue === undefined$1) { - newValue = srcValue - } - assignMergeValue(object, key, newValue) - } - }, - keysIn - ) - } - - /** - * A specialized version of `baseMerge` for arrays and objects which performs - * deep merges and tracks traversed objects enabling objects with circular - * references to be merged. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @param {string} key The key of the value to merge. - * @param {number} srcIndex The index of `source`. - * @param {Function} mergeFunc The function to merge values. - * @param {Function} [customizer] The function to customize assigned values. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - */ - function baseMergeDeep( - object, - source, - key, - srcIndex, - mergeFunc, - customizer, - stack - ) { - var objValue = safeGet(object, key), - srcValue = safeGet(source, key), - stacked = stack.get(srcValue) - - if (stacked) { - assignMergeValue(object, key, stacked) - return - } - var newValue = customizer - ? customizer(objValue, srcValue, key + "", object, source, stack) - : undefined$1 - - var isCommon = newValue === undefined$1 - - if (isCommon) { - var isArr = isArray(srcValue), - isBuff = !isArr && isBuffer(srcValue), - isTyped = !isArr && !isBuff && isTypedArray(srcValue) - - newValue = srcValue - if (isArr || isBuff || isTyped) { - if (isArray(objValue)) { - newValue = objValue - } else if (isArrayLikeObject(objValue)) { - newValue = copyArray(objValue) - } else if (isBuff) { - isCommon = false - newValue = cloneBuffer(srcValue, true) - } else if (isTyped) { - isCommon = false - newValue = cloneTypedArray(srcValue, true) - } else { - newValue = [] - } - } else if (isPlainObject(srcValue) || isArguments(srcValue)) { - newValue = objValue - if (isArguments(objValue)) { - newValue = toPlainObject(objValue) - } else if (!isObject(objValue) || isFunction(objValue)) { - newValue = initCloneObject(srcValue) - } - } else { - isCommon = false - } - } - if (isCommon) { - // Recursively merge objects and arrays (susceptible to call stack limits). - stack.set(srcValue, newValue) - mergeFunc(newValue, srcValue, srcIndex, customizer, stack) - stack["delete"](srcValue) - } - assignMergeValue(object, key, newValue) - } - - /** - * The base implementation of `_.nth` which doesn't coerce arguments. - * - * @private - * @param {Array} array The array to query. - * @param {number} n The index of the element to return. - * @returns {*} Returns the nth element of `array`. - */ - function baseNth(array, n) { - var length = array.length - if (!length) { - return - } - n += n < 0 ? length : 0 - return isIndex(n, length) ? array[n] : undefined$1 - } - - /** - * The base implementation of `_.orderBy` without param guards. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. - * @param {string[]} orders The sort orders of `iteratees`. - * @returns {Array} Returns the new sorted array. - */ - function baseOrderBy(collection, iteratees, orders) { - var index = -1 - iteratees = arrayMap( - iteratees.length ? iteratees : [identity], - baseUnary(getIteratee()) - ) - - var result = baseMap(collection, function(value, key, collection) { - var criteria = arrayMap(iteratees, function(iteratee) { - return iteratee(value) - }) - return { criteria: criteria, index: ++index, value: value } - }) - - return baseSortBy(result, function(object, other) { - return compareMultiple(object, other, orders) - }) - } - - /** - * The base implementation of `_.pick` without support for individual - * property identifiers. - * - * @private - * @param {Object} object The source object. - * @param {string[]} paths The property paths to pick. - * @returns {Object} Returns the new object. - */ - function basePick(object, paths) { - return basePickBy(object, paths, function(value, path) { - return hasIn(object, path) - }) - } - - /** - * The base implementation of `_.pickBy` without support for iteratee shorthands. - * - * @private - * @param {Object} object The source object. - * @param {string[]} paths The property paths to pick. - * @param {Function} predicate The function invoked per property. - * @returns {Object} Returns the new object. - */ - function basePickBy(object, paths, predicate) { - var index = -1, - length = paths.length, - result = {} - - while (++index < length) { - var path = paths[index], - value = baseGet(object, path) - - if (predicate(value, path)) { - baseSet(result, castPath(path, object), value) - } - } - return result - } - - /** - * A specialized version of `baseProperty` which supports deep paths. - * - * @private - * @param {Array|string} path The path of the property to get. - * @returns {Function} Returns the new accessor function. - */ - function basePropertyDeep(path) { - return function(object) { - return baseGet(object, path) - } - } - - /** - * The base implementation of `_.pullAllBy` without support for iteratee - * shorthands. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns `array`. - */ - function basePullAll(array, values, iteratee, comparator) { - var indexOf = comparator ? baseIndexOfWith : baseIndexOf, - index = -1, - length = values.length, - seen = array - - if (array === values) { - values = copyArray(values) - } - if (iteratee) { - seen = arrayMap(array, baseUnary(iteratee)) - } - while (++index < length) { - var fromIndex = 0, - value = values[index], - computed = iteratee ? iteratee(value) : value - - while ( - (fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1 - ) { - if (seen !== array) { - splice.call(seen, fromIndex, 1) - } - splice.call(array, fromIndex, 1) - } - } - return array - } - - /** - * The base implementation of `_.pullAt` without support for individual - * indexes or capturing the removed elements. - * - * @private - * @param {Array} array The array to modify. - * @param {number[]} indexes The indexes of elements to remove. - * @returns {Array} Returns `array`. - */ - function basePullAt(array, indexes) { - var length = array ? indexes.length : 0, - lastIndex = length - 1 - - while (length--) { - var index = indexes[length] - if (length == lastIndex || index !== previous) { - var previous = index - if (isIndex(index)) { - splice.call(array, index, 1) - } else { - baseUnset(array, index) - } - } - } - return array - } - - /** - * The base implementation of `_.random` without support for returning - * floating-point numbers. - * - * @private - * @param {number} lower The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the random number. - */ - function baseRandom(lower, upper) { - return lower + nativeFloor(nativeRandom() * (upper - lower + 1)) - } - - /** - * The base implementation of `_.range` and `_.rangeRight` which doesn't - * coerce arguments. - * - * @private - * @param {number} start The start of the range. - * @param {number} end The end of the range. - * @param {number} step The value to increment or decrement by. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Array} Returns the range of numbers. - */ - function baseRange(start, end, step, fromRight) { - var index = -1, - length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), - result = Array(length) - - while (length--) { - result[fromRight ? length : ++index] = start - start += step - } - return result - } - - /** - * The base implementation of `_.repeat` which doesn't coerce arguments. - * - * @private - * @param {string} string The string to repeat. - * @param {number} n The number of times to repeat the string. - * @returns {string} Returns the repeated string. - */ - function baseRepeat(string, n) { - var result = "" - if (!string || n < 1 || n > MAX_SAFE_INTEGER) { - return result - } - // Leverage the exponentiation by squaring algorithm for a faster repeat. - // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. - do { - if (n % 2) { - result += string - } - n = nativeFloor(n / 2) - if (n) { - string += string - } - } while (n) - - return result - } - - /** - * The base implementation of `_.rest` which doesn't validate or coerce arguments. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @returns {Function} Returns the new function. - */ - function baseRest(func, start) { - return setToString(overRest(func, start, identity), func + "") - } - - /** - * The base implementation of `_.sample`. - * - * @private - * @param {Array|Object} collection The collection to sample. - * @returns {*} Returns the random element. - */ - function baseSample(collection) { - return arraySample(values(collection)) - } - - /** - * The base implementation of `_.sampleSize` without param guards. - * - * @private - * @param {Array|Object} collection The collection to sample. - * @param {number} n The number of elements to sample. - * @returns {Array} Returns the random elements. - */ - function baseSampleSize(collection, n) { - var array = values(collection) - return shuffleSelf(array, baseClamp(n, 0, array.length)) - } - - /** - * The base implementation of `_.set`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @param {Function} [customizer] The function to customize path creation. - * @returns {Object} Returns `object`. - */ - function baseSet(object, path, value, customizer) { - if (!isObject(object)) { - return object - } - path = castPath(path, object) - - var index = -1, - length = path.length, - lastIndex = length - 1, - nested = object - - while (nested != null && ++index < length) { - var key = toKey(path[index]), - newValue = value - - if (index != lastIndex) { - var objValue = nested[key] - newValue = customizer - ? customizer(objValue, key, nested) - : undefined$1 - if (newValue === undefined$1) { - newValue = isObject(objValue) - ? objValue - : isIndex(path[index + 1]) - ? [] - : {} - } - } - assignValue(nested, key, newValue) - nested = nested[key] - } - return object - } - - /** - * The base implementation of `setData` without support for hot loop shorting. - * - * @private - * @param {Function} func The function to associate metadata with. - * @param {*} data The metadata. - * @returns {Function} Returns `func`. - */ - var baseSetData = !metaMap - ? identity - : function(func, data) { - metaMap.set(func, data) - return func - } - - /** - * The base implementation of `setToString` without support for hot loop shorting. - * - * @private - * @param {Function} func The function to modify. - * @param {Function} string The `toString` result. - * @returns {Function} Returns `func`. - */ - var baseSetToString = !defineProperty - ? identity - : function(func, string) { - return defineProperty(func, "toString", { - configurable: true, - enumerable: false, - value: constant(string), - writable: true, - }) - } - - /** - * The base implementation of `_.shuffle`. - * - * @private - * @param {Array|Object} collection The collection to shuffle. - * @returns {Array} Returns the new shuffled array. - */ - function baseShuffle(collection) { - return shuffleSelf(values(collection)) - } - - /** - * The base implementation of `_.slice` without an iteratee call guard. - * - * @private - * @param {Array} array The array to slice. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the slice of `array`. - */ - function baseSlice(array, start, end) { - var index = -1, - length = array.length - - if (start < 0) { - start = -start > length ? 0 : length + start - } - end = end > length ? length : end - if (end < 0) { - end += length - } - length = start > end ? 0 : (end - start) >>> 0 - start >>>= 0 - - var result = Array(length) - while (++index < length) { - result[index] = array[index + start] - } - return result - } - - /** - * The base implementation of `_.some` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - */ - function baseSome(collection, predicate) { - var result - - baseEach(collection, function(value, index, collection) { - result = predicate(value, index, collection) - return !result - }) - return !!result - } - - /** - * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which - * performs a binary search of `array` to determine the index at which `value` - * should be inserted into `array` in order to maintain its sort order. - * - * @private - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {boolean} [retHighest] Specify returning the highest qualified index. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - */ - function baseSortedIndex(array, value, retHighest) { - var low = 0, - high = array == null ? low : array.length - - if ( - typeof value == "number" && - value === value && - high <= HALF_MAX_ARRAY_LENGTH - ) { - while (low < high) { - var mid = (low + high) >>> 1, - computed = array[mid] - - if ( - computed !== null && - !isSymbol(computed) && - (retHighest ? computed <= value : computed < value) - ) { - low = mid + 1 - } else { - high = mid - } - } - return high - } - return baseSortedIndexBy(array, value, identity, retHighest) - } - - /** - * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` - * which invokes `iteratee` for `value` and each element of `array` to compute - * their sort ranking. The iteratee is invoked with one argument; (value). - * - * @private - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} iteratee The iteratee invoked per element. - * @param {boolean} [retHighest] Specify returning the highest qualified index. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - */ - function baseSortedIndexBy(array, value, iteratee, retHighest) { - value = iteratee(value) - - var low = 0, - high = array == null ? 0 : array.length, - valIsNaN = value !== value, - valIsNull = value === null, - valIsSymbol = isSymbol(value), - valIsUndefined = value === undefined$1 - - while (low < high) { - var mid = nativeFloor((low + high) / 2), - computed = iteratee(array[mid]), - othIsDefined = computed !== undefined$1, - othIsNull = computed === null, - othIsReflexive = computed === computed, - othIsSymbol = isSymbol(computed) - - if (valIsNaN) { - var setLow = retHighest || othIsReflexive - } else if (valIsUndefined) { - setLow = othIsReflexive && (retHighest || othIsDefined) - } else if (valIsNull) { - setLow = - othIsReflexive && othIsDefined && (retHighest || !othIsNull) - } else if (valIsSymbol) { - setLow = - othIsReflexive && - othIsDefined && - !othIsNull && - (retHighest || !othIsSymbol) - } else if (othIsNull || othIsSymbol) { - setLow = false - } else { - setLow = retHighest ? computed <= value : computed < value - } - if (setLow) { - low = mid + 1 - } else { - high = mid - } - } - return nativeMin(high, MAX_ARRAY_INDEX) - } - - /** - * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without - * support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - */ - function baseSortedUniq(array, iteratee) { - var index = -1, - length = array.length, - resIndex = 0, - result = [] - - while (++index < length) { - var value = array[index], - computed = iteratee ? iteratee(value) : value - - if (!index || !eq(computed, seen)) { - var seen = computed - result[resIndex++] = value === 0 ? 0 : value - } - } - return result - } - - /** - * The base implementation of `_.toNumber` which doesn't ensure correct - * conversions of binary, hexadecimal, or octal string values. - * - * @private - * @param {*} value The value to process. - * @returns {number} Returns the number. - */ - function baseToNumber(value) { - if (typeof value == "number") { - return value - } - if (isSymbol(value)) { - return NAN - } - return +value - } - - /** - * The base implementation of `_.toString` which doesn't convert nullish - * values to empty strings. - * - * @private - * @param {*} value The value to process. - * @returns {string} Returns the string. - */ - function baseToString(value) { - // Exit early for strings to avoid a performance hit in some environments. - if (typeof value == "string") { - return value - } - if (isArray(value)) { - // Recursively convert values (susceptible to call stack limits). - return arrayMap(value, baseToString) + "" - } - if (isSymbol(value)) { - return symbolToString ? symbolToString.call(value) : "" - } - var result = value + "" - return result == "0" && 1 / value == -INFINITY ? "-0" : result - } - - /** - * The base implementation of `_.uniqBy` without support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new duplicate free array. - */ - function baseUniq(array, iteratee, comparator) { - var index = -1, - includes = arrayIncludes, - length = array.length, - isCommon = true, - result = [], - seen = result - - if (comparator) { - isCommon = false - includes = arrayIncludesWith - } else if (length >= LARGE_ARRAY_SIZE) { - var set = iteratee ? null : createSet(array) - if (set) { - return setToArray(set) - } - isCommon = false - includes = cacheHas - seen = new SetCache() - } else { - seen = iteratee ? [] : result - } - outer: while (++index < length) { - var value = array[index], - computed = iteratee ? iteratee(value) : value - - value = comparator || value !== 0 ? value : 0 - if (isCommon && computed === computed) { - var seenIndex = seen.length - while (seenIndex--) { - if (seen[seenIndex] === computed) { - continue outer - } - } - if (iteratee) { - seen.push(computed) - } - result.push(value) - } else if (!includes(seen, computed, comparator)) { - if (seen !== result) { - seen.push(computed) - } - result.push(value) - } - } - return result - } - - /** - * The base implementation of `_.unset`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The property path to unset. - * @returns {boolean} Returns `true` if the property is deleted, else `false`. - */ - function baseUnset(object, path) { - path = castPath(path, object) - object = parent(object, path) - return object == null || delete object[toKey(last(path))] - } - - /** - * The base implementation of `_.update`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to update. - * @param {Function} updater The function to produce the updated value. - * @param {Function} [customizer] The function to customize path creation. - * @returns {Object} Returns `object`. - */ - function baseUpdate(object, path, updater, customizer) { - return baseSet( - object, - path, - updater(baseGet(object, path)), - customizer - ) - } - - /** - * The base implementation of methods like `_.dropWhile` and `_.takeWhile` - * without support for iteratee shorthands. - * - * @private - * @param {Array} array The array to query. - * @param {Function} predicate The function invoked per iteration. - * @param {boolean} [isDrop] Specify dropping elements instead of taking them. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Array} Returns the slice of `array`. - */ - function baseWhile(array, predicate, isDrop, fromRight) { - var length = array.length, - index = fromRight ? length : -1 - - while ( - (fromRight ? index-- : ++index < length) && - predicate(array[index], index, array) - ) {} - - return isDrop - ? baseSlice( - array, - fromRight ? 0 : index, - fromRight ? index + 1 : length - ) - : baseSlice( - array, - fromRight ? index + 1 : 0, - fromRight ? length : index - ) - } - - /** - * The base implementation of `wrapperValue` which returns the result of - * performing a sequence of actions on the unwrapped `value`, where each - * successive action is supplied the return value of the previous. - * - * @private - * @param {*} value The unwrapped value. - * @param {Array} actions Actions to perform to resolve the unwrapped value. - * @returns {*} Returns the resolved value. - */ - function baseWrapperValue(value, actions) { - var result = value - if (result instanceof LazyWrapper) { - result = result.value() - } - return arrayReduce( - actions, - function(result, action) { - return action.func.apply( - action.thisArg, - arrayPush([result], action.args) - ) - }, - result - ) - } - - /** - * The base implementation of methods like `_.xor`, without support for - * iteratee shorthands, that accepts an array of arrays to inspect. - * - * @private - * @param {Array} arrays The arrays to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of values. - */ - function baseXor(arrays, iteratee, comparator) { - var length = arrays.length - if (length < 2) { - return length ? baseUniq(arrays[0]) : [] - } - var index = -1, - result = Array(length) - - while (++index < length) { - var array = arrays[index], - othIndex = -1 - - while (++othIndex < length) { - if (othIndex != index) { - result[index] = baseDifference( - result[index] || array, - arrays[othIndex], - iteratee, - comparator - ) - } - } - } - return baseUniq(baseFlatten(result, 1), iteratee, comparator) - } - - /** - * This base implementation of `_.zipObject` which assigns values using `assignFunc`. - * - * @private - * @param {Array} props The property identifiers. - * @param {Array} values The property values. - * @param {Function} assignFunc The function to assign values. - * @returns {Object} Returns the new object. - */ - function baseZipObject(props, values, assignFunc) { - var index = -1, - length = props.length, - valsLength = values.length, - result = {} - - while (++index < length) { - var value = index < valsLength ? values[index] : undefined$1 - assignFunc(result, props[index], value) - } - return result - } - - /** - * Casts `value` to an empty array if it's not an array like object. - * - * @private - * @param {*} value The value to inspect. - * @returns {Array|Object} Returns the cast array-like object. - */ - function castArrayLikeObject(value) { - return isArrayLikeObject(value) ? value : [] - } - - /** - * Casts `value` to `identity` if it's not a function. - * - * @private - * @param {*} value The value to inspect. - * @returns {Function} Returns cast function. - */ - function castFunction(value) { - return typeof value == "function" ? value : identity - } - - /** - * Casts `value` to a path array if it's not one. - * - * @private - * @param {*} value The value to inspect. - * @param {Object} [object] The object to query keys on. - * @returns {Array} Returns the cast property path array. - */ - function castPath(value, object) { - if (isArray(value)) { - return value - } - return isKey(value, object) ? [value] : stringToPath(toString(value)) - } - - /** - * A `baseRest` alias which can be replaced with `identity` by module - * replacement plugins. - * - * @private - * @type {Function} - * @param {Function} func The function to apply a rest parameter to. - * @returns {Function} Returns the new function. - */ - var castRest = baseRest - - /** - * Casts `array` to a slice if it's needed. - * - * @private - * @param {Array} array The array to inspect. - * @param {number} start The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the cast slice. - */ - function castSlice(array, start, end) { - var length = array.length - end = end === undefined$1 ? length : end - return !start && end >= length ? array : baseSlice(array, start, end) - } - - /** - * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout). - * - * @private - * @param {number|Object} id The timer id or timeout object of the timer to clear. - */ - var clearTimeout = - ctxClearTimeout || - function(id) { - return root.clearTimeout(id) - } - - /** - * Creates a clone of `buffer`. - * - * @private - * @param {Buffer} buffer The buffer to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Buffer} Returns the cloned buffer. - */ - function cloneBuffer(buffer, isDeep) { - if (isDeep) { - return buffer.slice() - } - var length = buffer.length, - result = allocUnsafe - ? allocUnsafe(length) - : new buffer.constructor(length) - - buffer.copy(result) - return result - } - - /** - * Creates a clone of `arrayBuffer`. - * - * @private - * @param {ArrayBuffer} arrayBuffer The array buffer to clone. - * @returns {ArrayBuffer} Returns the cloned array buffer. - */ - function cloneArrayBuffer(arrayBuffer) { - var result = new arrayBuffer.constructor(arrayBuffer.byteLength) - new Uint8Array(result).set(new Uint8Array(arrayBuffer)) - return result - } - - /** - * Creates a clone of `dataView`. - * - * @private - * @param {Object} dataView The data view to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the cloned data view. - */ - function cloneDataView(dataView, isDeep) { - var buffer = isDeep - ? cloneArrayBuffer(dataView.buffer) - : dataView.buffer - return new dataView.constructor( - buffer, - dataView.byteOffset, - dataView.byteLength - ) - } - - /** - * Creates a clone of `regexp`. - * - * @private - * @param {Object} regexp The regexp to clone. - * @returns {Object} Returns the cloned regexp. - */ - function cloneRegExp(regexp) { - var result = new regexp.constructor( - regexp.source, - reFlags.exec(regexp) - ) - result.lastIndex = regexp.lastIndex - return result - } - - /** - * Creates a clone of the `symbol` object. - * - * @private - * @param {Object} symbol The symbol object to clone. - * @returns {Object} Returns the cloned symbol object. - */ - function cloneSymbol(symbol) { - return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {} - } - - /** - * Creates a clone of `typedArray`. - * - * @private - * @param {Object} typedArray The typed array to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the cloned typed array. - */ - function cloneTypedArray(typedArray, isDeep) { - var buffer = isDeep - ? cloneArrayBuffer(typedArray.buffer) - : typedArray.buffer - return new typedArray.constructor( - buffer, - typedArray.byteOffset, - typedArray.length - ) - } - - /** - * Compares values to sort them in ascending order. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {number} Returns the sort order indicator for `value`. - */ - function compareAscending(value, other) { - if (value !== other) { - var valIsDefined = value !== undefined$1, - valIsNull = value === null, - valIsReflexive = value === value, - valIsSymbol = isSymbol(value) - - var othIsDefined = other !== undefined$1, - othIsNull = other === null, - othIsReflexive = other === other, - othIsSymbol = isSymbol(other) - - if ( - (!othIsNull && !othIsSymbol && !valIsSymbol && value > other) || - (valIsSymbol && - othIsDefined && - othIsReflexive && - !othIsNull && - !othIsSymbol) || - (valIsNull && othIsDefined && othIsReflexive) || - (!valIsDefined && othIsReflexive) || - !valIsReflexive - ) { - return 1 - } - if ( - (!valIsNull && !valIsSymbol && !othIsSymbol && value < other) || - (othIsSymbol && - valIsDefined && - valIsReflexive && - !valIsNull && - !valIsSymbol) || - (othIsNull && valIsDefined && valIsReflexive) || - (!othIsDefined && valIsReflexive) || - !othIsReflexive - ) { - return -1 - } - } - return 0 - } - - /** - * Used by `_.orderBy` to compare multiple properties of a value to another - * and stable sort them. - * - * If `orders` is unspecified, all values are sorted in ascending order. Otherwise, - * specify an order of "desc" for descending or "asc" for ascending sort order - * of corresponding values. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {boolean[]|string[]} orders The order to sort by for each property. - * @returns {number} Returns the sort order indicator for `object`. - */ - function compareMultiple(object, other, orders) { - var index = -1, - objCriteria = object.criteria, - othCriteria = other.criteria, - length = objCriteria.length, - ordersLength = orders.length - - while (++index < length) { - var result = compareAscending( - objCriteria[index], - othCriteria[index] - ) - if (result) { - if (index >= ordersLength) { - return result - } - var order = orders[index] - return result * (order == "desc" ? -1 : 1) - } - } - // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications - // that causes it, under certain circumstances, to provide the same value for - // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 - // for more details. - // - // This also ensures a stable sort in V8 and other engines. - // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. - return object.index - other.index - } - - /** - * Creates an array that is the composition of partially applied arguments, - * placeholders, and provided arguments into a single array of arguments. - * - * @private - * @param {Array} args The provided arguments. - * @param {Array} partials The arguments to prepend to those provided. - * @param {Array} holders The `partials` placeholder indexes. - * @params {boolean} [isCurried] Specify composing for a curried function. - * @returns {Array} Returns the new array of composed arguments. - */ - function composeArgs(args, partials, holders, isCurried) { - var argsIndex = -1, - argsLength = args.length, - holdersLength = holders.length, - leftIndex = -1, - leftLength = partials.length, - rangeLength = nativeMax(argsLength - holdersLength, 0), - result = Array(leftLength + rangeLength), - isUncurried = !isCurried - - while (++leftIndex < leftLength) { - result[leftIndex] = partials[leftIndex] - } - while (++argsIndex < holdersLength) { - if (isUncurried || argsIndex < argsLength) { - result[holders[argsIndex]] = args[argsIndex] - } - } - while (rangeLength--) { - result[leftIndex++] = args[argsIndex++] - } - return result - } - - /** - * This function is like `composeArgs` except that the arguments composition - * is tailored for `_.partialRight`. - * - * @private - * @param {Array} args The provided arguments. - * @param {Array} partials The arguments to append to those provided. - * @param {Array} holders The `partials` placeholder indexes. - * @params {boolean} [isCurried] Specify composing for a curried function. - * @returns {Array} Returns the new array of composed arguments. - */ - function composeArgsRight(args, partials, holders, isCurried) { - var argsIndex = -1, - argsLength = args.length, - holdersIndex = -1, - holdersLength = holders.length, - rightIndex = -1, - rightLength = partials.length, - rangeLength = nativeMax(argsLength - holdersLength, 0), - result = Array(rangeLength + rightLength), - isUncurried = !isCurried - - while (++argsIndex < rangeLength) { - result[argsIndex] = args[argsIndex] - } - var offset = argsIndex - while (++rightIndex < rightLength) { - result[offset + rightIndex] = partials[rightIndex] - } - while (++holdersIndex < holdersLength) { - if (isUncurried || argsIndex < argsLength) { - result[offset + holders[holdersIndex]] = args[argsIndex++] - } - } - return result - } - - /** - * Copies the values of `source` to `array`. - * - * @private - * @param {Array} source The array to copy values from. - * @param {Array} [array=[]] The array to copy values to. - * @returns {Array} Returns `array`. - */ - function copyArray(source, array) { - var index = -1, - length = source.length - - array || (array = Array(length)) - while (++index < length) { - array[index] = source[index] - } - return array - } - - /** - * Copies properties of `source` to `object`. - * - * @private - * @param {Object} source The object to copy properties from. - * @param {Array} props The property identifiers to copy. - * @param {Object} [object={}] The object to copy properties to. - * @param {Function} [customizer] The function to customize copied values. - * @returns {Object} Returns `object`. - */ - function copyObject(source, props, object, customizer) { - var isNew = !object - object || (object = {}) - - var index = -1, - length = props.length - - while (++index < length) { - var key = props[index] - - var newValue = customizer - ? customizer(object[key], source[key], key, object, source) - : undefined$1 - - if (newValue === undefined$1) { - newValue = source[key] - } - if (isNew) { - baseAssignValue(object, key, newValue) - } else { - assignValue(object, key, newValue) - } - } - return object - } - - /** - * Copies own symbols of `source` to `object`. - * - * @private - * @param {Object} source The object to copy symbols from. - * @param {Object} [object={}] The object to copy symbols to. - * @returns {Object} Returns `object`. - */ - function copySymbols(source, object) { - return copyObject(source, getSymbols(source), object) - } - - /** - * Copies own and inherited symbols of `source` to `object`. - * - * @private - * @param {Object} source The object to copy symbols from. - * @param {Object} [object={}] The object to copy symbols to. - * @returns {Object} Returns `object`. - */ - function copySymbolsIn(source, object) { - return copyObject(source, getSymbolsIn(source), object) - } - - /** - * Creates a function like `_.groupBy`. - * - * @private - * @param {Function} setter The function to set accumulator values. - * @param {Function} [initializer] The accumulator object initializer. - * @returns {Function} Returns the new aggregator function. - */ - function createAggregator(setter, initializer) { - return function(collection, iteratee) { - var func = isArray(collection) ? arrayAggregator : baseAggregator, - accumulator = initializer ? initializer() : {} - - return func( - collection, - setter, - getIteratee(iteratee, 2), - accumulator - ) - } - } - - /** - * Creates a function like `_.assign`. - * - * @private - * @param {Function} assigner The function to assign values. - * @returns {Function} Returns the new assigner function. - */ - function createAssigner(assigner) { - return baseRest(function(object, sources) { - var index = -1, - length = sources.length, - customizer = length > 1 ? sources[length - 1] : undefined$1, - guard = length > 2 ? sources[2] : undefined$1 - - customizer = - assigner.length > 3 && typeof customizer == "function" - ? (length--, customizer) - : undefined$1 - - if (guard && isIterateeCall(sources[0], sources[1], guard)) { - customizer = length < 3 ? undefined$1 : customizer - length = 1 - } - object = Object(object) - while (++index < length) { - var source = sources[index] - if (source) { - assigner(object, source, index, customizer) - } - } - return object - }) - } - - /** - * Creates a `baseEach` or `baseEachRight` function. - * - * @private - * @param {Function} eachFunc The function to iterate over a collection. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new base function. - */ - function createBaseEach(eachFunc, fromRight) { - return function(collection, iteratee) { - if (collection == null) { - return collection - } - if (!isArrayLike(collection)) { - return eachFunc(collection, iteratee) - } - var length = collection.length, - index = fromRight ? length : -1, - iterable = Object(collection) - - while (fromRight ? index-- : ++index < length) { - if (iteratee(iterable[index], index, iterable) === false) { - break - } - } - return collection - } - } - - /** - * Creates a base function for methods like `_.forIn` and `_.forOwn`. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new base function. - */ - function createBaseFor(fromRight) { - return function(object, iteratee, keysFunc) { - var index = -1, - iterable = Object(object), - props = keysFunc(object), - length = props.length - - while (length--) { - var key = props[fromRight ? length : ++index] - if (iteratee(iterable[key], key, iterable) === false) { - break - } - } - return object - } - } - - /** - * Creates a function that wraps `func` to invoke it with the optional `this` - * binding of `thisArg`. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} [thisArg] The `this` binding of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createBind(func, bitmask, thisArg) { - var isBind = bitmask & WRAP_BIND_FLAG, - Ctor = createCtor(func) - - function wrapper() { - var fn = - this && this !== root && this instanceof wrapper ? Ctor : func - return fn.apply(isBind ? thisArg : this, arguments) - } - return wrapper - } - - /** - * Creates a function like `_.lowerFirst`. - * - * @private - * @param {string} methodName The name of the `String` case method to use. - * @returns {Function} Returns the new case function. - */ - function createCaseFirst(methodName) { - return function(string) { - string = toString(string) - - var strSymbols = hasUnicode(string) - ? stringToArray(string) - : undefined$1 - - var chr = strSymbols ? strSymbols[0] : string.charAt(0) - - var trailing = strSymbols - ? castSlice(strSymbols, 1).join("") - : string.slice(1) - - return chr[methodName]() + trailing - } - } - - /** - * Creates a function like `_.camelCase`. - * - * @private - * @param {Function} callback The function to combine each word. - * @returns {Function} Returns the new compounder function. - */ - function createCompounder(callback) { - return function(string) { - return arrayReduce( - words(deburr(string).replace(reApos, "")), - callback, - "" - ) - } - } - - /** - * Creates a function that produces an instance of `Ctor` regardless of - * whether it was invoked as part of a `new` expression or by `call` or `apply`. - * - * @private - * @param {Function} Ctor The constructor to wrap. - * @returns {Function} Returns the new wrapped function. - */ - function createCtor(Ctor) { - return function() { - // Use a `switch` statement to work with class constructors. See - // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist - // for more details. - var args = arguments - switch (args.length) { - case 0: - return new Ctor() - case 1: - return new Ctor(args[0]) - case 2: - return new Ctor(args[0], args[1]) - case 3: - return new Ctor(args[0], args[1], args[2]) - case 4: - return new Ctor(args[0], args[1], args[2], args[3]) - case 5: - return new Ctor(args[0], args[1], args[2], args[3], args[4]) - case 6: - return new Ctor( - args[0], - args[1], - args[2], - args[3], - args[4], - args[5] - ) - case 7: - return new Ctor( - args[0], - args[1], - args[2], - args[3], - args[4], - args[5], - args[6] - ) - } - var thisBinding = baseCreate(Ctor.prototype), - result = Ctor.apply(thisBinding, args) - - // Mimic the constructor's `return` behavior. - // See https://es5.github.io/#x13.2.2 for more details. - return isObject(result) ? result : thisBinding - } - } - - /** - * Creates a function that wraps `func` to enable currying. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {number} arity The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createCurry(func, bitmask, arity) { - var Ctor = createCtor(func) - - function wrapper() { - var length = arguments.length, - args = Array(length), - index = length, - placeholder = getHolder(wrapper) - - while (index--) { - args[index] = arguments[index] - } - var holders = - length < 3 && - args[0] !== placeholder && - args[length - 1] !== placeholder - ? [] - : replaceHolders(args, placeholder) - - length -= holders.length - if (length < arity) { - return createRecurry( - func, - bitmask, - createHybrid, - wrapper.placeholder, - undefined$1, - args, - holders, - undefined$1, - undefined$1, - arity - length - ) - } - var fn = - this && this !== root && this instanceof wrapper ? Ctor : func - return apply(fn, this, args) - } - return wrapper - } - - /** - * Creates a `_.find` or `_.findLast` function. - * - * @private - * @param {Function} findIndexFunc The function to find the collection index. - * @returns {Function} Returns the new find function. - */ - function createFind(findIndexFunc) { - return function(collection, predicate, fromIndex) { - var iterable = Object(collection) - if (!isArrayLike(collection)) { - var iteratee = getIteratee(predicate, 3) - collection = keys(collection) - predicate = function(key) { - return iteratee(iterable[key], key, iterable) - } - } - var index = findIndexFunc(collection, predicate, fromIndex) - return index > -1 - ? iterable[iteratee ? collection[index] : index] - : undefined$1 - } - } - - /** - * Creates a `_.flow` or `_.flowRight` function. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new flow function. - */ - function createFlow(fromRight) { - return flatRest(function(funcs) { - var length = funcs.length, - index = length, - prereq = LodashWrapper.prototype.thru - - if (fromRight) { - funcs.reverse() - } - while (index--) { - var func = funcs[index] - if (typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - if (prereq && !wrapper && getFuncName(func) == "wrapper") { - var wrapper = new LodashWrapper([], true) - } - } - index = wrapper ? index : length - while (++index < length) { - func = funcs[index] - - var funcName = getFuncName(func), - data = funcName == "wrapper" ? getData(func) : undefined$1 - - if ( - data && - isLaziable(data[0]) && - data[1] == - (WRAP_ARY_FLAG | - WRAP_CURRY_FLAG | - WRAP_PARTIAL_FLAG | - WRAP_REARG_FLAG) && - !data[4].length && - data[9] == 1 - ) { - wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]) - } else { - wrapper = - func.length == 1 && isLaziable(func) - ? wrapper[funcName]() - : wrapper.thru(func) - } - } - return function() { - var args = arguments, - value = args[0] - - if (wrapper && args.length == 1 && isArray(value)) { - return wrapper.plant(value).value() - } - var index = 0, - result = length ? funcs[index].apply(this, args) : value - - while (++index < length) { - result = funcs[index].call(this, result) - } - return result - } - }) - } - - /** - * Creates a function that wraps `func` to invoke it with optional `this` - * binding of `thisArg`, partial application, and currying. - * - * @private - * @param {Function|string} func The function or method name to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to prepend to those provided to - * the new function. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [partialsRight] The arguments to append to those provided - * to the new function. - * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createHybrid( - func, - bitmask, - thisArg, - partials, - holders, - partialsRight, - holdersRight, - argPos, - ary, - arity - ) { - var isAry = bitmask & WRAP_ARY_FLAG, - isBind = bitmask & WRAP_BIND_FLAG, - isBindKey = bitmask & WRAP_BIND_KEY_FLAG, - isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), - isFlip = bitmask & WRAP_FLIP_FLAG, - Ctor = isBindKey ? undefined$1 : createCtor(func) - - function wrapper() { - var length = arguments.length, - args = Array(length), - index = length - - while (index--) { - args[index] = arguments[index] - } - if (isCurried) { - var placeholder = getHolder(wrapper), - holdersCount = countHolders(args, placeholder) - } - if (partials) { - args = composeArgs(args, partials, holders, isCurried) - } - if (partialsRight) { - args = composeArgsRight( - args, - partialsRight, - holdersRight, - isCurried - ) - } - length -= holdersCount - if (isCurried && length < arity) { - var newHolders = replaceHolders(args, placeholder) - return createRecurry( - func, - bitmask, - createHybrid, - wrapper.placeholder, - thisArg, - args, - newHolders, - argPos, - ary, - arity - length - ) - } - var thisBinding = isBind ? thisArg : this, - fn = isBindKey ? thisBinding[func] : func - - length = args.length - if (argPos) { - args = reorder(args, argPos) - } else if (isFlip && length > 1) { - args.reverse() - } - if (isAry && ary < length) { - args.length = ary - } - if (this && this !== root && this instanceof wrapper) { - fn = Ctor || createCtor(fn) - } - return fn.apply(thisBinding, args) - } - return wrapper - } - - /** - * Creates a function like `_.invertBy`. - * - * @private - * @param {Function} setter The function to set accumulator values. - * @param {Function} toIteratee The function to resolve iteratees. - * @returns {Function} Returns the new inverter function. - */ - function createInverter(setter, toIteratee) { - return function(object, iteratee) { - return baseInverter(object, setter, toIteratee(iteratee), {}) - } - } - - /** - * Creates a function that performs a mathematical operation on two values. - * - * @private - * @param {Function} operator The function to perform the operation. - * @param {number} [defaultValue] The value used for `undefined` arguments. - * @returns {Function} Returns the new mathematical operation function. - */ - function createMathOperation(operator, defaultValue) { - return function(value, other) { - var result - if (value === undefined$1 && other === undefined$1) { - return defaultValue - } - if (value !== undefined$1) { - result = value - } - if (other !== undefined$1) { - if (result === undefined$1) { - return other - } - if (typeof value == "string" || typeof other == "string") { - value = baseToString(value) - other = baseToString(other) - } else { - value = baseToNumber(value) - other = baseToNumber(other) - } - result = operator(value, other) - } - return result - } - } - - /** - * Creates a function like `_.over`. - * - * @private - * @param {Function} arrayFunc The function to iterate over iteratees. - * @returns {Function} Returns the new over function. - */ - function createOver(arrayFunc) { - return flatRest(function(iteratees) { - iteratees = arrayMap(iteratees, baseUnary(getIteratee())) - return baseRest(function(args) { - var thisArg = this - return arrayFunc(iteratees, function(iteratee) { - return apply(iteratee, thisArg, args) - }) - }) - }) - } - - /** - * Creates the padding for `string` based on `length`. The `chars` string - * is truncated if the number of characters exceeds `length`. - * - * @private - * @param {number} length The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padding for `string`. - */ - function createPadding(length, chars) { - chars = chars === undefined$1 ? " " : baseToString(chars) - - var charsLength = chars.length - if (charsLength < 2) { - return charsLength ? baseRepeat(chars, length) : chars - } - var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))) - return hasUnicode(chars) - ? castSlice(stringToArray(result), 0, length).join("") - : result.slice(0, length) - } - - /** - * Creates a function that wraps `func` to invoke it with the `this` binding - * of `thisArg` and `partials` prepended to the arguments it receives. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} thisArg The `this` binding of `func`. - * @param {Array} partials The arguments to prepend to those provided to - * the new function. - * @returns {Function} Returns the new wrapped function. - */ - function createPartial(func, bitmask, thisArg, partials) { - var isBind = bitmask & WRAP_BIND_FLAG, - Ctor = createCtor(func) - - function wrapper() { - var argsIndex = -1, - argsLength = arguments.length, - leftIndex = -1, - leftLength = partials.length, - args = Array(leftLength + argsLength), - fn = - this && this !== root && this instanceof wrapper ? Ctor : func - - while (++leftIndex < leftLength) { - args[leftIndex] = partials[leftIndex] - } - while (argsLength--) { - args[leftIndex++] = arguments[++argsIndex] - } - return apply(fn, isBind ? thisArg : this, args) - } - return wrapper - } - - /** - * Creates a `_.range` or `_.rangeRight` function. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new range function. - */ - function createRange(fromRight) { - return function(start, end, step) { - if ( - step && - typeof step != "number" && - isIterateeCall(start, end, step) - ) { - end = step = undefined$1 - } - // Ensure the sign of `-0` is preserved. - start = toFinite(start) - if (end === undefined$1) { - end = start - start = 0 - } else { - end = toFinite(end) - } - step = - step === undefined$1 ? (start < end ? 1 : -1) : toFinite(step) - return baseRange(start, end, step, fromRight) - } - } - - /** - * Creates a function that performs a relational operation on two values. - * - * @private - * @param {Function} operator The function to perform the operation. - * @returns {Function} Returns the new relational operation function. - */ - function createRelationalOperation(operator) { - return function(value, other) { - if (!(typeof value == "string" && typeof other == "string")) { - value = toNumber(value) - other = toNumber(other) - } - return operator(value, other) - } - } - - /** - * Creates a function that wraps `func` to continue currying. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {Function} wrapFunc The function to create the `func` wrapper. - * @param {*} placeholder The placeholder value. - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to prepend to those provided to - * the new function. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createRecurry( - func, - bitmask, - wrapFunc, - placeholder, - thisArg, - partials, - holders, - argPos, - ary, - arity - ) { - var isCurry = bitmask & WRAP_CURRY_FLAG, - newHolders = isCurry ? holders : undefined$1, - newHoldersRight = isCurry ? undefined$1 : holders, - newPartials = isCurry ? partials : undefined$1, - newPartialsRight = isCurry ? undefined$1 : partials - - bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG - bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG) - - if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { - bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG) - } - var newData = [ - func, - bitmask, - thisArg, - newPartials, - newHolders, - newPartialsRight, - newHoldersRight, - argPos, - ary, - arity, - ] - - var result = wrapFunc.apply(undefined$1, newData) - if (isLaziable(func)) { - setData(result, newData) - } - result.placeholder = placeholder - return setWrapToString(result, func, bitmask) - } - - /** - * Creates a function like `_.round`. - * - * @private - * @param {string} methodName The name of the `Math` method to use when rounding. - * @returns {Function} Returns the new round function. - */ - function createRound(methodName) { - var func = Math[methodName] - return function(number, precision) { - number = toNumber(number) - precision = - precision == null ? 0 : nativeMin(toInteger(precision), 292) - if (precision && nativeIsFinite(number)) { - // Shift with exponential notation to avoid floating-point issues. - // See [MDN](https://mdn.io/round#Examples) for more details. - var pair = (toString(number) + "e").split("e"), - value = func(pair[0] + "e" + (+pair[1] + precision)) - - pair = (toString(value) + "e").split("e") - return +(pair[0] + "e" + (+pair[1] - precision)) - } - return func(number) - } - } - - /** - * Creates a set object of `values`. - * - * @private - * @param {Array} values The values to add to the set. - * @returns {Object} Returns the new set. - */ - var createSet = !(Set && 1 / setToArray(new Set([, -0]))[1] == INFINITY) - ? noop - : function(values) { - return new Set(values) - } - - /** - * Creates a `_.toPairs` or `_.toPairsIn` function. - * - * @private - * @param {Function} keysFunc The function to get the keys of a given object. - * @returns {Function} Returns the new pairs function. - */ - function createToPairs(keysFunc) { - return function(object) { - var tag = getTag(object) - if (tag == mapTag) { - return mapToArray(object) - } - if (tag == setTag) { - return setToPairs(object) - } - return baseToPairs(object, keysFunc(object)) - } - } - - /** - * Creates a function that either curries or invokes `func` with optional - * `this` binding and partially applied arguments. - * - * @private - * @param {Function|string} func The function or method name to wrap. - * @param {number} bitmask The bitmask flags. - * 1 - `_.bind` - * 2 - `_.bindKey` - * 4 - `_.curry` or `_.curryRight` of a bound function - * 8 - `_.curry` - * 16 - `_.curryRight` - * 32 - `_.partial` - * 64 - `_.partialRight` - * 128 - `_.rearg` - * 256 - `_.ary` - * 512 - `_.flip` - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to be partially applied. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createWrap( - func, - bitmask, - thisArg, - partials, - holders, - argPos, - ary, - arity - ) { - var isBindKey = bitmask & WRAP_BIND_KEY_FLAG - if (!isBindKey && typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - var length = partials ? partials.length : 0 - if (!length) { - bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG) - partials = holders = undefined$1 - } - ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0) - arity = arity === undefined$1 ? arity : toInteger(arity) - length -= holders ? holders.length : 0 - - if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { - var partialsRight = partials, - holdersRight = holders - - partials = holders = undefined$1 - } - var data = isBindKey ? undefined$1 : getData(func) - - var newData = [ - func, - bitmask, - thisArg, - partials, - holders, - partialsRight, - holdersRight, - argPos, - ary, - arity, - ] - - if (data) { - mergeData(newData, data) - } - func = newData[0] - bitmask = newData[1] - thisArg = newData[2] - partials = newData[3] - holders = newData[4] - arity = newData[9] = - newData[9] === undefined$1 - ? isBindKey - ? 0 - : func.length - : nativeMax(newData[9] - length, 0) - - if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { - bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG) - } - if (!bitmask || bitmask == WRAP_BIND_FLAG) { - var result = createBind(func, bitmask, thisArg) - } else if ( - bitmask == WRAP_CURRY_FLAG || - bitmask == WRAP_CURRY_RIGHT_FLAG - ) { - result = createCurry(func, bitmask, arity) - } else if ( - (bitmask == WRAP_PARTIAL_FLAG || - bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && - !holders.length - ) { - result = createPartial(func, bitmask, thisArg, partials) - } else { - result = createHybrid.apply(undefined$1, newData) - } - var setter = data ? baseSetData : setData - return setWrapToString(setter(result, newData), func, bitmask) - } - - /** - * Used by `_.defaults` to customize its `_.assignIn` use to assign properties - * of source objects to the destination object for all destination properties - * that resolve to `undefined`. - * - * @private - * @param {*} objValue The destination value. - * @param {*} srcValue The source value. - * @param {string} key The key of the property to assign. - * @param {Object} object The parent object of `objValue`. - * @returns {*} Returns the value to assign. - */ - function customDefaultsAssignIn(objValue, srcValue, key, object) { - if ( - objValue === undefined$1 || - (eq(objValue, objectProto[key]) && - !hasOwnProperty.call(object, key)) - ) { - return srcValue - } - return objValue - } - - /** - * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source - * objects into destination objects that are passed thru. - * - * @private - * @param {*} objValue The destination value. - * @param {*} srcValue The source value. - * @param {string} key The key of the property to merge. - * @param {Object} object The parent object of `objValue`. - * @param {Object} source The parent object of `srcValue`. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - * @returns {*} Returns the value to assign. - */ - function customDefaultsMerge( - objValue, - srcValue, - key, - object, - source, - stack - ) { - if (isObject(objValue) && isObject(srcValue)) { - // Recursively merge objects and arrays (susceptible to call stack limits). - stack.set(srcValue, objValue) - baseMerge( - objValue, - srcValue, - undefined$1, - customDefaultsMerge, - stack - ) - stack["delete"](srcValue) - } - return objValue - } - - /** - * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain - * objects. - * - * @private - * @param {*} value The value to inspect. - * @param {string} key The key of the property to inspect. - * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. - */ - function customOmitClone(value) { - return isPlainObject(value) ? undefined$1 : value - } - - /** - * A specialized version of `baseIsEqualDeep` for arrays with support for - * partial deep comparisons. - * - * @private - * @param {Array} array The array to compare. - * @param {Array} other The other array to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `array` and `other` objects. - * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. - */ - function equalArrays( - array, - other, - bitmask, - customizer, - equalFunc, - stack - ) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - arrLength = array.length, - othLength = other.length - - if (arrLength != othLength && !(isPartial && othLength > arrLength)) { - return false - } - // Assume cyclic values are equal. - var stacked = stack.get(array) - if (stacked && stack.get(other)) { - return stacked == other - } - var index = -1, - result = true, - seen = - bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined$1 - - stack.set(array, other) - stack.set(other, array) - - // Ignore non-index properties. - while (++index < arrLength) { - var arrValue = array[index], - othValue = other[index] - - if (customizer) { - var compared = isPartial - ? customizer(othValue, arrValue, index, other, array, stack) - : customizer(arrValue, othValue, index, array, other, stack) - } - if (compared !== undefined$1) { - if (compared) { - continue - } - result = false - break - } - // Recursively compare arrays (susceptible to call stack limits). - if (seen) { - if ( - !arraySome(other, function(othValue, othIndex) { - if ( - !cacheHas(seen, othIndex) && - (arrValue === othValue || - equalFunc(arrValue, othValue, bitmask, customizer, stack)) - ) { - return seen.push(othIndex) - } - }) - ) { - result = false - break - } - } else if ( - !( - arrValue === othValue || - equalFunc(arrValue, othValue, bitmask, customizer, stack) - ) - ) { - result = false - break - } - } - stack["delete"](array) - stack["delete"](other) - return result - } - - /** - * A specialized version of `baseIsEqualDeep` for comparing objects of - * the same `toStringTag`. - * - * **Note:** This function only supports comparing values with tags of - * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {string} tag The `toStringTag` of the objects to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function equalByTag( - object, - other, - tag, - bitmask, - customizer, - equalFunc, - stack - ) { - switch (tag) { - case dataViewTag: - if ( - object.byteLength != other.byteLength || - object.byteOffset != other.byteOffset - ) { - return false - } - object = object.buffer - other = other.buffer - - case arrayBufferTag: - if ( - object.byteLength != other.byteLength || - !equalFunc(new Uint8Array(object), new Uint8Array(other)) - ) { - return false - } - return true - - case boolTag: - case dateTag: - case numberTag: - // Coerce booleans to `1` or `0` and dates to milliseconds. - // Invalid dates are coerced to `NaN`. - return eq(+object, +other) - - case errorTag: - return ( - object.name == other.name && object.message == other.message - ) - - case regexpTag: - case stringTag: - // Coerce regexes to strings and treat strings, primitives and objects, - // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring - // for more details. - return object == other + "" - - case mapTag: - var convert = mapToArray - - case setTag: - var isPartial = bitmask & COMPARE_PARTIAL_FLAG - convert || (convert = setToArray) - - if (object.size != other.size && !isPartial) { - return false - } - // Assume cyclic values are equal. - var stacked = stack.get(object) - if (stacked) { - return stacked == other - } - bitmask |= COMPARE_UNORDERED_FLAG - - // Recursively compare objects (susceptible to call stack limits). - stack.set(object, other) - var result = equalArrays( - convert(object), - convert(other), - bitmask, - customizer, - equalFunc, - stack - ) - stack["delete"](object) - return result - - case symbolTag: - if (symbolValueOf) { - return symbolValueOf.call(object) == symbolValueOf.call(other) - } - } - return false - } - - /** - * A specialized version of `baseIsEqualDeep` for objects with support for - * partial deep comparisons. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function equalObjects( - object, - other, - bitmask, - customizer, - equalFunc, - stack - ) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - objProps = getAllKeys(object), - objLength = objProps.length, - othProps = getAllKeys(other), - othLength = othProps.length - - if (objLength != othLength && !isPartial) { - return false - } - var index = objLength - while (index--) { - var key = objProps[index] - if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { - return false - } - } - // Assume cyclic values are equal. - var stacked = stack.get(object) - if (stacked && stack.get(other)) { - return stacked == other - } - var result = true - stack.set(object, other) - stack.set(other, object) - - var skipCtor = isPartial - while (++index < objLength) { - key = objProps[index] - var objValue = object[key], - othValue = other[key] - - if (customizer) { - var compared = isPartial - ? customizer(othValue, objValue, key, other, object, stack) - : customizer(objValue, othValue, key, object, other, stack) - } - // Recursively compare objects (susceptible to call stack limits). - if ( - !(compared === undefined$1 - ? objValue === othValue || - equalFunc(objValue, othValue, bitmask, customizer, stack) - : compared) - ) { - result = false - break - } - skipCtor || (skipCtor = key == "constructor") - } - if (result && !skipCtor) { - var objCtor = object.constructor, - othCtor = other.constructor - - // Non `Object` object instances with different constructors are not equal. - if ( - objCtor != othCtor && - "constructor" in object && "constructor" in other && - !( - typeof objCtor == "function" && - objCtor instanceof objCtor && - typeof othCtor == "function" && - othCtor instanceof othCtor - ) - ) { - result = false - } - } - stack["delete"](object) - stack["delete"](other) - return result - } - - /** - * A specialized version of `baseRest` which flattens the rest array. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @returns {Function} Returns the new function. - */ - function flatRest(func) { - return setToString(overRest(func, undefined$1, flatten), func + "") - } - - /** - * Creates an array of own enumerable property names and symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names and symbols. - */ - function getAllKeys(object) { - return baseGetAllKeys(object, keys, getSymbols) - } - - /** - * Creates an array of own and inherited enumerable property names and - * symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names and symbols. - */ - function getAllKeysIn(object) { - return baseGetAllKeys(object, keysIn, getSymbolsIn) - } - - /** - * Gets metadata for `func`. - * - * @private - * @param {Function} func The function to query. - * @returns {*} Returns the metadata for `func`. - */ - var getData = !metaMap - ? noop - : function(func) { - return metaMap.get(func) - } - - /** - * Gets the name of `func`. - * - * @private - * @param {Function} func The function to query. - * @returns {string} Returns the function name. - */ - function getFuncName(func) { - var result = func.name + "", - array = realNames[result], - length = hasOwnProperty.call(realNames, result) ? array.length : 0 - - while (length--) { - var data = array[length], - otherFunc = data.func - if (otherFunc == null || otherFunc == func) { - return data.name - } - } - return result - } - - /** - * Gets the argument placeholder value for `func`. - * - * @private - * @param {Function} func The function to inspect. - * @returns {*} Returns the placeholder value. - */ - function getHolder(func) { - var object = hasOwnProperty.call(lodash, "placeholder") - ? lodash - : func - return object.placeholder - } - - /** - * Gets the appropriate "iteratee" function. If `_.iteratee` is customized, - * this function returns the custom method, otherwise it returns `baseIteratee`. - * If arguments are provided, the chosen function is invoked with them and - * its result is returned. - * - * @private - * @param {*} [value] The value to convert to an iteratee. - * @param {number} [arity] The arity of the created iteratee. - * @returns {Function} Returns the chosen function or its result. - */ - function getIteratee() { - var result = lodash.iteratee || iteratee - result = result === iteratee ? baseIteratee : result - return arguments.length ? result(arguments[0], arguments[1]) : result - } - - /** - * Gets the data for `map`. - * - * @private - * @param {Object} map The map to query. - * @param {string} key The reference key. - * @returns {*} Returns the map data. - */ - function getMapData(map, key) { - var data = map.__data__ - return isKeyable(key) - ? data[typeof key == "string" ? "string" : "hash"] - : data.map - } - - /** - * Gets the property names, values, and compare flags of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the match data of `object`. - */ - function getMatchData(object) { - var result = keys(object), - length = result.length - - while (length--) { - var key = result[length], - value = object[key] - - result[length] = [key, value, isStrictComparable(value)] - } - return result - } - - /** - * Gets the native function at `key` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the method to get. - * @returns {*} Returns the function if it's native, else `undefined`. - */ - function getNative(object, key) { - var value = getValue(object, key) - return baseIsNative(value) ? value : undefined$1 - } - - /** - * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the raw `toStringTag`. - */ - function getRawTag(value) { - var isOwn = hasOwnProperty.call(value, symToStringTag), - tag = value[symToStringTag] - - try { - value[symToStringTag] = undefined$1 - var unmasked = true - } catch (e) {} - - var result = nativeObjectToString.call(value) - if (unmasked) { - if (isOwn) { - value[symToStringTag] = tag - } else { - delete value[symToStringTag] - } - } - return result - } - - /** - * Creates an array of the own enumerable symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. - */ - var getSymbols = !nativeGetSymbols - ? stubArray - : function(object) { - if (object == null) { - return [] - } - object = Object(object) - return arrayFilter(nativeGetSymbols(object), function(symbol) { - return propertyIsEnumerable.call(object, symbol) - }) - } - - /** - * Creates an array of the own and inherited enumerable symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. - */ - var getSymbolsIn = !nativeGetSymbols - ? stubArray - : function(object) { - var result = [] - while (object) { - arrayPush(result, getSymbols(object)) - object = getPrototype(object) - } - return result - } - - /** - * Gets the `toStringTag` of `value`. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ - var getTag = baseGetTag - - // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. - if ( - (DataView && - getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || - (Map && getTag(new Map()) != mapTag) || - (Promise && getTag(Promise.resolve()) != promiseTag) || - (Set && getTag(new Set()) != setTag) || - (WeakMap && getTag(new WeakMap()) != weakMapTag) - ) { - getTag = function(value) { - var result = baseGetTag(value), - Ctor = result == objectTag ? value.constructor : undefined$1, - ctorString = Ctor ? toSource(Ctor) : "" - - if (ctorString) { - switch (ctorString) { - case dataViewCtorString: - return dataViewTag - case mapCtorString: - return mapTag - case promiseCtorString: - return promiseTag - case setCtorString: - return setTag - case weakMapCtorString: - return weakMapTag - } - } - return result - } - } - - /** - * Gets the view, applying any `transforms` to the `start` and `end` positions. - * - * @private - * @param {number} start The start of the view. - * @param {number} end The end of the view. - * @param {Array} transforms The transformations to apply to the view. - * @returns {Object} Returns an object containing the `start` and `end` - * positions of the view. - */ - function getView(start, end, transforms) { - var index = -1, - length = transforms.length - - while (++index < length) { - var data = transforms[index], - size = data.size - - switch (data.type) { - case "drop": - start += size - break - case "dropRight": - end -= size - break - case "take": - end = nativeMin(end, start + size) - break - case "takeRight": - start = nativeMax(start, end - size) - break - } - } - return { start: start, end: end } - } - - /** - * Extracts wrapper details from the `source` body comment. - * - * @private - * @param {string} source The source to inspect. - * @returns {Array} Returns the wrapper details. - */ - function getWrapDetails(source) { - var match = source.match(reWrapDetails) - return match ? match[1].split(reSplitDetails) : [] - } - - /** - * Checks if `path` exists on `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @param {Function} hasFunc The function to check properties. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - */ - function hasPath(object, path, hasFunc) { - path = castPath(path, object) - - var index = -1, - length = path.length, - result = false - - while (++index < length) { - var key = toKey(path[index]) - if (!(result = object != null && hasFunc(object, key))) { - break - } - object = object[key] - } - if (result || ++index != length) { - return result - } - length = object == null ? 0 : object.length - return ( - !!length && - isLength(length) && - isIndex(key, length) && - (isArray(object) || isArguments(object)) - ) - } - - /** - * Initializes an array clone. - * - * @private - * @param {Array} array The array to clone. - * @returns {Array} Returns the initialized clone. - */ - function initCloneArray(array) { - var length = array.length, - result = new array.constructor(length) - - // Add properties assigned by `RegExp#exec`. - if ( - length && - typeof array[0] == "string" && - hasOwnProperty.call(array, "index") - ) { - result.index = array.index - result.input = array.input - } - return result - } - - /** - * Initializes an object clone. - * - * @private - * @param {Object} object The object to clone. - * @returns {Object} Returns the initialized clone. - */ - function initCloneObject(object) { - return typeof object.constructor == "function" && !isPrototype(object) - ? baseCreate(getPrototype(object)) - : {} - } - - /** - * Initializes an object clone based on its `toStringTag`. - * - * **Note:** This function only supports cloning values with tags of - * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. - * - * @private - * @param {Object} object The object to clone. - * @param {string} tag The `toStringTag` of the object to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the initialized clone. - */ - function initCloneByTag(object, tag, isDeep) { - var Ctor = object.constructor - switch (tag) { - case arrayBufferTag: - return cloneArrayBuffer(object) - - case boolTag: - case dateTag: - return new Ctor(+object) - - case dataViewTag: - return cloneDataView(object, isDeep) - - case float32Tag: - case float64Tag: - case int8Tag: - case int16Tag: - case int32Tag: - case uint8Tag: - case uint8ClampedTag: - case uint16Tag: - case uint32Tag: - return cloneTypedArray(object, isDeep) - - case mapTag: - return new Ctor() - - case numberTag: - case stringTag: - return new Ctor(object) - - case regexpTag: - return cloneRegExp(object) - - case setTag: - return new Ctor() - - case symbolTag: - return cloneSymbol(object) - } - } - - /** - * Inserts wrapper `details` in a comment at the top of the `source` body. - * - * @private - * @param {string} source The source to modify. - * @returns {Array} details The details to insert. - * @returns {string} Returns the modified source. - */ - function insertWrapDetails(source, details) { - var length = details.length - if (!length) { - return source - } - var lastIndex = length - 1 - details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex] - details = details.join(length > 2 ? ", " : " ") - return source.replace( - reWrapComment, - "{\n/* [wrapped with " + details + "] */\n" - ) - } - - /** - * Checks if `value` is a flattenable `arguments` object or array. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. - */ - function isFlattenable(value) { - return ( - isArray(value) || - isArguments(value) || - !!(spreadableSymbol && value && value[spreadableSymbol]) - ) - } - - /** - * Checks if `value` is a valid array-like index. - * - * @private - * @param {*} value The value to check. - * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. - * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. - */ - function isIndex(value, length) { - var type = typeof value - length = length == null ? MAX_SAFE_INTEGER : length - - return ( - !!length && - (type == "number" || (type != "symbol" && reIsUint.test(value))) && - value > -1 && value % 1 == 0 && value < length - ) - } - - /** - * Checks if the given arguments are from an iteratee call. - * - * @private - * @param {*} value The potential iteratee value argument. - * @param {*} index The potential iteratee index or key argument. - * @param {*} object The potential iteratee object argument. - * @returns {boolean} Returns `true` if the arguments are from an iteratee call, - * else `false`. - */ - function isIterateeCall(value, index, object) { - if (!isObject(object)) { - return false - } - var type = typeof index - if ( - type == "number" - ? isArrayLike(object) && isIndex(index, object.length) - : type == "string" && index in object - ) { - return eq(object[index], value) - } - return false - } - - /** - * Checks if `value` is a property name and not a property path. - * - * @private - * @param {*} value The value to check. - * @param {Object} [object] The object to query keys on. - * @returns {boolean} Returns `true` if `value` is a property name, else `false`. - */ - function isKey(value, object) { - if (isArray(value)) { - return false - } - var type = typeof value - if ( - type == "number" || - type == "symbol" || - type == "boolean" || - value == null || - isSymbol(value) - ) { - return true - } - return ( - reIsPlainProp.test(value) || - !reIsDeepProp.test(value) || - (object != null && value in Object(object)) - ) - } - - /** - * Checks if `value` is suitable for use as unique object key. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is suitable, else `false`. - */ - function isKeyable(value) { - var type = typeof value - return type == "string" || - type == "number" || - type == "symbol" || - type == "boolean" - ? value !== "__proto__" - : value === null - } - - /** - * Checks if `func` has a lazy counterpart. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` has a lazy counterpart, - * else `false`. - */ - function isLaziable(func) { - var funcName = getFuncName(func), - other = lodash[funcName] - - if ( - typeof other != "function" || - !(funcName in LazyWrapper.prototype) - ) { - return false - } - if (func === other) { - return true - } - var data = getData(other) - return !!data && func === data[0] - } - - /** - * Checks if `func` has its source masked. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` is masked, else `false`. - */ - function isMasked(func) { - return !!maskSrcKey && maskSrcKey in func - } - - /** - * Checks if `func` is capable of being masked. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `func` is maskable, else `false`. - */ - var isMaskable = coreJsData ? isFunction : stubFalse - - /** - * Checks if `value` is likely a prototype object. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. - */ - function isPrototype(value) { - var Ctor = value && value.constructor, - proto = (typeof Ctor == "function" && Ctor.prototype) || objectProto - - return value === proto - } - - /** - * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` if suitable for strict - * equality comparisons, else `false`. - */ - function isStrictComparable(value) { - return value === value && !isObject(value) - } - - /** - * A specialized version of `matchesProperty` for source values suitable - * for strict equality comparisons, i.e. `===`. - * - * @private - * @param {string} key The key of the property to get. - * @param {*} srcValue The value to match. - * @returns {Function} Returns the new spec function. - */ - function matchesStrictComparable(key, srcValue) { - return function(object) { - if (object == null) { - return false - } - return ( - object[key] === srcValue && - (srcValue !== undefined$1 || key in Object(object)) - ) - } - } - - /** - * A specialized version of `_.memoize` which clears the memoized function's - * cache when it exceeds `MAX_MEMOIZE_SIZE`. - * - * @private - * @param {Function} func The function to have its output memoized. - * @returns {Function} Returns the new memoized function. - */ - function memoizeCapped(func) { - var result = memoize(func, function(key) { - if (cache.size === MAX_MEMOIZE_SIZE) { - cache.clear() - } - return key - }) - - var cache = result.cache - return result - } - - /** - * Merges the function metadata of `source` into `data`. - * - * Merging metadata reduces the number of wrappers used to invoke a function. - * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` - * may be applied regardless of execution order. Methods like `_.ary` and - * `_.rearg` modify function arguments, making the order in which they are - * executed important, preventing the merging of metadata. However, we make - * an exception for a safe combined case where curried functions have `_.ary` - * and or `_.rearg` applied. - * - * @private - * @param {Array} data The destination metadata. - * @param {Array} source The source metadata. - * @returns {Array} Returns `data`. - */ - function mergeData(data, source) { - var bitmask = data[1], - srcBitmask = source[1], - newBitmask = bitmask | srcBitmask, - isCommon = - newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG) - - var isCombo = - (srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG) || - (srcBitmask == WRAP_ARY_FLAG && - bitmask == WRAP_REARG_FLAG && - data[7].length <= source[8]) || - (srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && - source[7].length <= source[8] && - bitmask == WRAP_CURRY_FLAG) - - // Exit early if metadata can't be merged. - if (!(isCommon || isCombo)) { - return data - } - // Use source `thisArg` if available. - if (srcBitmask & WRAP_BIND_FLAG) { - data[2] = source[2] - // Set when currying a bound function. - newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG - } - // Compose partial arguments. - var value = source[3] - if (value) { - var partials = data[3] - data[3] = partials ? composeArgs(partials, value, source[4]) : value - data[4] = partials - ? replaceHolders(data[3], PLACEHOLDER) - : source[4] - } - // Compose partial right arguments. - value = source[5] - if (value) { - partials = data[5] - data[5] = partials - ? composeArgsRight(partials, value, source[6]) - : value - data[6] = partials - ? replaceHolders(data[5], PLACEHOLDER) - : source[6] - } - // Use source `argPos` if available. - value = source[7] - if (value) { - data[7] = value - } - // Use source `ary` if it's smaller. - if (srcBitmask & WRAP_ARY_FLAG) { - data[8] = - data[8] == null ? source[8] : nativeMin(data[8], source[8]) - } - // Use source `arity` if one is not provided. - if (data[9] == null) { - data[9] = source[9] - } - // Use source `func` and merge bitmasks. - data[0] = source[0] - data[1] = newBitmask - - return data - } - - /** - * This function is like - * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * except that it includes inherited enumerable properties. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function nativeKeysIn(object) { - var result = [] - if (object != null) { - for (var key in Object(object)) { - result.push(key) - } - } - return result - } - - /** - * Converts `value` to a string using `Object.prototype.toString`. - * - * @private - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - */ - function objectToString(value) { - return nativeObjectToString.call(value) - } - - /** - * A specialized version of `baseRest` which transforms the rest array. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @param {Function} transform The rest array transform. - * @returns {Function} Returns the new function. - */ - function overRest(func, start, transform) { - start = nativeMax(start === undefined$1 ? func.length - 1 : start, 0) - return function() { - var args = arguments, - index = -1, - length = nativeMax(args.length - start, 0), - array = Array(length) - - while (++index < length) { - array[index] = args[start + index] - } - index = -1 - var otherArgs = Array(start + 1) - while (++index < start) { - otherArgs[index] = args[index] - } - otherArgs[start] = transform(array) - return apply(func, this, otherArgs) - } - } - - /** - * Gets the parent value at `path` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} path The path to get the parent value of. - * @returns {*} Returns the parent value. - */ - function parent(object, path) { - return path.length < 2 - ? object - : baseGet(object, baseSlice(path, 0, -1)) - } - - /** - * Reorder `array` according to the specified indexes where the element at - * the first index is assigned as the first element, the element at - * the second index is assigned as the second element, and so on. - * - * @private - * @param {Array} array The array to reorder. - * @param {Array} indexes The arranged array indexes. - * @returns {Array} Returns `array`. - */ - function reorder(array, indexes) { - var arrLength = array.length, - length = nativeMin(indexes.length, arrLength), - oldArray = copyArray(array) - - while (length--) { - var index = indexes[length] - array[length] = isIndex(index, arrLength) - ? oldArray[index] - : undefined$1 - } - return array - } - - /** - * Gets the value at `key`, unless `key` is "__proto__" or "constructor". - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ - function safeGet(object, key) { - if (key === "constructor" && typeof object[key] === "function") { - return - } - - if (key == "__proto__") { - return - } - - return object[key] - } - - /** - * Sets metadata for `func`. - * - * **Note:** If this function becomes hot, i.e. is invoked a lot in a short - * period of time, it will trip its breaker and transition to an identity - * function to avoid garbage collection pauses in V8. See - * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070) - * for more details. - * - * @private - * @param {Function} func The function to associate metadata with. - * @param {*} data The metadata. - * @returns {Function} Returns `func`. - */ - var setData = shortOut(baseSetData) - - /** - * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout). - * - * @private - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @returns {number|Object} Returns the timer id or timeout object. - */ - var setTimeout = - ctxSetTimeout || - function(func, wait) { - return root.setTimeout(func, wait) - } - - /** - * Sets the `toString` method of `func` to return `string`. - * - * @private - * @param {Function} func The function to modify. - * @param {Function} string The `toString` result. - * @returns {Function} Returns `func`. - */ - var setToString = shortOut(baseSetToString) - - /** - * Sets the `toString` method of `wrapper` to mimic the source of `reference` - * with wrapper details in a comment at the top of the source body. - * - * @private - * @param {Function} wrapper The function to modify. - * @param {Function} reference The reference function. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @returns {Function} Returns `wrapper`. - */ - function setWrapToString(wrapper, reference, bitmask) { - var source = reference + "" - return setToString( - wrapper, - insertWrapDetails( - source, - updateWrapDetails(getWrapDetails(source), bitmask) - ) - ) - } - - /** - * Creates a function that'll short out and invoke `identity` instead - * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` - * milliseconds. - * - * @private - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new shortable function. - */ - function shortOut(func) { - var count = 0, - lastCalled = 0 - - return function() { - var stamp = nativeNow(), - remaining = HOT_SPAN - (stamp - lastCalled) - - lastCalled = stamp - if (remaining > 0) { - if (++count >= HOT_COUNT) { - return arguments[0] - } - } else { - count = 0 - } - return func.apply(undefined$1, arguments) - } - } - - /** - * A specialized version of `_.shuffle` which mutates and sets the size of `array`. - * - * @private - * @param {Array} array The array to shuffle. - * @param {number} [size=array.length] The size of `array`. - * @returns {Array} Returns `array`. - */ - function shuffleSelf(array, size) { - var index = -1, - length = array.length, - lastIndex = length - 1 - - size = size === undefined$1 ? length : size - while (++index < size) { - var rand = baseRandom(index, lastIndex), - value = array[rand] - - array[rand] = array[index] - array[index] = value - } - array.length = size - return array - } - - /** - * Converts `string` to a property path array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the property path array. - */ - var stringToPath = memoizeCapped(function(string) { - var result = [] - if (string.charCodeAt(0) === 46 /* . */) { - result.push("") - } - string.replace(rePropName, function(match, number, quote, subString) { - result.push( - quote ? subString.replace(reEscapeChar, "$1") : number || match - ) - }) - return result - }) - - /** - * Converts `value` to a string key if it's not a string or symbol. - * - * @private - * @param {*} value The value to inspect. - * @returns {string|symbol} Returns the key. - */ - function toKey(value) { - if (typeof value == "string" || isSymbol(value)) { - return value - } - var result = value + "" - return result == "0" && 1 / value == -INFINITY ? "-0" : result - } - - /** - * Converts `func` to its source code. - * - * @private - * @param {Function} func The function to convert. - * @returns {string} Returns the source code. - */ - function toSource(func) { - if (func != null) { - try { - return funcToString.call(func) - } catch (e) {} - try { - return func + "" - } catch (e) {} - } - return "" - } - - /** - * Updates wrapper `details` based on `bitmask` flags. - * - * @private - * @returns {Array} details The details to modify. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @returns {Array} Returns `details`. - */ - function updateWrapDetails(details, bitmask) { - arrayEach(wrapFlags, function(pair) { - var value = "_." + pair[0] - if (bitmask & pair[1] && !arrayIncludes(details, value)) { - details.push(value) - } - }) - return details.sort() - } - - /** - * Creates a clone of `wrapper`. - * - * @private - * @param {Object} wrapper The wrapper to clone. - * @returns {Object} Returns the cloned wrapper. - */ - function wrapperClone(wrapper) { - if (wrapper instanceof LazyWrapper) { - return wrapper.clone() - } - var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__) - result.__actions__ = copyArray(wrapper.__actions__) - result.__index__ = wrapper.__index__ - result.__values__ = wrapper.__values__ - return result - } - - /*------------------------------------------------------------------------*/ - - /** - * Creates an array of elements split into groups the length of `size`. - * If `array` can't be split evenly, the final chunk will be the remaining - * elements. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to process. - * @param {number} [size=1] The length of each chunk - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the new array of chunks. - * @example - * - * _.chunk(['a', 'b', 'c', 'd'], 2); - * // => [['a', 'b'], ['c', 'd']] - * - * _.chunk(['a', 'b', 'c', 'd'], 3); - * // => [['a', 'b', 'c'], ['d']] - */ - function chunk(array, size, guard) { - if ( - guard ? isIterateeCall(array, size, guard) : size === undefined$1 - ) { - size = 1 - } else { - size = nativeMax(toInteger(size), 0) - } - var length = array == null ? 0 : array.length - if (!length || size < 1) { - return [] - } - var index = 0, - resIndex = 0, - result = Array(nativeCeil(length / size)) - - while (index < length) { - result[resIndex++] = baseSlice(array, index, (index += size)) - } - return result - } - - /** - * Creates an array with all falsey values removed. The values `false`, `null`, - * `0`, `""`, `undefined`, and `NaN` are falsey. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to compact. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.compact([0, 1, false, 2, '', 3]); - * // => [1, 2, 3] - */ - function compact(array) { - var index = -1, - length = array == null ? 0 : array.length, - resIndex = 0, - result = [] - - while (++index < length) { - var value = array[index] - if (value) { - result[resIndex++] = value - } - } - return result - } - - /** - * Creates a new array concatenating `array` with any additional arrays - * and/or values. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to concatenate. - * @param {...*} [values] The values to concatenate. - * @returns {Array} Returns the new concatenated array. - * @example - * - * var array = [1]; - * var other = _.concat(array, 2, [3], [[4]]); - * - * console.log(other); - * // => [1, 2, 3, [4]] - * - * console.log(array); - * // => [1] - */ - function concat() { - var length = arguments.length - if (!length) { - return [] - } - var args = Array(length - 1), - array = arguments[0], - index = length - - while (index--) { - args[index - 1] = arguments[index] - } - return arrayPush( - isArray(array) ? copyArray(array) : [array], - baseFlatten(args, 1) - ) - } - - /** - * Creates an array of `array` values not included in the other given arrays - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. The order and references of result values are - * determined by the first array. - * - * **Note:** Unlike `_.pullAll`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @returns {Array} Returns the new array of filtered values. - * @see _.without, _.xor - * @example - * - * _.difference([2, 1], [2, 3]); - * // => [1] - */ - var difference = baseRest(function(array, values) { - return isArrayLikeObject(array) - ? baseDifference( - array, - baseFlatten(values, 1, isArrayLikeObject, true) - ) - : [] - }) - - /** - * This method is like `_.difference` except that it accepts `iteratee` which - * is invoked for each element of `array` and `values` to generate the criterion - * by which they're compared. The order and references of result values are - * determined by the first array. The iteratee is invoked with one argument: - * (value). - * - * **Note:** Unlike `_.pullAllBy`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [1.2] - * - * // The `_.property` iteratee shorthand. - * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); - * // => [{ 'x': 2 }] - */ - var differenceBy = baseRest(function(array, values) { - var iteratee = last(values) - if (isArrayLikeObject(iteratee)) { - iteratee = undefined$1 - } - return isArrayLikeObject(array) - ? baseDifference( - array, - baseFlatten(values, 1, isArrayLikeObject, true), - getIteratee(iteratee, 2) - ) - : [] - }) - - /** - * This method is like `_.difference` except that it accepts `comparator` - * which is invoked to compare elements of `array` to `values`. The order and - * references of result values are determined by the first array. The comparator - * is invoked with two arguments: (arrVal, othVal). - * - * **Note:** Unlike `_.pullAllWith`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * - * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); - * // => [{ 'x': 2, 'y': 1 }] - */ - var differenceWith = baseRest(function(array, values) { - var comparator = last(values) - if (isArrayLikeObject(comparator)) { - comparator = undefined$1 - } - return isArrayLikeObject(array) - ? baseDifference( - array, - baseFlatten(values, 1, isArrayLikeObject, true), - undefined$1, - comparator - ) - : [] - }) - - /** - * Creates a slice of `array` with `n` elements dropped from the beginning. - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to drop. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.drop([1, 2, 3]); - * // => [2, 3] - * - * _.drop([1, 2, 3], 2); - * // => [3] - * - * _.drop([1, 2, 3], 5); - * // => [] - * - * _.drop([1, 2, 3], 0); - * // => [1, 2, 3] - */ - function drop(array, n, guard) { - var length = array == null ? 0 : array.length - if (!length) { - return [] - } - n = guard || n === undefined$1 ? 1 : toInteger(n) - return baseSlice(array, n < 0 ? 0 : n, length) - } - - /** - * Creates a slice of `array` with `n` elements dropped from the end. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to drop. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.dropRight([1, 2, 3]); - * // => [1, 2] - * - * _.dropRight([1, 2, 3], 2); - * // => [1] - * - * _.dropRight([1, 2, 3], 5); - * // => [] - * - * _.dropRight([1, 2, 3], 0); - * // => [1, 2, 3] - */ - function dropRight(array, n, guard) { - var length = array == null ? 0 : array.length - if (!length) { - return [] - } - n = guard || n === undefined$1 ? 1 : toInteger(n) - n = length - n - return baseSlice(array, 0, n < 0 ? 0 : n) - } - - /** - * Creates a slice of `array` excluding elements dropped from the end. - * Elements are dropped until `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.dropRightWhile(users, function(o) { return !o.active; }); - * // => objects for ['barney'] - * - * // The `_.matches` iteratee shorthand. - * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }); - * // => objects for ['barney', 'fred'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.dropRightWhile(users, ['active', false]); - * // => objects for ['barney'] - * - * // The `_.property` iteratee shorthand. - * _.dropRightWhile(users, 'active'); - * // => objects for ['barney', 'fred', 'pebbles'] - */ - function dropRightWhile(array, predicate) { - return array && array.length - ? baseWhile(array, getIteratee(predicate, 3), true, true) - : [] - } - - /** - * Creates a slice of `array` excluding elements dropped from the beginning. - * Elements are dropped until `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.dropWhile(users, function(o) { return !o.active; }); - * // => objects for ['pebbles'] - * - * // The `_.matches` iteratee shorthand. - * _.dropWhile(users, { 'user': 'barney', 'active': false }); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.dropWhile(users, ['active', false]); - * // => objects for ['pebbles'] - * - * // The `_.property` iteratee shorthand. - * _.dropWhile(users, 'active'); - * // => objects for ['barney', 'fred', 'pebbles'] - */ - function dropWhile(array, predicate) { - return array && array.length - ? baseWhile(array, getIteratee(predicate, 3), true) - : [] - } - - /** - * Fills elements of `array` with `value` from `start` up to, but not - * including, `end`. - * - * **Note:** This method mutates `array`. - * - * @static - * @memberOf _ - * @since 3.2.0 - * @category Array - * @param {Array} array The array to fill. - * @param {*} value The value to fill `array` with. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns `array`. - * @example - * - * var array = [1, 2, 3]; - * - * _.fill(array, 'a'); - * console.log(array); - * // => ['a', 'a', 'a'] - * - * _.fill(Array(3), 2); - * // => [2, 2, 2] - * - * _.fill([4, 6, 8, 10], '*', 1, 3); - * // => [4, '*', '*', 10] - */ - function fill(array, value, start, end) { - var length = array == null ? 0 : array.length - if (!length) { - return [] - } - if ( - start && - typeof start != "number" && - isIterateeCall(array, value, start) - ) { - start = 0 - end = length - } - return baseFill(array, value, start, end) - } - - /** - * This method is like `_.find` except that it returns the index of the first - * element `predicate` returns truthy for instead of the element itself. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=0] The index to search from. - * @returns {number} Returns the index of the found element, else `-1`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.findIndex(users, function(o) { return o.user == 'barney'; }); - * // => 0 - * - * // The `_.matches` iteratee shorthand. - * _.findIndex(users, { 'user': 'fred', 'active': false }); - * // => 1 - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findIndex(users, ['active', false]); - * // => 0 - * - * // The `_.property` iteratee shorthand. - * _.findIndex(users, 'active'); - * // => 2 - */ - function findIndex(array, predicate, fromIndex) { - var length = array == null ? 0 : array.length - if (!length) { - return -1 - } - var index = fromIndex == null ? 0 : toInteger(fromIndex) - if (index < 0) { - index = nativeMax(length + index, 0) - } - return baseFindIndex(array, getIteratee(predicate, 3), index) - } - - /** - * This method is like `_.findIndex` except that it iterates over elements - * of `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=array.length-1] The index to search from. - * @returns {number} Returns the index of the found element, else `-1`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }); - * // => 2 - * - * // The `_.matches` iteratee shorthand. - * _.findLastIndex(users, { 'user': 'barney', 'active': true }); - * // => 0 - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findLastIndex(users, ['active', false]); - * // => 2 - * - * // The `_.property` iteratee shorthand. - * _.findLastIndex(users, 'active'); - * // => 0 - */ - function findLastIndex(array, predicate, fromIndex) { - var length = array == null ? 0 : array.length - if (!length) { - return -1 - } - var index = length - 1 - if (fromIndex !== undefined$1) { - index = toInteger(fromIndex) - index = - fromIndex < 0 - ? nativeMax(length + index, 0) - : nativeMin(index, length - 1) - } - return baseFindIndex(array, getIteratee(predicate, 3), index, true) - } - - /** - * Flattens `array` a single level deep. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to flatten. - * @returns {Array} Returns the new flattened array. - * @example - * - * _.flatten([1, [2, [3, [4]], 5]]); - * // => [1, 2, [3, [4]], 5] - */ - function flatten(array) { - var length = array == null ? 0 : array.length - return length ? baseFlatten(array, 1) : [] - } - - /** - * Recursively flattens `array`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to flatten. - * @returns {Array} Returns the new flattened array. - * @example - * - * _.flattenDeep([1, [2, [3, [4]], 5]]); - * // => [1, 2, 3, 4, 5] - */ - function flattenDeep(array) { - var length = array == null ? 0 : array.length - return length ? baseFlatten(array, INFINITY) : [] - } - - /** - * Recursively flatten `array` up to `depth` times. - * - * @static - * @memberOf _ - * @since 4.4.0 - * @category Array - * @param {Array} array The array to flatten. - * @param {number} [depth=1] The maximum recursion depth. - * @returns {Array} Returns the new flattened array. - * @example - * - * var array = [1, [2, [3, [4]], 5]]; - * - * _.flattenDepth(array, 1); - * // => [1, 2, [3, [4]], 5] - * - * _.flattenDepth(array, 2); - * // => [1, 2, 3, [4], 5] - */ - function flattenDepth(array, depth) { - var length = array == null ? 0 : array.length - if (!length) { - return [] - } - depth = depth === undefined$1 ? 1 : toInteger(depth) - return baseFlatten(array, depth) - } - - /** - * The inverse of `_.toPairs`; this method returns an object composed - * from key-value `pairs`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} pairs The key-value pairs. - * @returns {Object} Returns the new object. - * @example - * - * _.fromPairs([['a', 1], ['b', 2]]); - * // => { 'a': 1, 'b': 2 } - */ - function fromPairs(pairs) { - var index = -1, - length = pairs == null ? 0 : pairs.length, - result = {} - - while (++index < length) { - var pair = pairs[index] - result[pair[0]] = pair[1] - } - return result - } - - /** - * Gets the first element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @alias first - * @category Array - * @param {Array} array The array to query. - * @returns {*} Returns the first element of `array`. - * @example - * - * _.head([1, 2, 3]); - * // => 1 - * - * _.head([]); - * // => undefined - */ - function head(array) { - return array && array.length ? array[0] : undefined$1 - } - - /** - * Gets the index at which the first occurrence of `value` is found in `array` - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. If `fromIndex` is negative, it's used as the - * offset from the end of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=0] The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.indexOf([1, 2, 1, 2], 2); - * // => 1 - * - * // Search from the `fromIndex`. - * _.indexOf([1, 2, 1, 2], 2, 2); - * // => 3 - */ - function indexOf(array, value, fromIndex) { - var length = array == null ? 0 : array.length - if (!length) { - return -1 - } - var index = fromIndex == null ? 0 : toInteger(fromIndex) - if (index < 0) { - index = nativeMax(length + index, 0) - } - return baseIndexOf(array, value, index) - } - - /** - * Gets all but the last element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.initial([1, 2, 3]); - * // => [1, 2] - */ - function initial(array) { - var length = array == null ? 0 : array.length - return length ? baseSlice(array, 0, -1) : [] - } - - /** - * Creates an array of unique values that are included in all given arrays - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. The order and references of result values are - * determined by the first array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * _.intersection([2, 1], [2, 3]); - * // => [2] - */ - var intersection = baseRest(function(arrays) { - var mapped = arrayMap(arrays, castArrayLikeObject) - return mapped.length && mapped[0] === arrays[0] - ? baseIntersection(mapped) - : [] - }) - - /** - * This method is like `_.intersection` except that it accepts `iteratee` - * which is invoked for each element of each `arrays` to generate the criterion - * by which they're compared. The order and references of result values are - * determined by the first array. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [2.1] - * - * // The `_.property` iteratee shorthand. - * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }] - */ - var intersectionBy = baseRest(function(arrays) { - var iteratee = last(arrays), - mapped = arrayMap(arrays, castArrayLikeObject) - - if (iteratee === last(mapped)) { - iteratee = undefined$1 - } else { - mapped.pop() - } - return mapped.length && mapped[0] === arrays[0] - ? baseIntersection(mapped, getIteratee(iteratee, 2)) - : [] - }) - - /** - * This method is like `_.intersection` except that it accepts `comparator` - * which is invoked to compare elements of `arrays`. The order and references - * of result values are determined by the first array. The comparator is - * invoked with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.intersectionWith(objects, others, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }] - */ - var intersectionWith = baseRest(function(arrays) { - var comparator = last(arrays), - mapped = arrayMap(arrays, castArrayLikeObject) - - comparator = - typeof comparator == "function" ? comparator : undefined$1 - if (comparator) { - mapped.pop() - } - return mapped.length && mapped[0] === arrays[0] - ? baseIntersection(mapped, undefined$1, comparator) - : [] - }) - - /** - * Converts all elements in `array` into a string separated by `separator`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to convert. - * @param {string} [separator=','] The element separator. - * @returns {string} Returns the joined string. - * @example - * - * _.join(['a', 'b', 'c'], '~'); - * // => 'a~b~c' - */ - function join(array, separator) { - return array == null ? "" : nativeJoin.call(array, separator) - } - - /** - * Gets the last element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @returns {*} Returns the last element of `array`. - * @example - * - * _.last([1, 2, 3]); - * // => 3 - */ - function last(array) { - var length = array == null ? 0 : array.length - return length ? array[length - 1] : undefined$1 - } - - /** - * This method is like `_.indexOf` except that it iterates over elements of - * `array` from right to left. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=array.length-1] The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.lastIndexOf([1, 2, 1, 2], 2); - * // => 3 - * - * // Search from the `fromIndex`. - * _.lastIndexOf([1, 2, 1, 2], 2, 2); - * // => 1 - */ - function lastIndexOf(array, value, fromIndex) { - var length = array == null ? 0 : array.length - if (!length) { - return -1 - } - var index = length - if (fromIndex !== undefined$1) { - index = toInteger(fromIndex) - index = - index < 0 - ? nativeMax(length + index, 0) - : nativeMin(index, length - 1) - } - return value === value - ? strictLastIndexOf(array, value, index) - : baseFindIndex(array, baseIsNaN, index, true) - } - - /** - * Gets the element at index `n` of `array`. If `n` is negative, the nth - * element from the end is returned. - * - * @static - * @memberOf _ - * @since 4.11.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=0] The index of the element to return. - * @returns {*} Returns the nth element of `array`. - * @example - * - * var array = ['a', 'b', 'c', 'd']; - * - * _.nth(array, 1); - * // => 'b' - * - * _.nth(array, -2); - * // => 'c'; - */ - function nth(array, n) { - return array && array.length - ? baseNth(array, toInteger(n)) - : undefined$1 - } - - /** - * Removes all given values from `array` using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove` - * to remove elements from an array by predicate. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {...*} [values] The values to remove. - * @returns {Array} Returns `array`. - * @example - * - * var array = ['a', 'b', 'c', 'a', 'b', 'c']; - * - * _.pull(array, 'a', 'c'); - * console.log(array); - * // => ['b', 'b'] - */ - var pull = baseRest(pullAll) - - /** - * This method is like `_.pull` except that it accepts an array of values to remove. - * - * **Note:** Unlike `_.difference`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @returns {Array} Returns `array`. - * @example - * - * var array = ['a', 'b', 'c', 'a', 'b', 'c']; - * - * _.pullAll(array, ['a', 'c']); - * console.log(array); - * // => ['b', 'b'] - */ - function pullAll(array, values) { - return array && array.length && values && values.length - ? basePullAll(array, values) - : array - } - - /** - * This method is like `_.pullAll` except that it accepts `iteratee` which is - * invoked for each element of `array` and `values` to generate the criterion - * by which they're compared. The iteratee is invoked with one argument: (value). - * - * **Note:** Unlike `_.differenceBy`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns `array`. - * @example - * - * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; - * - * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); - * console.log(array); - * // => [{ 'x': 2 }] - */ - function pullAllBy(array, values, iteratee) { - return array && array.length && values && values.length - ? basePullAll(array, values, getIteratee(iteratee, 2)) - : array - } - - /** - * This method is like `_.pullAll` except that it accepts `comparator` which - * is invoked to compare elements of `array` to `values`. The comparator is - * invoked with two arguments: (arrVal, othVal). - * - * **Note:** Unlike `_.differenceWith`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns `array`. - * @example - * - * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; - * - * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); - * console.log(array); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] - */ - function pullAllWith(array, values, comparator) { - return array && array.length && values && values.length - ? basePullAll(array, values, undefined$1, comparator) - : array - } - - /** - * Removes elements from `array` corresponding to `indexes` and returns an - * array of removed elements. - * - * **Note:** Unlike `_.at`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {...(number|number[])} [indexes] The indexes of elements to remove. - * @returns {Array} Returns the new array of removed elements. - * @example - * - * var array = ['a', 'b', 'c', 'd']; - * var pulled = _.pullAt(array, [1, 3]); - * - * console.log(array); - * // => ['a', 'c'] - * - * console.log(pulled); - * // => ['b', 'd'] - */ - var pullAt = flatRest(function(array, indexes) { - var length = array == null ? 0 : array.length, - result = baseAt(array, indexes) - - basePullAt( - array, - arrayMap(indexes, function(index) { - return isIndex(index, length) ? +index : index - }).sort(compareAscending) - ) - - return result - }) - - /** - * Removes all elements from `array` that `predicate` returns truthy for - * and returns an array of the removed elements. The predicate is invoked - * with three arguments: (value, index, array). - * - * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` - * to pull elements from an array by value. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new array of removed elements. - * @example - * - * var array = [1, 2, 3, 4]; - * var evens = _.remove(array, function(n) { - * return n % 2 == 0; - * }); - * - * console.log(array); - * // => [1, 3] - * - * console.log(evens); - * // => [2, 4] - */ - function remove(array, predicate) { - var result = [] - if (!(array && array.length)) { - return result - } - var index = -1, - indexes = [], - length = array.length - - predicate = getIteratee(predicate, 3) - while (++index < length) { - var value = array[index] - if (predicate(value, index, array)) { - result.push(value) - indexes.push(index) - } - } - basePullAt(array, indexes) - return result - } - - /** - * Reverses `array` so that the first element becomes the last, the second - * element becomes the second to last, and so on. - * - * **Note:** This method mutates `array` and is based on - * [`Array#reverse`](https://mdn.io/Array/reverse). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @returns {Array} Returns `array`. - * @example - * - * var array = [1, 2, 3]; - * - * _.reverse(array); - * // => [3, 2, 1] - * - * console.log(array); - * // => [3, 2, 1] - */ - function reverse(array) { - return array == null ? array : nativeReverse.call(array) - } - - /** - * Creates a slice of `array` from `start` up to, but not including, `end`. - * - * **Note:** This method is used instead of - * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are - * returned. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to slice. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the slice of `array`. - */ - function slice(array, start, end) { - var length = array == null ? 0 : array.length - if (!length) { - return [] - } - if ( - end && - typeof end != "number" && - isIterateeCall(array, start, end) - ) { - start = 0 - end = length - } else { - start = start == null ? 0 : toInteger(start) - end = end === undefined$1 ? length : toInteger(end) - } - return baseSlice(array, start, end) - } - - /** - * Uses a binary search to determine the lowest index at which `value` - * should be inserted into `array` in order to maintain its sort order. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * _.sortedIndex([30, 50], 40); - * // => 1 - */ - function sortedIndex(array, value) { - return baseSortedIndex(array, value) - } - - /** - * This method is like `_.sortedIndex` except that it accepts `iteratee` - * which is invoked for `value` and each element of `array` to compute their - * sort ranking. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * var objects = [{ 'x': 4 }, { 'x': 5 }]; - * - * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); - * // => 0 - * - * // The `_.property` iteratee shorthand. - * _.sortedIndexBy(objects, { 'x': 4 }, 'x'); - * // => 0 - */ - function sortedIndexBy(array, value, iteratee) { - return baseSortedIndexBy(array, value, getIteratee(iteratee, 2)) - } - - /** - * This method is like `_.indexOf` except that it performs a binary - * search on a sorted `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.sortedIndexOf([4, 5, 5, 5, 6], 5); - * // => 1 - */ - function sortedIndexOf(array, value) { - var length = array == null ? 0 : array.length - if (length) { - var index = baseSortedIndex(array, value) - if (index < length && eq(array[index], value)) { - return index - } - } - return -1 - } - - /** - * This method is like `_.sortedIndex` except that it returns the highest - * index at which `value` should be inserted into `array` in order to - * maintain its sort order. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * _.sortedLastIndex([4, 5, 5, 5, 6], 5); - * // => 4 - */ - function sortedLastIndex(array, value) { - return baseSortedIndex(array, value, true) - } - - /** - * This method is like `_.sortedLastIndex` except that it accepts `iteratee` - * which is invoked for `value` and each element of `array` to compute their - * sort ranking. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * var objects = [{ 'x': 4 }, { 'x': 5 }]; - * - * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); - * // => 1 - * - * // The `_.property` iteratee shorthand. - * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x'); - * // => 1 - */ - function sortedLastIndexBy(array, value, iteratee) { - return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true) - } - - /** - * This method is like `_.lastIndexOf` except that it performs a binary - * search on a sorted `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5); - * // => 3 - */ - function sortedLastIndexOf(array, value) { - var length = array == null ? 0 : array.length - if (length) { - var index = baseSortedIndex(array, value, true) - 1 - if (eq(array[index], value)) { - return index - } - } - return -1 - } - - /** - * This method is like `_.uniq` except that it's designed and optimized - * for sorted arrays. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.sortedUniq([1, 1, 2]); - * // => [1, 2] - */ - function sortedUniq(array) { - return array && array.length ? baseSortedUniq(array) : [] - } - - /** - * This method is like `_.uniqBy` except that it's designed and optimized - * for sorted arrays. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); - * // => [1.1, 2.3] - */ - function sortedUniqBy(array, iteratee) { - return array && array.length - ? baseSortedUniq(array, getIteratee(iteratee, 2)) - : [] - } - - /** - * Gets all but the first element of `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to query. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.tail([1, 2, 3]); - * // => [2, 3] - */ - function tail(array) { - var length = array == null ? 0 : array.length - return length ? baseSlice(array, 1, length) : [] - } - - /** - * Creates a slice of `array` with `n` elements taken from the beginning. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to take. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.take([1, 2, 3]); - * // => [1] - * - * _.take([1, 2, 3], 2); - * // => [1, 2] - * - * _.take([1, 2, 3], 5); - * // => [1, 2, 3] - * - * _.take([1, 2, 3], 0); - * // => [] - */ - function take(array, n, guard) { - if (!(array && array.length)) { - return [] - } - n = guard || n === undefined$1 ? 1 : toInteger(n) - return baseSlice(array, 0, n < 0 ? 0 : n) - } - - /** - * Creates a slice of `array` with `n` elements taken from the end. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to take. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.takeRight([1, 2, 3]); - * // => [3] - * - * _.takeRight([1, 2, 3], 2); - * // => [2, 3] - * - * _.takeRight([1, 2, 3], 5); - * // => [1, 2, 3] - * - * _.takeRight([1, 2, 3], 0); - * // => [] - */ - function takeRight(array, n, guard) { - var length = array == null ? 0 : array.length - if (!length) { - return [] - } - n = guard || n === undefined$1 ? 1 : toInteger(n) - n = length - n - return baseSlice(array, n < 0 ? 0 : n, length) - } - - /** - * Creates a slice of `array` with elements taken from the end. Elements are - * taken until `predicate` returns falsey. The predicate is invoked with - * three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.takeRightWhile(users, function(o) { return !o.active; }); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.matches` iteratee shorthand. - * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false }); - * // => objects for ['pebbles'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.takeRightWhile(users, ['active', false]); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.property` iteratee shorthand. - * _.takeRightWhile(users, 'active'); - * // => [] - */ - function takeRightWhile(array, predicate) { - return array && array.length - ? baseWhile(array, getIteratee(predicate, 3), false, true) - : [] - } - - /** - * Creates a slice of `array` with elements taken from the beginning. Elements - * are taken until `predicate` returns falsey. The predicate is invoked with - * three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.takeWhile(users, function(o) { return !o.active; }); - * // => objects for ['barney', 'fred'] - * - * // The `_.matches` iteratee shorthand. - * _.takeWhile(users, { 'user': 'barney', 'active': false }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.takeWhile(users, ['active', false]); - * // => objects for ['barney', 'fred'] - * - * // The `_.property` iteratee shorthand. - * _.takeWhile(users, 'active'); - * // => [] - */ - function takeWhile(array, predicate) { - return array && array.length - ? baseWhile(array, getIteratee(predicate, 3)) - : [] - } - - /** - * Creates an array of unique values, in order, from all given arrays using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of combined values. - * @example - * - * _.union([2], [1, 2]); - * // => [2, 1] - */ - var union = baseRest(function(arrays) { - return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true)) - }) - - /** - * This method is like `_.union` except that it accepts `iteratee` which is - * invoked for each element of each `arrays` to generate the criterion by - * which uniqueness is computed. Result values are chosen from the first - * array in which the value occurs. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of combined values. - * @example - * - * _.unionBy([2.1], [1.2, 2.3], Math.floor); - * // => [2.1, 1.2] - * - * // The `_.property` iteratee shorthand. - * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }, { 'x': 2 }] - */ - var unionBy = baseRest(function(arrays) { - var iteratee = last(arrays) - if (isArrayLikeObject(iteratee)) { - iteratee = undefined$1 - } - return baseUniq( - baseFlatten(arrays, 1, isArrayLikeObject, true), - getIteratee(iteratee, 2) - ) - }) - - /** - * This method is like `_.union` except that it accepts `comparator` which - * is invoked to compare elements of `arrays`. Result values are chosen from - * the first array in which the value occurs. The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of combined values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.unionWith(objects, others, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] - */ - var unionWith = baseRest(function(arrays) { - var comparator = last(arrays) - comparator = - typeof comparator == "function" ? comparator : undefined$1 - return baseUniq( - baseFlatten(arrays, 1, isArrayLikeObject, true), - undefined$1, - comparator - ) - }) - - /** - * Creates a duplicate-free version of an array, using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons, in which only the first occurrence of each element - * is kept. The order of result values is determined by the order they occur - * in the array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.uniq([2, 1, 2]); - * // => [2, 1] - */ - function uniq(array) { - return array && array.length ? baseUniq(array) : [] - } - - /** - * This method is like `_.uniq` except that it accepts `iteratee` which is - * invoked for each element in `array` to generate the criterion by which - * uniqueness is computed. The order of result values is determined by the - * order they occur in the array. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.uniqBy([2.1, 1.2, 2.3], Math.floor); - * // => [2.1, 1.2] - * - * // The `_.property` iteratee shorthand. - * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }, { 'x': 2 }] - */ - function uniqBy(array, iteratee) { - return array && array.length - ? baseUniq(array, getIteratee(iteratee, 2)) - : [] - } - - /** - * This method is like `_.uniq` except that it accepts `comparator` which - * is invoked to compare elements of `array`. The order of result values is - * determined by the order they occur in the array.The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.uniqWith(objects, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] - */ - function uniqWith(array, comparator) { - comparator = - typeof comparator == "function" ? comparator : undefined$1 - return array && array.length - ? baseUniq(array, undefined$1, comparator) - : [] - } - - /** - * This method is like `_.zip` except that it accepts an array of grouped - * elements and creates an array regrouping the elements to their pre-zip - * configuration. - * - * @static - * @memberOf _ - * @since 1.2.0 - * @category Array - * @param {Array} array The array of grouped elements to process. - * @returns {Array} Returns the new array of regrouped elements. - * @example - * - * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); - * // => [['a', 1, true], ['b', 2, false]] - * - * _.unzip(zipped); - * // => [['a', 'b'], [1, 2], [true, false]] - */ - function unzip(array) { - if (!(array && array.length)) { - return [] - } - var length = 0 - array = arrayFilter(array, function(group) { - if (isArrayLikeObject(group)) { - length = nativeMax(group.length, length) - return true - } - }) - return baseTimes(length, function(index) { - return arrayMap(array, baseProperty(index)) - }) - } - - /** - * This method is like `_.unzip` except that it accepts `iteratee` to specify - * how regrouped values should be combined. The iteratee is invoked with the - * elements of each group: (...group). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Array - * @param {Array} array The array of grouped elements to process. - * @param {Function} [iteratee=_.identity] The function to combine - * regrouped values. - * @returns {Array} Returns the new array of regrouped elements. - * @example - * - * var zipped = _.zip([1, 2], [10, 20], [100, 200]); - * // => [[1, 10, 100], [2, 20, 200]] - * - * _.unzipWith(zipped, _.add); - * // => [3, 30, 300] - */ - function unzipWith(array, iteratee) { - if (!(array && array.length)) { - return [] - } - var result = unzip(array) - if (iteratee == null) { - return result - } - return arrayMap(result, function(group) { - return apply(iteratee, undefined$1, group) - }) - } - - /** - * Creates an array excluding all given values using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * **Note:** Unlike `_.pull`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...*} [values] The values to exclude. - * @returns {Array} Returns the new array of filtered values. - * @see _.difference, _.xor - * @example - * - * _.without([2, 1, 2, 3], 1, 2); - * // => [3] - */ - var without = baseRest(function(array, values) { - return isArrayLikeObject(array) ? baseDifference(array, values) : [] - }) - - /** - * Creates an array of unique values that is the - * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) - * of the given arrays. The order of result values is determined by the order - * they occur in the arrays. - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of filtered values. - * @see _.difference, _.without - * @example - * - * _.xor([2, 1], [2, 3]); - * // => [1, 3] - */ - var xor = baseRest(function(arrays) { - return baseXor(arrayFilter(arrays, isArrayLikeObject)) - }) - - /** - * This method is like `_.xor` except that it accepts `iteratee` which is - * invoked for each element of each `arrays` to generate the criterion by - * which by which they're compared. The order of result values is determined - * by the order they occur in the arrays. The iteratee is invoked with one - * argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [1.2, 3.4] - * - * // The `_.property` iteratee shorthand. - * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 2 }] - */ - var xorBy = baseRest(function(arrays) { - var iteratee = last(arrays) - if (isArrayLikeObject(iteratee)) { - iteratee = undefined$1 - } - return baseXor( - arrayFilter(arrays, isArrayLikeObject), - getIteratee(iteratee, 2) - ) - }) - - /** - * This method is like `_.xor` except that it accepts `comparator` which is - * invoked to compare elements of `arrays`. The order of result values is - * determined by the order they occur in the arrays. The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.xorWith(objects, others, _.isEqual); - * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] - */ - var xorWith = baseRest(function(arrays) { - var comparator = last(arrays) - comparator = - typeof comparator == "function" ? comparator : undefined$1 - return baseXor( - arrayFilter(arrays, isArrayLikeObject), - undefined$1, - comparator - ) - }) - - /** - * Creates an array of grouped elements, the first of which contains the - * first elements of the given arrays, the second of which contains the - * second elements of the given arrays, and so on. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to process. - * @returns {Array} Returns the new array of grouped elements. - * @example - * - * _.zip(['a', 'b'], [1, 2], [true, false]); - * // => [['a', 1, true], ['b', 2, false]] - */ - var zip = baseRest(unzip) - - /** - * This method is like `_.fromPairs` except that it accepts two arrays, - * one of property identifiers and one of corresponding values. - * - * @static - * @memberOf _ - * @since 0.4.0 - * @category Array - * @param {Array} [props=[]] The property identifiers. - * @param {Array} [values=[]] The property values. - * @returns {Object} Returns the new object. - * @example - * - * _.zipObject(['a', 'b'], [1, 2]); - * // => { 'a': 1, 'b': 2 } - */ - function zipObject(props, values) { - return baseZipObject(props || [], values || [], assignValue) - } - - /** - * This method is like `_.zipObject` except that it supports property paths. - * - * @static - * @memberOf _ - * @since 4.1.0 - * @category Array - * @param {Array} [props=[]] The property identifiers. - * @param {Array} [values=[]] The property values. - * @returns {Object} Returns the new object. - * @example - * - * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); - * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } - */ - function zipObjectDeep(props, values) { - return baseZipObject(props || [], values || [], baseSet) - } - - /** - * This method is like `_.zip` except that it accepts `iteratee` to specify - * how grouped values should be combined. The iteratee is invoked with the - * elements of each group: (...group). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Array - * @param {...Array} [arrays] The arrays to process. - * @param {Function} [iteratee=_.identity] The function to combine - * grouped values. - * @returns {Array} Returns the new array of grouped elements. - * @example - * - * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { - * return a + b + c; - * }); - * // => [111, 222] - */ - var zipWith = baseRest(function(arrays) { - var length = arrays.length, - iteratee = length > 1 ? arrays[length - 1] : undefined$1 - - iteratee = - typeof iteratee == "function" - ? (arrays.pop(), iteratee) - : undefined$1 - return unzipWith(arrays, iteratee) - }) - - /*------------------------------------------------------------------------*/ - - /** - * Creates a `lodash` wrapper instance that wraps `value` with explicit method - * chain sequences enabled. The result of such sequences must be unwrapped - * with `_#value`. - * - * @static - * @memberOf _ - * @since 1.3.0 - * @category Seq - * @param {*} value The value to wrap. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'pebbles', 'age': 1 } - * ]; - * - * var youngest = _ - * .chain(users) - * .sortBy('age') - * .map(function(o) { - * return o.user + ' is ' + o.age; - * }) - * .head() - * .value(); - * // => 'pebbles is 1' - */ - function chain(value) { - var result = lodash(value) - result.__chain__ = true - return result - } - - /** - * This method invokes `interceptor` and returns `value`. The interceptor - * is invoked with one argument; (value). The purpose of this method is to - * "tap into" a method chain sequence in order to modify intermediate results. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @param {*} value The value to provide to `interceptor`. - * @param {Function} interceptor The function to invoke. - * @returns {*} Returns `value`. - * @example - * - * _([1, 2, 3]) - * .tap(function(array) { - * // Mutate input array. - * array.pop(); - * }) - * .reverse() - * .value(); - * // => [2, 1] - */ - function tap(value, interceptor) { - interceptor(value) - return value - } - - /** - * This method is like `_.tap` except that it returns the result of `interceptor`. - * The purpose of this method is to "pass thru" values replacing intermediate - * results in a method chain sequence. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Seq - * @param {*} value The value to provide to `interceptor`. - * @param {Function} interceptor The function to invoke. - * @returns {*} Returns the result of `interceptor`. - * @example - * - * _(' abc ') - * .chain() - * .trim() - * .thru(function(value) { - * return [value]; - * }) - * .value(); - * // => ['abc'] - */ - function thru(value, interceptor) { - return interceptor(value) - } - - /** - * This method is the wrapper version of `_.at`. - * - * @name at - * @memberOf _ - * @since 1.0.0 - * @category Seq - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; - * - * _(object).at(['a[0].b.c', 'a[1]']).value(); - * // => [3, 4] - */ - var wrapperAt = flatRest(function(paths) { - var length = paths.length, - start = length ? paths[0] : 0, - value = this.__wrapped__, - interceptor = function(object) { - return baseAt(object, paths) - } - - if ( - length > 1 || - this.__actions__.length || - !(value instanceof LazyWrapper) || - !isIndex(start) - ) { - return this.thru(interceptor) - } - value = value.slice(start, +start + (length ? 1 : 0)) - value.__actions__.push({ - func: thru, - args: [interceptor], - thisArg: undefined$1, - }) - return new LodashWrapper(value, this.__chain__).thru(function(array) { - if (length && !array.length) { - array.push(undefined$1) - } - return array - }) - }) - - /** - * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. - * - * @name chain - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 } - * ]; - * - * // A sequence without explicit chaining. - * _(users).head(); - * // => { 'user': 'barney', 'age': 36 } - * - * // A sequence with explicit chaining. - * _(users) - * .chain() - * .head() - * .pick('user') - * .value(); - * // => { 'user': 'barney' } - */ - function wrapperChain() { - return chain(this) - } - - /** - * Executes the chain sequence and returns the wrapped result. - * - * @name commit - * @memberOf _ - * @since 3.2.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var array = [1, 2]; - * var wrapped = _(array).push(3); - * - * console.log(array); - * // => [1, 2] - * - * wrapped = wrapped.commit(); - * console.log(array); - * // => [1, 2, 3] - * - * wrapped.last(); - * // => 3 - * - * console.log(array); - * // => [1, 2, 3] - */ - function wrapperCommit() { - return new LodashWrapper(this.value(), this.__chain__) - } - - /** - * Gets the next value on a wrapped object following the - * [iterator protocol](https://mdn.io/iteration_protocols#iterator). - * - * @name next - * @memberOf _ - * @since 4.0.0 - * @category Seq - * @returns {Object} Returns the next iterator value. - * @example - * - * var wrapped = _([1, 2]); - * - * wrapped.next(); - * // => { 'done': false, 'value': 1 } - * - * wrapped.next(); - * // => { 'done': false, 'value': 2 } - * - * wrapped.next(); - * // => { 'done': true, 'value': undefined } - */ - function wrapperNext() { - if (this.__values__ === undefined$1) { - this.__values__ = toArray(this.value()) - } - var done = this.__index__ >= this.__values__.length, - value = done ? undefined$1 : this.__values__[this.__index__++] - - return { done: done, value: value } - } - - /** - * Enables the wrapper to be iterable. - * - * @name Symbol.iterator - * @memberOf _ - * @since 4.0.0 - * @category Seq - * @returns {Object} Returns the wrapper object. - * @example - * - * var wrapped = _([1, 2]); - * - * wrapped[Symbol.iterator]() === wrapped; - * // => true - * - * Array.from(wrapped); - * // => [1, 2] - */ - function wrapperToIterator() { - return this - } - - /** - * Creates a clone of the chain sequence planting `value` as the wrapped value. - * - * @name plant - * @memberOf _ - * @since 3.2.0 - * @category Seq - * @param {*} value The value to plant. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * function square(n) { - * return n * n; - * } - * - * var wrapped = _([1, 2]).map(square); - * var other = wrapped.plant([3, 4]); - * - * other.value(); - * // => [9, 16] - * - * wrapped.value(); - * // => [1, 4] - */ - function wrapperPlant(value) { - var result, - parent = this - - while (parent instanceof baseLodash) { - var clone = wrapperClone(parent) - clone.__index__ = 0 - clone.__values__ = undefined$1 - if (result) { - previous.__wrapped__ = clone - } else { - result = clone - } - var previous = clone - parent = parent.__wrapped__ - } - previous.__wrapped__ = value - return result - } - - /** - * This method is the wrapper version of `_.reverse`. - * - * **Note:** This method mutates the wrapped array. - * - * @name reverse - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var array = [1, 2, 3]; - * - * _(array).reverse().value() - * // => [3, 2, 1] - * - * console.log(array); - * // => [3, 2, 1] - */ - function wrapperReverse() { - var value = this.__wrapped__ - if (value instanceof LazyWrapper) { - var wrapped = value - if (this.__actions__.length) { - wrapped = new LazyWrapper(this) - } - wrapped = wrapped.reverse() - wrapped.__actions__.push({ - func: thru, - args: [reverse], - thisArg: undefined$1, - }) - return new LodashWrapper(wrapped, this.__chain__) - } - return this.thru(reverse) - } - - /** - * Executes the chain sequence to resolve the unwrapped value. - * - * @name value - * @memberOf _ - * @since 0.1.0 - * @alias toJSON, valueOf - * @category Seq - * @returns {*} Returns the resolved unwrapped value. - * @example - * - * _([1, 2, 3]).value(); - * // => [1, 2, 3] - */ - function wrapperValue() { - return baseWrapperValue(this.__wrapped__, this.__actions__) - } - - /*------------------------------------------------------------------------*/ - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The corresponding value of - * each key is the number of times the key was returned by `iteratee`. The - * iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * _.countBy([6.1, 4.2, 6.3], Math.floor); - * // => { '4': 1, '6': 2 } - * - * // The `_.property` iteratee shorthand. - * _.countBy(['one', 'two', 'three'], 'length'); - * // => { '3': 2, '5': 1 } - */ - var countBy = createAggregator(function(result, value, key) { - if (hasOwnProperty.call(result, key)) { - ++result[key] - } else { - baseAssignValue(result, key, 1) - } - }) - - /** - * Checks if `predicate` returns truthy for **all** elements of `collection`. - * Iteration is stopped once `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index|key, collection). - * - * **Note:** This method returns `true` for - * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because - * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of - * elements of empty collections. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false`. - * @example - * - * _.every([true, 1, null, 'yes'], Boolean); - * // => false - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': false } - * ]; - * - * // The `_.matches` iteratee shorthand. - * _.every(users, { 'user': 'barney', 'active': false }); - * // => false - * - * // The `_.matchesProperty` iteratee shorthand. - * _.every(users, ['active', false]); - * // => true - * - * // The `_.property` iteratee shorthand. - * _.every(users, 'active'); - * // => false - */ - function every(collection, predicate, guard) { - var func = isArray(collection) ? arrayEvery : baseEvery - if (guard && isIterateeCall(collection, predicate, guard)) { - predicate = undefined$1 - } - return func(collection, getIteratee(predicate, 3)) - } - - /** - * Iterates over elements of `collection`, returning an array of all elements - * `predicate` returns truthy for. The predicate is invoked with three - * arguments: (value, index|key, collection). - * - * **Note:** Unlike `_.remove`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - * @see _.reject - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': true }, - * { 'user': 'fred', 'age': 40, 'active': false } - * ]; - * - * _.filter(users, function(o) { return !o.active; }); - * // => objects for ['fred'] - * - * // The `_.matches` iteratee shorthand. - * _.filter(users, { 'age': 36, 'active': true }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.filter(users, ['active', false]); - * // => objects for ['fred'] - * - * // The `_.property` iteratee shorthand. - * _.filter(users, 'active'); - * // => objects for ['barney'] - */ - function filter(collection, predicate) { - var func = isArray(collection) ? arrayFilter : baseFilter - return func(collection, getIteratee(predicate, 3)) - } - - /** - * Iterates over elements of `collection`, returning the first element - * `predicate` returns truthy for. The predicate is invoked with three - * arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=0] The index to search from. - * @returns {*} Returns the matched element, else `undefined`. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': true }, - * { 'user': 'fred', 'age': 40, 'active': false }, - * { 'user': 'pebbles', 'age': 1, 'active': true } - * ]; - * - * _.find(users, function(o) { return o.age < 40; }); - * // => object for 'barney' - * - * // The `_.matches` iteratee shorthand. - * _.find(users, { 'age': 1, 'active': true }); - * // => object for 'pebbles' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.find(users, ['active', false]); - * // => object for 'fred' - * - * // The `_.property` iteratee shorthand. - * _.find(users, 'active'); - * // => object for 'barney' - */ - var find = createFind(findIndex) - - /** - * This method is like `_.find` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Collection - * @param {Array|Object} collection The collection to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=collection.length-1] The index to search from. - * @returns {*} Returns the matched element, else `undefined`. - * @example - * - * _.findLast([1, 2, 3, 4], function(n) { - * return n % 2 == 1; - * }); - * // => 3 - */ - var findLast = createFind(findLastIndex) - - /** - * Creates a flattened array of values by running each element in `collection` - * thru `iteratee` and flattening the mapped results. The iteratee is invoked - * with three arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [n, n]; - * } - * - * _.flatMap([1, 2], duplicate); - * // => [1, 1, 2, 2] - */ - function flatMap(collection, iteratee) { - return baseFlatten(map(collection, iteratee), 1) - } - - /** - * This method is like `_.flatMap` except that it recursively flattens the - * mapped results. - * - * @static - * @memberOf _ - * @since 4.7.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [[[n, n]]]; - * } - * - * _.flatMapDeep([1, 2], duplicate); - * // => [1, 1, 2, 2] - */ - function flatMapDeep(collection, iteratee) { - return baseFlatten(map(collection, iteratee), INFINITY) - } - - /** - * This method is like `_.flatMap` except that it recursively flattens the - * mapped results up to `depth` times. - * - * @static - * @memberOf _ - * @since 4.7.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {number} [depth=1] The maximum recursion depth. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [[[n, n]]]; - * } - * - * _.flatMapDepth([1, 2], duplicate, 2); - * // => [[1, 1], [2, 2]] - */ - function flatMapDepth(collection, iteratee, depth) { - depth = depth === undefined$1 ? 1 : toInteger(depth) - return baseFlatten(map(collection, iteratee), depth) - } - - /** - * Iterates over elements of `collection` and invokes `iteratee` for each element. - * The iteratee is invoked with three arguments: (value, index|key, collection). - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * **Note:** As with other "Collections" methods, objects with a "length" - * property are iterated like arrays. To avoid this behavior use `_.forIn` - * or `_.forOwn` for object iteration. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @alias each - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - * @see _.forEachRight - * @example - * - * _.forEach([1, 2], function(value) { - * console.log(value); - * }); - * // => Logs `1` then `2`. - * - * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a' then 'b' (iteration order is not guaranteed). - */ - function forEach(collection, iteratee) { - var func = isArray(collection) ? arrayEach : baseEach - return func(collection, getIteratee(iteratee, 3)) - } - - /** - * This method is like `_.forEach` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @alias eachRight - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - * @see _.forEach - * @example - * - * _.forEachRight([1, 2], function(value) { - * console.log(value); - * }); - * // => Logs `2` then `1`. - */ - function forEachRight(collection, iteratee) { - var func = isArray(collection) ? arrayEachRight : baseEachRight - return func(collection, getIteratee(iteratee, 3)) - } - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The order of grouped values - * is determined by the order they occur in `collection`. The corresponding - * value of each key is an array of elements responsible for generating the - * key. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * _.groupBy([6.1, 4.2, 6.3], Math.floor); - * // => { '4': [4.2], '6': [6.1, 6.3] } - * - * // The `_.property` iteratee shorthand. - * _.groupBy(['one', 'two', 'three'], 'length'); - * // => { '3': ['one', 'two'], '5': ['three'] } - */ - var groupBy = createAggregator(function(result, value, key) { - if (hasOwnProperty.call(result, key)) { - result[key].push(value) - } else { - baseAssignValue(result, key, [value]) - } - }) - - /** - * Checks if `value` is in `collection`. If `collection` is a string, it's - * checked for a substring of `value`, otherwise - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * is used for equality comparisons. If `fromIndex` is negative, it's used as - * the offset from the end of `collection`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object|string} collection The collection to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=0] The index to search from. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. - * @returns {boolean} Returns `true` if `value` is found, else `false`. - * @example - * - * _.includes([1, 2, 3], 1); - * // => true - * - * _.includes([1, 2, 3], 1, 2); - * // => false - * - * _.includes({ 'a': 1, 'b': 2 }, 1); - * // => true - * - * _.includes('abcd', 'bc'); - * // => true - */ - function includes(collection, value, fromIndex, guard) { - collection = isArrayLike(collection) ? collection : values(collection) - fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0 - - var length = collection.length - if (fromIndex < 0) { - fromIndex = nativeMax(length + fromIndex, 0) - } - return isString(collection) - ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 - : !!length && baseIndexOf(collection, value, fromIndex) > -1 - } - - /** - * Invokes the method at `path` of each element in `collection`, returning - * an array of the results of each invoked method. Any additional arguments - * are provided to each invoked method. If `path` is a function, it's invoked - * for, and `this` bound to, each element in `collection`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Array|Function|string} path The path of the method to invoke or - * the function invoked per iteration. - * @param {...*} [args] The arguments to invoke each method with. - * @returns {Array} Returns the array of results. - * @example - * - * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); - * // => [[1, 5, 7], [1, 2, 3]] - * - * _.invokeMap([123, 456], String.prototype.split, ''); - * // => [['1', '2', '3'], ['4', '5', '6']] - */ - var invokeMap = baseRest(function(collection, path, args) { - var index = -1, - isFunc = typeof path == "function", - result = isArrayLike(collection) ? Array(collection.length) : [] - - baseEach(collection, function(value) { - result[++index] = isFunc - ? apply(path, value, args) - : baseInvoke(value, path, args) - }) - return result - }) - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The corresponding value of - * each key is the last element responsible for generating the key. The - * iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * var array = [ - * { 'dir': 'left', 'code': 97 }, - * { 'dir': 'right', 'code': 100 } - * ]; - * - * _.keyBy(array, function(o) { - * return String.fromCharCode(o.code); - * }); - * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } - * - * _.keyBy(array, 'dir'); - * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } - */ - var keyBy = createAggregator(function(result, value, key) { - baseAssignValue(result, key, value) - }) - - /** - * Creates an array of values by running each element in `collection` thru - * `iteratee`. The iteratee is invoked with three arguments: - * (value, index|key, collection). - * - * Many lodash methods are guarded to work as iteratees for methods like - * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. - * - * The guarded methods are: - * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, - * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, - * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, - * `template`, `trim`, `trimEnd`, `trimStart`, and `words` - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - * @example - * - * function square(n) { - * return n * n; - * } - * - * _.map([4, 8], square); - * // => [16, 64] - * - * _.map({ 'a': 4, 'b': 8 }, square); - * // => [16, 64] (iteration order is not guaranteed) - * - * var users = [ - * { 'user': 'barney' }, - * { 'user': 'fred' } - * ]; - * - * // The `_.property` iteratee shorthand. - * _.map(users, 'user'); - * // => ['barney', 'fred'] - */ - function map(collection, iteratee) { - var func = isArray(collection) ? arrayMap : baseMap - return func(collection, getIteratee(iteratee, 3)) - } - - /** - * This method is like `_.sortBy` except that it allows specifying the sort - * orders of the iteratees to sort by. If `orders` is unspecified, all values - * are sorted in ascending order. Otherwise, specify an order of "desc" for - * descending or "asc" for ascending sort order of corresponding values. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] - * The iteratees to sort by. - * @param {string[]} [orders] The sort orders of `iteratees`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. - * @returns {Array} Returns the new sorted array. - * @example - * - * var users = [ - * { 'user': 'fred', 'age': 48 }, - * { 'user': 'barney', 'age': 34 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'barney', 'age': 36 } - * ]; - * - * // Sort by `user` in ascending order and by `age` in descending order. - * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); - * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] - */ - function orderBy(collection, iteratees, orders, guard) { - if (collection == null) { - return [] - } - if (!isArray(iteratees)) { - iteratees = iteratees == null ? [] : [iteratees] - } - orders = guard ? undefined$1 : orders - if (!isArray(orders)) { - orders = orders == null ? [] : [orders] - } - return baseOrderBy(collection, iteratees, orders) - } - - /** - * Creates an array of elements split into two groups, the first of which - * contains elements `predicate` returns truthy for, the second of which - * contains elements `predicate` returns falsey for. The predicate is - * invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the array of grouped elements. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': true }, - * { 'user': 'pebbles', 'age': 1, 'active': false } - * ]; - * - * _.partition(users, function(o) { return o.active; }); - * // => objects for [['fred'], ['barney', 'pebbles']] - * - * // The `_.matches` iteratee shorthand. - * _.partition(users, { 'age': 1, 'active': false }); - * // => objects for [['pebbles'], ['barney', 'fred']] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.partition(users, ['active', false]); - * // => objects for [['barney', 'pebbles'], ['fred']] - * - * // The `_.property` iteratee shorthand. - * _.partition(users, 'active'); - * // => objects for [['fred'], ['barney', 'pebbles']] - */ - var partition = createAggregator( - function(result, value, key) { - result[key ? 0 : 1].push(value) - }, - function() { - return [[], []] - } - ) - - /** - * Reduces `collection` to a value which is the accumulated result of running - * each element in `collection` thru `iteratee`, where each successive - * invocation is supplied the return value of the previous. If `accumulator` - * is not given, the first element of `collection` is used as the initial - * value. The iteratee is invoked with four arguments: - * (accumulator, value, index|key, collection). - * - * Many lodash methods are guarded to work as iteratees for methods like - * `_.reduce`, `_.reduceRight`, and `_.transform`. - * - * The guarded methods are: - * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, - * and `sortBy` - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @returns {*} Returns the accumulated value. - * @see _.reduceRight - * @example - * - * _.reduce([1, 2], function(sum, n) { - * return sum + n; - * }, 0); - * // => 3 - * - * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { - * (result[value] || (result[value] = [])).push(key); - * return result; - * }, {}); - * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) - */ - function reduce(collection, iteratee, accumulator) { - var func = isArray(collection) ? arrayReduce : baseReduce, - initAccum = arguments.length < 3 - - return func( - collection, - getIteratee(iteratee, 4), - accumulator, - initAccum, - baseEach - ) - } - - /** - * This method is like `_.reduce` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @returns {*} Returns the accumulated value. - * @see _.reduce - * @example - * - * var array = [[0, 1], [2, 3], [4, 5]]; - * - * _.reduceRight(array, function(flattened, other) { - * return flattened.concat(other); - * }, []); - * // => [4, 5, 2, 3, 0, 1] - */ - function reduceRight(collection, iteratee, accumulator) { - var func = isArray(collection) ? arrayReduceRight : baseReduce, - initAccum = arguments.length < 3 - - return func( - collection, - getIteratee(iteratee, 4), - accumulator, - initAccum, - baseEachRight - ) - } - - /** - * The opposite of `_.filter`; this method returns the elements of `collection` - * that `predicate` does **not** return truthy for. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - * @see _.filter - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': true } - * ]; - * - * _.reject(users, function(o) { return !o.active; }); - * // => objects for ['fred'] - * - * // The `_.matches` iteratee shorthand. - * _.reject(users, { 'age': 40, 'active': true }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.reject(users, ['active', false]); - * // => objects for ['fred'] - * - * // The `_.property` iteratee shorthand. - * _.reject(users, 'active'); - * // => objects for ['barney'] - */ - function reject(collection, predicate) { - var func = isArray(collection) ? arrayFilter : baseFilter - return func(collection, negate(getIteratee(predicate, 3))) - } - - /** - * Gets a random element from `collection`. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Collection - * @param {Array|Object} collection The collection to sample. - * @returns {*} Returns the random element. - * @example - * - * _.sample([1, 2, 3, 4]); - * // => 2 - */ - function sample(collection) { - var func = isArray(collection) ? arraySample : baseSample - return func(collection) - } - - /** - * Gets `n` random elements at unique keys from `collection` up to the - * size of `collection`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to sample. - * @param {number} [n=1] The number of elements to sample. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the random elements. - * @example - * - * _.sampleSize([1, 2, 3], 2); - * // => [3, 1] - * - * _.sampleSize([1, 2, 3], 4); - * // => [2, 3, 1] - */ - function sampleSize(collection, n, guard) { - if ( - guard ? isIterateeCall(collection, n, guard) : n === undefined$1 - ) { - n = 1 - } else { - n = toInteger(n) - } - var func = isArray(collection) ? arraySampleSize : baseSampleSize - return func(collection, n) - } - - /** - * Creates an array of shuffled values, using a version of the - * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to shuffle. - * @returns {Array} Returns the new shuffled array. - * @example - * - * _.shuffle([1, 2, 3, 4]); - * // => [4, 1, 3, 2] - */ - function shuffle(collection) { - var func = isArray(collection) ? arrayShuffle : baseShuffle - return func(collection) - } - - /** - * Gets the size of `collection` by returning its length for array-like - * values or the number of own enumerable string keyed properties for objects. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object|string} collection The collection to inspect. - * @returns {number} Returns the collection size. - * @example - * - * _.size([1, 2, 3]); - * // => 3 - * - * _.size({ 'a': 1, 'b': 2 }); - * // => 2 - * - * _.size('pebbles'); - * // => 7 - */ - function size(collection) { - if (collection == null) { - return 0 - } - if (isArrayLike(collection)) { - return isString(collection) - ? stringSize(collection) - : collection.length - } - var tag = getTag(collection) - if (tag == mapTag || tag == setTag) { - return collection.size - } - return baseKeys(collection).length - } - - /** - * Checks if `predicate` returns truthy for **any** element of `collection`. - * Iteration is stopped once `predicate` returns truthy. The predicate is - * invoked with three arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - * @example - * - * _.some([null, 0, 'yes', false], Boolean); - * // => true - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false } - * ]; - * - * // The `_.matches` iteratee shorthand. - * _.some(users, { 'user': 'barney', 'active': false }); - * // => false - * - * // The `_.matchesProperty` iteratee shorthand. - * _.some(users, ['active', false]); - * // => true - * - * // The `_.property` iteratee shorthand. - * _.some(users, 'active'); - * // => true - */ - function some(collection, predicate, guard) { - var func = isArray(collection) ? arraySome : baseSome - if (guard && isIterateeCall(collection, predicate, guard)) { - predicate = undefined$1 - } - return func(collection, getIteratee(predicate, 3)) - } - - /** - * Creates an array of elements, sorted in ascending order by the results of - * running each element in a collection thru each iteratee. This method - * performs a stable sort, that is, it preserves the original sort order of - * equal elements. The iteratees are invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {...(Function|Function[])} [iteratees=[_.identity]] - * The iteratees to sort by. - * @returns {Array} Returns the new sorted array. - * @example - * - * var users = [ - * { 'user': 'fred', 'age': 48 }, - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'barney', 'age': 34 } - * ]; - * - * _.sortBy(users, [function(o) { return o.user; }]); - * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] - * - * _.sortBy(users, ['user', 'age']); - * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]] - */ - var sortBy = baseRest(function(collection, iteratees) { - if (collection == null) { - return [] - } - var length = iteratees.length - if ( - length > 1 && - isIterateeCall(collection, iteratees[0], iteratees[1]) - ) { - iteratees = [] - } else if ( - length > 2 && - isIterateeCall(iteratees[0], iteratees[1], iteratees[2]) - ) { - iteratees = [iteratees[0]] - } - return baseOrderBy(collection, baseFlatten(iteratees, 1), []) - }) - - /*------------------------------------------------------------------------*/ - - /** - * Gets the timestamp of the number of milliseconds that have elapsed since - * the Unix epoch (1 January 1970 00:00:00 UTC). - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Date - * @returns {number} Returns the timestamp. - * @example - * - * _.defer(function(stamp) { - * console.log(_.now() - stamp); - * }, _.now()); - * // => Logs the number of milliseconds it took for the deferred invocation. - */ - var now = - ctxNow || - function() { - return root.Date.now() - } - - /*------------------------------------------------------------------------*/ - - /** - * The opposite of `_.before`; this method creates a function that invokes - * `func` once it's called `n` or more times. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {number} n The number of calls before `func` is invoked. - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var saves = ['profile', 'settings']; - * - * var done = _.after(saves.length, function() { - * console.log('done saving!'); - * }); - * - * _.forEach(saves, function(type) { - * asyncSave({ 'type': type, 'complete': done }); - * }); - * // => Logs 'done saving!' after the two async saves have completed. - */ - function after(n, func) { - if (typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - n = toInteger(n) - return function() { - if (--n < 1) { - return func.apply(this, arguments) - } - } - } - - /** - * Creates a function that invokes `func`, with up to `n` arguments, - * ignoring any additional arguments. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to cap arguments for. - * @param {number} [n=func.length] The arity cap. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new capped function. - * @example - * - * _.map(['6', '8', '10'], _.ary(parseInt, 1)); - * // => [6, 8, 10] - */ - function ary(func, n, guard) { - n = guard ? undefined$1 : n - n = func && n == null ? func.length : n - return createWrap( - func, - WRAP_ARY_FLAG, - undefined$1, - undefined$1, - undefined$1, - undefined$1, - n - ) - } - - /** - * Creates a function that invokes `func`, with the `this` binding and arguments - * of the created function, while it's called less than `n` times. Subsequent - * calls to the created function return the result of the last `func` invocation. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {number} n The number of calls at which `func` is no longer invoked. - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * jQuery(element).on('click', _.before(5, addContactToList)); - * // => Allows adding up to 4 contacts to the list. - */ - function before(n, func) { - var result - if (typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - n = toInteger(n) - return function() { - if (--n > 0) { - result = func.apply(this, arguments) - } - if (n <= 1) { - func = undefined$1 - } - return result - } - } - - /** - * Creates a function that invokes `func` with the `this` binding of `thisArg` - * and `partials` prepended to the arguments it receives. - * - * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, - * may be used as a placeholder for partially applied arguments. - * - * **Note:** Unlike native `Function#bind`, this method doesn't set the "length" - * property of bound functions. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to bind. - * @param {*} thisArg The `this` binding of `func`. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * function greet(greeting, punctuation) { - * return greeting + ' ' + this.user + punctuation; - * } - * - * var object = { 'user': 'fred' }; - * - * var bound = _.bind(greet, object, 'hi'); - * bound('!'); - * // => 'hi fred!' - * - * // Bound with placeholders. - * var bound = _.bind(greet, object, _, '!'); - * bound('hi'); - * // => 'hi fred!' - */ - var bind = baseRest(function(func, thisArg, partials) { - var bitmask = WRAP_BIND_FLAG - if (partials.length) { - var holders = replaceHolders(partials, getHolder(bind)) - bitmask |= WRAP_PARTIAL_FLAG - } - return createWrap(func, bitmask, thisArg, partials, holders) - }) - - /** - * Creates a function that invokes the method at `object[key]` with `partials` - * prepended to the arguments it receives. - * - * This method differs from `_.bind` by allowing bound functions to reference - * methods that may be redefined or don't yet exist. See - * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) - * for more details. - * - * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * @static - * @memberOf _ - * @since 0.10.0 - * @category Function - * @param {Object} object The object to invoke the method on. - * @param {string} key The key of the method. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * var object = { - * 'user': 'fred', - * 'greet': function(greeting, punctuation) { - * return greeting + ' ' + this.user + punctuation; - * } - * }; - * - * var bound = _.bindKey(object, 'greet', 'hi'); - * bound('!'); - * // => 'hi fred!' - * - * object.greet = function(greeting, punctuation) { - * return greeting + 'ya ' + this.user + punctuation; - * }; - * - * bound('!'); - * // => 'hiya fred!' - * - * // Bound with placeholders. - * var bound = _.bindKey(object, 'greet', _, '!'); - * bound('hi'); - * // => 'hiya fred!' - */ - var bindKey = baseRest(function(object, key, partials) { - var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG - if (partials.length) { - var holders = replaceHolders(partials, getHolder(bindKey)) - bitmask |= WRAP_PARTIAL_FLAG - } - return createWrap(key, bitmask, object, partials, holders) - }) - - /** - * Creates a function that accepts arguments of `func` and either invokes - * `func` returning its result, if at least `arity` number of arguments have - * been provided, or returns a function that accepts the remaining `func` - * arguments, and so on. The arity of `func` may be specified if `func.length` - * is not sufficient. - * - * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, - * may be used as a placeholder for provided arguments. - * - * **Note:** This method doesn't set the "length" property of curried functions. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Function - * @param {Function} func The function to curry. - * @param {number} [arity=func.length] The arity of `func`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new curried function. - * @example - * - * var abc = function(a, b, c) { - * return [a, b, c]; - * }; - * - * var curried = _.curry(abc); - * - * curried(1)(2)(3); - * // => [1, 2, 3] - * - * curried(1, 2)(3); - * // => [1, 2, 3] - * - * curried(1, 2, 3); - * // => [1, 2, 3] - * - * // Curried with placeholders. - * curried(1)(_, 3)(2); - * // => [1, 2, 3] - */ - function curry(func, arity, guard) { - arity = guard ? undefined$1 : arity - var result = createWrap( - func, - WRAP_CURRY_FLAG, - undefined$1, - undefined$1, - undefined$1, - undefined$1, - undefined$1, - arity - ) - result.placeholder = curry.placeholder - return result - } - - /** - * This method is like `_.curry` except that arguments are applied to `func` - * in the manner of `_.partialRight` instead of `_.partial`. - * - * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for provided arguments. - * - * **Note:** This method doesn't set the "length" property of curried functions. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to curry. - * @param {number} [arity=func.length] The arity of `func`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new curried function. - * @example - * - * var abc = function(a, b, c) { - * return [a, b, c]; - * }; - * - * var curried = _.curryRight(abc); - * - * curried(3)(2)(1); - * // => [1, 2, 3] - * - * curried(2, 3)(1); - * // => [1, 2, 3] - * - * curried(1, 2, 3); - * // => [1, 2, 3] - * - * // Curried with placeholders. - * curried(3)(1, _)(2); - * // => [1, 2, 3] - */ - function curryRight(func, arity, guard) { - arity = guard ? undefined$1 : arity - var result = createWrap( - func, - WRAP_CURRY_RIGHT_FLAG, - undefined$1, - undefined$1, - undefined$1, - undefined$1, - undefined$1, - arity - ) - result.placeholder = curryRight.placeholder - return result - } - - /** - * Creates a debounced function that delays invoking `func` until after `wait` - * milliseconds have elapsed since the last time the debounced function was - * invoked. The debounced function comes with a `cancel` method to cancel - * delayed `func` invocations and a `flush` method to immediately invoke them. - * Provide `options` to indicate whether `func` should be invoked on the - * leading and/or trailing edge of the `wait` timeout. The `func` is invoked - * with the last arguments provided to the debounced function. Subsequent - * calls to the debounced function return the result of the last `func` - * invocation. - * - * **Note:** If `leading` and `trailing` options are `true`, `func` is - * invoked on the trailing edge of the timeout only if the debounced function - * is invoked more than once during the `wait` timeout. - * - * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred - * until to the next tick, similar to `setTimeout` with a timeout of `0`. - * - * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) - * for details over the differences between `_.debounce` and `_.throttle`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to debounce. - * @param {number} [wait=0] The number of milliseconds to delay. - * @param {Object} [options={}] The options object. - * @param {boolean} [options.leading=false] - * Specify invoking on the leading edge of the timeout. - * @param {number} [options.maxWait] - * The maximum time `func` is allowed to be delayed before it's invoked. - * @param {boolean} [options.trailing=true] - * Specify invoking on the trailing edge of the timeout. - * @returns {Function} Returns the new debounced function. - * @example - * - * // Avoid costly calculations while the window size is in flux. - * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); - * - * // Invoke `sendMail` when clicked, debouncing subsequent calls. - * jQuery(element).on('click', _.debounce(sendMail, 300, { - * 'leading': true, - * 'trailing': false - * })); - * - * // Ensure `batchLog` is invoked once after 1 second of debounced calls. - * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); - * var source = new EventSource('/stream'); - * jQuery(source).on('message', debounced); - * - * // Cancel the trailing debounced invocation. - * jQuery(window).on('popstate', debounced.cancel); - */ - function debounce(func, wait, options) { - var lastArgs, - lastThis, - maxWait, - result, - timerId, - lastCallTime, - lastInvokeTime = 0, - leading = false, - maxing = false, - trailing = true - - if (typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - wait = toNumber(wait) || 0 - if (isObject(options)) { - leading = !!options.leading - maxing = "maxWait" in options - maxWait = maxing - ? nativeMax(toNumber(options.maxWait) || 0, wait) - : maxWait - trailing = "trailing" in options ? !!options.trailing : trailing - } - - function invokeFunc(time) { - var args = lastArgs, - thisArg = lastThis - - lastArgs = lastThis = undefined$1 - lastInvokeTime = time - result = func.apply(thisArg, args) - return result - } - - function leadingEdge(time) { - // Reset any `maxWait` timer. - lastInvokeTime = time - // Start the timer for the trailing edge. - timerId = setTimeout(timerExpired, wait) - // Invoke the leading edge. - return leading ? invokeFunc(time) : result - } - - function remainingWait(time) { - var timeSinceLastCall = time - lastCallTime, - timeSinceLastInvoke = time - lastInvokeTime, - timeWaiting = wait - timeSinceLastCall - - return maxing - ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) - : timeWaiting - } - - function shouldInvoke(time) { - var timeSinceLastCall = time - lastCallTime, - timeSinceLastInvoke = time - lastInvokeTime - - // Either this is the first call, activity has stopped and we're at the - // trailing edge, the system time has gone backwards and we're treating - // it as the trailing edge, or we've hit the `maxWait` limit. - return ( - lastCallTime === undefined$1 || - timeSinceLastCall >= wait || - timeSinceLastCall < 0 || - (maxing && timeSinceLastInvoke >= maxWait) - ) - } - - function timerExpired() { - var time = now() - if (shouldInvoke(time)) { - return trailingEdge(time) - } - // Restart the timer. - timerId = setTimeout(timerExpired, remainingWait(time)) - } - - function trailingEdge(time) { - timerId = undefined$1 - - // Only invoke if we have `lastArgs` which means `func` has been - // debounced at least once. - if (trailing && lastArgs) { - return invokeFunc(time) - } - lastArgs = lastThis = undefined$1 - return result - } - - function cancel() { - if (timerId !== undefined$1) { - clearTimeout(timerId) - } - lastInvokeTime = 0 - lastArgs = lastCallTime = lastThis = timerId = undefined$1 - } - - function flush() { - return timerId === undefined$1 ? result : trailingEdge(now()) - } - - function debounced() { - var time = now(), - isInvoking = shouldInvoke(time) - - lastArgs = arguments - lastThis = this - lastCallTime = time - - if (isInvoking) { - if (timerId === undefined$1) { - return leadingEdge(lastCallTime) - } - if (maxing) { - // Handle invocations in a tight loop. - clearTimeout(timerId) - timerId = setTimeout(timerExpired, wait) - return invokeFunc(lastCallTime) - } - } - if (timerId === undefined$1) { - timerId = setTimeout(timerExpired, wait) - } - return result - } - debounced.cancel = cancel - debounced.flush = flush - return debounced - } - - /** - * Defers invoking the `func` until the current call stack has cleared. Any - * additional arguments are provided to `func` when it's invoked. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to defer. - * @param {...*} [args] The arguments to invoke `func` with. - * @returns {number} Returns the timer id. - * @example - * - * _.defer(function(text) { - * console.log(text); - * }, 'deferred'); - * // => Logs 'deferred' after one millisecond. - */ - var defer = baseRest(function(func, args) { - return baseDelay(func, 1, args) - }) - - /** - * Invokes `func` after `wait` milliseconds. Any additional arguments are - * provided to `func` when it's invoked. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @param {...*} [args] The arguments to invoke `func` with. - * @returns {number} Returns the timer id. - * @example - * - * _.delay(function(text) { - * console.log(text); - * }, 1000, 'later'); - * // => Logs 'later' after one second. - */ - var delay = baseRest(function(func, wait, args) { - return baseDelay(func, toNumber(wait) || 0, args) - }) - - /** - * Creates a function that invokes `func` with arguments reversed. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to flip arguments for. - * @returns {Function} Returns the new flipped function. - * @example - * - * var flipped = _.flip(function() { - * return _.toArray(arguments); - * }); - * - * flipped('a', 'b', 'c', 'd'); - * // => ['d', 'c', 'b', 'a'] - */ - function flip(func) { - return createWrap(func, WRAP_FLIP_FLAG) - } - - /** - * Creates a function that memoizes the result of `func`. If `resolver` is - * provided, it determines the cache key for storing the result based on the - * arguments provided to the memoized function. By default, the first argument - * provided to the memoized function is used as the map cache key. The `func` - * is invoked with the `this` binding of the memoized function. - * - * **Note:** The cache is exposed as the `cache` property on the memoized - * function. Its creation may be customized by replacing the `_.memoize.Cache` - * constructor with one whose instances implement the - * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) - * method interface of `clear`, `delete`, `get`, `has`, and `set`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to have its output memoized. - * @param {Function} [resolver] The function to resolve the cache key. - * @returns {Function} Returns the new memoized function. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * var other = { 'c': 3, 'd': 4 }; - * - * var values = _.memoize(_.values); - * values(object); - * // => [1, 2] - * - * values(other); - * // => [3, 4] - * - * object.a = 2; - * values(object); - * // => [1, 2] - * - * // Modify the result cache. - * values.cache.set(object, ['a', 'b']); - * values(object); - * // => ['a', 'b'] - * - * // Replace `_.memoize.Cache`. - * _.memoize.Cache = WeakMap; - */ - function memoize(func, resolver) { - if ( - typeof func != "function" || - (resolver != null && typeof resolver != "function") - ) { - throw new TypeError(FUNC_ERROR_TEXT) - } - var memoized = function() { - var args = arguments, - key = resolver ? resolver.apply(this, args) : args[0], - cache = memoized.cache - - if (cache.has(key)) { - return cache.get(key) - } - var result = func.apply(this, args) - memoized.cache = cache.set(key, result) || cache - return result - } - memoized.cache = new (memoize.Cache || MapCache)() - return memoized - } - - // Expose `MapCache`. - memoize.Cache = MapCache - - /** - * Creates a function that negates the result of the predicate `func`. The - * `func` predicate is invoked with the `this` binding and arguments of the - * created function. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} predicate The predicate to negate. - * @returns {Function} Returns the new negated function. - * @example - * - * function isEven(n) { - * return n % 2 == 0; - * } - * - * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); - * // => [1, 3, 5] - */ - function negate(predicate) { - if (typeof predicate != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - return function() { - var args = arguments - switch (args.length) { - case 0: - return !predicate.call(this) - case 1: - return !predicate.call(this, args[0]) - case 2: - return !predicate.call(this, args[0], args[1]) - case 3: - return !predicate.call(this, args[0], args[1], args[2]) - } - return !predicate.apply(this, args) - } - } - - /** - * Creates a function that is restricted to invoking `func` once. Repeat calls - * to the function return the value of the first invocation. The `func` is - * invoked with the `this` binding and arguments of the created function. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var initialize = _.once(createApplication); - * initialize(); - * initialize(); - * // => `createApplication` is invoked once - */ - function once(func) { - return before(2, func) - } - - /** - * Creates a function that invokes `func` with its arguments transformed. - * - * @static - * @since 4.0.0 - * @memberOf _ - * @category Function - * @param {Function} func The function to wrap. - * @param {...(Function|Function[])} [transforms=[_.identity]] - * The argument transforms. - * @returns {Function} Returns the new function. - * @example - * - * function doubled(n) { - * return n * 2; - * } - * - * function square(n) { - * return n * n; - * } - * - * var func = _.overArgs(function(x, y) { - * return [x, y]; - * }, [square, doubled]); - * - * func(9, 3); - * // => [81, 6] - * - * func(10, 5); - * // => [100, 10] - */ - var overArgs = castRest(function(func, transforms) { - transforms = - transforms.length == 1 && isArray(transforms[0]) - ? arrayMap(transforms[0], baseUnary(getIteratee())) - : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee())) - - var funcsLength = transforms.length - return baseRest(function(args) { - var index = -1, - length = nativeMin(args.length, funcsLength) - - while (++index < length) { - args[index] = transforms[index].call(this, args[index]) - } - return apply(func, this, args) - }) - }) - - /** - * Creates a function that invokes `func` with `partials` prepended to the - * arguments it receives. This method is like `_.bind` except it does **not** - * alter the `this` binding. - * - * The `_.partial.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * **Note:** This method doesn't set the "length" property of partially - * applied functions. - * - * @static - * @memberOf _ - * @since 0.2.0 - * @category Function - * @param {Function} func The function to partially apply arguments to. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * function greet(greeting, name) { - * return greeting + ' ' + name; - * } - * - * var sayHelloTo = _.partial(greet, 'hello'); - * sayHelloTo('fred'); - * // => 'hello fred' - * - * // Partially applied with placeholders. - * var greetFred = _.partial(greet, _, 'fred'); - * greetFred('hi'); - * // => 'hi fred' - */ - var partial = baseRest(function(func, partials) { - var holders = replaceHolders(partials, getHolder(partial)) - return createWrap( - func, - WRAP_PARTIAL_FLAG, - undefined$1, - partials, - holders - ) - }) - - /** - * This method is like `_.partial` except that partially applied arguments - * are appended to the arguments it receives. - * - * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * **Note:** This method doesn't set the "length" property of partially - * applied functions. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Function - * @param {Function} func The function to partially apply arguments to. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * function greet(greeting, name) { - * return greeting + ' ' + name; - * } - * - * var greetFred = _.partialRight(greet, 'fred'); - * greetFred('hi'); - * // => 'hi fred' - * - * // Partially applied with placeholders. - * var sayHelloTo = _.partialRight(greet, 'hello', _); - * sayHelloTo('fred'); - * // => 'hello fred' - */ - var partialRight = baseRest(function(func, partials) { - var holders = replaceHolders(partials, getHolder(partialRight)) - return createWrap( - func, - WRAP_PARTIAL_RIGHT_FLAG, - undefined$1, - partials, - holders - ) - }) - - /** - * Creates a function that invokes `func` with arguments arranged according - * to the specified `indexes` where the argument value at the first index is - * provided as the first argument, the argument value at the second index is - * provided as the second argument, and so on. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to rearrange arguments for. - * @param {...(number|number[])} indexes The arranged argument indexes. - * @returns {Function} Returns the new function. - * @example - * - * var rearged = _.rearg(function(a, b, c) { - * return [a, b, c]; - * }, [2, 0, 1]); - * - * rearged('b', 'c', 'a') - * // => ['a', 'b', 'c'] - */ - var rearg = flatRest(function(func, indexes) { - return createWrap( - func, - WRAP_REARG_FLAG, - undefined$1, - undefined$1, - undefined$1, - indexes - ) - }) - - /** - * Creates a function that invokes `func` with the `this` binding of the - * created function and arguments from `start` and beyond provided as - * an array. - * - * **Note:** This method is based on the - * [rest parameter](https://mdn.io/rest_parameters). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @returns {Function} Returns the new function. - * @example - * - * var say = _.rest(function(what, names) { - * return what + ' ' + _.initial(names).join(', ') + - * (_.size(names) > 1 ? ', & ' : '') + _.last(names); - * }); - * - * say('hello', 'fred', 'barney', 'pebbles'); - * // => 'hello fred, barney, & pebbles' - */ - function rest(func, start) { - if (typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - start = start === undefined$1 ? start : toInteger(start) - return baseRest(func, start) - } - - /** - * Creates a function that invokes `func` with the `this` binding of the - * create function and an array of arguments much like - * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). - * - * **Note:** This method is based on the - * [spread operator](https://mdn.io/spread_operator). - * - * @static - * @memberOf _ - * @since 3.2.0 - * @category Function - * @param {Function} func The function to spread arguments over. - * @param {number} [start=0] The start position of the spread. - * @returns {Function} Returns the new function. - * @example - * - * var say = _.spread(function(who, what) { - * return who + ' says ' + what; - * }); - * - * say(['fred', 'hello']); - * // => 'fred says hello' - * - * var numbers = Promise.all([ - * Promise.resolve(40), - * Promise.resolve(36) - * ]); - * - * numbers.then(_.spread(function(x, y) { - * return x + y; - * })); - * // => a Promise of 76 - */ - function spread(func, start) { - if (typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - start = start == null ? 0 : nativeMax(toInteger(start), 0) - return baseRest(function(args) { - var array = args[start], - otherArgs = castSlice(args, 0, start) - - if (array) { - arrayPush(otherArgs, array) - } - return apply(func, this, otherArgs) - }) - } - - /** - * Creates a throttled function that only invokes `func` at most once per - * every `wait` milliseconds. The throttled function comes with a `cancel` - * method to cancel delayed `func` invocations and a `flush` method to - * immediately invoke them. Provide `options` to indicate whether `func` - * should be invoked on the leading and/or trailing edge of the `wait` - * timeout. The `func` is invoked with the last arguments provided to the - * throttled function. Subsequent calls to the throttled function return the - * result of the last `func` invocation. - * - * **Note:** If `leading` and `trailing` options are `true`, `func` is - * invoked on the trailing edge of the timeout only if the throttled function - * is invoked more than once during the `wait` timeout. - * - * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred - * until to the next tick, similar to `setTimeout` with a timeout of `0`. - * - * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) - * for details over the differences between `_.throttle` and `_.debounce`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to throttle. - * @param {number} [wait=0] The number of milliseconds to throttle invocations to. - * @param {Object} [options={}] The options object. - * @param {boolean} [options.leading=true] - * Specify invoking on the leading edge of the timeout. - * @param {boolean} [options.trailing=true] - * Specify invoking on the trailing edge of the timeout. - * @returns {Function} Returns the new throttled function. - * @example - * - * // Avoid excessively updating the position while scrolling. - * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); - * - * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. - * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); - * jQuery(element).on('click', throttled); - * - * // Cancel the trailing throttled invocation. - * jQuery(window).on('popstate', throttled.cancel); - */ - function throttle(func, wait, options) { - var leading = true, - trailing = true - - if (typeof func != "function") { - throw new TypeError(FUNC_ERROR_TEXT) - } - if (isObject(options)) { - leading = "leading" in options ? !!options.leading : leading - trailing = "trailing" in options ? !!options.trailing : trailing - } - return debounce(func, wait, { - leading: leading, - maxWait: wait, - trailing: trailing, - }) - } - - /** - * Creates a function that accepts up to one argument, ignoring any - * additional arguments. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to cap arguments for. - * @returns {Function} Returns the new capped function. - * @example - * - * _.map(['6', '8', '10'], _.unary(parseInt)); - * // => [6, 8, 10] - */ - function unary(func) { - return ary(func, 1) - } - - /** - * Creates a function that provides `value` to `wrapper` as its first - * argument. Any additional arguments provided to the function are appended - * to those provided to the `wrapper`. The wrapper is invoked with the `this` - * binding of the created function. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {*} value The value to wrap. - * @param {Function} [wrapper=identity] The wrapper function. - * @returns {Function} Returns the new function. - * @example - * - * var p = _.wrap(_.escape, function(func, text) { - * return '

' + func(text) + '

'; - * }); - * - * p('fred, barney, & pebbles'); - * // => '

fred, barney, & pebbles

' - */ - function wrap(value, wrapper) { - return partial(castFunction(wrapper), value) - } - - /*------------------------------------------------------------------------*/ - - /** - * Casts `value` as an array if it's not one. - * - * @static - * @memberOf _ - * @since 4.4.0 - * @category Lang - * @param {*} value The value to inspect. - * @returns {Array} Returns the cast array. - * @example - * - * _.castArray(1); - * // => [1] - * - * _.castArray({ 'a': 1 }); - * // => [{ 'a': 1 }] - * - * _.castArray('abc'); - * // => ['abc'] - * - * _.castArray(null); - * // => [null] - * - * _.castArray(undefined); - * // => [undefined] - * - * _.castArray(); - * // => [] - * - * var array = [1, 2, 3]; - * console.log(_.castArray(array) === array); - * // => true - */ - function castArray() { - if (!arguments.length) { - return [] - } - var value = arguments[0] - return isArray(value) ? value : [value] - } - - /** - * Creates a shallow clone of `value`. - * - * **Note:** This method is loosely based on the - * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) - * and supports cloning arrays, array buffers, booleans, date objects, maps, - * numbers, `Object` objects, regexes, sets, strings, symbols, and typed - * arrays. The own enumerable properties of `arguments` objects are cloned - * as plain objects. An empty object is returned for uncloneable values such - * as error objects, functions, DOM nodes, and WeakMaps. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to clone. - * @returns {*} Returns the cloned value. - * @see _.cloneDeep - * @example - * - * var objects = [{ 'a': 1 }, { 'b': 2 }]; - * - * var shallow = _.clone(objects); - * console.log(shallow[0] === objects[0]); - * // => true - */ - function clone(value) { - return baseClone(value, CLONE_SYMBOLS_FLAG) - } - - /** - * This method is like `_.clone` except that it accepts `customizer` which - * is invoked to produce the cloned value. If `customizer` returns `undefined`, - * cloning is handled by the method instead. The `customizer` is invoked with - * up to four arguments; (value [, index|key, object, stack]). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to clone. - * @param {Function} [customizer] The function to customize cloning. - * @returns {*} Returns the cloned value. - * @see _.cloneDeepWith - * @example - * - * function customizer(value) { - * if (_.isElement(value)) { - * return value.cloneNode(false); - * } - * } - * - * var el = _.cloneWith(document.body, customizer); - * - * console.log(el === document.body); - * // => false - * console.log(el.nodeName); - * // => 'BODY' - * console.log(el.childNodes.length); - * // => 0 - */ - function cloneWith(value, customizer) { - customizer = - typeof customizer == "function" ? customizer : undefined$1 - return baseClone(value, CLONE_SYMBOLS_FLAG, customizer) - } - - /** - * This method is like `_.clone` except that it recursively clones `value`. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Lang - * @param {*} value The value to recursively clone. - * @returns {*} Returns the deep cloned value. - * @see _.clone - * @example - * - * var objects = [{ 'a': 1 }, { 'b': 2 }]; - * - * var deep = _.cloneDeep(objects); - * console.log(deep[0] === objects[0]); - * // => false - */ - function cloneDeep(value) { - return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG) - } - - /** - * This method is like `_.cloneWith` except that it recursively clones `value`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to recursively clone. - * @param {Function} [customizer] The function to customize cloning. - * @returns {*} Returns the deep cloned value. - * @see _.cloneWith - * @example - * - * function customizer(value) { - * if (_.isElement(value)) { - * return value.cloneNode(true); - * } - * } - * - * var el = _.cloneDeepWith(document.body, customizer); - * - * console.log(el === document.body); - * // => false - * console.log(el.nodeName); - * // => 'BODY' - * console.log(el.childNodes.length); - * // => 20 - */ - function cloneDeepWith(value, customizer) { - customizer = - typeof customizer == "function" ? customizer : undefined$1 - return baseClone( - value, - CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, - customizer - ) - } - - /** - * Checks if `object` conforms to `source` by invoking the predicate - * properties of `source` with the corresponding property values of `object`. - * - * **Note:** This method is equivalent to `_.conforms` when `source` is - * partially applied. - * - * @static - * @memberOf _ - * @since 4.14.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property predicates to conform to. - * @returns {boolean} Returns `true` if `object` conforms, else `false`. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * - * _.conformsTo(object, { 'b': function(n) { return n > 1; } }); - * // => true - * - * _.conformsTo(object, { 'b': function(n) { return n > 2; } }); - * // => false - */ - function conformsTo(object, source) { - return source == null || baseConformsTo(object, source, keys(source)) - } - - /** - * Performs a - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * comparison between two values to determine if they are equivalent. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.eq(object, object); - * // => true - * - * _.eq(object, other); - * // => false - * - * _.eq('a', 'a'); - * // => true - * - * _.eq('a', Object('a')); - * // => false - * - * _.eq(NaN, NaN); - * // => true - */ - function eq(value, other) { - return value === other || (value !== value && other !== other) - } - - /** - * Checks if `value` is greater than `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than `other`, - * else `false`. - * @see _.lt - * @example - * - * _.gt(3, 1); - * // => true - * - * _.gt(3, 3); - * // => false - * - * _.gt(1, 3); - * // => false - */ - var gt = createRelationalOperation(baseGt) - - /** - * Checks if `value` is greater than or equal to `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than or equal to - * `other`, else `false`. - * @see _.lte - * @example - * - * _.gte(3, 1); - * // => true - * - * _.gte(3, 3); - * // => true - * - * _.gte(1, 3); - * // => false - */ - var gte = createRelationalOperation(function(value, other) { - return value >= other - }) - - /** - * Checks if `value` is likely an `arguments` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - * else `false`. - * @example - * - * _.isArguments(function() { return arguments; }()); - * // => true - * - * _.isArguments([1, 2, 3]); - * // => false - */ - var isArguments = baseIsArguments( - (function() { - return arguments - })() - ) - ? baseIsArguments - : function(value) { - return ( - isObjectLike(value) && - hasOwnProperty.call(value, "callee") && - !propertyIsEnumerable.call(value, "callee") - ) - } - - /** - * Checks if `value` is classified as an `Array` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. - * @example - * - * _.isArray([1, 2, 3]); - * // => true - * - * _.isArray(document.body.children); - * // => false - * - * _.isArray('abc'); - * // => false - * - * _.isArray(_.noop); - * // => false - */ - var isArray = Array.isArray - - /** - * Checks if `value` is classified as an `ArrayBuffer` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. - * @example - * - * _.isArrayBuffer(new ArrayBuffer(2)); - * // => true - * - * _.isArrayBuffer(new Array(2)); - * // => false - */ - var isArrayBuffer = nodeIsArrayBuffer - ? baseUnary(nodeIsArrayBuffer) - : baseIsArrayBuffer - - /** - * Checks if `value` is array-like. A value is considered array-like if it's - * not a function and has a `value.length` that's an integer greater than or - * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is array-like, else `false`. - * @example - * - * _.isArrayLike([1, 2, 3]); - * // => true - * - * _.isArrayLike(document.body.children); - * // => true - * - * _.isArrayLike('abc'); - * // => true - * - * _.isArrayLike(_.noop); - * // => false - */ - function isArrayLike(value) { - return value != null && isLength(value.length) && !isFunction(value) - } - - /** - * This method is like `_.isArrayLike` except that it also checks if `value` - * is an object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array-like object, - * else `false`. - * @example - * - * _.isArrayLikeObject([1, 2, 3]); - * // => true - * - * _.isArrayLikeObject(document.body.children); - * // => true - * - * _.isArrayLikeObject('abc'); - * // => false - * - * _.isArrayLikeObject(_.noop); - * // => false - */ - function isArrayLikeObject(value) { - return isObjectLike(value) && isArrayLike(value) - } - - /** - * Checks if `value` is classified as a boolean primitive or object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. - * @example - * - * _.isBoolean(false); - * // => true - * - * _.isBoolean(null); - * // => false - */ - function isBoolean(value) { - return ( - value === true || - value === false || - (isObjectLike(value) && baseGetTag(value) == boolTag) - ) - } - - /** - * Checks if `value` is a buffer. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. - * @example - * - * _.isBuffer(new Buffer(2)); - * // => true - * - * _.isBuffer(new Uint8Array(2)); - * // => false - */ - var isBuffer = nativeIsBuffer || stubFalse - - /** - * Checks if `value` is classified as a `Date` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a date object, else `false`. - * @example - * - * _.isDate(new Date); - * // => true - * - * _.isDate('Mon April 23 2012'); - * // => false - */ - var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate - - /** - * Checks if `value` is likely a DOM element. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. - * @example - * - * _.isElement(document.body); - * // => true - * - * _.isElement(''); - * // => false - */ - function isElement(value) { - return ( - isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value) - ) - } - - /** - * Checks if `value` is an empty object, collection, map, or set. - * - * Objects are considered empty if they have no own enumerable string keyed - * properties. - * - * Array-like values such as `arguments` objects, arrays, buffers, strings, or - * jQuery-like collections are considered empty if they have a `length` of `0`. - * Similarly, maps and sets are considered empty if they have a `size` of `0`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is empty, else `false`. - * @example - * - * _.isEmpty(null); - * // => true - * - * _.isEmpty(true); - * // => true - * - * _.isEmpty(1); - * // => true - * - * _.isEmpty([1, 2, 3]); - * // => false - * - * _.isEmpty({ 'a': 1 }); - * // => false - */ - function isEmpty(value) { - if (value == null) { - return true - } - if ( - isArrayLike(value) && - (isArray(value) || - typeof value == "string" || - typeof value.splice == "function" || - isBuffer(value) || - isTypedArray(value) || - isArguments(value)) - ) { - return !value.length - } - var tag = getTag(value) - if (tag == mapTag || tag == setTag) { - return !value.size - } - if (isPrototype(value)) { - return !baseKeys(value).length - } - for (var key in value) { - if (hasOwnProperty.call(value, key)) { - return false - } - } - return true - } - - /** - * Performs a deep comparison between two values to determine if they are - * equivalent. - * - * **Note:** This method supports comparing arrays, array buffers, booleans, - * date objects, error objects, maps, numbers, `Object` objects, regexes, - * sets, strings, symbols, and typed arrays. `Object` objects are compared - * by their own, not inherited, enumerable properties. Functions and DOM - * nodes are compared by strict equality, i.e. `===`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.isEqual(object, other); - * // => true - * - * object === other; - * // => false - */ - function isEqual(value, other) { - return baseIsEqual(value, other) - } - - /** - * This method is like `_.isEqual` except that it accepts `customizer` which - * is invoked to compare values. If `customizer` returns `undefined`, comparisons - * are handled by the method instead. The `customizer` is invoked with up to - * six arguments: (objValue, othValue [, index|key, object, other, stack]). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * function isGreeting(value) { - * return /^h(?:i|ello)$/.test(value); - * } - * - * function customizer(objValue, othValue) { - * if (isGreeting(objValue) && isGreeting(othValue)) { - * return true; - * } - * } - * - * var array = ['hello', 'goodbye']; - * var other = ['hi', 'goodbye']; - * - * _.isEqualWith(array, other, customizer); - * // => true - */ - function isEqualWith(value, other, customizer) { - customizer = - typeof customizer == "function" ? customizer : undefined$1 - var result = customizer ? customizer(value, other) : undefined$1 - return result === undefined$1 - ? baseIsEqual(value, other, undefined$1, customizer) - : !!result - } - - /** - * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, - * `SyntaxError`, `TypeError`, or `URIError` object. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an error object, else `false`. - * @example - * - * _.isError(new Error); - * // => true - * - * _.isError(Error); - * // => false - */ - function isError(value) { - if (!isObjectLike(value)) { - return false - } - var tag = baseGetTag(value) - return ( - tag == errorTag || - tag == domExcTag || - (typeof value.message == "string" && - typeof value.name == "string" && - !isPlainObject(value)) - ) - } - - /** - * Checks if `value` is a finite primitive number. - * - * **Note:** This method is based on - * [`Number.isFinite`](https://mdn.io/Number/isFinite). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. - * @example - * - * _.isFinite(3); - * // => true - * - * _.isFinite(Number.MIN_VALUE); - * // => true - * - * _.isFinite(Infinity); - * // => false - * - * _.isFinite('3'); - * // => false - */ - function isFinite(value) { - return typeof value == "number" && nativeIsFinite(value) - } - - /** - * Checks if `value` is classified as a `Function` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - * - * _.isFunction(/abc/); - * // => false - */ - function isFunction(value) { - if (!isObject(value)) { - return false - } - // The use of `Object#toString` avoids issues with the `typeof` operator - // in Safari 9 which returns 'object' for typed arrays and other constructors. - var tag = baseGetTag(value) - return ( - tag == funcTag || - tag == genTag || - tag == asyncTag || - tag == proxyTag - ) - } - - /** - * Checks if `value` is an integer. - * - * **Note:** This method is based on - * [`Number.isInteger`](https://mdn.io/Number/isInteger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an integer, else `false`. - * @example - * - * _.isInteger(3); - * // => true - * - * _.isInteger(Number.MIN_VALUE); - * // => false - * - * _.isInteger(Infinity); - * // => false - * - * _.isInteger('3'); - * // => false - */ - function isInteger(value) { - return typeof value == "number" && value == toInteger(value) - } - - /** - * Checks if `value` is a valid array-like length. - * - * **Note:** This method is loosely based on - * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. - * @example - * - * _.isLength(3); - * // => true - * - * _.isLength(Number.MIN_VALUE); - * // => false - * - * _.isLength(Infinity); - * // => false - * - * _.isLength('3'); - * // => false - */ - function isLength(value) { - return ( - typeof value == "number" && - value > -1 && - value % 1 == 0 && - value <= MAX_SAFE_INTEGER - ) - } - - /** - * Checks if `value` is the - * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) - * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(_.noop); - * // => true - * - * _.isObject(null); - * // => false - */ - function isObject(value) { - var type = typeof value - return value != null && (type == "object" || type == "function") - } - - /** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. - * @example - * - * _.isObjectLike({}); - * // => true - * - * _.isObjectLike([1, 2, 3]); - * // => true - * - * _.isObjectLike(_.noop); - * // => false - * - * _.isObjectLike(null); - * // => false - */ - function isObjectLike(value) { - return value != null && typeof value == "object" - } - - /** - * Checks if `value` is classified as a `Map` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a map, else `false`. - * @example - * - * _.isMap(new Map); - * // => true - * - * _.isMap(new WeakMap); - * // => false - */ - var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap - - /** - * Performs a partial deep comparison between `object` and `source` to - * determine if `object` contains equivalent property values. - * - * **Note:** This method is equivalent to `_.matches` when `source` is - * partially applied. - * - * Partial comparisons will match empty array and empty object `source` - * values against any array or object value, respectively. See `_.isEqual` - * for a list of supported value comparisons. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * - * _.isMatch(object, { 'b': 2 }); - * // => true - * - * _.isMatch(object, { 'b': 1 }); - * // => false - */ - function isMatch(object, source) { - return ( - object === source || - baseIsMatch(object, source, getMatchData(source)) - ) - } - - /** - * This method is like `_.isMatch` except that it accepts `customizer` which - * is invoked to compare values. If `customizer` returns `undefined`, comparisons - * are handled by the method instead. The `customizer` is invoked with five - * arguments: (objValue, srcValue, index|key, object, source). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - * @example - * - * function isGreeting(value) { - * return /^h(?:i|ello)$/.test(value); - * } - * - * function customizer(objValue, srcValue) { - * if (isGreeting(objValue) && isGreeting(srcValue)) { - * return true; - * } - * } - * - * var object = { 'greeting': 'hello' }; - * var source = { 'greeting': 'hi' }; - * - * _.isMatchWith(object, source, customizer); - * // => true - */ - function isMatchWith(object, source, customizer) { - customizer = - typeof customizer == "function" ? customizer : undefined$1 - return baseIsMatch(object, source, getMatchData(source), customizer) - } - - /** - * Checks if `value` is `NaN`. - * - * **Note:** This method is based on - * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as - * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for - * `undefined` and other non-number values. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. - * @example - * - * _.isNaN(NaN); - * // => true - * - * _.isNaN(new Number(NaN)); - * // => true - * - * isNaN(undefined); - * // => true - * - * _.isNaN(undefined); - * // => false - */ - function isNaN(value) { - // An `NaN` primitive is the only value that is not equal to itself. - // Perform the `toStringTag` check first to avoid errors with some - // ActiveX objects in IE. - return isNumber(value) && value != +value - } - - /** - * Checks if `value` is a pristine native function. - * - * **Note:** This method can't reliably detect native functions in the presence - * of the core-js package because core-js circumvents this kind of detection. - * Despite multiple requests, the core-js maintainer has made it clear: any - * attempt to fix the detection will be obstructed. As a result, we're left - * with little choice but to throw an error. Unfortunately, this also affects - * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), - * which rely on core-js. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - * @example - * - * _.isNative(Array.prototype.push); - * // => true - * - * _.isNative(_); - * // => false - */ - function isNative(value) { - if (isMaskable(value)) { - throw new Error(CORE_ERROR_TEXT) - } - return baseIsNative(value) - } - - /** - * Checks if `value` is `null`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `null`, else `false`. - * @example - * - * _.isNull(null); - * // => true - * - * _.isNull(void 0); - * // => false - */ - function isNull(value) { - return value === null - } - - /** - * Checks if `value` is `null` or `undefined`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is nullish, else `false`. - * @example - * - * _.isNil(null); - * // => true - * - * _.isNil(void 0); - * // => true - * - * _.isNil(NaN); - * // => false - */ - function isNil(value) { - return value == null - } - - /** - * Checks if `value` is classified as a `Number` primitive or object. - * - * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are - * classified as numbers, use the `_.isFinite` method. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a number, else `false`. - * @example - * - * _.isNumber(3); - * // => true - * - * _.isNumber(Number.MIN_VALUE); - * // => true - * - * _.isNumber(Infinity); - * // => true - * - * _.isNumber('3'); - * // => false - */ - function isNumber(value) { - return ( - typeof value == "number" || - (isObjectLike(value) && baseGetTag(value) == numberTag) - ) - } - - /** - * Checks if `value` is a plain object, that is, an object created by the - * `Object` constructor or one with a `[[Prototype]]` of `null`. - * - * @static - * @memberOf _ - * @since 0.8.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * _.isPlainObject(new Foo); - * // => false - * - * _.isPlainObject([1, 2, 3]); - * // => false - * - * _.isPlainObject({ 'x': 0, 'y': 0 }); - * // => true - * - * _.isPlainObject(Object.create(null)); - * // => true - */ - function isPlainObject(value) { - if (!isObjectLike(value) || baseGetTag(value) != objectTag) { - return false - } - var proto = getPrototype(value) - if (proto === null) { - return true - } - var Ctor = - hasOwnProperty.call(proto, "constructor") && proto.constructor - return ( - typeof Ctor == "function" && - Ctor instanceof Ctor && - funcToString.call(Ctor) == objectCtorString - ) - } - - /** - * Checks if `value` is classified as a `RegExp` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. - * @example - * - * _.isRegExp(/abc/); - * // => true - * - * _.isRegExp('/abc/'); - * // => false - */ - var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp - - /** - * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 - * double precision number which isn't the result of a rounded unsafe integer. - * - * **Note:** This method is based on - * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`. - * @example - * - * _.isSafeInteger(3); - * // => true - * - * _.isSafeInteger(Number.MIN_VALUE); - * // => false - * - * _.isSafeInteger(Infinity); - * // => false - * - * _.isSafeInteger('3'); - * // => false - */ - function isSafeInteger(value) { - return ( - isInteger(value) && - value >= -MAX_SAFE_INTEGER && - value <= MAX_SAFE_INTEGER - ) - } - - /** - * Checks if `value` is classified as a `Set` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a set, else `false`. - * @example - * - * _.isSet(new Set); - * // => true - * - * _.isSet(new WeakSet); - * // => false - */ - var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet - - /** - * Checks if `value` is classified as a `String` primitive or object. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a string, else `false`. - * @example - * - * _.isString('abc'); - * // => true - * - * _.isString(1); - * // => false - */ - function isString(value) { - return ( - typeof value == "string" || - (!isArray(value) && - isObjectLike(value) && - baseGetTag(value) == stringTag) - ) - } - - /** - * Checks if `value` is classified as a `Symbol` primitive or object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. - * @example - * - * _.isSymbol(Symbol.iterator); - * // => true - * - * _.isSymbol('abc'); - * // => false - */ - function isSymbol(value) { - return ( - typeof value == "symbol" || - (isObjectLike(value) && baseGetTag(value) == symbolTag) - ) - } - - /** - * Checks if `value` is classified as a typed array. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - * @example - * - * _.isTypedArray(new Uint8Array); - * // => true - * - * _.isTypedArray([]); - * // => false - */ - var isTypedArray = nodeIsTypedArray - ? baseUnary(nodeIsTypedArray) - : baseIsTypedArray - - /** - * Checks if `value` is `undefined`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. - * @example - * - * _.isUndefined(void 0); - * // => true - * - * _.isUndefined(null); - * // => false - */ - function isUndefined(value) { - return value === undefined$1 - } - - /** - * Checks if `value` is classified as a `WeakMap` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a weak map, else `false`. - * @example - * - * _.isWeakMap(new WeakMap); - * // => true - * - * _.isWeakMap(new Map); - * // => false - */ - function isWeakMap(value) { - return isObjectLike(value) && getTag(value) == weakMapTag - } - - /** - * Checks if `value` is classified as a `WeakSet` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a weak set, else `false`. - * @example - * - * _.isWeakSet(new WeakSet); - * // => true - * - * _.isWeakSet(new Set); - * // => false - */ - function isWeakSet(value) { - return isObjectLike(value) && baseGetTag(value) == weakSetTag - } - - /** - * Checks if `value` is less than `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than `other`, - * else `false`. - * @see _.gt - * @example - * - * _.lt(1, 3); - * // => true - * - * _.lt(3, 3); - * // => false - * - * _.lt(3, 1); - * // => false - */ - var lt = createRelationalOperation(baseLt) - - /** - * Checks if `value` is less than or equal to `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than or equal to - * `other`, else `false`. - * @see _.gte - * @example - * - * _.lte(1, 3); - * // => true - * - * _.lte(3, 3); - * // => true - * - * _.lte(3, 1); - * // => false - */ - var lte = createRelationalOperation(function(value, other) { - return value <= other - }) - - /** - * Converts `value` to an array. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to convert. - * @returns {Array} Returns the converted array. - * @example - * - * _.toArray({ 'a': 1, 'b': 2 }); - * // => [1, 2] - * - * _.toArray('abc'); - * // => ['a', 'b', 'c'] - * - * _.toArray(1); - * // => [] - * - * _.toArray(null); - * // => [] - */ - function toArray(value) { - if (!value) { - return [] - } - if (isArrayLike(value)) { - return isString(value) ? stringToArray(value) : copyArray(value) - } - if (symIterator && value[symIterator]) { - return iteratorToArray(value[symIterator]()) - } - var tag = getTag(value), - func = - tag == mapTag ? mapToArray : tag == setTag ? setToArray : values - - return func(value) - } - - /** - * Converts `value` to a finite number. - * - * @static - * @memberOf _ - * @since 4.12.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted number. - * @example - * - * _.toFinite(3.2); - * // => 3.2 - * - * _.toFinite(Number.MIN_VALUE); - * // => 5e-324 - * - * _.toFinite(Infinity); - * // => 1.7976931348623157e+308 - * - * _.toFinite('3.2'); - * // => 3.2 - */ - function toFinite(value) { - if (!value) { - return value === 0 ? value : 0 - } - value = toNumber(value) - if (value === INFINITY || value === -INFINITY) { - var sign = value < 0 ? -1 : 1 - return sign * MAX_INTEGER - } - return value === value ? value : 0 - } - - /** - * Converts `value` to an integer. - * - * **Note:** This method is loosely based on - * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toInteger(3.2); - * // => 3 - * - * _.toInteger(Number.MIN_VALUE); - * // => 0 - * - * _.toInteger(Infinity); - * // => 1.7976931348623157e+308 - * - * _.toInteger('3.2'); - * // => 3 - */ - function toInteger(value) { - var result = toFinite(value), - remainder = result % 1 - - return result === result - ? remainder - ? result - remainder - : result - : 0 - } - - /** - * Converts `value` to an integer suitable for use as the length of an - * array-like object. - * - * **Note:** This method is based on - * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toLength(3.2); - * // => 3 - * - * _.toLength(Number.MIN_VALUE); - * // => 0 - * - * _.toLength(Infinity); - * // => 4294967295 - * - * _.toLength('3.2'); - * // => 3 - */ - function toLength(value) { - return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0 - } - - /** - * Converts `value` to a number. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to process. - * @returns {number} Returns the number. - * @example - * - * _.toNumber(3.2); - * // => 3.2 - * - * _.toNumber(Number.MIN_VALUE); - * // => 5e-324 - * - * _.toNumber(Infinity); - * // => Infinity - * - * _.toNumber('3.2'); - * // => 3.2 - */ - function toNumber(value) { - if (typeof value == "number") { - return value - } - if (isSymbol(value)) { - return NAN - } - if (isObject(value)) { - var other = - typeof value.valueOf == "function" ? value.valueOf() : value - value = isObject(other) ? other + "" : other - } - if (typeof value != "string") { - return value === 0 ? value : +value - } - value = value.replace(reTrim, "") - var isBinary = reIsBinary.test(value) - return isBinary || reIsOctal.test(value) - ? freeParseInt(value.slice(2), isBinary ? 2 : 8) - : reIsBadHex.test(value) - ? NAN - : +value - } - - /** - * Converts `value` to a plain object flattening inherited enumerable string - * keyed properties of `value` to own properties of the plain object. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {Object} Returns the converted plain object. - * @example - * - * function Foo() { - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.assign({ 'a': 1 }, new Foo); - * // => { 'a': 1, 'b': 2 } - * - * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); - * // => { 'a': 1, 'b': 2, 'c': 3 } - */ - function toPlainObject(value) { - return copyObject(value, keysIn(value)) - } - - /** - * Converts `value` to a safe integer. A safe integer can be compared and - * represented correctly. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toSafeInteger(3.2); - * // => 3 - * - * _.toSafeInteger(Number.MIN_VALUE); - * // => 0 - * - * _.toSafeInteger(Infinity); - * // => 9007199254740991 - * - * _.toSafeInteger('3.2'); - * // => 3 - */ - function toSafeInteger(value) { - return value - ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) - : value === 0 - ? value - : 0 - } - - /** - * Converts `value` to a string. An empty string is returned for `null` - * and `undefined` values. The sign of `-0` is preserved. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - * @example - * - * _.toString(null); - * // => '' - * - * _.toString(-0); - * // => '-0' - * - * _.toString([1, 2, 3]); - * // => '1,2,3' - */ - function toString(value) { - return value == null ? "" : baseToString(value) - } - - /*------------------------------------------------------------------------*/ - - /** - * Assigns own enumerable string keyed properties of source objects to the - * destination object. Source objects are applied from left to right. - * Subsequent sources overwrite property assignments of previous sources. - * - * **Note:** This method mutates `object` and is loosely based on - * [`Object.assign`](https://mdn.io/Object/assign). - * - * @static - * @memberOf _ - * @since 0.10.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.assignIn - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * function Bar() { - * this.c = 3; - * } - * - * Foo.prototype.b = 2; - * Bar.prototype.d = 4; - * - * _.assign({ 'a': 0 }, new Foo, new Bar); - * // => { 'a': 1, 'c': 3 } - */ - var assign = createAssigner(function(object, source) { - if (isPrototype(source) || isArrayLike(source)) { - copyObject(source, keys(source), object) - return - } - for (var key in source) { - if (hasOwnProperty.call(source, key)) { - assignValue(object, key, source[key]) - } - } - }) - - /** - * This method is like `_.assign` except that it iterates over own and - * inherited source properties. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias extend - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.assign - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * function Bar() { - * this.c = 3; - * } - * - * Foo.prototype.b = 2; - * Bar.prototype.d = 4; - * - * _.assignIn({ 'a': 0 }, new Foo, new Bar); - * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } - */ - var assignIn = createAssigner(function(object, source) { - copyObject(source, keysIn(source), object) - }) - - /** - * This method is like `_.assignIn` except that it accepts `customizer` - * which is invoked to produce the assigned values. If `customizer` returns - * `undefined`, assignment is handled by the method instead. The `customizer` - * is invoked with five arguments: (objValue, srcValue, key, object, source). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias extendWith - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @see _.assignWith - * @example - * - * function customizer(objValue, srcValue) { - * return _.isUndefined(objValue) ? srcValue : objValue; - * } - * - * var defaults = _.partialRight(_.assignInWith, customizer); - * - * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var assignInWith = createAssigner(function( - object, - source, - srcIndex, - customizer - ) { - copyObject(source, keysIn(source), object, customizer) - }) - - /** - * This method is like `_.assign` except that it accepts `customizer` - * which is invoked to produce the assigned values. If `customizer` returns - * `undefined`, assignment is handled by the method instead. The `customizer` - * is invoked with five arguments: (objValue, srcValue, key, object, source). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @see _.assignInWith - * @example - * - * function customizer(objValue, srcValue) { - * return _.isUndefined(objValue) ? srcValue : objValue; - * } - * - * var defaults = _.partialRight(_.assignWith, customizer); - * - * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var assignWith = createAssigner(function( - object, - source, - srcIndex, - customizer - ) { - copyObject(source, keys(source), object, customizer) - }) - - /** - * Creates an array of values corresponding to `paths` of `object`. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Array} Returns the picked values. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; - * - * _.at(object, ['a[0].b.c', 'a[1]']); - * // => [3, 4] - */ - var at = flatRest(baseAt) - - /** - * Creates an object that inherits from the `prototype` object. If a - * `properties` object is given, its own enumerable string keyed properties - * are assigned to the created object. - * - * @static - * @memberOf _ - * @since 2.3.0 - * @category Object - * @param {Object} prototype The object to inherit from. - * @param {Object} [properties] The properties to assign to the object. - * @returns {Object} Returns the new object. - * @example - * - * function Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * function Circle() { - * Shape.call(this); - * } - * - * Circle.prototype = _.create(Shape.prototype, { - * 'constructor': Circle - * }); - * - * var circle = new Circle; - * circle instanceof Circle; - * // => true - * - * circle instanceof Shape; - * // => true - */ - function create(prototype, properties) { - var result = baseCreate(prototype) - return properties == null ? result : baseAssign(result, properties) - } - - /** - * Assigns own and inherited enumerable string keyed properties of source - * objects to the destination object for all destination properties that - * resolve to `undefined`. Source objects are applied from left to right. - * Once a property is set, additional values of the same property are ignored. - * - * **Note:** This method mutates `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.defaultsDeep - * @example - * - * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var defaults = baseRest(function(object, sources) { - object = Object(object) - - var index = -1 - var length = sources.length - var guard = length > 2 ? sources[2] : undefined$1 - - if (guard && isIterateeCall(sources[0], sources[1], guard)) { - length = 1 - } - - while (++index < length) { - var source = sources[index] - var props = keysIn(source) - var propsIndex = -1 - var propsLength = props.length - - while (++propsIndex < propsLength) { - var key = props[propsIndex] - var value = object[key] - - if ( - value === undefined$1 || - (eq(value, objectProto[key]) && - !hasOwnProperty.call(object, key)) - ) { - object[key] = source[key] - } - } - } - - return object - }) - - /** - * This method is like `_.defaults` except that it recursively assigns - * default properties. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 3.10.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.defaults - * @example - * - * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); - * // => { 'a': { 'b': 2, 'c': 3 } } - */ - var defaultsDeep = baseRest(function(args) { - args.push(undefined$1, customDefaultsMerge) - return apply(mergeWith, undefined$1, args) - }) - - /** - * This method is like `_.find` except that it returns the key of the first - * element `predicate` returns truthy for instead of the element itself. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Object - * @param {Object} object The object to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {string|undefined} Returns the key of the matched element, - * else `undefined`. - * @example - * - * var users = { - * 'barney': { 'age': 36, 'active': true }, - * 'fred': { 'age': 40, 'active': false }, - * 'pebbles': { 'age': 1, 'active': true } - * }; - * - * _.findKey(users, function(o) { return o.age < 40; }); - * // => 'barney' (iteration order is not guaranteed) - * - * // The `_.matches` iteratee shorthand. - * _.findKey(users, { 'age': 1, 'active': true }); - * // => 'pebbles' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findKey(users, ['active', false]); - * // => 'fred' - * - * // The `_.property` iteratee shorthand. - * _.findKey(users, 'active'); - * // => 'barney' - */ - function findKey(object, predicate) { - return baseFindKey(object, getIteratee(predicate, 3), baseForOwn) - } - - /** - * This method is like `_.findKey` except that it iterates over elements of - * a collection in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {string|undefined} Returns the key of the matched element, - * else `undefined`. - * @example - * - * var users = { - * 'barney': { 'age': 36, 'active': true }, - * 'fred': { 'age': 40, 'active': false }, - * 'pebbles': { 'age': 1, 'active': true } - * }; - * - * _.findLastKey(users, function(o) { return o.age < 40; }); - * // => returns 'pebbles' assuming `_.findKey` returns 'barney' - * - * // The `_.matches` iteratee shorthand. - * _.findLastKey(users, { 'age': 36, 'active': true }); - * // => 'barney' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findLastKey(users, ['active', false]); - * // => 'fred' - * - * // The `_.property` iteratee shorthand. - * _.findLastKey(users, 'active'); - * // => 'pebbles' - */ - function findLastKey(object, predicate) { - return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight) - } - - /** - * Iterates over own and inherited enumerable string keyed properties of an - * object and invokes `iteratee` for each property. The iteratee is invoked - * with three arguments: (value, key, object). Iteratee functions may exit - * iteration early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 0.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forInRight - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forIn(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). - */ - function forIn(object, iteratee) { - return object == null - ? object - : baseFor(object, getIteratee(iteratee, 3), keysIn) - } - - /** - * This method is like `_.forIn` except that it iterates over properties of - * `object` in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forIn - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forInRight(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. - */ - function forInRight(object, iteratee) { - return object == null - ? object - : baseForRight(object, getIteratee(iteratee, 3), keysIn) - } - - /** - * Iterates over own enumerable string keyed properties of an object and - * invokes `iteratee` for each property. The iteratee is invoked with three - * arguments: (value, key, object). Iteratee functions may exit iteration - * early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 0.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forOwnRight - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forOwn(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a' then 'b' (iteration order is not guaranteed). - */ - function forOwn(object, iteratee) { - return object && baseForOwn(object, getIteratee(iteratee, 3)) - } - - /** - * This method is like `_.forOwn` except that it iterates over properties of - * `object` in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forOwn - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forOwnRight(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. - */ - function forOwnRight(object, iteratee) { - return object && baseForOwnRight(object, getIteratee(iteratee, 3)) - } - - /** - * Creates an array of function property names from own enumerable properties - * of `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to inspect. - * @returns {Array} Returns the function names. - * @see _.functionsIn - * @example - * - * function Foo() { - * this.a = _.constant('a'); - * this.b = _.constant('b'); - * } - * - * Foo.prototype.c = _.constant('c'); - * - * _.functions(new Foo); - * // => ['a', 'b'] - */ - function functions(object) { - return object == null ? [] : baseFunctions(object, keys(object)) - } - - /** - * Creates an array of function property names from own and inherited - * enumerable properties of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to inspect. - * @returns {Array} Returns the function names. - * @see _.functions - * @example - * - * function Foo() { - * this.a = _.constant('a'); - * this.b = _.constant('b'); - * } - * - * Foo.prototype.c = _.constant('c'); - * - * _.functionsIn(new Foo); - * // => ['a', 'b', 'c'] - */ - function functionsIn(object) { - return object == null ? [] : baseFunctions(object, keysIn(object)) - } - - /** - * Gets the value at `path` of `object`. If the resolved value is - * `undefined`, the `defaultValue` is returned in its place. - * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.get(object, 'a[0].b.c'); - * // => 3 - * - * _.get(object, ['a', '0', 'b', 'c']); - * // => 3 - * - * _.get(object, 'a.b.c', 'default'); - * // => 'default' - */ - function get(object, path, defaultValue) { - var result = object == null ? undefined$1 : baseGet(object, path) - return result === undefined$1 ? defaultValue : result - } - - /** - * Checks if `path` is a direct property of `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - * @example - * - * var object = { 'a': { 'b': 2 } }; - * var other = _.create({ 'a': _.create({ 'b': 2 }) }); - * - * _.has(object, 'a'); - * // => true - * - * _.has(object, 'a.b'); - * // => true - * - * _.has(object, ['a', 'b']); - * // => true - * - * _.has(other, 'a'); - * // => false - */ - function has(object, path) { - return object != null && hasPath(object, path, baseHas) - } - - /** - * Checks if `path` is a direct or inherited property of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - * @example - * - * var object = _.create({ 'a': _.create({ 'b': 2 }) }); - * - * _.hasIn(object, 'a'); - * // => true - * - * _.hasIn(object, 'a.b'); - * // => true - * - * _.hasIn(object, ['a', 'b']); - * // => true - * - * _.hasIn(object, 'b'); - * // => false - */ - function hasIn(object, path) { - return object != null && hasPath(object, path, baseHasIn) - } - - /** - * Creates an object composed of the inverted keys and values of `object`. - * If `object` contains duplicate values, subsequent values overwrite - * property assignments of previous values. - * - * @static - * @memberOf _ - * @since 0.7.0 - * @category Object - * @param {Object} object The object to invert. - * @returns {Object} Returns the new inverted object. - * @example - * - * var object = { 'a': 1, 'b': 2, 'c': 1 }; - * - * _.invert(object); - * // => { '1': 'c', '2': 'b' } - */ - var invert = createInverter(function(result, value, key) { - if (value != null && typeof value.toString != "function") { - value = nativeObjectToString.call(value) - } - - result[value] = key - }, constant(identity)) - - /** - * This method is like `_.invert` except that the inverted object is generated - * from the results of running each element of `object` thru `iteratee`. The - * corresponding inverted value of each inverted key is an array of keys - * responsible for generating the inverted value. The iteratee is invoked - * with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.1.0 - * @category Object - * @param {Object} object The object to invert. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Object} Returns the new inverted object. - * @example - * - * var object = { 'a': 1, 'b': 2, 'c': 1 }; - * - * _.invertBy(object); - * // => { '1': ['a', 'c'], '2': ['b'] } - * - * _.invertBy(object, function(value) { - * return 'group' + value; - * }); - * // => { 'group1': ['a', 'c'], 'group2': ['b'] } - */ - var invertBy = createInverter(function(result, value, key) { - if (value != null && typeof value.toString != "function") { - value = nativeObjectToString.call(value) - } - - if (hasOwnProperty.call(result, value)) { - result[value].push(key) - } else { - result[value] = [key] - } - }, getIteratee) - - /** - * Invokes the method at `path` of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the method to invoke. - * @param {...*} [args] The arguments to invoke the method with. - * @returns {*} Returns the result of the invoked method. - * @example - * - * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; - * - * _.invoke(object, 'a[0].b.c.slice', 1, 3); - * // => [2, 3] - */ - var invoke = baseRest(baseInvoke) - - /** - * Creates an array of the own enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. See the - * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * for more details. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keys(new Foo); - * // => ['a', 'b'] (iteration order is not guaranteed) - * - * _.keys('hi'); - * // => ['0', '1'] - */ - function keys(object) { - return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object) - } - - /** - * Creates an array of the own and inherited enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keysIn(new Foo); - * // => ['a', 'b', 'c'] (iteration order is not guaranteed) - */ - function keysIn(object) { - return isArrayLike(object) - ? arrayLikeKeys(object, true) - : baseKeysIn(object) - } - - /** - * The opposite of `_.mapValues`; this method creates an object with the - * same values as `object` and keys generated by running each own enumerable - * string keyed property of `object` thru `iteratee`. The iteratee is invoked - * with three arguments: (value, key, object). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns the new mapped object. - * @see _.mapValues - * @example - * - * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { - * return key + value; - * }); - * // => { 'a1': 1, 'b2': 2 } - */ - function mapKeys(object, iteratee) { - var result = {} - iteratee = getIteratee(iteratee, 3) - - baseForOwn(object, function(value, key, object) { - baseAssignValue(result, iteratee(value, key, object), value) - }) - return result - } - - /** - * Creates an object with the same keys as `object` and values generated - * by running each own enumerable string keyed property of `object` thru - * `iteratee`. The iteratee is invoked with three arguments: - * (value, key, object). - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns the new mapped object. - * @see _.mapKeys - * @example - * - * var users = { - * 'fred': { 'user': 'fred', 'age': 40 }, - * 'pebbles': { 'user': 'pebbles', 'age': 1 } - * }; - * - * _.mapValues(users, function(o) { return o.age; }); - * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) - * - * // The `_.property` iteratee shorthand. - * _.mapValues(users, 'age'); - * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) - */ - function mapValues(object, iteratee) { - var result = {} - iteratee = getIteratee(iteratee, 3) - - baseForOwn(object, function(value, key, object) { - baseAssignValue(result, key, iteratee(value, key, object)) - }) - return result - } - - /** - * This method is like `_.assign` except that it recursively merges own and - * inherited enumerable string keyed properties of source objects into the - * destination object. Source properties that resolve to `undefined` are - * skipped if a destination value exists. Array and plain object properties - * are merged recursively. Other objects and value types are overridden by - * assignment. Source objects are applied from left to right. Subsequent - * sources overwrite property assignments of previous sources. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @example - * - * var object = { - * 'a': [{ 'b': 2 }, { 'd': 4 }] - * }; - * - * var other = { - * 'a': [{ 'c': 3 }, { 'e': 5 }] - * }; - * - * _.merge(object, other); - * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } - */ - var merge = createAssigner(function(object, source, srcIndex) { - baseMerge(object, source, srcIndex) - }) - - /** - * This method is like `_.merge` except that it accepts `customizer` which - * is invoked to produce the merged values of the destination and source - * properties. If `customizer` returns `undefined`, merging is handled by the - * method instead. The `customizer` is invoked with six arguments: - * (objValue, srcValue, key, object, source, stack). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} customizer The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * function customizer(objValue, srcValue) { - * if (_.isArray(objValue)) { - * return objValue.concat(srcValue); - * } - * } - * - * var object = { 'a': [1], 'b': [2] }; - * var other = { 'a': [3], 'b': [4] }; - * - * _.mergeWith(object, other, customizer); - * // => { 'a': [1, 3], 'b': [2, 4] } - */ - var mergeWith = createAssigner(function( - object, - source, - srcIndex, - customizer - ) { - baseMerge(object, source, srcIndex, customizer) - }) - - /** - * The opposite of `_.pick`; this method creates an object composed of the - * own and inherited enumerable property paths of `object` that are not omitted. - * - * **Note:** This method is considerably slower than `_.pick`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The source object. - * @param {...(string|string[])} [paths] The property paths to omit. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.omit(object, ['a', 'c']); - * // => { 'b': '2' } - */ - var omit = flatRest(function(object, paths) { - var result = {} - if (object == null) { - return result - } - var isDeep = false - paths = arrayMap(paths, function(path) { - path = castPath(path, object) - isDeep || (isDeep = path.length > 1) - return path - }) - copyObject(object, getAllKeysIn(object), result) - if (isDeep) { - result = baseClone( - result, - CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, - customOmitClone - ) - } - var length = paths.length - while (length--) { - baseUnset(result, paths[length]) - } - return result - }) - - /** - * The opposite of `_.pickBy`; this method creates an object composed of - * the own and inherited enumerable string keyed properties of `object` that - * `predicate` doesn't return truthy for. The predicate is invoked with two - * arguments: (value, key). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The source object. - * @param {Function} [predicate=_.identity] The function invoked per property. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.omitBy(object, _.isNumber); - * // => { 'b': '2' } - */ - function omitBy(object, predicate) { - return pickBy(object, negate(getIteratee(predicate))) - } - - /** - * Creates an object composed of the picked `object` properties. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The source object. - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.pick(object, ['a', 'c']); - * // => { 'a': 1, 'c': 3 } - */ - var pick = flatRest(function(object, paths) { - return object == null ? {} : basePick(object, paths) - }) - - /** - * Creates an object composed of the `object` properties `predicate` returns - * truthy for. The predicate is invoked with two arguments: (value, key). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The source object. - * @param {Function} [predicate=_.identity] The function invoked per property. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.pickBy(object, _.isNumber); - * // => { 'a': 1, 'c': 3 } - */ - function pickBy(object, predicate) { - if (object == null) { - return {} - } - var props = arrayMap(getAllKeysIn(object), function(prop) { - return [prop] - }) - predicate = getIteratee(predicate) - return basePickBy(object, props, function(value, path) { - return predicate(value, path[0]) - }) - } - - /** - * This method is like `_.get` except that if the resolved value is a - * function it's invoked with the `this` binding of its parent object and - * its result is returned. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to resolve. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; - * - * _.result(object, 'a[0].b.c1'); - * // => 3 - * - * _.result(object, 'a[0].b.c2'); - * // => 4 - * - * _.result(object, 'a[0].b.c3', 'default'); - * // => 'default' - * - * _.result(object, 'a[0].b.c3', _.constant('default')); - * // => 'default' - */ - function result(object, path, defaultValue) { - path = castPath(path, object) - - var index = -1, - length = path.length - - // Ensure the loop is entered when path is empty. - if (!length) { - length = 1 - object = undefined$1 - } - while (++index < length) { - var value = - object == null ? undefined$1 : object[toKey(path[index])] - if (value === undefined$1) { - index = length - value = defaultValue - } - object = isFunction(value) ? value.call(object) : value - } - return object - } - - /** - * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, - * it's created. Arrays are created for missing index properties while objects - * are created for all other missing properties. Use `_.setWith` to customize - * `path` creation. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @returns {Object} Returns `object`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.set(object, 'a[0].b.c', 4); - * console.log(object.a[0].b.c); - * // => 4 - * - * _.set(object, ['x', '0', 'y', 'z'], 5); - * console.log(object.x[0].y.z); - * // => 5 - */ - function set(object, path, value) { - return object == null ? object : baseSet(object, path, value) - } - - /** - * This method is like `_.set` except that it accepts `customizer` which is - * invoked to produce the objects of `path`. If `customizer` returns `undefined` - * path creation is handled by the method instead. The `customizer` is invoked - * with three arguments: (nsValue, key, nsObject). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * var object = {}; - * - * _.setWith(object, '[0][1]', 'a', Object); - * // => { '0': { '1': 'a' } } - */ - function setWith(object, path, value, customizer) { - customizer = - typeof customizer == "function" ? customizer : undefined$1 - return object == null - ? object - : baseSet(object, path, value, customizer) - } - - /** - * Creates an array of own enumerable string keyed-value pairs for `object` - * which can be consumed by `_.fromPairs`. If `object` is a map or set, its - * entries are returned. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias entries - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the key-value pairs. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.toPairs(new Foo); - * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) - */ - var toPairs = createToPairs(keys) - - /** - * Creates an array of own and inherited enumerable string keyed-value pairs - * for `object` which can be consumed by `_.fromPairs`. If `object` is a map - * or set, its entries are returned. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias entriesIn - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the key-value pairs. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.toPairsIn(new Foo); - * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) - */ - var toPairsIn = createToPairs(keysIn) - - /** - * An alternative to `_.reduce`; this method transforms `object` to a new - * `accumulator` object which is the result of running each of its own - * enumerable string keyed properties thru `iteratee`, with each invocation - * potentially mutating the `accumulator` object. If `accumulator` is not - * provided, a new object with the same `[[Prototype]]` will be used. The - * iteratee is invoked with four arguments: (accumulator, value, key, object). - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 1.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The custom accumulator value. - * @returns {*} Returns the accumulated value. - * @example - * - * _.transform([2, 3, 4], function(result, n) { - * result.push(n *= n); - * return n % 2 == 0; - * }, []); - * // => [4, 9] - * - * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { - * (result[value] || (result[value] = [])).push(key); - * }, {}); - * // => { '1': ['a', 'c'], '2': ['b'] } - */ - function transform(object, iteratee, accumulator) { - var isArr = isArray(object), - isArrLike = isArr || isBuffer(object) || isTypedArray(object) - - iteratee = getIteratee(iteratee, 4) - if (accumulator == null) { - var Ctor = object && object.constructor - if (isArrLike) { - accumulator = isArr ? new Ctor() : [] - } else if (isObject(object)) { - accumulator = isFunction(Ctor) - ? baseCreate(getPrototype(object)) - : {} - } else { - accumulator = {} - } - } - ;(isArrLike ? arrayEach : baseForOwn)(object, function( - value, - index, - object - ) { - return iteratee(accumulator, value, index, object) - }) - return accumulator - } - - /** - * Removes the property at `path` of `object`. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to unset. - * @returns {boolean} Returns `true` if the property is deleted, else `false`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 7 } }] }; - * _.unset(object, 'a[0].b.c'); - * // => true - * - * console.log(object); - * // => { 'a': [{ 'b': {} }] }; - * - * _.unset(object, ['a', '0', 'b', 'c']); - * // => true - * - * console.log(object); - * // => { 'a': [{ 'b': {} }] }; - */ - function unset(object, path) { - return object == null ? true : baseUnset(object, path) - } - - /** - * This method is like `_.set` except that accepts `updater` to produce the - * value to set. Use `_.updateWith` to customize `path` creation. The `updater` - * is invoked with one argument: (value). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {Function} updater The function to produce the updated value. - * @returns {Object} Returns `object`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.update(object, 'a[0].b.c', function(n) { return n * n; }); - * console.log(object.a[0].b.c); - * // => 9 - * - * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); - * console.log(object.x[0].y.z); - * // => 0 - */ - function update(object, path, updater) { - return object == null - ? object - : baseUpdate(object, path, castFunction(updater)) - } - - /** - * This method is like `_.update` except that it accepts `customizer` which is - * invoked to produce the objects of `path`. If `customizer` returns `undefined` - * path creation is handled by the method instead. The `customizer` is invoked - * with three arguments: (nsValue, key, nsObject). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {Function} updater The function to produce the updated value. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * var object = {}; - * - * _.updateWith(object, '[0][1]', _.constant('a'), Object); - * // => { '0': { '1': 'a' } } - */ - function updateWith(object, path, updater, customizer) { - customizer = - typeof customizer == "function" ? customizer : undefined$1 - return object == null - ? object - : baseUpdate(object, path, castFunction(updater), customizer) - } - - /** - * Creates an array of the own enumerable string keyed property values of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property values. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.values(new Foo); - * // => [1, 2] (iteration order is not guaranteed) - * - * _.values('hi'); - * // => ['h', 'i'] - */ - function values(object) { - return object == null ? [] : baseValues(object, keys(object)) - } - - /** - * Creates an array of the own and inherited enumerable string keyed property - * values of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property values. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.valuesIn(new Foo); - * // => [1, 2, 3] (iteration order is not guaranteed) - */ - function valuesIn(object) { - return object == null ? [] : baseValues(object, keysIn(object)) - } - - /*------------------------------------------------------------------------*/ - - /** - * Clamps `number` within the inclusive `lower` and `upper` bounds. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Number - * @param {number} number The number to clamp. - * @param {number} [lower] The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the clamped number. - * @example - * - * _.clamp(-10, -5, 5); - * // => -5 - * - * _.clamp(10, -5, 5); - * // => 5 - */ - function clamp(number, lower, upper) { - if (upper === undefined$1) { - upper = lower - lower = undefined$1 - } - if (upper !== undefined$1) { - upper = toNumber(upper) - upper = upper === upper ? upper : 0 - } - if (lower !== undefined$1) { - lower = toNumber(lower) - lower = lower === lower ? lower : 0 - } - return baseClamp(toNumber(number), lower, upper) - } - - /** - * Checks if `n` is between `start` and up to, but not including, `end`. If - * `end` is not specified, it's set to `start` with `start` then set to `0`. - * If `start` is greater than `end` the params are swapped to support - * negative ranges. - * - * @static - * @memberOf _ - * @since 3.3.0 - * @category Number - * @param {number} number The number to check. - * @param {number} [start=0] The start of the range. - * @param {number} end The end of the range. - * @returns {boolean} Returns `true` if `number` is in the range, else `false`. - * @see _.range, _.rangeRight - * @example - * - * _.inRange(3, 2, 4); - * // => true - * - * _.inRange(4, 8); - * // => true - * - * _.inRange(4, 2); - * // => false - * - * _.inRange(2, 2); - * // => false - * - * _.inRange(1.2, 2); - * // => true - * - * _.inRange(5.2, 4); - * // => false - * - * _.inRange(-3, -2, -6); - * // => true - */ - function inRange(number, start, end) { - start = toFinite(start) - if (end === undefined$1) { - end = start - start = 0 - } else { - end = toFinite(end) - } - number = toNumber(number) - return baseInRange(number, start, end) - } - - /** - * Produces a random number between the inclusive `lower` and `upper` bounds. - * If only one argument is provided a number between `0` and the given number - * is returned. If `floating` is `true`, or either `lower` or `upper` are - * floats, a floating-point number is returned instead of an integer. - * - * **Note:** JavaScript follows the IEEE-754 standard for resolving - * floating-point values which can produce unexpected results. - * - * @static - * @memberOf _ - * @since 0.7.0 - * @category Number - * @param {number} [lower=0] The lower bound. - * @param {number} [upper=1] The upper bound. - * @param {boolean} [floating] Specify returning a floating-point number. - * @returns {number} Returns the random number. - * @example - * - * _.random(0, 5); - * // => an integer between 0 and 5 - * - * _.random(5); - * // => also an integer between 0 and 5 - * - * _.random(5, true); - * // => a floating-point number between 0 and 5 - * - * _.random(1.2, 5.2); - * // => a floating-point number between 1.2 and 5.2 - */ - function random(lower, upper, floating) { - if ( - floating && - typeof floating != "boolean" && - isIterateeCall(lower, upper, floating) - ) { - upper = floating = undefined$1 - } - if (floating === undefined$1) { - if (typeof upper == "boolean") { - floating = upper - upper = undefined$1 - } else if (typeof lower == "boolean") { - floating = lower - lower = undefined$1 - } - } - if (lower === undefined$1 && upper === undefined$1) { - lower = 0 - upper = 1 - } else { - lower = toFinite(lower) - if (upper === undefined$1) { - upper = lower - lower = 0 - } else { - upper = toFinite(upper) - } - } - if (lower > upper) { - var temp = lower - lower = upper - upper = temp - } - if (floating || lower % 1 || upper % 1) { - var rand = nativeRandom() - return nativeMin( - lower + - rand * - (upper - - lower + - freeParseFloat("1e-" + ((rand + "").length - 1))), - upper - ) - } - return baseRandom(lower, upper) - } - - /*------------------------------------------------------------------------*/ - - /** - * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the camel cased string. - * @example - * - * _.camelCase('Foo Bar'); - * // => 'fooBar' - * - * _.camelCase('--foo-bar--'); - * // => 'fooBar' - * - * _.camelCase('__FOO_BAR__'); - * // => 'fooBar' - */ - var camelCase = createCompounder(function(result, word, index) { - word = word.toLowerCase() - return result + (index ? capitalize(word) : word) - }) - - /** - * Converts the first character of `string` to upper case and the remaining - * to lower case. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to capitalize. - * @returns {string} Returns the capitalized string. - * @example - * - * _.capitalize('FRED'); - * // => 'Fred' - */ - function capitalize(string) { - return upperFirst(toString(string).toLowerCase()) - } - - /** - * Deburrs `string` by converting - * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) - * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) - * letters to basic Latin letters and removing - * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to deburr. - * @returns {string} Returns the deburred string. - * @example - * - * _.deburr('déjà vu'); - * // => 'deja vu' - */ - function deburr(string) { - string = toString(string) - return ( - string && - string.replace(reLatin, deburrLetter).replace(reComboMark, "") - ) - } - - /** - * Checks if `string` ends with the given target string. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to inspect. - * @param {string} [target] The string to search for. - * @param {number} [position=string.length] The position to search up to. - * @returns {boolean} Returns `true` if `string` ends with `target`, - * else `false`. - * @example - * - * _.endsWith('abc', 'c'); - * // => true - * - * _.endsWith('abc', 'b'); - * // => false - * - * _.endsWith('abc', 'b', 2); - * // => true - */ - function endsWith(string, target, position) { - string = toString(string) - target = baseToString(target) - - var length = string.length - position = - position === undefined$1 - ? length - : baseClamp(toInteger(position), 0, length) - - var end = position - position -= target.length - return position >= 0 && string.slice(position, end) == target - } - - /** - * Converts the characters "&", "<", ">", '"', and "'" in `string` to their - * corresponding HTML entities. - * - * **Note:** No other characters are escaped. To escape additional - * characters use a third-party library like [_he_](https://mths.be/he). - * - * Though the ">" character is escaped for symmetry, characters like - * ">" and "/" don't need escaping in HTML and have no special meaning - * unless they're part of a tag or unquoted attribute value. See - * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) - * (under "semi-related fun fact") for more details. - * - * When working with HTML you should always - * [quote attribute values](http://wonko.com/post/html-escaping) to reduce - * XSS vectors. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category String - * @param {string} [string=''] The string to escape. - * @returns {string} Returns the escaped string. - * @example - * - * _.escape('fred, barney, & pebbles'); - * // => 'fred, barney, & pebbles' - */ - function escape(string) { - string = toString(string) - return string && reHasUnescapedHtml.test(string) - ? string.replace(reUnescapedHtml, escapeHtmlChar) - : string - } - - /** - * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", - * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to escape. - * @returns {string} Returns the escaped string. - * @example - * - * _.escapeRegExp('[lodash](https://lodash.com/)'); - * // => '\[lodash\]\(https://lodash\.com/\)' - */ - function escapeRegExp(string) { - string = toString(string) - return string && reHasRegExpChar.test(string) - ? string.replace(reRegExpChar, "\\$&") - : string - } - - /** - * Converts `string` to - * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the kebab cased string. - * @example - * - * _.kebabCase('Foo Bar'); - * // => 'foo-bar' - * - * _.kebabCase('fooBar'); - * // => 'foo-bar' - * - * _.kebabCase('__FOO_BAR__'); - * // => 'foo-bar' - */ - var kebabCase = createCompounder(function(result, word, index) { - return result + (index ? "-" : "") + word.toLowerCase() - }) - - /** - * Converts `string`, as space separated words, to lower case. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the lower cased string. - * @example - * - * _.lowerCase('--Foo-Bar--'); - * // => 'foo bar' - * - * _.lowerCase('fooBar'); - * // => 'foo bar' - * - * _.lowerCase('__FOO_BAR__'); - * // => 'foo bar' - */ - var lowerCase = createCompounder(function(result, word, index) { - return result + (index ? " " : "") + word.toLowerCase() - }) - - /** - * Converts the first character of `string` to lower case. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the converted string. - * @example - * - * _.lowerFirst('Fred'); - * // => 'fred' - * - * _.lowerFirst('FRED'); - * // => 'fRED' - */ - var lowerFirst = createCaseFirst("toLowerCase") - - /** - * Pads `string` on the left and right sides if it's shorter than `length`. - * Padding characters are truncated if they can't be evenly divided by `length`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.pad('abc', 8); - * // => ' abc ' - * - * _.pad('abc', 8, '_-'); - * // => '_-abc_-_' - * - * _.pad('abc', 3); - * // => 'abc' - */ - function pad(string, length, chars) { - string = toString(string) - length = toInteger(length) - - var strLength = length ? stringSize(string) : 0 - if (!length || strLength >= length) { - return string - } - var mid = (length - strLength) / 2 - return ( - createPadding(nativeFloor(mid), chars) + - string + - createPadding(nativeCeil(mid), chars) - ) - } - - /** - * Pads `string` on the right side if it's shorter than `length`. Padding - * characters are truncated if they exceed `length`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.padEnd('abc', 6); - * // => 'abc ' - * - * _.padEnd('abc', 6, '_-'); - * // => 'abc_-_' - * - * _.padEnd('abc', 3); - * // => 'abc' - */ - function padEnd(string, length, chars) { - string = toString(string) - length = toInteger(length) - - var strLength = length ? stringSize(string) : 0 - return length && strLength < length - ? string + createPadding(length - strLength, chars) - : string - } - - /** - * Pads `string` on the left side if it's shorter than `length`. Padding - * characters are truncated if they exceed `length`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.padStart('abc', 6); - * // => ' abc' - * - * _.padStart('abc', 6, '_-'); - * // => '_-_abc' - * - * _.padStart('abc', 3); - * // => 'abc' - */ - function padStart(string, length, chars) { - string = toString(string) - length = toInteger(length) - - var strLength = length ? stringSize(string) : 0 - return length && strLength < length - ? createPadding(length - strLength, chars) + string - : string - } - - /** - * Converts `string` to an integer of the specified radix. If `radix` is - * `undefined` or `0`, a `radix` of `10` is used unless `value` is a - * hexadecimal, in which case a `radix` of `16` is used. - * - * **Note:** This method aligns with the - * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category String - * @param {string} string The string to convert. - * @param {number} [radix=10] The radix to interpret `value` by. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {number} Returns the converted integer. - * @example - * - * _.parseInt('08'); - * // => 8 - * - * _.map(['6', '08', '10'], _.parseInt); - * // => [6, 8, 10] - */ - function parseInt(string, radix, guard) { - if (guard || radix == null) { - radix = 0 - } else if (radix) { - radix = +radix - } - return nativeParseInt( - toString(string).replace(reTrimStart, ""), - radix || 0 - ) - } - - /** - * Repeats the given string `n` times. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to repeat. - * @param {number} [n=1] The number of times to repeat the string. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {string} Returns the repeated string. - * @example - * - * _.repeat('*', 3); - * // => '***' - * - * _.repeat('abc', 2); - * // => 'abcabc' - * - * _.repeat('abc', 0); - * // => '' - */ - function repeat(string, n, guard) { - if (guard ? isIterateeCall(string, n, guard) : n === undefined$1) { - n = 1 - } else { - n = toInteger(n) - } - return baseRepeat(toString(string), n) - } - - /** - * Replaces matches for `pattern` in `string` with `replacement`. - * - * **Note:** This method is based on - * [`String#replace`](https://mdn.io/String/replace). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to modify. - * @param {RegExp|string} pattern The pattern to replace. - * @param {Function|string} replacement The match replacement. - * @returns {string} Returns the modified string. - * @example - * - * _.replace('Hi Fred', 'Fred', 'Barney'); - * // => 'Hi Barney' - */ - function replace() { - var args = arguments, - string = toString(args[0]) - - return args.length < 3 ? string : string.replace(args[1], args[2]) - } - - /** - * Converts `string` to - * [snake case](https://en.wikipedia.org/wiki/Snake_case). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the snake cased string. - * @example - * - * _.snakeCase('Foo Bar'); - * // => 'foo_bar' - * - * _.snakeCase('fooBar'); - * // => 'foo_bar' - * - * _.snakeCase('--FOO-BAR--'); - * // => 'foo_bar' - */ - var snakeCase = createCompounder(function(result, word, index) { - return result + (index ? "_" : "") + word.toLowerCase() - }) - - /** - * Splits `string` by `separator`. - * - * **Note:** This method is based on - * [`String#split`](https://mdn.io/String/split). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to split. - * @param {RegExp|string} separator The separator pattern to split by. - * @param {number} [limit] The length to truncate results to. - * @returns {Array} Returns the string segments. - * @example - * - * _.split('a-b-c', '-', 2); - * // => ['a', 'b'] - */ - function split(string, separator, limit) { - if ( - limit && - typeof limit != "number" && - isIterateeCall(string, separator, limit) - ) { - separator = limit = undefined$1 - } - limit = limit === undefined$1 ? MAX_ARRAY_LENGTH : limit >>> 0 - if (!limit) { - return [] - } - string = toString(string) - if ( - string && - (typeof separator == "string" || - (separator != null && !isRegExp(separator))) - ) { - separator = baseToString(separator) - if (!separator && hasUnicode(string)) { - return castSlice(stringToArray(string), 0, limit) - } - } - return string.split(separator, limit) - } - - /** - * Converts `string` to - * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). - * - * @static - * @memberOf _ - * @since 3.1.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the start cased string. - * @example - * - * _.startCase('--foo-bar--'); - * // => 'Foo Bar' - * - * _.startCase('fooBar'); - * // => 'Foo Bar' - * - * _.startCase('__FOO_BAR__'); - * // => 'FOO BAR' - */ - var startCase = createCompounder(function(result, word, index) { - return result + (index ? " " : "") + upperFirst(word) - }) - - /** - * Checks if `string` starts with the given target string. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to inspect. - * @param {string} [target] The string to search for. - * @param {number} [position=0] The position to search from. - * @returns {boolean} Returns `true` if `string` starts with `target`, - * else `false`. - * @example - * - * _.startsWith('abc', 'a'); - * // => true - * - * _.startsWith('abc', 'b'); - * // => false - * - * _.startsWith('abc', 'b', 1); - * // => true - */ - function startsWith(string, target, position) { - string = toString(string) - position = - position == null - ? 0 - : baseClamp(toInteger(position), 0, string.length) - - target = baseToString(target) - return string.slice(position, position + target.length) == target - } - - /** - * Creates a compiled template function that can interpolate data properties - * in "interpolate" delimiters, HTML-escape interpolated data properties in - * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data - * properties may be accessed as free variables in the template. If a setting - * object is given, it takes precedence over `_.templateSettings` values. - * - * **Note:** In the development build `_.template` utilizes - * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) - * for easier debugging. - * - * For more information on precompiling templates see - * [lodash's custom builds documentation](https://lodash.com/custom-builds). - * - * For more information on Chrome extension sandboxes see - * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category String - * @param {string} [string=''] The template string. - * @param {Object} [options={}] The options object. - * @param {RegExp} [options.escape=_.templateSettings.escape] - * The HTML "escape" delimiter. - * @param {RegExp} [options.evaluate=_.templateSettings.evaluate] - * The "evaluate" delimiter. - * @param {Object} [options.imports=_.templateSettings.imports] - * An object to import into the template as free variables. - * @param {RegExp} [options.interpolate=_.templateSettings.interpolate] - * The "interpolate" delimiter. - * @param {string} [options.sourceURL='lodash.templateSources[n]'] - * The sourceURL of the compiled template. - * @param {string} [options.variable='obj'] - * The data object variable name. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the compiled template function. - * @example - * - * // Use the "interpolate" delimiter to create a compiled template. - * var compiled = _.template('hello <%= user %>!'); - * compiled({ 'user': 'fred' }); - * // => 'hello fred!' - * - * // Use the HTML "escape" delimiter to escape data property values. - * var compiled = _.template('<%- value %>'); - * compiled({ 'value': '