| OLD | NEW |
|---|
| (Empty) |
| 1 var _internal; | |
| 2 (function(exports) { | |
| 3 'use strict'; | |
| 4 class EfficientLength extends core.Object { | |
| 5 } | |
| 6 let ListIterable$ = dart.generic(function(E) { | |
| 7 class ListIterable extends collection.IterableBase$(E) { | |
| 8 ListIterable() { | |
| 9 super.IterableBase(); | |
| 10 } | |
| 11 get iterator() { | |
| 12 return new ListIterator(this); | |
| 13 } | |
| 14 forEach(action) { | |
| 15 let length = this.length; | |
| 16 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 17 action(this.elementAt(i)); | |
| 18 if (length !== this.length) { | |
| 19 throw new core.ConcurrentModificationError(this); | |
| 20 } | |
| 21 } | |
| 22 } | |
| 23 get isEmpty() { | |
| 24 return this.length === 0; | |
| 25 } | |
| 26 get first() { | |
| 27 if (this.length === 0) | |
| 28 throw IterableElementError.noElement(); | |
| 29 return this.elementAt(0); | |
| 30 } | |
| 31 get last() { | |
| 32 if (this.length === 0) | |
| 33 throw IterableElementError.noElement(); | |
| 34 return this.elementAt(dart.notNull(this.length) - 1); | |
| 35 } | |
| 36 get single() { | |
| 37 if (this.length === 0) | |
| 38 throw IterableElementError.noElement(); | |
| 39 if (dart.notNull(this.length) > 1) | |
| 40 throw IterableElementError.tooMany(); | |
| 41 return this.elementAt(0); | |
| 42 } | |
| 43 contains(element) { | |
| 44 let length = this.length; | |
| 45 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 46 if (dart.equals(this.elementAt(i), element)) | |
| 47 return true; | |
| 48 if (length !== this.length) { | |
| 49 throw new core.ConcurrentModificationError(this); | |
| 50 } | |
| 51 } | |
| 52 return false; | |
| 53 } | |
| 54 every(test) { | |
| 55 let length = this.length; | |
| 56 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 57 if (!dart.notNull(test(this.elementAt(i)))) | |
| 58 return false; | |
| 59 if (length !== this.length) { | |
| 60 throw new core.ConcurrentModificationError(this); | |
| 61 } | |
| 62 } | |
| 63 return true; | |
| 64 } | |
| 65 any(test) { | |
| 66 let length = this.length; | |
| 67 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 68 if (test(this.elementAt(i))) | |
| 69 return true; | |
| 70 if (length !== this.length) { | |
| 71 throw new core.ConcurrentModificationError(this); | |
| 72 } | |
| 73 } | |
| 74 return false; | |
| 75 } | |
| 76 firstWhere(test, opt$) { | |
| 77 let orElse = opt$.orElse === void 0 ? null : opt$.orElse; | |
| 78 let length = this.length; | |
| 79 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 80 let element = this.elementAt(i); | |
| 81 if (test(element)) | |
| 82 return element; | |
| 83 if (length !== this.length) { | |
| 84 throw new core.ConcurrentModificationError(this); | |
| 85 } | |
| 86 } | |
| 87 if (orElse !== null) | |
| 88 return orElse(); | |
| 89 throw IterableElementError.noElement(); | |
| 90 } | |
| 91 lastWhere(test, opt$) { | |
| 92 let orElse = opt$.orElse === void 0 ? null : opt$.orElse; | |
| 93 let length = this.length; | |
| 94 for (let i = dart.notNull(length) - 1; dart.notNull(i) >= 0; i = dart.no
tNull(i) - 1) { | |
| 95 let element = this.elementAt(i); | |
| 96 if (test(element)) | |
| 97 return element; | |
| 98 if (length !== this.length) { | |
| 99 throw new core.ConcurrentModificationError(this); | |
| 100 } | |
| 101 } | |
| 102 if (orElse !== null) | |
| 103 return orElse(); | |
| 104 throw IterableElementError.noElement(); | |
| 105 } | |
| 106 singleWhere(test) { | |
| 107 let length = this.length; | |
| 108 let match = null; | |
| 109 let matchFound = false; | |
| 110 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 111 let element = this.elementAt(i); | |
| 112 if (test(element)) { | |
| 113 if (matchFound) { | |
| 114 throw IterableElementError.tooMany(); | |
| 115 } | |
| 116 matchFound = true; | |
| 117 match = element; | |
| 118 } | |
| 119 if (length !== this.length) { | |
| 120 throw new core.ConcurrentModificationError(this); | |
| 121 } | |
| 122 } | |
| 123 if (matchFound) | |
| 124 return match; | |
| 125 throw IterableElementError.noElement(); | |
| 126 } | |
| 127 join(separator) { | |
| 128 if (separator === void 0) | |
| 129 separator = ""; | |
| 130 let length = this.length; | |
| 131 if (!dart.notNull(separator.isEmpty)) { | |
| 132 if (length === 0) | |
| 133 return ""; | |
| 134 let first = `${this.elementAt(0)}`; | |
| 135 if (length !== this.length) { | |
| 136 throw new core.ConcurrentModificationError(this); | |
| 137 } | |
| 138 let buffer = new core.StringBuffer(first); | |
| 139 for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNu
ll(i) + 1) { | |
| 140 buffer.write(separator); | |
| 141 buffer.write(this.elementAt(i)); | |
| 142 if (length !== this.length) { | |
| 143 throw new core.ConcurrentModificationError(this); | |
| 144 } | |
| 145 } | |
| 146 return buffer.toString(); | |
| 147 } else { | |
| 148 let buffer = new core.StringBuffer(); | |
| 149 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNu
ll(i) + 1) { | |
| 150 buffer.write(this.elementAt(i)); | |
| 151 if (length !== this.length) { | |
| 152 throw new core.ConcurrentModificationError(this); | |
| 153 } | |
| 154 } | |
| 155 return buffer.toString(); | |
| 156 } | |
| 157 } | |
| 158 where(test) { | |
| 159 return super.where(test); | |
| 160 } | |
| 161 map(f) { | |
| 162 return new MappedListIterable(this, f); | |
| 163 } | |
| 164 reduce(combine) { | |
| 165 let length = this.length; | |
| 166 if (length === 0) | |
| 167 throw IterableElementError.noElement(); | |
| 168 let value = this.elementAt(0); | |
| 169 for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 170 value = dart.dinvokef(combine, value, this.elementAt(i)); | |
| 171 if (length !== this.length) { | |
| 172 throw new core.ConcurrentModificationError(this); | |
| 173 } | |
| 174 } | |
| 175 return value; | |
| 176 } | |
| 177 fold(initialValue, combine) { | |
| 178 let value = initialValue; | |
| 179 let length = this.length; | |
| 180 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 181 value = dart.dinvokef(combine, value, this.elementAt(i)); | |
| 182 if (length !== this.length) { | |
| 183 throw new core.ConcurrentModificationError(this); | |
| 184 } | |
| 185 } | |
| 186 return value; | |
| 187 } | |
| 188 skip(count) { | |
| 189 return new SubListIterable(this, count, null); | |
| 190 } | |
| 191 skipWhile(test) { | |
| 192 return super.skipWhile(test); | |
| 193 } | |
| 194 take(count) { | |
| 195 return new SubListIterable(this, 0, count); | |
| 196 } | |
| 197 takeWhile(test) { | |
| 198 return super.takeWhile(test); | |
| 199 } | |
| 200 toList(opt$) { | |
| 201 let growable = opt$.growable === void 0 ? true : opt$.growable; | |
| 202 let result = null; | |
| 203 if (growable) { | |
| 204 result = ((_) => { | |
| 205 _.length = this.length; | |
| 206 return _; | |
| 207 }).bind(this)(new core.List()); | |
| 208 } else { | |
| 209 result = new core.List(this.length); | |
| 210 } | |
| 211 for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.no
tNull(i) + 1) { | |
| 212 result.set(i, this.elementAt(i)); | |
| 213 } | |
| 214 return result; | |
| 215 } | |
| 216 toSet() { | |
| 217 let result = new core.Set(); | |
| 218 for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.no
tNull(i) + 1) { | |
| 219 result.add(this.elementAt(i)); | |
| 220 } | |
| 221 return result; | |
| 222 } | |
| 223 } | |
| 224 return ListIterable; | |
| 225 }); | |
| 226 let ListIterable = ListIterable$(dart.dynamic); | |
| 227 let _iterable = Symbol('_iterable'); | |
| 228 let _start = Symbol('_start'); | |
| 229 let _endOrLength = Symbol('_endOrLength'); | |
| 230 let _endIndex = Symbol('_endIndex'); | |
| 231 let _startIndex = Symbol('_startIndex'); | |
| 232 let SubListIterable$ = dart.generic(function(E) { | |
| 233 class SubListIterable extends ListIterable$(E) { | |
| 234 SubListIterable($_iterable, $_start, $_endOrLength) { | |
| 235 this[_iterable] = $_iterable; | |
| 236 this[_start] = $_start; | |
| 237 this[_endOrLength] = $_endOrLength; | |
| 238 super.ListIterable(); | |
| 239 core.RangeError.checkNotNegative(this[_start], "start"); | |
| 240 if (this[_endOrLength] !== null) { | |
| 241 core.RangeError.checkNotNegative(this[_endOrLength], "end"); | |
| 242 if (dart.notNull(this[_start]) > dart.notNull(this[_endOrLength])) { | |
| 243 throw new core.RangeError.range(this[_start], 0, this[_endOrLength],
"start"); | |
| 244 } | |
| 245 } | |
| 246 } | |
| 247 get [_endIndex]() { | |
| 248 let length = this[_iterable].length; | |
| 249 if (this[_endOrLength] === null || dart.notNull(this[_endOrLength]) > da
rt.notNull(length)) | |
| 250 return length; | |
| 251 return this[_endOrLength]; | |
| 252 } | |
| 253 get [_startIndex]() { | |
| 254 let length = this[_iterable].length; | |
| 255 if (dart.notNull(this[_start]) > dart.notNull(length)) | |
| 256 return length; | |
| 257 return this[_start]; | |
| 258 } | |
| 259 get length() { | |
| 260 let length = this[_iterable].length; | |
| 261 if (dart.notNull(this[_start]) >= dart.notNull(length)) | |
| 262 return 0; | |
| 263 if (this[_endOrLength] === null || dart.notNull(this[_endOrLength]) >= d
art.notNull(length)) { | |
| 264 return dart.notNull(length) - dart.notNull(this[_start]); | |
| 265 } | |
| 266 return dart.notNull(this[_endOrLength]) - dart.notNull(this[_start]); | |
| 267 } | |
| 268 elementAt(index) { | |
| 269 let realIndex = dart.notNull(this[_startIndex]) + dart.notNull(index); | |
| 270 if (dart.notNull(index) < 0 || dart.notNull(realIndex) >= dart.notNull(t
his[_endIndex])) { | |
| 271 throw new core.RangeError.index(index, this, "index"); | |
| 272 } | |
| 273 return this[_iterable].elementAt(realIndex); | |
| 274 } | |
| 275 skip(count) { | |
| 276 core.RangeError.checkNotNegative(count, "count"); | |
| 277 let newStart = dart.notNull(this[_start]) + dart.notNull(count); | |
| 278 if (this[_endOrLength] !== null && dart.notNull(newStart) >= dart.notNul
l(this[_endOrLength])) { | |
| 279 return new EmptyIterable(); | |
| 280 } | |
| 281 return new SubListIterable(this[_iterable], newStart, this[_endOrLength]
); | |
| 282 } | |
| 283 take(count) { | |
| 284 core.RangeError.checkNotNegative(count, "count"); | |
| 285 if (this[_endOrLength] === null) { | |
| 286 return new SubListIterable(this[_iterable], this[_start], dart.notNull
(this[_start]) + dart.notNull(count)); | |
| 287 } else { | |
| 288 let newEnd = dart.notNull(this[_start]) + dart.notNull(count); | |
| 289 if (dart.notNull(this[_endOrLength]) < dart.notNull(newEnd)) | |
| 290 return this; | |
| 291 return new SubListIterable(this[_iterable], this[_start], newEnd); | |
| 292 } | |
| 293 } | |
| 294 toList(opt$) { | |
| 295 let growable = opt$.growable === void 0 ? true : opt$.growable; | |
| 296 let start = this[_start]; | |
| 297 let end = this[_iterable].length; | |
| 298 if (this[_endOrLength] !== null && dart.notNull(this[_endOrLength]) < da
rt.notNull(end)) | |
| 299 end = this[_endOrLength]; | |
| 300 let length = dart.notNull(end) - dart.notNull(start); | |
| 301 if (dart.notNull(length) < 0) | |
| 302 length = 0; | |
| 303 let result = growable ? ((_) => { | |
| 304 _.length = length; | |
| 305 return _; | |
| 306 }).bind(this)(new core.List()) : new core.List(length); | |
| 307 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 308 result.set(i, this[_iterable].elementAt(dart.notNull(start) + dart.not
Null(i))); | |
| 309 if (dart.notNull(this[_iterable].length) < dart.notNull(end)) | |
| 310 throw new core.ConcurrentModificationError(this); | |
| 311 } | |
| 312 return dart.as(result, core.List$(E)); | |
| 313 } | |
| 314 } | |
| 315 return SubListIterable; | |
| 316 }); | |
| 317 let SubListIterable = SubListIterable$(dart.dynamic); | |
| 318 let _length = Symbol('_length'); | |
| 319 let _index = Symbol('_index'); | |
| 320 let _current = Symbol('_current'); | |
| 321 let ListIterator$ = dart.generic(function(E) { | |
| 322 class ListIterator extends core.Object { | |
| 323 ListIterator(iterable) { | |
| 324 this[_iterable] = iterable; | |
| 325 this[_length] = iterable.length; | |
| 326 this[_index] = 0; | |
| 327 this[_current] = null; | |
| 328 } | |
| 329 get current() { | |
| 330 return this[_current]; | |
| 331 } | |
| 332 moveNext() { | |
| 333 let length = this[_iterable].length; | |
| 334 if (this[_length] !== length) { | |
| 335 throw new core.ConcurrentModificationError(this[_iterable]); | |
| 336 } | |
| 337 if (dart.notNull(this[_index]) >= dart.notNull(length)) { | |
| 338 this[_current] = null; | |
| 339 return false; | |
| 340 } | |
| 341 this[_current] = this[_iterable].elementAt(this[_index]); | |
| 342 this[_index] = dart.notNull(this[_index]) + 1; | |
| 343 return true; | |
| 344 } | |
| 345 } | |
| 346 return ListIterator; | |
| 347 }); | |
| 348 let ListIterator = ListIterator$(dart.dynamic); | |
| 349 let _f = Symbol('_f'); | |
| 350 let MappedIterable$ = dart.generic(function(S, T) { | |
| 351 class MappedIterable extends collection.IterableBase$(T) { | |
| 352 MappedIterable(iterable, function) { | |
| 353 if (dart.is(iterable, EfficientLength)) { | |
| 354 return new EfficientLengthMappedIterable(iterable, function); | |
| 355 } | |
| 356 return new MappedIterable._(dart.as(iterable, core.Iterable$(S)), functi
on); | |
| 357 } | |
| 358 MappedIterable$_($_iterable, $_f) { | |
| 359 this[_iterable] = $_iterable; | |
| 360 this[_f] = $_f; | |
| 361 super.IterableBase(); | |
| 362 } | |
| 363 get iterator() { | |
| 364 return new MappedIterator(this[_iterable].iterator, this[_f]); | |
| 365 } | |
| 366 get length() { | |
| 367 return this[_iterable].length; | |
| 368 } | |
| 369 get isEmpty() { | |
| 370 return this[_iterable].isEmpty; | |
| 371 } | |
| 372 get first() { | |
| 373 return this[_f](this[_iterable].first); | |
| 374 } | |
| 375 get last() { | |
| 376 return this[_f](this[_iterable].last); | |
| 377 } | |
| 378 get single() { | |
| 379 return this[_f](this[_iterable].single); | |
| 380 } | |
| 381 elementAt(index) { | |
| 382 return this[_f](this[_iterable].elementAt(index)); | |
| 383 } | |
| 384 } | |
| 385 dart.defineNamedConstructor(MappedIterable, '_'); | |
| 386 return MappedIterable; | |
| 387 }); | |
| 388 let MappedIterable = MappedIterable$(dart.dynamic, dart.dynamic); | |
| 389 let EfficientLengthMappedIterable$ = dart.generic(function(S, T) { | |
| 390 class EfficientLengthMappedIterable extends MappedIterable$(S, T) { | |
| 391 EfficientLengthMappedIterable(iterable, function) { | |
| 392 super.MappedIterable$_(dart.as(iterable, core.Iterable$(S)), function); | |
| 393 } | |
| 394 } | |
| 395 return EfficientLengthMappedIterable; | |
| 396 }); | |
| 397 let EfficientLengthMappedIterable = EfficientLengthMappedIterable$(dart.dynami
c, dart.dynamic); | |
| 398 let _iterator = Symbol('_iterator'); | |
| 399 let MappedIterator$ = dart.generic(function(S, T) { | |
| 400 class MappedIterator extends core.Iterator$(T) { | |
| 401 MappedIterator($_iterator, $_f) { | |
| 402 this[_iterator] = $_iterator; | |
| 403 this[_f] = $_f; | |
| 404 this[_current] = null; | |
| 405 super.Iterator(); | |
| 406 } | |
| 407 moveNext() { | |
| 408 if (this[_iterator].moveNext()) { | |
| 409 this[_current] = this[_f](this[_iterator].current); | |
| 410 return true; | |
| 411 } | |
| 412 this[_current] = null; | |
| 413 return false; | |
| 414 } | |
| 415 get current() { | |
| 416 return this[_current]; | |
| 417 } | |
| 418 } | |
| 419 return MappedIterator; | |
| 420 }); | |
| 421 let MappedIterator = MappedIterator$(dart.dynamic, dart.dynamic); | |
| 422 let _source = Symbol('_source'); | |
| 423 let MappedListIterable$ = dart.generic(function(S, T) { | |
| 424 class MappedListIterable extends ListIterable$(T) { | |
| 425 MappedListIterable($_source, $_f) { | |
| 426 this[_source] = $_source; | |
| 427 this[_f] = $_f; | |
| 428 super.ListIterable(); | |
| 429 } | |
| 430 get length() { | |
| 431 return this[_source].length; | |
| 432 } | |
| 433 elementAt(index) { | |
| 434 return this[_f](this[_source].elementAt(index)); | |
| 435 } | |
| 436 } | |
| 437 return MappedListIterable; | |
| 438 }); | |
| 439 let MappedListIterable = MappedListIterable$(dart.dynamic, dart.dynamic); | |
| 440 let WhereIterable$ = dart.generic(function(E) { | |
| 441 class WhereIterable extends collection.IterableBase$(E) { | |
| 442 WhereIterable($_iterable, $_f) { | |
| 443 this[_iterable] = $_iterable; | |
| 444 this[_f] = $_f; | |
| 445 super.IterableBase(); | |
| 446 } | |
| 447 get iterator() { | |
| 448 return new WhereIterator(this[_iterable].iterator, this[_f]); | |
| 449 } | |
| 450 } | |
| 451 return WhereIterable; | |
| 452 }); | |
| 453 let WhereIterable = WhereIterable$(dart.dynamic); | |
| 454 let WhereIterator$ = dart.generic(function(E) { | |
| 455 class WhereIterator extends core.Iterator$(E) { | |
| 456 WhereIterator($_iterator, $_f) { | |
| 457 this[_iterator] = $_iterator; | |
| 458 this[_f] = $_f; | |
| 459 super.Iterator(); | |
| 460 } | |
| 461 moveNext() { | |
| 462 while (this[_iterator].moveNext()) { | |
| 463 if (this[_f](this[_iterator].current)) { | |
| 464 return true; | |
| 465 } | |
| 466 } | |
| 467 return false; | |
| 468 } | |
| 469 get current() { | |
| 470 return this[_iterator].current; | |
| 471 } | |
| 472 } | |
| 473 return WhereIterator; | |
| 474 }); | |
| 475 let WhereIterator = WhereIterator$(dart.dynamic); | |
| 476 let ExpandIterable$ = dart.generic(function(S, T) { | |
| 477 class ExpandIterable extends collection.IterableBase$(T) { | |
| 478 ExpandIterable($_iterable, $_f) { | |
| 479 this[_iterable] = $_iterable; | |
| 480 this[_f] = $_f; | |
| 481 super.IterableBase(); | |
| 482 } | |
| 483 get iterator() { | |
| 484 return new ExpandIterator(this[_iterable].iterator, dart.closureWrap(thi
s[_f], "(S) → Iterable<T>")); | |
| 485 } | |
| 486 } | |
| 487 return ExpandIterable; | |
| 488 }); | |
| 489 let ExpandIterable = ExpandIterable$(dart.dynamic, dart.dynamic); | |
| 490 let _currentExpansion = Symbol('_currentExpansion'); | |
| 491 let _nextExpansion = Symbol('_nextExpansion'); | |
| 492 let ExpandIterator$ = dart.generic(function(S, T) { | |
| 493 class ExpandIterator extends core.Object { | |
| 494 ExpandIterator($_iterator, $_f) { | |
| 495 this[_iterator] = $_iterator; | |
| 496 this[_f] = $_f; | |
| 497 this[_currentExpansion] = dart.as(new EmptyIterator(), core.Iterator$(T)
); | |
| 498 this[_current] = null; | |
| 499 } | |
| 500 [_nextExpansion]() {} | |
| 501 get current() { | |
| 502 return this[_current]; | |
| 503 } | |
| 504 moveNext() { | |
| 505 if (this[_currentExpansion] === null) | |
| 506 return false; | |
| 507 while (!dart.notNull(this[_currentExpansion].moveNext())) { | |
| 508 this[_current] = null; | |
| 509 if (this[_iterator].moveNext()) { | |
| 510 this[_currentExpansion] = null; | |
| 511 this[_currentExpansion] = dart.as(dart.dinvokef(this[_f], this[_iter
ator].current).iterator, core.Iterator$(T)); | |
| 512 } else { | |
| 513 return false; | |
| 514 } | |
| 515 } | |
| 516 this[_current] = this[_currentExpansion].current; | |
| 517 return true; | |
| 518 } | |
| 519 } | |
| 520 return ExpandIterator; | |
| 521 }); | |
| 522 let ExpandIterator = ExpandIterator$(dart.dynamic, dart.dynamic); | |
| 523 let _takeCount = Symbol('_takeCount'); | |
| 524 let TakeIterable$ = dart.generic(function(E) { | |
| 525 class TakeIterable extends collection.IterableBase$(E) { | |
| 526 TakeIterable(iterable, takeCount) { | |
| 527 if (dart.notNull(!(typeof takeCount == number)) || dart.notNull(takeCoun
t) < 0) { | |
| 528 throw new core.ArgumentError(takeCount); | |
| 529 } | |
| 530 if (dart.is(iterable, EfficientLength)) { | |
| 531 return new EfficientLengthTakeIterable(iterable, takeCount); | |
| 532 } | |
| 533 return new TakeIterable._(iterable, takeCount); | |
| 534 } | |
| 535 TakeIterable$_($_iterable, $_takeCount) { | |
| 536 this[_iterable] = $_iterable; | |
| 537 this[_takeCount] = $_takeCount; | |
| 538 super.IterableBase(); | |
| 539 } | |
| 540 get iterator() { | |
| 541 return new TakeIterator(this[_iterable].iterator, this[_takeCount]); | |
| 542 } | |
| 543 } | |
| 544 dart.defineNamedConstructor(TakeIterable, '_'); | |
| 545 return TakeIterable; | |
| 546 }); | |
| 547 let TakeIterable = TakeIterable$(dart.dynamic); | |
| 548 let EfficientLengthTakeIterable$ = dart.generic(function(E) { | |
| 549 class EfficientLengthTakeIterable extends TakeIterable$(E) { | |
| 550 EfficientLengthTakeIterable(iterable, takeCount) { | |
| 551 super.TakeIterable$_(iterable, takeCount); | |
| 552 } | |
| 553 get length() { | |
| 554 let iterableLength = this[_iterable].length; | |
| 555 if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount])) | |
| 556 return this[_takeCount]; | |
| 557 return iterableLength; | |
| 558 } | |
| 559 } | |
| 560 return EfficientLengthTakeIterable; | |
| 561 }); | |
| 562 let EfficientLengthTakeIterable = EfficientLengthTakeIterable$(dart.dynamic); | |
| 563 let _remaining = Symbol('_remaining'); | |
| 564 let TakeIterator$ = dart.generic(function(E) { | |
| 565 class TakeIterator extends core.Iterator$(E) { | |
| 566 TakeIterator($_iterator, $_remaining) { | |
| 567 this[_iterator] = $_iterator; | |
| 568 this[_remaining] = $_remaining; | |
| 569 super.Iterator(); | |
| 570 dart.assert(dart.notNull(typeof this[_remaining] == number) && dart.notN
ull(this[_remaining]) >= 0); | |
| 571 } | |
| 572 moveNext() { | |
| 573 this[_remaining] = dart.notNull(this[_remaining]) - 1; | |
| 574 if (dart.notNull(this[_remaining]) >= 0) { | |
| 575 return this[_iterator].moveNext(); | |
| 576 } | |
| 577 this[_remaining] = -1; | |
| 578 return false; | |
| 579 } | |
| 580 get current() { | |
| 581 if (dart.notNull(this[_remaining]) < 0) | |
| 582 return null; | |
| 583 return this[_iterator].current; | |
| 584 } | |
| 585 } | |
| 586 return TakeIterator; | |
| 587 }); | |
| 588 let TakeIterator = TakeIterator$(dart.dynamic); | |
| 589 let TakeWhileIterable$ = dart.generic(function(E) { | |
| 590 class TakeWhileIterable extends collection.IterableBase$(E) { | |
| 591 TakeWhileIterable($_iterable, $_f) { | |
| 592 this[_iterable] = $_iterable; | |
| 593 this[_f] = $_f; | |
| 594 super.IterableBase(); | |
| 595 } | |
| 596 get iterator() { | |
| 597 return new TakeWhileIterator(this[_iterable].iterator, dart.closureWrap(
this[_f], "(E) → bool")); | |
| 598 } | |
| 599 } | |
| 600 return TakeWhileIterable; | |
| 601 }); | |
| 602 let TakeWhileIterable = TakeWhileIterable$(dart.dynamic); | |
| 603 let _isFinished = Symbol('_isFinished'); | |
| 604 let TakeWhileIterator$ = dart.generic(function(E) { | |
| 605 class TakeWhileIterator extends core.Iterator$(E) { | |
| 606 TakeWhileIterator($_iterator, $_f) { | |
| 607 this[_iterator] = $_iterator; | |
| 608 this[_f] = $_f; | |
| 609 this[_isFinished] = false; | |
| 610 super.Iterator(); | |
| 611 } | |
| 612 moveNext() { | |
| 613 if (this[_isFinished]) | |
| 614 return false; | |
| 615 if (!dart.notNull(this[_iterator].moveNext()) || !dart.notNull(dart.dinv
okef(this[_f], this[_iterator].current))) { | |
| 616 this[_isFinished] = true; | |
| 617 return false; | |
| 618 } | |
| 619 return true; | |
| 620 } | |
| 621 get current() { | |
| 622 if (this[_isFinished]) | |
| 623 return null; | |
| 624 return this[_iterator].current; | |
| 625 } | |
| 626 } | |
| 627 return TakeWhileIterator; | |
| 628 }); | |
| 629 let TakeWhileIterator = TakeWhileIterator$(dart.dynamic); | |
| 630 let _skipCount = Symbol('_skipCount'); | |
| 631 let SkipIterable$ = dart.generic(function(E) { | |
| 632 class SkipIterable extends collection.IterableBase$(E) { | |
| 633 SkipIterable(iterable, count) { | |
| 634 if (dart.is(iterable, EfficientLength)) { | |
| 635 return new EfficientLengthSkipIterable(iterable, count); | |
| 636 } | |
| 637 return new SkipIterable._(iterable, count); | |
| 638 } | |
| 639 SkipIterable$_($_iterable, $_skipCount) { | |
| 640 this[_iterable] = $_iterable; | |
| 641 this[_skipCount] = $_skipCount; | |
| 642 super.IterableBase(); | |
| 643 if (!(typeof this[_skipCount] == number)) { | |
| 644 throw new core.ArgumentError.value(this[_skipCount], "count is not an
integer"); | |
| 645 } | |
| 646 core.RangeError.checkNotNegative(this[_skipCount], "count"); | |
| 647 } | |
| 648 skip(count) { | |
| 649 if (!(typeof this[_skipCount] == number)) { | |
| 650 throw new core.ArgumentError.value(this[_skipCount], "count is not an
integer"); | |
| 651 } | |
| 652 core.RangeError.checkNotNegative(this[_skipCount], "count"); | |
| 653 return new SkipIterable._(this[_iterable], dart.notNull(this[_skipCount]
) + dart.notNull(count)); | |
| 654 } | |
| 655 get iterator() { | |
| 656 return new SkipIterator(this[_iterable].iterator, this[_skipCount]); | |
| 657 } | |
| 658 } | |
| 659 dart.defineNamedConstructor(SkipIterable, '_'); | |
| 660 return SkipIterable; | |
| 661 }); | |
| 662 let SkipIterable = SkipIterable$(dart.dynamic); | |
| 663 let EfficientLengthSkipIterable$ = dart.generic(function(E) { | |
| 664 class EfficientLengthSkipIterable extends SkipIterable$(E) { | |
| 665 EfficientLengthSkipIterable(iterable, skipCount) { | |
| 666 super.SkipIterable$_(iterable, skipCount); | |
| 667 } | |
| 668 get length() { | |
| 669 let length = dart.notNull(this[_iterable].length) - dart.notNull(this[_s
kipCount]); | |
| 670 if (dart.notNull(length) >= 0) | |
| 671 return length; | |
| 672 return 0; | |
| 673 } | |
| 674 } | |
| 675 return EfficientLengthSkipIterable; | |
| 676 }); | |
| 677 let EfficientLengthSkipIterable = EfficientLengthSkipIterable$(dart.dynamic); | |
| 678 let SkipIterator$ = dart.generic(function(E) { | |
| 679 class SkipIterator extends core.Iterator$(E) { | |
| 680 SkipIterator($_iterator, $_skipCount) { | |
| 681 this[_iterator] = $_iterator; | |
| 682 this[_skipCount] = $_skipCount; | |
| 683 super.Iterator(); | |
| 684 dart.assert(dart.notNull(typeof this[_skipCount] == number) && dart.notN
ull(this[_skipCount]) >= 0); | |
| 685 } | |
| 686 moveNext() { | |
| 687 for (let i = 0; dart.notNull(i) < dart.notNull(this[_skipCount]); i = da
rt.notNull(i) + 1) | |
| 688 this[_iterator].moveNext(); | |
| 689 this[_skipCount] = 0; | |
| 690 return this[_iterator].moveNext(); | |
| 691 } | |
| 692 get current() { | |
| 693 return this[_iterator].current; | |
| 694 } | |
| 695 } | |
| 696 return SkipIterator; | |
| 697 }); | |
| 698 let SkipIterator = SkipIterator$(dart.dynamic); | |
| 699 let SkipWhileIterable$ = dart.generic(function(E) { | |
| 700 class SkipWhileIterable extends collection.IterableBase$(E) { | |
| 701 SkipWhileIterable($_iterable, $_f) { | |
| 702 this[_iterable] = $_iterable; | |
| 703 this[_f] = $_f; | |
| 704 super.IterableBase(); | |
| 705 } | |
| 706 get iterator() { | |
| 707 return new SkipWhileIterator(this[_iterable].iterator, dart.closureWrap(
this[_f], "(E) → bool")); | |
| 708 } | |
| 709 } | |
| 710 return SkipWhileIterable; | |
| 711 }); | |
| 712 let SkipWhileIterable = SkipWhileIterable$(dart.dynamic); | |
| 713 let _hasSkipped = Symbol('_hasSkipped'); | |
| 714 let SkipWhileIterator$ = dart.generic(function(E) { | |
| 715 class SkipWhileIterator extends core.Iterator$(E) { | |
| 716 SkipWhileIterator($_iterator, $_f) { | |
| 717 this[_iterator] = $_iterator; | |
| 718 this[_f] = $_f; | |
| 719 this[_hasSkipped] = false; | |
| 720 super.Iterator(); | |
| 721 } | |
| 722 moveNext() { | |
| 723 if (!dart.notNull(this[_hasSkipped])) { | |
| 724 this[_hasSkipped] = true; | |
| 725 while (this[_iterator].moveNext()) { | |
| 726 if (!dart.notNull(dart.dinvokef(this[_f], this[_iterator].current))) | |
| 727 return true; | |
| 728 } | |
| 729 } | |
| 730 return this[_iterator].moveNext(); | |
| 731 } | |
| 732 get current() { | |
| 733 return this[_iterator].current; | |
| 734 } | |
| 735 } | |
| 736 return SkipWhileIterator; | |
| 737 }); | |
| 738 let SkipWhileIterator = SkipWhileIterator$(dart.dynamic); | |
| 739 let EmptyIterable$ = dart.generic(function(E) { | |
| 740 class EmptyIterable extends collection.IterableBase$(E) { | |
| 741 EmptyIterable() { | |
| 742 super.IterableBase(); | |
| 743 } | |
| 744 get iterator() { | |
| 745 return dart.as(new EmptyIterator(), core.Iterator$(E)); | |
| 746 } | |
| 747 forEach(action) {} | |
| 748 get isEmpty() { | |
| 749 return true; | |
| 750 } | |
| 751 get length() { | |
| 752 return 0; | |
| 753 } | |
| 754 get first() { | |
| 755 throw IterableElementError.noElement(); | |
| 756 } | |
| 757 get last() { | |
| 758 throw IterableElementError.noElement(); | |
| 759 } | |
| 760 get single() { | |
| 761 throw IterableElementError.noElement(); | |
| 762 } | |
| 763 elementAt(index) { | |
| 764 throw new core.RangeError.range(index, 0, 0, "index"); | |
| 765 } | |
| 766 contains(element) { | |
| 767 return false; | |
| 768 } | |
| 769 every(test) { | |
| 770 return true; | |
| 771 } | |
| 772 any(test) { | |
| 773 return false; | |
| 774 } | |
| 775 firstWhere(test, opt$) { | |
| 776 let orElse = opt$.orElse === void 0 ? null : opt$.orElse; | |
| 777 if (orElse !== null) | |
| 778 return orElse(); | |
| 779 throw IterableElementError.noElement(); | |
| 780 } | |
| 781 lastWhere(test, opt$) { | |
| 782 let orElse = opt$.orElse === void 0 ? null : opt$.orElse; | |
| 783 if (orElse !== null) | |
| 784 return orElse(); | |
| 785 throw IterableElementError.noElement(); | |
| 786 } | |
| 787 singleWhere(test, opt$) { | |
| 788 let orElse = opt$.orElse === void 0 ? null : opt$.orElse; | |
| 789 if (orElse !== null) | |
| 790 return orElse(); | |
| 791 throw IterableElementError.noElement(); | |
| 792 } | |
| 793 join(separator) { | |
| 794 if (separator === void 0) | |
| 795 separator = ""; | |
| 796 return ""; | |
| 797 } | |
| 798 where(test) { | |
| 799 return this; | |
| 800 } | |
| 801 map(f) { | |
| 802 return new EmptyIterable(); | |
| 803 } | |
| 804 reduce(combine) { | |
| 805 throw IterableElementError.noElement(); | |
| 806 } | |
| 807 fold(initialValue, combine) { | |
| 808 return initialValue; | |
| 809 } | |
| 810 skip(count) { | |
| 811 core.RangeError.checkNotNegative(count, "count"); | |
| 812 return this; | |
| 813 } | |
| 814 skipWhile(test) { | |
| 815 return this; | |
| 816 } | |
| 817 take(count) { | |
| 818 core.RangeError.checkNotNegative(count, "count"); | |
| 819 return this; | |
| 820 } | |
| 821 takeWhile(test) { | |
| 822 return this; | |
| 823 } | |
| 824 toList(opt$) { | |
| 825 let growable = opt$.growable === void 0 ? true : opt$.growable; | |
| 826 return growable ? new List.from([]) : new core.List(0); | |
| 827 } | |
| 828 toSet() { | |
| 829 return new core.Set(); | |
| 830 } | |
| 831 } | |
| 832 return EmptyIterable; | |
| 833 }); | |
| 834 let EmptyIterable = EmptyIterable$(dart.dynamic); | |
| 835 let EmptyIterator$ = dart.generic(function(E) { | |
| 836 class EmptyIterator extends core.Object { | |
| 837 EmptyIterator() { | |
| 838 } | |
| 839 moveNext() { | |
| 840 return false; | |
| 841 } | |
| 842 get current() { | |
| 843 return null; | |
| 844 } | |
| 845 } | |
| 846 return EmptyIterator; | |
| 847 }); | |
| 848 let EmptyIterator = EmptyIterator$(dart.dynamic); | |
| 849 let BidirectionalIterator$ = dart.generic(function(T) { | |
| 850 class BidirectionalIterator extends core.Object { | |
| 851 } | |
| 852 return BidirectionalIterator; | |
| 853 }); | |
| 854 let BidirectionalIterator = BidirectionalIterator$(dart.dynamic); | |
| 855 let _rangeCheck = Symbol('_rangeCheck'); | |
| 856 let IterableMixinWorkaround$ = dart.generic(function(T) { | |
| 857 class IterableMixinWorkaround extends core.Object { | |
| 858 static contains(iterable, element) { | |
| 859 for (let e of iterable) { | |
| 860 if (dart.equals(e, element)) | |
| 861 return true; | |
| 862 } | |
| 863 return false; | |
| 864 } | |
| 865 static forEach(iterable, f) { | |
| 866 for (let e of iterable) { | |
| 867 dart.dinvokef(f, e); | |
| 868 } | |
| 869 } | |
| 870 static any(iterable, f) { | |
| 871 for (let e of iterable) { | |
| 872 if (dart.dinvokef(f, e)) | |
| 873 return true; | |
| 874 } | |
| 875 return false; | |
| 876 } | |
| 877 static every(iterable, f) { | |
| 878 for (let e of iterable) { | |
| 879 if (!dart.notNull(dart.dinvokef(f, e))) | |
| 880 return false; | |
| 881 } | |
| 882 return true; | |
| 883 } | |
| 884 static reduce(iterable, combine) { | |
| 885 let iterator = iterable.iterator; | |
| 886 if (!dart.notNull(iterator.moveNext())) | |
| 887 throw IterableElementError.noElement(); | |
| 888 let value = iterator.current; | |
| 889 while (iterator.moveNext()) { | |
| 890 value = dart.dinvokef(combine, value, iterator.current); | |
| 891 } | |
| 892 return value; | |
| 893 } | |
| 894 static fold(iterable, initialValue, combine) { | |
| 895 for (let element of iterable) { | |
| 896 initialValue = dart.dinvokef(combine, initialValue, element); | |
| 897 } | |
| 898 return initialValue; | |
| 899 } | |
| 900 static removeWhereList(list, test) { | |
| 901 let retained = new List.from([]); | |
| 902 let length = list.length; | |
| 903 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 904 let element = list.get(i); | |
| 905 if (!dart.notNull(dart.dinvokef(test, element))) { | |
| 906 retained.add(element); | |
| 907 } | |
| 908 if (length !== list.length) { | |
| 909 throw new core.ConcurrentModificationError(list); | |
| 910 } | |
| 911 } | |
| 912 if (retained.length === length) | |
| 913 return; | |
| 914 list.length = retained.length; | |
| 915 for (let i = 0; dart.notNull(i) < dart.notNull(retained.length); i = dar
t.notNull(i) + 1) { | |
| 916 list.set(i, retained.get(i)); | |
| 917 } | |
| 918 } | |
| 919 static isEmpty(iterable) { | |
| 920 return !dart.notNull(iterable.iterator.moveNext()); | |
| 921 } | |
| 922 static first(iterable) { | |
| 923 let it = iterable.iterator; | |
| 924 if (!dart.notNull(it.moveNext())) { | |
| 925 throw IterableElementError.noElement(); | |
| 926 } | |
| 927 return it.current; | |
| 928 } | |
| 929 static last(iterable) { | |
| 930 let it = iterable.iterator; | |
| 931 if (!dart.notNull(it.moveNext())) { | |
| 932 throw IterableElementError.noElement(); | |
| 933 } | |
| 934 let result = null; | |
| 935 do { | |
| 936 result = it.current; | |
| 937 } while (it.moveNext()); | |
| 938 return result; | |
| 939 } | |
| 940 static single(iterable) { | |
| 941 let it = iterable.iterator; | |
| 942 if (!dart.notNull(it.moveNext())) | |
| 943 throw IterableElementError.noElement(); | |
| 944 let result = it.current; | |
| 945 if (it.moveNext()) | |
| 946 throw IterableElementError.tooMany(); | |
| 947 return result; | |
| 948 } | |
| 949 static firstWhere(iterable, test, orElse) { | |
| 950 for (let element of iterable) { | |
| 951 if (dart.dinvokef(test, element)) | |
| 952 return element; | |
| 953 } | |
| 954 if (orElse !== null) | |
| 955 return orElse(); | |
| 956 throw IterableElementError.noElement(); | |
| 957 } | |
| 958 static lastWhere(iterable, test, orElse) { | |
| 959 let result = null; | |
| 960 let foundMatching = false; | |
| 961 for (let element of iterable) { | |
| 962 if (dart.dinvokef(test, element)) { | |
| 963 result = element; | |
| 964 foundMatching = true; | |
| 965 } | |
| 966 } | |
| 967 if (foundMatching) | |
| 968 return result; | |
| 969 if (orElse !== null) | |
| 970 return orElse(); | |
| 971 throw IterableElementError.noElement(); | |
| 972 } | |
| 973 static lastWhereList(list, test, orElse) { | |
| 974 for (let i = dart.notNull(list.length) - 1; dart.notNull(i) >= 0; i = da
rt.notNull(i) - 1) { | |
| 975 let element = list.get(i); | |
| 976 if (dart.dinvokef(test, element)) | |
| 977 return element; | |
| 978 } | |
| 979 if (orElse !== null) | |
| 980 return orElse(); | |
| 981 throw IterableElementError.noElement(); | |
| 982 } | |
| 983 static singleWhere(iterable, test) { | |
| 984 let result = null; | |
| 985 let foundMatching = false; | |
| 986 for (let element of iterable) { | |
| 987 if (dart.dinvokef(test, element)) { | |
| 988 if (foundMatching) { | |
| 989 throw IterableElementError.tooMany(); | |
| 990 } | |
| 991 result = element; | |
| 992 foundMatching = true; | |
| 993 } | |
| 994 } | |
| 995 if (foundMatching) | |
| 996 return result; | |
| 997 throw IterableElementError.noElement(); | |
| 998 } | |
| 999 static elementAt(iterable, index) { | |
| 1000 if (!(typeof index == number)) | |
| 1001 throw new core.ArgumentError.notNull("index"); | |
| 1002 core.RangeError.checkNotNegative(index, "index"); | |
| 1003 let elementIndex = 0; | |
| 1004 for (let element of iterable) { | |
| 1005 if (index === elementIndex) | |
| 1006 return element; | |
| 1007 elementIndex = dart.notNull(elementIndex) + 1; | |
| 1008 } | |
| 1009 throw new core.RangeError.index(index, iterable, "index", null, elementI
ndex); | |
| 1010 } | |
| 1011 static join(iterable, separator) { | |
| 1012 if (separator === void 0) | |
| 1013 separator = null; | |
| 1014 let buffer = new core.StringBuffer(); | |
| 1015 buffer.writeAll(iterable, separator); | |
| 1016 return buffer.toString(); | |
| 1017 } | |
| 1018 static joinList(list, separator) { | |
| 1019 if (separator === void 0) | |
| 1020 separator = null; | |
| 1021 if (list.isEmpty) | |
| 1022 return ""; | |
| 1023 if (list.length === 1) | |
| 1024 return `${list.get(0)}`; | |
| 1025 let buffer = new core.StringBuffer(); | |
| 1026 if (separator.isEmpty) { | |
| 1027 for (let i = 0; dart.notNull(i) < dart.notNull(list.length); i = dart.
notNull(i) + 1) { | |
| 1028 buffer.write(list.get(i)); | |
| 1029 } | |
| 1030 } else { | |
| 1031 buffer.write(list.get(0)); | |
| 1032 for (let i = 1; dart.notNull(i) < dart.notNull(list.length); i = dart.
notNull(i) + 1) { | |
| 1033 buffer.write(separator); | |
| 1034 buffer.write(list.get(i)); | |
| 1035 } | |
| 1036 } | |
| 1037 return buffer.toString(); | |
| 1038 } | |
| 1039 where(iterable, f) { | |
| 1040 return new WhereIterable(dart.as(iterable, core.Iterable$(T)), dart.clos
ureWrap(f, "(T) → bool")); | |
| 1041 } | |
| 1042 static map(iterable, f) { | |
| 1043 return new MappedIterable(iterable, f); | |
| 1044 } | |
| 1045 static mapList(list, f) { | |
| 1046 return new MappedListIterable(list, f); | |
| 1047 } | |
| 1048 static expand(iterable, f) { | |
| 1049 return new ExpandIterable(iterable, f); | |
| 1050 } | |
| 1051 takeList(list, n) { | |
| 1052 return new SubListIterable(dart.as(list, core.Iterable$(T)), 0, n); | |
| 1053 } | |
| 1054 takeWhile(iterable, test) { | |
| 1055 return new TakeWhileIterable(dart.as(iterable, core.Iterable$(T)), dart.
closureWrap(test, "(T) → bool")); | |
| 1056 } | |
| 1057 skipList(list, n) { | |
| 1058 return new SubListIterable(dart.as(list, core.Iterable$(T)), n, null); | |
| 1059 } | |
| 1060 skipWhile(iterable, test) { | |
| 1061 return new SkipWhileIterable(dart.as(iterable, core.Iterable$(T)), dart.
closureWrap(test, "(T) → bool")); | |
| 1062 } | |
| 1063 reversedList(list) { | |
| 1064 return new ReversedListIterable(dart.as(list, core.Iterable$(T))); | |
| 1065 } | |
| 1066 static sortList(list, compare) { | |
| 1067 if (compare === null) | |
| 1068 compare = core.Comparable.compare; | |
| 1069 Sort.sort(list, compare); | |
| 1070 } | |
| 1071 static shuffleList(list, random) { | |
| 1072 if (random === null) | |
| 1073 random = new math.Random(); | |
| 1074 let length = list.length; | |
| 1075 while (dart.notNull(length) > 1) { | |
| 1076 let pos = random.nextInt(length); | |
| 1077 length = 1; | |
| 1078 let tmp = list.get(length); | |
| 1079 list.set(length, list.get(pos)); | |
| 1080 list.set(pos, tmp); | |
| 1081 } | |
| 1082 } | |
| 1083 static indexOfList(list, element, start) { | |
| 1084 return Lists.indexOf(list, element, start, list.length); | |
| 1085 } | |
| 1086 static lastIndexOfList(list, element, start) { | |
| 1087 if (start === null) | |
| 1088 start = dart.notNull(list.length) - 1; | |
| 1089 return Lists.lastIndexOf(list, element, start); | |
| 1090 } | |
| 1091 static [_rangeCheck](list, start, end) { | |
| 1092 core.RangeError.checkValidRange(start, end, list.length); | |
| 1093 } | |
| 1094 getRangeList(list, start, end) { | |
| 1095 _rangeCheck(list, start, end); | |
| 1096 return new SubListIterable(dart.as(list, core.Iterable$(T)), start, end)
; | |
| 1097 } | |
| 1098 static setRangeList(list, start, end, from, skipCount) { | |
| 1099 _rangeCheck(list, start, end); | |
| 1100 let length = dart.notNull(end) - dart.notNull(start); | |
| 1101 if (length === 0) | |
| 1102 return; | |
| 1103 if (dart.notNull(skipCount) < 0) | |
| 1104 throw new core.ArgumentError(skipCount); | |
| 1105 let otherList = null; | |
| 1106 let otherStart = null; | |
| 1107 if (dart.is(from, core.List)) { | |
| 1108 otherList = from; | |
| 1109 otherStart = skipCount; | |
| 1110 } else { | |
| 1111 otherList = from.skip(skipCount).toList({growable: false}); | |
| 1112 otherStart = 0; | |
| 1113 } | |
| 1114 if (dart.notNull(otherStart) + dart.notNull(length) > dart.notNull(other
List.length)) { | |
| 1115 throw IterableElementError.tooFew(); | |
| 1116 } | |
| 1117 Lists.copy(otherList, otherStart, list, start, length); | |
| 1118 } | |
| 1119 static replaceRangeList(list, start, end, iterable) { | |
| 1120 _rangeCheck(list, start, end); | |
| 1121 if (!dart.is(iterable, EfficientLength)) { | |
| 1122 iterable = iterable.toList(); | |
| 1123 } | |
| 1124 let removeLength = dart.notNull(end) - dart.notNull(start); | |
| 1125 let insertLength = iterable.length; | |
| 1126 if (dart.notNull(removeLength) >= dart.notNull(insertLength)) { | |
| 1127 let delta = dart.notNull(removeLength) - dart.notNull(insertLength); | |
| 1128 let insertEnd = dart.notNull(start) + dart.notNull(insertLength); | |
| 1129 let newEnd = dart.notNull(list.length) - dart.notNull(delta); | |
| 1130 list.setRange(start, insertEnd, iterable); | |
| 1131 if (delta !== 0) { | |
| 1132 list.setRange(insertEnd, newEnd, list, end); | |
| 1133 list.length = newEnd; | |
| 1134 } | |
| 1135 } else { | |
| 1136 let delta = dart.notNull(insertLength) - dart.notNull(removeLength); | |
| 1137 let newLength = dart.notNull(list.length) + dart.notNull(delta); | |
| 1138 let insertEnd = dart.notNull(start) + dart.notNull(insertLength); | |
| 1139 list.length = newLength; | |
| 1140 list.setRange(insertEnd, newLength, list, end); | |
| 1141 list.setRange(start, insertEnd, iterable); | |
| 1142 } | |
| 1143 } | |
| 1144 static fillRangeList(list, start, end, fillValue) { | |
| 1145 _rangeCheck(list, start, end); | |
| 1146 for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNul
l(i) + 1) { | |
| 1147 list.set(i, fillValue); | |
| 1148 } | |
| 1149 } | |
| 1150 static insertAllList(list, index, iterable) { | |
| 1151 core.RangeError.checkValueInInterval(index, 0, list.length, "index"); | |
| 1152 if (!dart.is(iterable, EfficientLength)) { | |
| 1153 iterable = iterable.toList({growable: false}); | |
| 1154 } | |
| 1155 let insertionLength = iterable.length; | |
| 1156 list.length = insertionLength; | |
| 1157 list.setRange(dart.notNull(index) + dart.notNull(insertionLength), list.
length, list, index); | |
| 1158 for (let element of iterable) { | |
| 1159 list.set((($tmp) => index = dart.notNull($tmp) + 1, $tmp)(index), elem
ent); | |
| 1160 } | |
| 1161 } | |
| 1162 static setAllList(list, index, iterable) { | |
| 1163 core.RangeError.checkValueInInterval(index, 0, list.length, "index"); | |
| 1164 for (let element of iterable) { | |
| 1165 list.set((($tmp) => index = dart.notNull($tmp) + 1, $tmp)(index), elem
ent); | |
| 1166 } | |
| 1167 } | |
| 1168 asMapList(l) { | |
| 1169 return new ListMapView(dart.as(l, core.List$(T))); | |
| 1170 } | |
| 1171 static setContainsAll(set, other) { | |
| 1172 for (let element of other) { | |
| 1173 if (!dart.notNull(set.contains(element))) | |
| 1174 return false; | |
| 1175 } | |
| 1176 return true; | |
| 1177 } | |
| 1178 static setIntersection(set, other, result) { | |
| 1179 let smaller = null; | |
| 1180 let larger = null; | |
| 1181 if (dart.notNull(set.length) < dart.notNull(other.length)) { | |
| 1182 smaller = set; | |
| 1183 larger = other; | |
| 1184 } else { | |
| 1185 smaller = other; | |
| 1186 larger = set; | |
| 1187 } | |
| 1188 for (let element of smaller) { | |
| 1189 if (larger.contains(element)) { | |
| 1190 result.add(element); | |
| 1191 } | |
| 1192 } | |
| 1193 return result; | |
| 1194 } | |
| 1195 static setUnion(set, other, result) { | |
| 1196 result.addAll(set); | |
| 1197 result.addAll(other); | |
| 1198 return result; | |
| 1199 } | |
| 1200 static setDifference(set, other, result) { | |
| 1201 for (let element of set) { | |
| 1202 if (!dart.notNull(other.contains(element))) { | |
| 1203 result.add(element); | |
| 1204 } | |
| 1205 } | |
| 1206 return result; | |
| 1207 } | |
| 1208 } | |
| 1209 return IterableMixinWorkaround; | |
| 1210 }); | |
| 1211 let IterableMixinWorkaround = IterableMixinWorkaround$(dart.dynamic); | |
| 1212 class IterableElementError extends core.Object { | |
| 1213 static noElement() { | |
| 1214 return new core.StateError("No element"); | |
| 1215 } | |
| 1216 static tooMany() { | |
| 1217 return new core.StateError("Too many elements"); | |
| 1218 } | |
| 1219 static tooFew() { | |
| 1220 return new core.StateError("Too few elements"); | |
| 1221 } | |
| 1222 } | |
| 1223 let FixedLengthListMixin$ = dart.generic(function(E) { | |
| 1224 class FixedLengthListMixin extends core.Object { | |
| 1225 set length(newLength) { | |
| 1226 throw new core.UnsupportedError("Cannot change the length of a fixed-len
gth list"); | |
| 1227 } | |
| 1228 add(value) { | |
| 1229 throw new core.UnsupportedError("Cannot add to a fixed-length list"); | |
| 1230 } | |
| 1231 insert(index, value) { | |
| 1232 throw new core.UnsupportedError("Cannot add to a fixed-length list"); | |
| 1233 } | |
| 1234 insertAll(at, iterable) { | |
| 1235 throw new core.UnsupportedError("Cannot add to a fixed-length list"); | |
| 1236 } | |
| 1237 addAll(iterable) { | |
| 1238 throw new core.UnsupportedError("Cannot add to a fixed-length list"); | |
| 1239 } | |
| 1240 remove(element) { | |
| 1241 throw new core.UnsupportedError("Cannot remove from a fixed-length list"
); | |
| 1242 } | |
| 1243 removeWhere(test) { | |
| 1244 throw new core.UnsupportedError("Cannot remove from a fixed-length list"
); | |
| 1245 } | |
| 1246 retainWhere(test) { | |
| 1247 throw new core.UnsupportedError("Cannot remove from a fixed-length list"
); | |
| 1248 } | |
| 1249 clear() { | |
| 1250 throw new core.UnsupportedError("Cannot clear a fixed-length list"); | |
| 1251 } | |
| 1252 removeAt(index) { | |
| 1253 throw new core.UnsupportedError("Cannot remove from a fixed-length list"
); | |
| 1254 } | |
| 1255 removeLast() { | |
| 1256 throw new core.UnsupportedError("Cannot remove from a fixed-length list"
); | |
| 1257 } | |
| 1258 removeRange(start, end) { | |
| 1259 throw new core.UnsupportedError("Cannot remove from a fixed-length list"
); | |
| 1260 } | |
| 1261 replaceRange(start, end, iterable) { | |
| 1262 throw new core.UnsupportedError("Cannot remove from a fixed-length list"
); | |
| 1263 } | |
| 1264 } | |
| 1265 return FixedLengthListMixin; | |
| 1266 }); | |
| 1267 let FixedLengthListMixin = FixedLengthListMixin$(dart.dynamic); | |
| 1268 let UnmodifiableListMixin$ = dart.generic(function(E) { | |
| 1269 class UnmodifiableListMixin extends core.Object { | |
| 1270 set(index, value) { | |
| 1271 throw new core.UnsupportedError("Cannot modify an unmodifiable list"); | |
| 1272 } | |
| 1273 set length(newLength) { | |
| 1274 throw new core.UnsupportedError("Cannot change the length of an unmodifi
able list"); | |
| 1275 } | |
| 1276 setAll(at, iterable) { | |
| 1277 throw new core.UnsupportedError("Cannot modify an unmodifiable list"); | |
| 1278 } | |
| 1279 add(value) { | |
| 1280 throw new core.UnsupportedError("Cannot add to an unmodifiable list"); | |
| 1281 } | |
| 1282 insert(index, value) { | |
| 1283 throw new core.UnsupportedError("Cannot add to an unmodifiable list"); | |
| 1284 } | |
| 1285 insertAll(at, iterable) { | |
| 1286 throw new core.UnsupportedError("Cannot add to an unmodifiable list"); | |
| 1287 } | |
| 1288 addAll(iterable) { | |
| 1289 throw new core.UnsupportedError("Cannot add to an unmodifiable list"); | |
| 1290 } | |
| 1291 remove(element) { | |
| 1292 throw new core.UnsupportedError("Cannot remove from an unmodifiable list
"); | |
| 1293 } | |
| 1294 removeWhere(test) { | |
| 1295 throw new core.UnsupportedError("Cannot remove from an unmodifiable list
"); | |
| 1296 } | |
| 1297 retainWhere(test) { | |
| 1298 throw new core.UnsupportedError("Cannot remove from an unmodifiable list
"); | |
| 1299 } | |
| 1300 sort(compare) { | |
| 1301 if (compare === void 0) | |
| 1302 compare = null; | |
| 1303 throw new core.UnsupportedError("Cannot modify an unmodifiable list"); | |
| 1304 } | |
| 1305 shuffle(random) { | |
| 1306 if (random === void 0) | |
| 1307 random = null; | |
| 1308 throw new core.UnsupportedError("Cannot modify an unmodifiable list"); | |
| 1309 } | |
| 1310 clear() { | |
| 1311 throw new core.UnsupportedError("Cannot clear an unmodifiable list"); | |
| 1312 } | |
| 1313 removeAt(index) { | |
| 1314 throw new core.UnsupportedError("Cannot remove from an unmodifiable list
"); | |
| 1315 } | |
| 1316 removeLast() { | |
| 1317 throw new core.UnsupportedError("Cannot remove from an unmodifiable list
"); | |
| 1318 } | |
| 1319 setRange(start, end, iterable, skipCount) { | |
| 1320 if (skipCount === void 0) | |
| 1321 skipCount = 0; | |
| 1322 throw new core.UnsupportedError("Cannot modify an unmodifiable list"); | |
| 1323 } | |
| 1324 removeRange(start, end) { | |
| 1325 throw new core.UnsupportedError("Cannot remove from an unmodifiable list
"); | |
| 1326 } | |
| 1327 replaceRange(start, end, iterable) { | |
| 1328 throw new core.UnsupportedError("Cannot remove from an unmodifiable list
"); | |
| 1329 } | |
| 1330 fillRange(start, end, fillValue) { | |
| 1331 if (fillValue === void 0) | |
| 1332 fillValue = null; | |
| 1333 throw new core.UnsupportedError("Cannot modify an unmodifiable list"); | |
| 1334 } | |
| 1335 } | |
| 1336 return UnmodifiableListMixin; | |
| 1337 }); | |
| 1338 let UnmodifiableListMixin = UnmodifiableListMixin$(dart.dynamic); | |
| 1339 let FixedLengthListBase$ = dart.generic(function(E) { | |
| 1340 class FixedLengthListBase extends dart.mixin(FixedLengthListMixin$(E)) { | |
| 1341 } | |
| 1342 return FixedLengthListBase; | |
| 1343 }); | |
| 1344 let FixedLengthListBase = FixedLengthListBase$(dart.dynamic); | |
| 1345 let UnmodifiableListBase$ = dart.generic(function(E) { | |
| 1346 class UnmodifiableListBase extends dart.mixin(UnmodifiableListMixin$(E)) { | |
| 1347 } | |
| 1348 return UnmodifiableListBase; | |
| 1349 }); | |
| 1350 let UnmodifiableListBase = UnmodifiableListBase$(dart.dynamic); | |
| 1351 let _backedList = Symbol('_backedList'); | |
| 1352 class _ListIndicesIterable extends ListIterable$(core.int) { | |
| 1353 _ListIndicesIterable($_backedList) { | |
| 1354 this[_backedList] = $_backedList; | |
| 1355 super.ListIterable(); | |
| 1356 } | |
| 1357 get length() { | |
| 1358 return this[_backedList].length; | |
| 1359 } | |
| 1360 elementAt(index) { | |
| 1361 core.RangeError.checkValidIndex(index, this); | |
| 1362 return index; | |
| 1363 } | |
| 1364 } | |
| 1365 let _values = Symbol('_values'); | |
| 1366 let ListMapView$ = dart.generic(function(E) { | |
| 1367 class ListMapView extends core.Object { | |
| 1368 ListMapView($_values) { | |
| 1369 this[_values] = $_values; | |
| 1370 } | |
| 1371 get(key) { | |
| 1372 return this.containsKey(key) ? this[_values].get(key) : null; | |
| 1373 } | |
| 1374 get length() { | |
| 1375 return this[_values].length; | |
| 1376 } | |
| 1377 get values() { | |
| 1378 return new SubListIterable(this[_values], 0, null); | |
| 1379 } | |
| 1380 get keys() { | |
| 1381 return new _ListIndicesIterable(this[_values]); | |
| 1382 } | |
| 1383 get isEmpty() { | |
| 1384 return this[_values].isEmpty; | |
| 1385 } | |
| 1386 get isNotEmpty() { | |
| 1387 return this[_values].isNotEmpty; | |
| 1388 } | |
| 1389 containsValue(value) { | |
| 1390 return this[_values].contains(value); | |
| 1391 } | |
| 1392 containsKey(key) { | |
| 1393 return dart.notNull(typeof key == number) && dart.notNull(key) >= 0 && d
art.notNull(key) < dart.notNull(this.length); | |
| 1394 } | |
| 1395 forEach(f) { | |
| 1396 let length = this[_values].length; | |
| 1397 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull
(i) + 1) { | |
| 1398 f(i, this[_values].get(i)); | |
| 1399 if (length !== this[_values].length) { | |
| 1400 throw new core.ConcurrentModificationError(this[_values]); | |
| 1401 } | |
| 1402 } | |
| 1403 } | |
| 1404 set(key, value) { | |
| 1405 throw new core.UnsupportedError("Cannot modify an unmodifiable map"); | |
| 1406 } | |
| 1407 putIfAbsent(key, ifAbsent) { | |
| 1408 throw new core.UnsupportedError("Cannot modify an unmodifiable map"); | |
| 1409 } | |
| 1410 remove(key) { | |
| 1411 throw new core.UnsupportedError("Cannot modify an unmodifiable map"); | |
| 1412 } | |
| 1413 clear() { | |
| 1414 throw new core.UnsupportedError("Cannot modify an unmodifiable map"); | |
| 1415 } | |
| 1416 addAll(other) { | |
| 1417 throw new core.UnsupportedError("Cannot modify an unmodifiable map"); | |
| 1418 } | |
| 1419 toString() { | |
| 1420 return collection.Maps.mapToString(this); | |
| 1421 } | |
| 1422 } | |
| 1423 return ListMapView; | |
| 1424 }); | |
| 1425 let ListMapView = ListMapView$(dart.dynamic); | |
| 1426 let ReversedListIterable$ = dart.generic(function(E) { | |
| 1427 class ReversedListIterable extends ListIterable$(E) { | |
| 1428 ReversedListIterable($_source) { | |
| 1429 this[_source] = $_source; | |
| 1430 super.ListIterable(); | |
| 1431 } | |
| 1432 get length() { | |
| 1433 return this[_source].length; | |
| 1434 } | |
| 1435 elementAt(index) { | |
| 1436 return this[_source].elementAt(dart.notNull(this[_source].length) - 1 -
dart.notNull(index)); | |
| 1437 } | |
| 1438 } | |
| 1439 return ReversedListIterable; | |
| 1440 }); | |
| 1441 let ReversedListIterable = ReversedListIterable$(dart.dynamic); | |
| 1442 class UnmodifiableListError extends core.Object { | |
| 1443 static add() { | |
| 1444 return new core.UnsupportedError("Cannot add to unmodifiable List"); | |
| 1445 } | |
| 1446 static change() { | |
| 1447 return new core.UnsupportedError("Cannot change the content of an unmodifi
able List"); | |
| 1448 } | |
| 1449 static length() { | |
| 1450 return new core.UnsupportedError("Cannot change length of unmodifiable Lis
t"); | |
| 1451 } | |
| 1452 static remove() { | |
| 1453 return new core.UnsupportedError("Cannot remove from unmodifiable List"); | |
| 1454 } | |
| 1455 } | |
| 1456 class NonGrowableListError extends core.Object { | |
| 1457 static add() { | |
| 1458 return new core.UnsupportedError("Cannot add to non-growable List"); | |
| 1459 } | |
| 1460 static length() { | |
| 1461 return new core.UnsupportedError("Cannot change length of non-growable Lis
t"); | |
| 1462 } | |
| 1463 static remove() { | |
| 1464 return new core.UnsupportedError("Cannot remove from non-growable List"); | |
| 1465 } | |
| 1466 } | |
| 1467 // Function makeListFixedLength: (List<dynamic>) → List | |
| 1468 function makeListFixedLength(growableList) { | |
| 1469 _interceptors.JSArray.markFixedList(growableList); | |
| 1470 return growableList; | |
| 1471 } | |
| 1472 class Lists extends core.Object { | |
| 1473 static copy(src, srcStart, dst, dstStart, count) { | |
| 1474 if (dart.notNull(srcStart) < dart.notNull(dstStart)) { | |
| 1475 for (let i = dart.notNull(srcStart) + dart.notNull(count) - 1, j = dart.
notNull(dstStart) + dart.notNull(count) - 1; dart.notNull(i) >= dart.notNull(src
Start); i = dart.notNull(i) - 1, j = dart.notNull(j) - 1) { | |
| 1476 dst.set(j, src.get(i)); | |
| 1477 } | |
| 1478 } else { | |
| 1479 for (let i = srcStart, j = dstStart; dart.notNull(i) < dart.notNull(srcS
tart) + dart.notNull(count); i = dart.notNull(i) + 1, j = dart.notNull(j) + 1) { | |
| 1480 dst.set(j, src.get(i)); | |
| 1481 } | |
| 1482 } | |
| 1483 } | |
| 1484 static areEqual(a, b) { | |
| 1485 if (core.identical(a, b)) | |
| 1486 return true; | |
| 1487 if (!dart.notNull(dart.is(b, core.List))) | |
| 1488 return false; | |
| 1489 let length = a.length; | |
| 1490 if (length !== dart.dload(b, 'length')) | |
| 1491 return false; | |
| 1492 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i
) + 1) { | |
| 1493 if (!dart.notNull(core.identical(a.get(i), dart.dindex(b, i)))) | |
| 1494 return false; | |
| 1495 } | |
| 1496 return true; | |
| 1497 } | |
| 1498 static indexOf(a, element, startIndex, endIndex) { | |
| 1499 if (dart.notNull(startIndex) >= dart.notNull(a.length)) { | |
| 1500 return -1; | |
| 1501 } | |
| 1502 if (dart.notNull(startIndex) < 0) { | |
| 1503 startIndex = 0; | |
| 1504 } | |
| 1505 for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dar
t.notNull(i) + 1) { | |
| 1506 if (dart.equals(a.get(i), element)) { | |
| 1507 return i; | |
| 1508 } | |
| 1509 } | |
| 1510 return -1; | |
| 1511 } | |
| 1512 static lastIndexOf(a, element, startIndex) { | |
| 1513 if (dart.notNull(startIndex) < 0) { | |
| 1514 return -1; | |
| 1515 } | |
| 1516 if (dart.notNull(startIndex) >= dart.notNull(a.length)) { | |
| 1517 startIndex = dart.notNull(a.length) - 1; | |
| 1518 } | |
| 1519 for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) { | |
| 1520 if (dart.equals(a.get(i), element)) { | |
| 1521 return i; | |
| 1522 } | |
| 1523 } | |
| 1524 return -1; | |
| 1525 } | |
| 1526 static indicesCheck(a, start, end) { | |
| 1527 core.RangeError.checkValidRange(start, end, a.length); | |
| 1528 } | |
| 1529 static rangeCheck(a, start, length) { | |
| 1530 core.RangeError.checkNotNegative(length); | |
| 1531 core.RangeError.checkNotNegative(start); | |
| 1532 if (dart.notNull(start) + dart.notNull(length) > dart.notNull(a.length)) { | |
| 1533 let message = `${start} + ${length} must be in the range [0..${a.length}
]`; | |
| 1534 throw new core.RangeError.range(length, 0, dart.notNull(a.length) - dart
.notNull(start), "length", message); | |
| 1535 } | |
| 1536 } | |
| 1537 } | |
| 1538 exports.printToZone = null; | |
| 1539 // Function printToConsole: (String) → void | |
| 1540 function printToConsole(line) { | |
| 1541 _js_primitives.printString(`${line}`); | |
| 1542 } | |
| 1543 let _doSort = Symbol('_doSort'); | |
| 1544 let _insertionSort = Symbol('_insertionSort'); | |
| 1545 let _dualPivotQuicksort = Symbol('_dualPivotQuicksort'); | |
| 1546 class Sort extends core.Object { | |
| 1547 static sort(a, compare) { | |
| 1548 _doSort(a, 0, dart.notNull(a.length) - 1, compare); | |
| 1549 } | |
| 1550 static sortRange(a, from, to, compare) { | |
| 1551 if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a.length) ||
dart.notNull(to) < dart.notNull(from)) { | |
| 1552 throw "OutOfRange"; | |
| 1553 } | |
| 1554 _doSort(a, from, dart.notNull(to) - 1, compare); | |
| 1555 } | |
| 1556 static [_doSort](a, left, right, compare) { | |
| 1557 if (dart.notNull(right) - dart.notNull(left) <= dart.notNull(Sort._INSERTI
ON_SORT_THRESHOLD)) { | |
| 1558 _insertionSort(a, left, right, compare); | |
| 1559 } else { | |
| 1560 _dualPivotQuicksort(a, left, right, compare); | |
| 1561 } | |
| 1562 } | |
| 1563 static [_insertionSort](a, left, right, compare) { | |
| 1564 for (let i = dart.notNull(left) + 1; dart.notNull(i) <= dart.notNull(right
); i = dart.notNull(i) + 1) { | |
| 1565 let el = a.get(i); | |
| 1566 let j = i; | |
| 1567 while (dart.notNull(j) > dart.notNull(left) && dart.notNull(dart.dinvoke
f(compare, a.get(dart.notNull(j) - 1), el)) > 0) { | |
| 1568 a.set(j, a.get(dart.notNull(j) - 1)); | |
| 1569 j = dart.notNull(j) - 1; | |
| 1570 } | |
| 1571 a.set(j, el); | |
| 1572 } | |
| 1573 } | |
| 1574 static [_dualPivotQuicksort](a, left, right, compare) { | |
| 1575 dart.assert(dart.notNull(right) - dart.notNull(left) > dart.notNull(Sort._
INSERTION_SORT_THRESHOLD)); | |
| 1576 let sixth = ((dart.notNull(right) - dart.notNull(left) + 1) / 6).truncate(
); | |
| 1577 let index1 = dart.notNull(left) + dart.notNull(sixth); | |
| 1578 let index5 = dart.notNull(right) - dart.notNull(sixth); | |
| 1579 let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2).truncate(); | |
| 1580 let index2 = dart.notNull(index3) - dart.notNull(sixth); | |
| 1581 let index4 = dart.notNull(index3) + dart.notNull(sixth); | |
| 1582 let el1 = a.get(index1); | |
| 1583 let el2 = a.get(index2); | |
| 1584 let el3 = a.get(index3); | |
| 1585 let el4 = a.get(index4); | |
| 1586 let el5 = a.get(index5); | |
| 1587 if (dart.notNull(dart.dinvokef(compare, el1, el2)) > 0) { | |
| 1588 let t = el1; | |
| 1589 el1 = el2; | |
| 1590 el2 = t; | |
| 1591 } | |
| 1592 if (dart.notNull(dart.dinvokef(compare, el4, el5)) > 0) { | |
| 1593 let t = el4; | |
| 1594 el4 = el5; | |
| 1595 el5 = t; | |
| 1596 } | |
| 1597 if (dart.notNull(dart.dinvokef(compare, el1, el3)) > 0) { | |
| 1598 let t = el1; | |
| 1599 el1 = el3; | |
| 1600 el3 = t; | |
| 1601 } | |
| 1602 if (dart.notNull(dart.dinvokef(compare, el2, el3)) > 0) { | |
| 1603 let t = el2; | |
| 1604 el2 = el3; | |
| 1605 el3 = t; | |
| 1606 } | |
| 1607 if (dart.notNull(dart.dinvokef(compare, el1, el4)) > 0) { | |
| 1608 let t = el1; | |
| 1609 el1 = el4; | |
| 1610 el4 = t; | |
| 1611 } | |
| 1612 if (dart.notNull(dart.dinvokef(compare, el3, el4)) > 0) { | |
| 1613 let t = el3; | |
| 1614 el3 = el4; | |
| 1615 el4 = t; | |
| 1616 } | |
| 1617 if (dart.notNull(dart.dinvokef(compare, el2, el5)) > 0) { | |
| 1618 let t = el2; | |
| 1619 el2 = el5; | |
| 1620 el5 = t; | |
| 1621 } | |
| 1622 if (dart.notNull(dart.dinvokef(compare, el2, el3)) > 0) { | |
| 1623 let t = el2; | |
| 1624 el2 = el3; | |
| 1625 el3 = t; | |
| 1626 } | |
| 1627 if (dart.notNull(dart.dinvokef(compare, el4, el5)) > 0) { | |
| 1628 let t = el4; | |
| 1629 el4 = el5; | |
| 1630 el5 = t; | |
| 1631 } | |
| 1632 let pivot1 = el2; | |
| 1633 let pivot2 = el4; | |
| 1634 a.set(index1, el1); | |
| 1635 a.set(index3, el3); | |
| 1636 a.set(index5, el5); | |
| 1637 a.set(index2, a.get(left)); | |
| 1638 a.set(index4, a.get(right)); | |
| 1639 let less = dart.notNull(left) + 1; | |
| 1640 let great = dart.notNull(right) - 1; | |
| 1641 let pivots_are_equal = dart.dinvokef(compare, pivot1, pivot2) === 0; | |
| 1642 if (pivots_are_equal) { | |
| 1643 let pivot = pivot1; | |
| 1644 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN
ull(k) + 1) { | |
| 1645 let ak = a.get(k); | |
| 1646 let comp = dart.dinvokef(compare, ak, pivot); | |
| 1647 if (comp === 0) | |
| 1648 continue; | |
| 1649 if (dart.notNull(comp) < 0) { | |
| 1650 if (k !== less) { | |
| 1651 a.set(k, a.get(less)); | |
| 1652 a.set(less, ak); | |
| 1653 } | |
| 1654 less = dart.notNull(less) + 1; | |
| 1655 } else { | |
| 1656 while (true) { | |
| 1657 comp = dart.dinvokef(compare, a.get(great), pivot); | |
| 1658 if (dart.notNull(comp) > 0) { | |
| 1659 great = dart.notNull(great) - 1; | |
| 1660 continue; | |
| 1661 } else if (dart.notNull(comp) < 0) { | |
| 1662 a.set(k, a.get(less)); | |
| 1663 a.set((($tmp) => less = dart.notNull($tmp) + 1, $tmp)(less), a.g
et(great)); | |
| 1664 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great), a
k); | |
| 1665 break; | |
| 1666 } else { | |
| 1667 a.set(k, a.get(great)); | |
| 1668 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great), a
k); | |
| 1669 break; | |
| 1670 } | |
| 1671 } | |
| 1672 } | |
| 1673 } | |
| 1674 } else { | |
| 1675 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN
ull(k) + 1) { | |
| 1676 let ak = a.get(k); | |
| 1677 let comp_pivot1 = dart.dinvokef(compare, ak, pivot1); | |
| 1678 if (dart.notNull(comp_pivot1) < 0) { | |
| 1679 if (k !== less) { | |
| 1680 a.set(k, a.get(less)); | |
| 1681 a.set(less, ak); | |
| 1682 } | |
| 1683 less = dart.notNull(less) + 1; | |
| 1684 } else { | |
| 1685 let comp_pivot2 = dart.dinvokef(compare, ak, pivot2); | |
| 1686 if (dart.notNull(comp_pivot2) > 0) { | |
| 1687 while (true) { | |
| 1688 let comp = dart.dinvokef(compare, a.get(great), pivot2); | |
| 1689 if (dart.notNull(comp) > 0) { | |
| 1690 great = dart.notNull(great) - 1; | |
| 1691 if (dart.notNull(great) < dart.notNull(k)) | |
| 1692 break; | |
| 1693 continue; | |
| 1694 } else { | |
| 1695 comp = dart.dinvokef(compare, a.get(great), pivot1); | |
| 1696 if (dart.notNull(comp) < 0) { | |
| 1697 a.set(k, a.get(less)); | |
| 1698 a.set((($tmp) => less = dart.notNull($tmp) + 1, $tmp)(less),
a.get(great)); | |
| 1699 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great
), ak); | |
| 1700 } else { | |
| 1701 a.set(k, a.get(great)); | |
| 1702 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great
), ak); | |
| 1703 } | |
| 1704 break; | |
| 1705 } | |
| 1706 } | |
| 1707 } | |
| 1708 } | |
| 1709 } | |
| 1710 } | |
| 1711 a.set(left, a.get(dart.notNull(less) - 1)); | |
| 1712 a.set(dart.notNull(less) - 1, pivot1); | |
| 1713 a.set(right, a.get(dart.notNull(great) + 1)); | |
| 1714 a.set(dart.notNull(great) + 1, pivot2); | |
| 1715 _doSort(a, left, dart.notNull(less) - 2, compare); | |
| 1716 _doSort(a, dart.notNull(great) + 2, right, compare); | |
| 1717 if (pivots_are_equal) { | |
| 1718 return; | |
| 1719 } | |
| 1720 if (dart.notNull(less) < dart.notNull(index1) && dart.notNull(great) > dar
t.notNull(index5)) { | |
| 1721 while (dart.dinvokef(compare, a.get(less), pivot1) === 0) { | |
| 1722 less = dart.notNull(less) + 1; | |
| 1723 } | |
| 1724 while (dart.dinvokef(compare, a.get(great), pivot2) === 0) { | |
| 1725 great = dart.notNull(great) - 1; | |
| 1726 } | |
| 1727 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN
ull(k) + 1) { | |
| 1728 let ak = a.get(k); | |
| 1729 let comp_pivot1 = dart.dinvokef(compare, ak, pivot1); | |
| 1730 if (comp_pivot1 === 0) { | |
| 1731 if (k !== less) { | |
| 1732 a.set(k, a.get(less)); | |
| 1733 a.set(less, ak); | |
| 1734 } | |
| 1735 less = dart.notNull(less) + 1; | |
| 1736 } else { | |
| 1737 let comp_pivot2 = dart.dinvokef(compare, ak, pivot2); | |
| 1738 if (comp_pivot2 === 0) { | |
| 1739 while (true) { | |
| 1740 let comp = dart.dinvokef(compare, a.get(great), pivot2); | |
| 1741 if (comp === 0) { | |
| 1742 great = dart.notNull(great) - 1; | |
| 1743 if (dart.notNull(great) < dart.notNull(k)) | |
| 1744 break; | |
| 1745 continue; | |
| 1746 } else { | |
| 1747 comp = dart.dinvokef(compare, a.get(great), pivot1); | |
| 1748 if (dart.notNull(comp) < 0) { | |
| 1749 a.set(k, a.get(less)); | |
| 1750 a.set((($tmp) => less = dart.notNull($tmp) + 1, $tmp)(less),
a.get(great)); | |
| 1751 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great
), ak); | |
| 1752 } else { | |
| 1753 a.set(k, a.get(great)); | |
| 1754 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great
), ak); | |
| 1755 } | |
| 1756 break; | |
| 1757 } | |
| 1758 } | |
| 1759 } | |
| 1760 } | |
| 1761 } | |
| 1762 _doSort(a, less, great, compare); | |
| 1763 } else { | |
| 1764 _doSort(a, less, great, compare); | |
| 1765 } | |
| 1766 } | |
| 1767 } | |
| 1768 Sort._INSERTION_SORT_THRESHOLD = 32; | |
| 1769 let _name = Symbol('_name'); | |
| 1770 class Symbol extends core.Object { | |
| 1771 Symbol(name) { | |
| 1772 this[_name] = name; | |
| 1773 } | |
| 1774 Symbol$unvalidated($_name) { | |
| 1775 this[_name] = $_name; | |
| 1776 } | |
| 1777 Symbol$validated(name) { | |
| 1778 this[_name] = validatePublicSymbol(name); | |
| 1779 } | |
| 1780 ['=='](other) { | |
| 1781 return dart.notNull(dart.is(other, Symbol)) && dart.notNull(dart.equals(th
is[_name], dart.dload(other, '_name'))); | |
| 1782 } | |
| 1783 get hashCode() { | |
| 1784 let arbitraryPrime = 664597; | |
| 1785 return 536870911 & dart.notNull(arbitraryPrime) * dart.notNull(this[_name]
.hashCode); | |
| 1786 } | |
| 1787 toString() { | |
| 1788 return `Symbol("${this[_name]}")`; | |
| 1789 } | |
| 1790 static getName(symbol) { | |
| 1791 return symbol[_name]; | |
| 1792 } | |
| 1793 static validatePublicSymbol(name) { | |
| 1794 if (dart.notNull(name.isEmpty) || dart.notNull(publicSymbolPattern.hasMatc
h(name))) | |
| 1795 return name; | |
| 1796 if (name.startsWith('_')) { | |
| 1797 throw new core.ArgumentError(`"${name}" is a private identifier`); | |
| 1798 } | |
| 1799 throw new core.ArgumentError(`"${name}" is not a valid (qualified) symbol
name`); | |
| 1800 } | |
| 1801 static isValidSymbol(name) { | |
| 1802 return dart.notNull(name.isEmpty) || dart.notNull(symbolPattern.hasMatch(n
ame)); | |
| 1803 } | |
| 1804 } | |
| 1805 dart.defineNamedConstructor(Symbol, 'unvalidated'); | |
| 1806 dart.defineNamedConstructor(Symbol, 'validated'); | |
| 1807 Symbol.reservedWordRE = '(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|
d(?:efault|o)|' + 'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ul
l)|' + 'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|' + 'v(?:ar|o
id)|w(?:hile|ith))'; | |
| 1808 Symbol.publicIdentifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[
a-zA-Z$][\\w$]*'; | |
| 1809 Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z
$_][\\w$]*'; | |
| 1810 Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)'; | |
| 1811 dart.defineLazyProperties(Symbol, { | |
| 1812 get publicSymbolPattern() { | |
| 1813 return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifie
rRE}(?:=?$|[.](?!$)))+?$`); | |
| 1814 }, | |
| 1815 get symbolPattern() { | |
| 1816 return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(?
:=?$|[.](?!$)))+?$`); | |
| 1817 } | |
| 1818 }); | |
| 1819 let POWERS_OF_TEN = /* Unimplemented const */new List.from([1.0, 10.0, 100.0,
1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 100
00000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0
, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 100000000000000
0000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]); | |
| 1820 // Exports: | |
| 1821 exports.EfficientLength = EfficientLength; | |
| 1822 exports.ListIterable = ListIterable; | |
| 1823 exports.ListIterable$ = ListIterable$; | |
| 1824 exports.SubListIterable = SubListIterable; | |
| 1825 exports.SubListIterable$ = SubListIterable$; | |
| 1826 exports.ListIterator = ListIterator; | |
| 1827 exports.ListIterator$ = ListIterator$; | |
| 1828 exports.MappedIterable = MappedIterable; | |
| 1829 exports.MappedIterable$ = MappedIterable$; | |
| 1830 exports.EfficientLengthMappedIterable = EfficientLengthMappedIterable; | |
| 1831 exports.EfficientLengthMappedIterable$ = EfficientLengthMappedIterable$; | |
| 1832 exports.MappedIterator = MappedIterator; | |
| 1833 exports.MappedIterator$ = MappedIterator$; | |
| 1834 exports.MappedListIterable = MappedListIterable; | |
| 1835 exports.MappedListIterable$ = MappedListIterable$; | |
| 1836 exports.WhereIterable = WhereIterable; | |
| 1837 exports.WhereIterable$ = WhereIterable$; | |
| 1838 exports.WhereIterator = WhereIterator; | |
| 1839 exports.WhereIterator$ = WhereIterator$; | |
| 1840 exports.ExpandIterable = ExpandIterable; | |
| 1841 exports.ExpandIterable$ = ExpandIterable$; | |
| 1842 exports.ExpandIterator = ExpandIterator; | |
| 1843 exports.ExpandIterator$ = ExpandIterator$; | |
| 1844 exports.TakeIterable = TakeIterable; | |
| 1845 exports.TakeIterable$ = TakeIterable$; | |
| 1846 exports.EfficientLengthTakeIterable = EfficientLengthTakeIterable; | |
| 1847 exports.EfficientLengthTakeIterable$ = EfficientLengthTakeIterable$; | |
| 1848 exports.TakeIterator = TakeIterator; | |
| 1849 exports.TakeIterator$ = TakeIterator$; | |
| 1850 exports.TakeWhileIterable = TakeWhileIterable; | |
| 1851 exports.TakeWhileIterable$ = TakeWhileIterable$; | |
| 1852 exports.TakeWhileIterator = TakeWhileIterator; | |
| 1853 exports.TakeWhileIterator$ = TakeWhileIterator$; | |
| 1854 exports.SkipIterable = SkipIterable; | |
| 1855 exports.SkipIterable$ = SkipIterable$; | |
| 1856 exports.EfficientLengthSkipIterable = EfficientLengthSkipIterable; | |
| 1857 exports.EfficientLengthSkipIterable$ = EfficientLengthSkipIterable$; | |
| 1858 exports.SkipIterator = SkipIterator; | |
| 1859 exports.SkipIterator$ = SkipIterator$; | |
| 1860 exports.SkipWhileIterable = SkipWhileIterable; | |
| 1861 exports.SkipWhileIterable$ = SkipWhileIterable$; | |
| 1862 exports.SkipWhileIterator = SkipWhileIterator; | |
| 1863 exports.SkipWhileIterator$ = SkipWhileIterator$; | |
| 1864 exports.EmptyIterable = EmptyIterable; | |
| 1865 exports.EmptyIterable$ = EmptyIterable$; | |
| 1866 exports.EmptyIterator = EmptyIterator; | |
| 1867 exports.EmptyIterator$ = EmptyIterator$; | |
| 1868 exports.BidirectionalIterator = BidirectionalIterator; | |
| 1869 exports.BidirectionalIterator$ = BidirectionalIterator$; | |
| 1870 exports.IterableMixinWorkaround = IterableMixinWorkaround; | |
| 1871 exports.IterableMixinWorkaround$ = IterableMixinWorkaround$; | |
| 1872 exports.IterableElementError = IterableElementError; | |
| 1873 exports.FixedLengthListMixin = FixedLengthListMixin; | |
| 1874 exports.FixedLengthListMixin$ = FixedLengthListMixin$; | |
| 1875 exports.UnmodifiableListMixin = UnmodifiableListMixin; | |
| 1876 exports.UnmodifiableListMixin$ = UnmodifiableListMixin$; | |
| 1877 exports.FixedLengthListBase = FixedLengthListBase; | |
| 1878 exports.FixedLengthListBase$ = FixedLengthListBase$; | |
| 1879 exports.UnmodifiableListBase = UnmodifiableListBase; | |
| 1880 exports.UnmodifiableListBase$ = UnmodifiableListBase$; | |
| 1881 exports.ListMapView = ListMapView; | |
| 1882 exports.ListMapView$ = ListMapView$; | |
| 1883 exports.ReversedListIterable = ReversedListIterable; | |
| 1884 exports.ReversedListIterable$ = ReversedListIterable$; | |
| 1885 exports.UnmodifiableListError = UnmodifiableListError; | |
| 1886 exports.NonGrowableListError = NonGrowableListError; | |
| 1887 exports.makeListFixedLength = makeListFixedLength; | |
| 1888 exports.Lists = Lists; | |
| 1889 exports.printToConsole = printToConsole; | |
| 1890 exports.Sort = Sort; | |
| 1891 exports.Symbol = Symbol; | |
| 1892 exports.POWERS_OF_TEN = POWERS_OF_TEN; | |
| 1893 })(_internal || (_internal = {})); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1020043002:
Replace dart_core.js with actual compiled SDK (Closed)
Base URL: git@github.com:dart-lang/dev_compiler.git@master