| 1 | ;
|
| 2 | var task_resolve_1 = require("./task.resolve");
|
| 3 | var _ = require("../lodash.custom");
|
| 4 | var Rx = require("rx");
|
| 5 | var Observable = Rx.Observable;
|
| 6 | var adaptors = require("./adaptors");
|
| 7 | var Immutable = require("immutable");
|
| 8 | var task_sequence_factories_1 = require("./task.sequence.factories");
|
| 9 | var task_runner_1 = require("./task.runner");
|
| 10 | var task_utils_1 = require("./task.utils");
|
| 11 | function createFlattenedSequence(tasks, trigger) {
|
| 12 | return flatten(tasks, []);
|
| 13 | function flatten(items, initial, options, viaName) {
|
| 14 | return items.reduce(function (all, task) {
|
| 15 | /**
|
| 16 | * If the current task has child tasks, we build a tree of
|
| 17 | * nested observables for it (a task with children cannot itself
|
| 18 | * be a task that should be run)
|
| 19 | */
|
| 20 | if (task.type === task_resolve_1.TaskTypes.TaskGroup || task.type === task_resolve_1.TaskTypes.ParentGroup) {
|
| 21 | /**
|
| 22 | * If we're looking at a group of tasks that was run
|
| 23 | * with sub-tasks, we need to resolve differently to
|
| 24 | * allow things such as parallel running to work as expected
|
| 25 | */
|
| 26 | if (task.subTasks.length && task.tasks.length) {
|
| 27 | /**
|
| 28 | * Build the list of tasks/groups
|
| 29 | * @type {Array}
|
| 30 | */
|
| 31 | var output = resolveGroupOfTasks(task, trigger.input);
|
| 32 | /**
|
| 33 | * Wrap as parallel group if this task has a runMode of 'parallel'
|
| 34 | */
|
| 35 | if (task.runMode === task_resolve_1.TaskRunModes.parallel) {
|
| 36 | return all.concat(task_sequence_factories_1.createSequenceParallelGroup({
|
| 37 | taskName: task.taskName,
|
| 38 | items: output,
|
| 39 | skipped: task.skipped
|
| 40 | }));
|
| 41 | }
|
| 42 | /**
|
| 43 | * Wrap as a series group if this task has a runMode of 'series'
|
| 44 | */
|
| 45 | if (task.runMode === task_resolve_1.TaskRunModes.series) {
|
| 46 | return all.concat(task_sequence_factories_1.createSequenceSeriesGroup({
|
| 47 | taskName: task.taskName,
|
| 48 | items: output,
|
| 49 | skipped: task.skipped
|
| 50 | }));
|
| 51 | }
|
| 52 | }
|
| 53 | /**
|
| 54 | * If the current task was marked as `parallel`, all immediate children
|
| 55 | * of (this task) will be run in `parallel`
|
| 56 | */
|
| 57 | if (task.runMode === task_resolve_1.TaskRunModes.parallel) {
|
| 58 | return all.concat(resolveGroup(task, task_sequence_factories_1.createSequenceParallelGroup));
|
| 59 | }
|
| 60 | /**
|
| 61 | * If the current task was marked as `series`, all immediate child tasks
|
| 62 | * will be queued and run in series - each waiting until the previous
|
| 63 | * one has completed
|
| 64 | */
|
| 65 | if (task.runMode === task_resolve_1.TaskRunModes.series) {
|
| 66 | return all.concat(resolveGroup(task, task_sequence_factories_1.createSequenceSeriesGroup));
|
| 67 | }
|
| 68 | }
|
| 69 | /**
|
| 70 | * At this point, we must be dealing with a task that should be run,
|
| 71 | * so we first check if it's an adaptor @ task first
|
| 72 | */
|
| 73 | if (task.type === task_resolve_1.TaskTypes.Adaptor) {
|
| 74 | return all.concat(getSequenceItemWithOptions(task, trigger, adaptors[task.adaptor].create(task, trigger), {}));
|
| 75 | }
|
| 76 | /**
|
| 77 | * Finally, if the does not have children tasks & is not an
|
| 78 | * adaptor task it must have at least 1 associated module
|
| 79 | * (or an inline function) so we can begin working with it
|
| 80 | * by first resolving the top-level options object for it.
|
| 81 | */
|
| 82 | var localOptions = _.assign({}, loadTopLevelOptions(task, trigger), options);
|
| 83 | /**
|
| 84 | * Decide where the callable function is coming from
|
| 85 | * (inline function, external task etc)
|
| 86 | * @type {CBFunction}
|
| 87 | */
|
| 88 | var callable = (function () {
|
| 89 | if (task.type === task_resolve_1.TaskTypes.InlineFunction) {
|
| 90 | return task.inlineFunctions[0];
|
| 91 | }
|
| 92 | return require(task.externalTasks[0].resolved);
|
| 93 | })();
|
| 94 | /**
|
| 95 | * Take the callable and create items with it + options
|
| 96 | */
|
| 97 | return all.concat(resolveFromFunction(task, callable, trigger, localOptions, viaName));
|
| 98 | }, initial);
|
| 99 | }
|
| 100 | /**
|
| 101 | * Resolve a group of tasks
|
| 102 | * @param task
|
| 103 | * @param groupCreatorFn
|
| 104 | * @param continueFn
|
| 105 | * @returns {any}
|
| 106 | */
|
| 107 | function resolveGroup(task, groupCreatorFn) {
|
| 108 | /**
|
| 109 | * If the group contains no subtasks
|
| 110 | */
|
| 111 | if (!task.subTasks.length) {
|
| 112 | /**
|
| 113 | * If a group has _default options,
|
| 114 | * but here no 'subTasks' were given, use the
|
| 115 | * default options always
|
| 116 | */
|
| 117 | var parentOptions = (function () {
|
| 118 | if (task.options._default !== undefined) {
|
| 119 | return _.merge({}, task.options._default, task.query, task.flags);
|
| 120 | }
|
| 121 | return task.options;
|
| 122 | })();
|
| 123 | /**
|
| 124 | * Here the group had no direct 'sub tasks', so just return the item
|
| 125 | */
|
| 126 | return [groupCreatorFn({
|
| 127 | taskName: task.taskName,
|
| 128 | items: flatten(task.tasks, [], parentOptions),
|
| 129 | skipped: task.skipped
|
| 130 | })];
|
| 131 | }
|
| 132 | /**
|
| 133 | * Use either subtasks directly, or if '*' was given, use
|
| 134 | * each key in the object to create a task
|
| 135 | */
|
| 136 | var lookupKeys = getLookupKeys(task.subTasks, task.options);
|
| 137 | /**
|
| 138 | * Now for each sub-task create a separate task item
|
| 139 | */
|
| 140 | return lookupKeys.map(function (subTaskName) {
|
| 141 | /**
|
| 142 | * When things like options, flags or query strings
|
| 143 | * were present on this task-group - pass them into the upcoming task instead
|
| 144 | * Order of presedence
|
| 145 | * flags -> query -> options -> shared
|
| 146 | */
|
| 147 | var taskOptions = _.merge({}, task.options._default, _.get(task.options, subTaskName, {}), task.query, task.flags);
|
| 148 | return groupCreatorFn({
|
| 149 | taskName: task.taskName,
|
| 150 | items: flatten(task.tasks, [], taskOptions, task.taskName + ":" + subTaskName),
|
| 151 | skipped: task.skipped,
|
| 152 | subTaskName: subTaskName
|
| 153 | });
|
| 154 | });
|
| 155 | }
|
| 156 | function resolveGroupOfTasks(task, input) {
|
| 157 | if (task.type === task_resolve_1.TaskTypes.ParentGroup) {
|
| 158 | var opts = _.merge({}, task.options._default, task.query, task.flags);
|
| 159 | return flatten(task.tasks, [], opts, task.taskName);
|
| 160 | }
|
| 161 | var lookupKeys = getLookupKeys(task.subTasks, task.options);
|
| 162 | return lookupKeys.reduce(function (acc, subTaskName) {
|
| 163 | var opts = _.merge({}, task.options._default, _.get(task.options, subTaskName, {}), _.get(input.options, [task.baseTaskName, subTaskName], {}), task.query, task.flags);
|
| 164 | return acc.concat(flatten(task.tasks, [], opts, task.taskName + ":" + subTaskName));
|
| 165 | }, []);
|
| 166 | }
|
| 167 | }
|
| 168 | exports.createFlattenedSequence = createFlattenedSequence;
|
| 169 | function resolveFromFunction(task, callable, trigger, localOptions, viaName) {
|
| 170 | /**
|
| 171 | * If the current item has no sub-tasks, we can return early
|
| 172 | * with a simple task creation using the global options
|
| 173 | *
|
| 174 | * eg:
|
| 175 | * $ crossbow run sass
|
| 176 | *
|
| 177 | * options:
|
| 178 | * sass:
|
| 179 | * input: "core.scss"
|
| 180 | * output: "core.css"
|
| 181 | *
|
| 182 | * -> `sass` task will be run with the options
|
| 183 | * {input: "core.scss", output: "core.css"}
|
| 184 | */
|
| 185 | if (!task.subTasks.length) {
|
| 186 | return getSequenceItemWithOptions(task, trigger, callable, localOptions, viaName);
|
| 187 | }
|
| 188 | /**
|
| 189 | * Get lookup keys for this task
|
| 190 | */
|
| 191 | var lookupKeys = getLookupKeys(task.subTasks, localOptions);
|
| 192 | /**
|
| 193 | * Now generate 1 task per lookup key.
|
| 194 | */
|
| 195 | var group = lookupKeys.reduce(function (acc, optionKey) {
|
| 196 | /**
|
| 197 | * `optionKey` here will be a string that represented the subTask
|
| 198 | * name, so we use that to try and find a child key
|
| 199 | * in the options that matched it.
|
| 200 | * */
|
| 201 | var currentOptionObject = _.merge({}, localOptions._default, _.get(localOptions, optionKey));
|
| 202 | var sequenceItems = getSequenceItemWithOptions(task, trigger, callable, currentOptionObject, optionKey)
|
| 203 | .map(function (seqItem) {
|
| 204 | seqItem.subTaskName = optionKey;
|
| 205 | return seqItem;
|
| 206 | });
|
| 207 | return acc.concat(sequenceItems);
|
| 208 | }, []);
|
| 209 | /**
|
| 210 | * Don't create a 'group' if we're only talking about 1 item
|
| 211 | */
|
| 212 | if (group.length === 1) {
|
| 213 | return group;
|
| 214 | }
|
| 215 | if (task.runMode === task_resolve_1.TaskRunModes.parallel) {
|
| 216 | return [task_sequence_factories_1.createSequenceParallelGroup({
|
| 217 | taskName: task.taskName,
|
| 218 | items: group,
|
| 219 | skipped: task.skipped
|
| 220 | })];
|
| 221 | }
|
| 222 | /**
|
| 223 | * If the current task was marked as `series`, all immediate child tasks
|
| 224 | * will be queued and run in series - each waiting until the previous
|
| 225 | * one has completed
|
| 226 | */
|
| 227 | if (task.runMode === task_resolve_1.TaskRunModes.series) {
|
| 228 | return [task_sequence_factories_1.createSequenceSeriesGroup({
|
| 229 | taskName: task.taskName,
|
| 230 | items: group,
|
| 231 | skipped: task.skipped
|
| 232 | })];
|
| 233 | }
|
| 234 | }
|
| 235 | function getSequenceItemWithOptions(task, trigger, imported, options, viaName) {
|
| 236 | /**
|
| 237 | * Merge incoming options with query + flags
|
| 238 | * eg:
|
| 239 | * $ sass?input=css/core.css --production
|
| 240 | * -> sass
|
| 241 | * input: css/core.css
|
| 242 | * production: true
|
| 243 | */
|
| 244 | var mergedOptionsWithQuery = _.merge({}, options, task.options, task.query, task.flags);
|
| 245 | /**
|
| 246 | * If the module did not export a function, but has a 'tasks'
|
| 247 | * property that is an array, use each function from it
|
| 248 | * eg:
|
| 249 | * module.exports.tasks = [sass, cssmin, version-rev]
|
| 250 | */
|
| 251 | if (imported.tasks && Array.isArray(imported.tasks)) {
|
| 252 | return imported.tasks.map(function (importedFn, i) {
|
| 253 | return task_sequence_factories_1.createSequenceTaskItem({
|
| 254 | fnName: getFunctionName(imported, i + 1),
|
| 255 | factory: importedFn,
|
| 256 | task: task,
|
| 257 | options: mergedOptionsWithQuery,
|
| 258 | viaName: viaName
|
| 259 | });
|
| 260 | });
|
| 261 | }
|
| 262 | /**
|
| 263 | * If the module exported a function, use that as the factory
|
| 264 | * and return a single task for it.
|
| 265 | * eg:
|
| 266 | * module.exports = function runSass() {}
|
| 267 | */
|
| 268 | if (typeof imported === "function") {
|
| 269 | return [task_sequence_factories_1.createSequenceTaskItem({
|
| 270 | fnName: getFunctionName(imported, 0),
|
| 271 | factory: imported,
|
| 272 | task: task,
|
| 273 | options: mergedOptionsWithQuery,
|
| 274 | viaName: viaName
|
| 275 | })];
|
| 276 | }
|
| 277 | }
|
| 278 | /**
|
| 279 | * For reporting purposes, try to 'name' a function
|
| 280 | */
|
| 281 | function getFunctionName(fn, count) {
|
| 282 | if (count === void 0) { count = 0; }
|
| 283 | if (fn.name === undefined) {
|
| 284 | return "Anonymous Function " + count;
|
| 285 | }
|
| 286 | return fn.name;
|
| 287 | }
|
| 288 | /**
|
| 289 | * ******************
|
| 290 | * Where the **--~~Magic~~--** happens!!!
|
| 291 | * ******************
|
| 292 | *
|
| 293 | * Creating a task runner in crossbow is really about
|
| 294 | * wrapping the process of running the tasks in a way
|
| 295 | * that allows comprehensive logging/reporting
|
| 296 | *
|
| 297 | * Series & Parallel have different semantics and are
|
| 298 | * therefor handled separately.
|
| 299 | *
|
| 300 | * Note that everything here is completely lazy and
|
| 301 | * nothing will be executed until a user calls subscribe
|
| 302 | */
|
| 303 | function createRunner(items, trigger) {
|
| 304 | return {
|
| 305 | sequence: items,
|
| 306 | series: function (ctx) {
|
| 307 | if (!ctx)
|
| 308 | ctx = Immutable.Map({});
|
| 309 | var flattened = createObservableTree(items, [], false, ctx);
|
| 310 | var run = Observable
|
| 311 | .from(flattened)
|
| 312 | .concatAll()
|
| 313 | .catch(function (x) { return Rx.Observable.empty(); });
|
| 314 | return run;
|
| 315 | },
|
| 316 | parallel: function (ctx) {
|
| 317 | if (!ctx)
|
| 318 | ctx = Immutable.Map({});
|
| 319 | var flattened = createObservableTree(items, [], true, ctx);
|
| 320 | var run = Observable.from(flattened).mergeAll();
|
| 321 | return run;
|
| 322 | }
|
| 323 | };
|
| 324 | /**
|
| 325 | * Any task in 'Parallel' run mode that throws an
|
| 326 | * error should not adversely affect sibling tasks
|
| 327 | */
|
| 328 | function shouldCatch(trigger) {
|
| 329 | return trigger.config.runMode === task_resolve_1.TaskRunModes.parallel;
|
| 330 | }
|
| 331 | /**
|
| 332 | * Create a nested tree of Observables that can contain tasks
|
| 333 | * alongside parallel/series groups. To understand how this works
|
| 334 | * you can think of the following to be an accurate representation of
|
| 335 | * what this function produces:
|
| 336 | *
|
| 337 | * const out = [
|
| 338 | Observable.concat(
|
| 339 | task1(),
|
| 340 | task2()
|
| 341 | ),
|
| 342 | Observable.concat(
|
| 343 | task3(),
|
| 344 | task4(),
|
| 345 | Observable.concat(
|
| 346 | task5(),
|
| 347 | task6(),
|
| 348 | task7()
|
| 349 | )
|
| 350 | )
|
| 351 | ];
|
| 352 | *
|
| 353 | */
|
| 354 | function createObservableTree(items, initial, addCatch, ctx) {
|
| 355 | if (addCatch === void 0) { addCatch = false; }
|
| 356 | return items.reduce(function (all, item) {
|
| 357 | var output;
|
| 358 | /**
|
| 359 | * If the current task was marked as `parallel`, all immediate children
|
| 360 | * of (this task) will be run in `parallel`
|
| 361 | */
|
| 362 | if (item.type === task_sequence_factories_1.SequenceItemTypes.ParallelGroup) {
|
| 363 | output = Observable.merge(createObservableTree(item.items, [], shouldCatch(trigger), ctx));
|
| 364 | }
|
| 365 | /**
|
| 366 | * If the current task was marked as `series`, all immediate child tasks
|
| 367 | * will be queued and run in series - each waiting until the previous
|
| 368 | * one has completed
|
| 369 | */
|
| 370 | if (item.type === task_sequence_factories_1.SequenceItemTypes.SeriesGroup) {
|
| 371 | output = Observable.concat(createObservableTree(item.items, [], false, ctx));
|
| 372 | }
|
| 373 | /**
|
| 374 | * Finally is item is a task, create an observable for it.
|
| 375 | */
|
| 376 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task && item.factory) {
|
| 377 | output = task_runner_1.createObservableFromSequenceItem(item, trigger, ctx);
|
| 378 | }
|
| 379 | /**
|
| 380 | * Should we add a catch clause to this item to enable
|
| 381 | * siblings to continue when a task errors
|
| 382 | */
|
| 383 | if (addCatch || !trigger.config.fail) {
|
| 384 | return all.concat(output.catch(function (x) { return Rx.Observable.empty(); }));
|
| 385 | }
|
| 386 | return all.concat(output);
|
| 387 | }, initial);
|
| 388 | }
|
| 389 | }
|
| 390 | exports.createRunner = createRunner;
|
| 391 | /**
|
| 392 | * From user input, try to locate a options object
|
| 393 | */
|
| 394 | function loadTopLevelOptions(task, trigger) {
|
| 395 | // todo - more robust way of matching options -> tasks
|
| 396 | var fullMatch = _.get(trigger.input.options, [task.taskName]);
|
| 397 | if (fullMatch !== undefined) {
|
| 398 | /**
|
| 399 | * If this item was given as top-level + options
|
| 400 | * just return the options here
|
| 401 | */
|
| 402 | if (fullMatch.options && fullMatch.tasks) {
|
| 403 | return fullMatch.options;
|
| 404 | }
|
| 405 | /**
|
| 406 | * If this task has a _default key, don't pass
|
| 407 | * all the options in, just pass the stuff under default
|
| 408 | */
|
| 409 | if (task.subTasks.length === 0 && fullMatch._default !== undefined) {
|
| 410 | return fullMatch._default;
|
| 411 | }
|
| 412 | return fullMatch;
|
| 413 | }
|
| 414 | if (task_utils_1.isInternal(task.rawInput)) {
|
| 415 | var lookup = task.taskName.replace(/(.+?)_internal_fn_\d{0,10}/, "");
|
| 416 | var fromInternal = _.get(trigger.input.options, [lookup]);
|
| 417 | if (fromInternal !== undefined) {
|
| 418 | return fromInternal;
|
| 419 | }
|
| 420 | }
|
| 421 | return {};
|
| 422 | }
|
| 423 | /**
|
| 424 | * After a bunch of tasks have run, we need to link up task-ended reports
|
| 425 | * with their original position in the sequence. This will allow us to
|
| 426 | * reconstruct the task render-tree but also show any tasks that errored
|
| 427 | * or did not complete
|
| 428 | * @param sequence
|
| 429 | * @param reports
|
| 430 | * @returns {*}
|
| 431 | */
|
| 432 | function decorateSequenceWithReports(sequence, reports) {
|
| 433 | return addMany(sequence, []);
|
| 434 | function addMany(sequence, initial) {
|
| 435 | return sequence.reduce(function (all, item) {
|
| 436 | var c = _.assign({}, item);
|
| 437 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task) {
|
| 438 | c.stats = getMergedStats(item, reports);
|
| 439 | return all.concat(c);
|
| 440 | }
|
| 441 | else {
|
| 442 | c.items = addMany(item.items, []);
|
| 443 | return all.concat(c);
|
| 444 | }
|
| 445 | }, initial);
|
| 446 | }
|
| 447 | }
|
| 448 | exports.decorateSequenceWithReports = decorateSequenceWithReports;
|
| 449 | /**
|
| 450 | * Look at every item in the sequence tree and count how many
|
| 451 | * error have occured
|
| 452 | */
|
| 453 | function countSequenceErrors(items) {
|
| 454 | return items.reduce(function (acc, item) {
|
| 455 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task) {
|
| 456 | var errors = _.get(item, "stats.errors", []);
|
| 457 | if (errors.length) {
|
| 458 | return acc + errors.length;
|
| 459 | }
|
| 460 | return acc;
|
| 461 | }
|
| 462 | return acc + countSequenceErrors(item.items);
|
| 463 | }, 0);
|
| 464 | }
|
| 465 | exports.countSequenceErrors = countSequenceErrors;
|
| 466 | function collectSkippedTasks(items, initial) {
|
| 467 | return items.reduce(function (acc, item) {
|
| 468 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task) {
|
| 469 | if (item.stats.skipped) {
|
| 470 | return acc.concat(item);
|
| 471 | }
|
| 472 | return acc;
|
| 473 | }
|
| 474 | return acc.concat(collectSkippedTasks(item.items, []));
|
| 475 | }, initial);
|
| 476 | }
|
| 477 | exports.collectSkippedTasks = collectSkippedTasks;
|
| 478 | function collectRunnableTasks(items, initial) {
|
| 479 | return items.reduce(function (acc, item) {
|
| 480 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task) {
|
| 481 | return acc.concat(item);
|
| 482 | }
|
| 483 | return acc.concat(collectRunnableTasks(item.items, []));
|
| 484 | }, initial);
|
| 485 | }
|
| 486 | exports.collectRunnableTasks = collectRunnableTasks;
|
| 487 | /**
|
| 488 | * Look at the reports array to find stats linked to a
|
| 489 | * given task
|
| 490 | */
|
| 491 | function getMergedStats(item, reports) {
|
| 492 | var match = reports.filter(function (report) {
|
| 493 | return report.item.seqUID === item.seqUID;
|
| 494 | });
|
| 495 | var start = match.filter(function (x) { return x.type === task_runner_1.TaskReportType.start; })[0];
|
| 496 | var error = match.filter(function (x) { return x.type === task_runner_1.TaskReportType.error; })[0];
|
| 497 | var end = match.filter(function (x) { return x.type === task_runner_1.TaskReportType.end; })[0];
|
| 498 | if (start && end) {
|
| 499 | return _.assign({}, start.stats, end.stats);
|
| 500 | }
|
| 501 | if (start && error) {
|
| 502 | var duration = error.stats.endTime - start.stats.startTime;
|
| 503 | return _.assign({}, start.stats, error.stats, { duration: duration });
|
| 504 | }
|
| 505 | if (start) {
|
| 506 | return _.assign({}, start.stats);
|
| 507 | }
|
| 508 | return { item: item, errors: [] };
|
| 509 | }
|
| 510 | /**
|
| 511 | * When we know a task has `subTasks` we need to check if
|
| 512 | * if the first entry in the subTasks array is a `*` - then
|
| 513 | * the user wants to run all tasks under this options
|
| 514 | * object. So we need to get the keys and use each one as a lookup
|
| 515 | * on the local options. (minus any excluded tasks)
|
| 516 | *
|
| 517 | * eg:
|
| 518 | * $ crossbow run sass:*
|
| 519 | *
|
| 520 | * options:
|
| 521 | * sass:
|
| 522 | * site: {input: "core.scss"}
|
| 523 | * debug: {input: "debug.scss"}
|
| 524 | *
|
| 525 | * lookupKeys = ['site', 'debug']
|
| 526 | */
|
| 527 | var blacklistedSubTaskNames = ["_default"];
|
| 528 | function getLookupKeys(subTasks, topLevelObject) {
|
| 529 | if (subTasks[0] === "*") {
|
| 530 | return Object.keys(topLevelObject)
|
| 531 | .filter(function (x) { return blacklistedSubTaskNames.indexOf(x) === -1; });
|
| 532 | }
|
| 533 | return subTasks;
|
| 534 | }
|
| 535 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task.sequence.js","sourceRoot":"","sources":["../src/task.sequence.ts"],"names":[],"mappings":"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"} |
| \ | No newline at end of file |