library angular.core.facade.lang;

export 'dart:core' show Type, RegExp, print, DateTime;

import 'dart:math' as math;

import 'dart:convert' as convert;

import 'dart:async' show Future;

bool isDart = true;

String getTypeNameForDebugging(Type type) => type.toString();

class Math {

static final _random = new math.Random();

static int floor(num n) => n.floor();

static double random() => _random.nextDouble();

}

int ENUM_INDEX(value) => value.index;

class CONST {

const CONST();

}

class ABSTRACT {

const ABSTRACT();

}

class IMPLEMENTS {

final interfaceClass;

const IMPLEMENTS(this.interfaceClass);

}

bool isPresent(obj) => obj != null;

bool isBlank(obj) => obj == null;

bool isString(obj) => obj is String;

bool isFunction(obj) => obj is Function;

bool isType(obj) => obj is Type;

bool isStringMap(obj) => obj is Map;

bool isArray(obj) => obj is List;

bool isPromise(obj) => obj is Future;

bool isNumber(obj) => obj is num;

bool isDate(obj) => obj is DateTime;

String stringify(obj) => obj.toString();

int serializeEnum(val) {

return val.index;

}

dynamic deserializeEnum(int val, Map<int, dynamic> values) {

return values[val];

}

class StringWrapper {

static String fromCharCode(int code) {

return new String.fromCharCode(code);

}

static int charCodeAt(String s, int index) {

return s.codeUnitAt(index);

}

static List<String> split(String s, RegExp regExp) {

var parts = <String>[];

var lastEnd = 0;

regExp.allMatches(s).forEach((match) {

parts.add(s.substring(lastEnd, match.start));

lastEnd = match.end;

for (var i = 0; i < match.groupCount; i++) {

parts.add(match.group(i + 1));

}

});

parts.add(s.substring(lastEnd));

return parts;

}

static bool equals(String s, String s2) {

return s == s2;

}

static String replace(String s, Pattern from, String replace) {

return s.replaceFirst(from, replace);

}

static String replaceAll(String s, RegExp from, String replace) {

return s.replaceAll(from, replace);

}

static String toUpperCase(String s) {

return s.toUpperCase();

}

static String toLowerCase(String s) {

return s.toLowerCase();

}

static startsWith(String s, String start) {

return s.startsWith(start);

}

static String substring(String s, int start, [int end]) {

return s.substring(start, end);

}

static String replaceAllMapped(String s, RegExp from, Function cb) {

return s.replaceAllMapped(from, cb);

}

static bool contains(String s, String substr) {

return s.contains(substr);

}

static int compare(String a, String b) => a.compareTo(b);

}

class StringJoiner {

final List<String> _parts = <String>[];

void add(String part) {

_parts.add(part);

}

String toString() => _parts.join("");

}

class NumberWrapper {

static String toFixed(num n, int fractionDigits) {

return n.toStringAsFixed(fractionDigits);

}

static bool equal(num a, num b) {

return a == b;

}

static int parseIntAutoRadix(String text) {

return int.parse(text);

}

static int parseInt(String text, int radix) {

return int.parse(text, radix: radix);

}

static double parseFloat(String text) {

return double.parse(text);

}

static double get NaN => double.NAN;

static bool isNaN(num value) => value.isNaN;

static bool isInteger(value) => value is int;

}

class RegExpWrapper {

static RegExp create(regExpStr, [String flags = '']) {

bool multiLine = flags.contains('m');

bool caseSensitive = !flags.contains('i');

return new RegExp(regExpStr,

multiLine: multiLine, caseSensitive: caseSensitive);

}

static Match firstMatch(RegExp regExp, String input) {

return regExp.firstMatch(input);

}

static bool test(RegExp regExp, String input) {

return regExp.hasMatch(input);

}

static Iterator<Match> matcher(RegExp regExp, String input) {

return regExp.allMatches(input).iterator;

}

}

class RegExpMatcherWrapper {

static _JSLikeMatch next(Iterator<Match> matcher) {

if (matcher.moveNext()) {

return new _JSLikeMatch(matcher.current);

}

return null;

}

}

class _JSLikeMatch {

Match _m;

_JSLikeMatch(this._m);

String operator [](index) => _m[index];

int get index => _m.start;

int get length => _m.groupCount + 1;

}

class FunctionWrapper {

static apply(Function fn, posArgs) {

return Function.apply(fn, posArgs);

}

}

class BaseException extends Error {

final dynamic context;

final String message;

final originalException;

final originalStack;

BaseException(

[this.message, this.originalException, this.originalStack, this.context]);

String toString() {

return this.message;

}

}

Error makeTypeError([String message = ""]) {

return new BaseException(message);

}

const _NAN_KEY = const Object();

bool looseIdentical(a, b) =>

a is String && b is String ? a == b : identical(a, b);

dynamic getMapKey(value) {

if (value is! num) return value;

return value.isNaN ? _NAN_KEY : value;

}

dynamic normalizeBlank(obj) => obj;

bool normalizeBool(bool obj) {

return isBlank(obj) ? false : obj;

}

bool isJsObject(o) {

return false;

}

var _assertionsEnabled = null;

bool assertionsEnabled() {

if (_assertionsEnabled == null) {

try {

assert(false);

_assertionsEnabled = false;

} catch (e) {

_assertionsEnabled = true;

}

}

return _assertionsEnabled;

}

class Json {

static parse(String s) => convert.JSON.decode(s);

static String stringify(data) {

var encoder = new convert.JsonEncoder.withIndent(" ");

return encoder.convert(data);

}

}

class DateWrapper {

static DateTime create(int year, [int month = 1, int day = 1, int hour = 0,

int minutes = 0, int seconds = 0, int milliseconds = 0]) {

return new DateTime(year, month, day, hour, minutes, seconds, milliseconds);

}

static DateTime fromMillis(int ms) {

return new DateTime.fromMillisecondsSinceEpoch(ms, isUtc: true);

}

static int toMillis(DateTime date) {

return date.millisecondsSinceEpoch;

}

static DateTime now() {

return new DateTime.now();

}

static String toJson(DateTime date) {

return date.toUtc().toIso8601String();

}

}

var global = null;