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