Lines Matching refs:self
577 self = new ($bind.apply(superclass.$$constructor, [null].concat(args)))();
580 $set_proto(self, klass.$$prototype);
581 return self;
3059 var self = $module($base, 'Opal');
3063 $defs(self, '$bridge', function $$bridge(constructor, klass) {
3067 $defs(self, '$coerce_to!', function $Opal_coerce_to$excl$1(object, type, method, $a) {
3079 $defs(self, '$coerce_to?', function $Opal_coerce_to$ques$2(object, type, method, $a) {
3097 $defs(self, '$try_convert', function $$try_convert(object, type, method) {
3109 $defs(self, '$compare', function $$compare(a, b) {
3119 $defs(self, '$destructure', function $$destructure(args) {
3136 $defs(self, '$respond_to?', function $Opal_respond_to$ques$3(obj, method, include_all) {
3147 $defs(self, '$instance_variable_name!', function $Opal_instance_variable_name$excl$4(name) {
3156 $defs(self, '$class_variable_name!', function $Opal_class_variable_name$excl$5(name) {
3165 $defs(self, '$const_name?', function $Opal_const_name$ques$6(const_name) {
3175 $defs(self, '$const_name!', function $Opal_const_name$excl$7(const_name) {
3176 var $a, self = this;
3184 self.$raise($$$('NameError'), "wrong constant name " + (const_name))
3189 $defs(self, '$pristine', function $$pristine(owner_class, $a) {
3209 return $defs(self, '$inspect', function $$inspect(value) {
3269 var self = $klass($base, $super, 'Module');
3271 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
3274 $defs(self, '$allocate', function $$allocate() {
3275 var self = this;
3280 if (self !== Opal.Module) Object.setPrototypeOf(module, self.$$prototype);
3285 $def(self, '$initialize', function $$initialize() {
3286 var block = $$initialize.$$p || nil, self = this;
3292 return $send(self, 'module_eval', [], block.$to_proc())
3298 $def(self, '$===', function $Module_$eq_eq_eq$1(object) {
3299 var self = this;
3305 return Opal.is_a(object, self);;
3308 $def(self, '$<', function $Module_$lt$2(other) {
3309 var self = this;
3316 var working = self,
3324 for (i = 0, ancestors = Opal.ancestors(self), length = ancestors.length; i < length; i++) {
3331 if (ancestors[i] === self) {
3340 $def(self, '$<=', function $Module_$lt_eq$3(other) {
3341 var self = this, $ret_or_1 = nil;
3343 if ($truthy(($ret_or_1 = self['$equal?'](other)))) {
3346 return $rb_lt(self, other)
3350 $def(self, '$>', function $Module_$gt$4(other) {
3351 var self = this;
3357 return $rb_lt(other, self);
3360 $def(self, '$>=', function $Module_$gt_eq$5(other) {
3361 var self = this, $ret_or_1 = nil;
3363 if ($truthy(($ret_or_1 = self['$equal?'](other)))) {
3366 return $rb_gt(self, other)
3370 $def(self, '$<=>', function $Module_$lt_eq_gt$6(other) {
3371 var self = this, lt = nil;
3375 if (self === other) {
3382 lt = $rb_lt(self, other);
3393 $def(self, '$alias_method', function $$alias_method(newname, oldname) {
3394 var self = this;
3397 $deny_frozen_access(self);
3400 Opal.alias(self, newname, oldname);
3401 return self;
3404 $def(self, '$alias_native', function $$alias_native(mid, jsid) {
3405 var self = this;
3409 $deny_frozen_access(self);
3410 Opal.alias_native(self, mid, jsid);
3411 return self;
3414 $def(self, '$ancestors', function $$ancestors() {
3415 var self = this;
3417 return Opal.ancestors(self);
3420 $def(self, '$append_features', function $$append_features(includer) {
3421 var self = this;
3425 Opal.append_features(self, includer);
3426 return self;
3429 $def(self, '$attr_accessor', function $$attr_accessor($a) {
3430 var $post_args, names, self = this;
3435 $send(self, 'attr_reader', $to_a(names));
3436 return $send(self, 'attr_writer', $to_a(names));
3439 $def(self, '$attr', function $$attr($a) {
3440 var $post_args, args, self = this;
3447 self.$warn("optional boolean argument is obsoleted", $hash2(["uplevel"], {"uplevel": 1}))
3449 args[1] ? self.$attr_accessor(args[0]) : self.$attr_reader(args[0]);
3453 return $send(self, 'attr_reader', $to_a(args));
3456 $def(self, '$attr_reader', function $$attr_reader($a) {
3457 var $post_args, names, self = this;
3463 $deny_frozen_access(self);
3465 var proto = self.$$prototype;
3480 Opal.defn(self, id, body);
3486 $def(self, '$attr_writer', function $$attr_writer($a) {
3487 var $post_args, names, self = this;
3493 $deny_frozen_access(self);
3495 var proto = self.$$prototype;
3510 Opal.defn(self, id, body);
3516 $def(self, '$autoload', function $$autoload(const$, path) {
3517 var self = this;
3520 $deny_frozen_access(self);
3530 if (!self.$$const.hasOwnProperty(const$)) {
3531 if (!self.$$autoload) {
3532 self.$$autoload = {};
3535 …self.$$autoload[const$] = { path: path, loaded: false, required: false, success: false, exception:…
3537 if (self.$const_added && !self.$const_added.$$pristine) {
3538 self.$const_added(const$);
3545 $def(self, '$autoload?', function $Module_autoload$ques$7(const$) {
3546 var self = this;
3549 …if (self.$$autoload && self.$$autoload[const$] && !self.$$autoload[const$].required && !self.$$aut…
3550 return self.$$autoload[const$].path;
3553 var ancestors = self.$ancestors();
3564 $def(self, '$class_variables', function $$class_variables() {
3565 var self = this;
3567 return Object.keys(Opal.class_variables(self));
3570 $def(self, '$class_variable_get', function $$class_variable_get(name) {
3571 var self = this;
3575 return Opal.class_variable_get(self, name, false);;
3578 $def(self, '$class_variable_set', function $$class_variable_set(name, value) {
3579 var self = this;
3582 $deny_frozen_access(self);
3584 return Opal.class_variable_set(self, name, value);;
3587 $def(self, '$class_variable_defined?', function $Module_class_variable_defined$ques$8(name) {
3588 var self = this;
3592 return Opal.class_variables(self).hasOwnProperty(name);;
3595 $def(self, '$const_added', $return_val(nil));
3596 $Opal.$pristine(self, "const_added");
3598 $def(self, '$remove_class_variable', function $$remove_class_variable(name) {
3599 var self = this;
3602 $deny_frozen_access(self);
3605 if (Opal.hasOwnProperty.call(self.$$cvars, name)) {
3606 var value = self.$$cvars[name];
3607 delete self.$$cvars[name];
3610 $Kernel.$raise($$$('NameError'), "cannot remove " + (name) + " for " + (self))
3615 $def(self, '$constants', function $$constants(inherit) {
3616 var self = this;
3620 return Opal.constants(self, inherit);;
3622 $defs(self, '$constants', function $$constants(inherit) {
3623 var self = this;
3629 var nesting = (self.$$nesting || []).concat($Object),
3640 return Opal.constants(self, inherit)
3644 $defs(self, '$nesting', function $$nesting() {
3645 var self = this;
3647 return self.$$nesting || [];
3650 $def(self, '$const_defined?', function $Module_const_defined$ques$9(name, inherit) {
3651 var self = this;
3660 var module, modules = [self], module_constants, i, ii;
3664 modules = modules.concat(Opal.ancestors(self));
3667 if (self.$$is_module) {
3689 $def(self, '$const_get', function $$const_get(name, inherit) {
3690 var self = this;
3701 return $send(name.$split("::"), 'inject', [self], function $$10(o, c){
3712 return Opal.$$([self], name);
3714 return Opal.const_get_local(self, name);
3719 $def(self, '$const_missing', function $$const_missing(name) {
3720 var self = this, full_const_name = nil;
3723 full_const_name = ($eqeq(self, $Object) ? (name) : ("" + (self) + "::" + (name)));
3727 $def(self, '$const_set', function $$const_set(name, value) {
3728 var self = this;
3731 $deny_frozen_access(self);
3736 $const_set(self, name, value);
3740 $def(self, '$public_constant', $return_val(nil));
3742 $def(self, '$define_method', function $$define_method(name, method) {
3743 var block = $$define_method.$$p || nil, self = this, $ret_or_1 = nil, $ret_or_2 = nil;
3750 $deny_frozen_access(self);
3755 …ndMethod'), $ret_or_2) ? ($lambda(function $$11($a){var $post_args, args, self = $$11.$$s == null …
3760 bound = method.$bind(self);
3761 …return $send(bound, 'call', $to_a(args));}, {$$arity: -1, $$s: self})) : ($Kernel.$raise($$$('Type…
3768 apply: function(target, self, args) { argument
3772 return target.apply(self, args);
3788 return Opal.defn(self, $jsid(name), block);
3792 $def(self, '$freeze', function $$freeze() {
3793 var self = this;
3796 if ($truthy(self['$frozen?']())) {
3797 return self
3800 if (!self.hasOwnProperty('$$base_module')) { $prop(self, '$$base_module', null); }
3802 return $freeze(self);
3806 $def(self, '$remove_method', function $$remove_method($a) {
3807 var $post_args, names, self = this;
3816 self.$raise($$$('TypeError'), "" + (self.$name()) + " is not a symbol nor a string")
3818 $deny_frozen_access(self);
3820 Opal.rdef(self, "$" + name);
3823 return self;
3826 $def(self, '$singleton_class?', function $Module_singleton_class$ques$12() {
3827 var self = this;
3829 return !!self.$$is_singleton;
3832 $def(self, '$include', function $$include($a) {
3833 var $post_args, mods, self = this;
3846 (mod).$append_features(self);
3847 (mod).$included(self);
3850 return self;
3853 $def(self, '$included_modules', function $$included_modules() {
3854 var self = this;
3856 return Opal.included_modules(self);
3859 $def(self, '$include?', function $Module_include$ques$13(mod) {
3860 var self = this;
3867 var i, ii, mod2, ancestors = Opal.ancestors(self);
3871 if (mod2 === mod && mod2 !== self) {
3880 $def(self, '$instance_method', function $$instance_method(name) {
3881 var self = this;
3884 var meth = self.$$prototype[$jsid(name)];
3887 …($$$('NameError').$new("undefined method `" + (name) + "' for class `" + (self.$name()) + "'", nam…
3890 return $$$('UnboundMethod').$new(self, meth.$$owner || self, meth, name);
3894 $def(self, '$instance_methods', function $$instance_methods(include_super) {
3895 var self = this;
3901 return Opal.instance_methods(self);
3903 return Opal.own_instance_methods(self);
3908 $def(self, '$included', $return_val(nil));
3910 $def(self, '$extended', $return_val(nil));
3912 $def(self, '$extend_object', function $$extend_object(object) {
3919 $def(self, '$method_added', function $$method_added($a) {
3928 $def(self, '$method_removed', function $$method_removed($a) {
3937 $def(self, '$method_undefined', function $$method_undefined($a) {
3946 $def(self, '$module_eval', function $$module_eval($a) {
3947 …var block = $$module_eval.$$p || nil, $post_args, args, $b, self = this, string = nil, file = nil,…
3963 … block = $send($Kernel, 'proc', [], function $$14(){var self = $$14.$$s == null ? this : $$14.$$s;
3965 return new Function("Opal,self", "return " + compiled)(Opal, self);}, {$$s: self});
3974 result = block.apply(self, [self]);
3981 $def(self, '$module_exec', function $$module_exec($a) {
3982 var block = $$module_exec.$$p || nil, $post_args, args, self = this;
3997 result = block.apply(self, args);
4004 $def(self, '$method_defined?', function $Module_method_defined$ques$15(method) {
4005 var self = this;
4008 var body = self.$$prototype[$jsid(method)];
4013 $def(self, '$module_function', function $$module_function($a) {
4014 var $post_args, methods, self = this;
4020 $deny_frozen_access(self);
4023 self.$$module_function = true;
4030 func = self.$$prototype[id];
4032 Opal.defs(self, id, func);
4037 return self;
4041 $def(self, '$name', function $$name() {
4042 var self = this;
4045 if (self.$$full_name) {
4046 return self.$$full_name;
4049 var result = [], base = self;
4068 return self.$$full_name = result.join('::');
4072 $def(self, '$prepend', function $$prepend($a) {
4073 var $post_args, mods, self = this;
4090 (mod).$prepend_features(self);
4091 (mod).$prepended(self);
4094 return self;
4097 $def(self, '$prepend_features', function $$prepend_features(prepender) {
4098 var self = this;
4104 if (!self.$$is_module) {
4105 … $Kernel.$raise($$$('TypeError'), "wrong argument type " + (self.$class()) + " (expected Module)");
4108 Opal.prepend_features(self, prepender)
4110 return self;
4113 $def(self, '$prepended', $return_val(nil));
4115 $def(self, '$remove_const', function $$remove_const(name) {
4116 var self = this;
4119 $deny_frozen_access(self);
4120 return Opal.const_remove(self, name);;
4123 $def(self, '$to_s', function $$to_s() {
4124 var self = this, $ret_or_1 = nil;
4126 if ($truthy(($ret_or_1 = Opal.Module.$name.call(self)))) {
4129 … return "#<" + (self.$$is_module ? 'Module' : 'Class') + ":0x" + (self.$__id__().$to_s(16)) + ">"
4133 $def(self, '$undef_method', function $$undef_method($a) {
4134 var $post_args, names, self = this;
4143 self.$raise($$$('TypeError'), "" + (self.$name()) + " is not a symbol nor a string")
4145 $deny_frozen_access(self);
4147 Opal.udef(self, "$" + names[i]);
4150 return self;
4153 $def(self, '$instance_variables', function $$instance_variables() {
4154 var self = this, consts = nil;
4157 consts = (Opal.Module.$$nesting = $nesting, self.$constants());
4161 for (var name in self) {
4162 …if (self.hasOwnProperty(name) && name.charAt(0) !== '$' && name !== 'constructor' && !consts['$inc…
4171 $def(self, '$dup', function $$dup() {
4172 var $yield = $$dup.$$p || nil, self = this, copy = nil;
4176 copy = $send2(self, $find_super(self, 'dup', $$dup, false, true), 'dup', [], $yield);
4177 copy.$copy_class_variables(self);
4178 copy.$copy_constants(self);
4182 $def(self, '$copy_class_variables', function $$copy_class_variables(other) {
4183 var self = this;
4187 self.$$cvars[name] = other.$$cvars[name];
4192 $def(self, '$copy_constants', function $$copy_constants(other) {
4193 var self = this;
4199 $const_set(self, name, other_constants[name]);
4204 $def(self, '$refine', function $$refine(klass) {
4205 …var block = $$refine.$$p || nil, $a, self = this, refinement_module = nil, m = nil, klass_id = nil;
4210 $a = [self, nil, nil], (refinement_module = $a[0]), (m = $a[1]), (klass_id = $a[2]), $a;
4213 if (typeof self.$$refine_modules === "undefined") {
4214 self.$$refine_modules = Object.create(null); field
4216 if (typeof self.$$refine_modules[klass_id] === "undefined") {
4217 m = self.$$refine_modules[klass_id] = $$$('Refinement').$new();
4220 m = self.$$refine_modules[klass_id];
4229 $def(self, '$refinements', function $$refinements() {
4230 var self = this;
4233 var refine_modules = self.$$refine_modules, hash = $hash2([], {});;
4242 $def(self, '$using', function $$using(mod) {
4246 $alias(self, "class_eval", "module_eval");
4247 $alias(self, "class_exec", "module_exec");
4248 return $alias(self, "inspect", "to_s");
4251 var self = $klass($base, $super, 'Refinement');
4253 var $proto = self.$$prototype;
4257 self.$attr_reader("refined_class");
4258 return $def(self, '$inspect', function $$inspect() {
4259 var $yield = $$inspect.$$p || nil, self = this;
4262 if ($truthy(self.refinement_module)) {
4263 …return "#<refinement:" + (self.refined_class.$inspect()) + "@" + (self.refinement_module.$inspect(…
4265 … return $send2(self, $find_super(self, 'inspect', $$inspect, false, true), 'inspect', [], $yield)
4272 …find_super = Opal.find_super, $Kernel = Opal.Kernel, $alias = Opal.alias, self = Opal.top, $nestin…
4276 self.$require("corelib/module");
4278 var self = $klass($base, $super, 'Class');
4280 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
4283 $defs(self, '$new', function $Class_new$1(superclass) {
4302 $def(self, '$allocate', function $$allocate() {
4303 var self = this;
4306 var obj = new self.$$constructor();
4312 $def(self, '$descendants', function $$descendants() {
4313 var self = this;
4315 …return $rb_plus(self.$subclasses(), $send(self.$subclasses(), 'map', [], "descendants".$to_proc())…
4318 $def(self, '$inherited', $return_val(nil));
4320 $def(self, '$initialize_dup', function $$initialize_dup(original) {
4321 var self = this;
4324 self.$initialize_copy(original);
4326 self.$$name = null;
4327 self.$$full_name = null;
4331 $def(self, '$new', function $Class_new$2($a) {
4332 var block = $Class_new$2.$$p || nil, $post_args, args, self = this;
4340 var object = self.$allocate();
4346 $def(self, '$subclasses', function $$subclasses() {
4347 var self = this;
4352 for (i = 0; i < self.$$subclasses.length; i++) {
4353 subclass = self.$$subclasses[i].deref();
4361 return self.$$subclasses;
4366 $def(self, '$superclass', function $$superclass() {
4367 var self = this;
4369 return self.$$super || nil;
4372 $def(self, '$to_s', function $$to_s() {
4373 var $yield = $$to_s.$$p || nil, self = this;
4377 var singleton_of = self.$$singleton_of;
4387 return $send2(self, $find_super(self, 'to_s', $$to_s, false, true), 'to_s', [], null);
4391 $def(self, '$attached_object', function $$attached_object() {
4392 var self = this;
4395 if (self.$$singleton_of != null) {
4396 return self.$$singleton_of;
4399 $Kernel.$raise($$$('TypeError'), "`" + (self) + "' is not a singleton class")
4403 return $alias(self, "inspect", "to_s");
4413 var self = $klass($base, $super, 'BasicObject');
4418 $def(self, '$initialize', function $$initialize($a) {
4427 $def(self, '$==', function $BasicObject_$eq_eq$1(other) {
4428 var self = this;
4430 return self === other;
4433 $def(self, '$eql?', function $BasicObject_eql$ques$2(other) {
4434 var self = this;
4436 return self['$=='](other)
4438 $alias(self, "equal?", "==");
4440 $def(self, '$__id__', function $$__id__() {
4441 var self = this;
4444 if (self.$$id != null) {
4445 return self.$$id;
4447 Opal.prop(self, '$$id', Opal.uid());
4448 return self.$$id;
4452 $def(self, '$__send__', function $$__send__(symbol, $a) {
4453 var block = $$__send__.$$p || nil, $post_args, args, self = this;
4462 self.$raise($$$('TypeError'), "" + (self.$inspect()) + " is not a symbol nor a string")
4465 var func = self[Opal.jsid(symbol)];
4472 return func.apply(self, args);
4476 self.$method_missing.$$p = block;
4479 return self.$method_missing.apply(self, [symbol].concat(args));
4483 $def(self, '$!', $return_val(false));
4486 $def(self, '$!=', function $BasicObject_$not_eq$3(other) {
4487 var self = this;
4489 return self['$=='](other)['$!']()
4492 $def(self, '$instance_eval', function $$instance_eval($a) {
4493 …var block = $$instance_eval.$$p || nil, $post_args, args, $b, self = this, string = nil, file = ni…
4509 … block = $send($Kernel, 'proc', [], function $$4(){var self = $$4.$$s == null ? this : $$4.$$s;
4511 return new Function("Opal,self", "return " + compiled)(Opal, self);}, {$$s: self});
4513 return self.$instance_variable_get(args.$first())
4526 if (self.$$is_a_module) {
4527 self.$$eval = true; field
4529 result = block.call(self, self);
4532 self.$$eval = false; field
4536 result = block.call(self, self);
4545 $def(self, '$instance_exec', function $$instance_exec($a) {
4546 var block = $$instance_exec.$$p || nil, $post_args, args, self = this;
4562 if (self.$$is_a_module) {
4563 self.$$eval = true; field
4565 result = block.apply(self, args);
4568 self.$$eval = false; field
4572 result = block.apply(self, args);
4581 $def(self, '$singleton_method_added', function $$singleton_method_added($a) {
4590 $def(self, '$singleton_method_removed', function $$singleton_method_removed($a) {
4599 $def(self, '$singleton_method_undefined', function $$singleton_method_undefined($a) {
4608 $def(self, '$method_missing', function $$method_missing(symbol, $a) {
4609 var block = $$method_missing.$$p || nil, $post_args, args, self = this, inspect_result = nil;
4616 inspect_result = $Opal.$inspect(self);
4619 $Opal.$pristine(self, "method_missing");
4620 …return $def(self, '$respond_to_missing?', function $BasicObject_respond_to_missing$ques$5(method_n…
4636 var self = $module($base, 'Kernel');
4638 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
4642 $def(self, '$=~', $return_val(false));
4644 $def(self, '$!~', function $Kernel_$excl_tilde$1(obj) {
4645 var self = this;
4647 return self['$=~'](obj)['$!']()
4650 $def(self, '$===', function $Kernel_$eq_eq_eq$2(other) {
4651 var self = this, $ret_or_1 = nil;
4653 if ($truthy(($ret_or_1 = self.$object_id()['$=='](other.$object_id())))) {
4656 return self['$=='](other)
4660 $def(self, '$<=>', function $Kernel_$lt_eq_gt$3(other) {
4661 var self = this;
4665 self.$$comparable = true;
4667 var x = self['$=='](other);
4677 $def(self, '$method', function $$method(name) {
4678 var self = this;
4681 var meth = self[$jsid(name)];
4684 …($$$('NameError').$new("undefined method `" + (name) + "' for class `" + (self.$class()) + "'", na…
4687 return $$$('Method').$new(self, meth.$$owner || self.$class(), meth, name);
4691 $def(self, '$methods', function $$methods(all) {
4692 var self = this;
4698 return Opal.methods(self);
4700 return Opal.own_methods(self);
4705 $def(self, '$public_methods', function $$public_methods(all) {
4706 var self = this;
4712 return Opal.methods(self);
4714 return Opal.receiver_methods(self);
4719 $def(self, '$Array', function $$Array(object) {
4742 $def(self, '$at_exit', function $$at_exit() {
4754 $def(self, '$caller', function $$caller(start, length) {
4775 $def(self, '$caller_locations', function $$caller_locations($a) {
4776 var $post_args, args, self = this;
4781 return $send($send(self, 'caller', $to_a(args)), 'map', [], function $$4(loc){
4787 $def(self, '$class', function $Kernel_class$5() {
4788 var self = this;
4790 return self.$$class;
4793 $def(self, '$copy_instance_variables', function $$copy_instance_variables(other) {
4794 var self = this;
4801 self[name] = other[name]; field
4807 $def(self, '$copy_singleton_methods', function $$copy_singleton_methods(other) {
4808 var self = this;
4815 var self_singleton_class = Opal.get_singleton_class(self);
4835 self[name] = other[name];
4841 $def(self, '$clone', function $$clone($kwargs) {
4842 var freeze, self = this, copy = nil;
4849 self.$raise($$('ArgumentError'), "unexpected value for freeze: " + (freeze.$class()))
4851 copy = self.$class().$allocate();
4852 copy.$copy_instance_variables(self);
4853 copy.$copy_singleton_methods(self);
4854 copy.$initialize_clone(self, $hash2(["freeze"], {"freeze": freeze}));
4855 … if (($eqeq(freeze, true) || (($truthy(freeze['$nil?']()) && ($truthy(self['$frozen?']())))))) {
4861 $def(self, '$initialize_clone', function $$initialize_clone(other, $kwargs) {
4862 var freeze, self = this;
4868 self.$initialize_copy(other);
4869 return self;
4872 $def(self, '$define_singleton_method', function $$define_singleton_method(name, method) {
4873 var block = $$define_singleton_method.$$p || nil, self = this;
4879 return $send(self.$singleton_class(), 'define_method', [name, method], block.$to_proc());
4882 $def(self, '$dup', function $$dup() {
4883 var self = this, copy = nil;
4886 copy = self.$class().$allocate();
4887 copy.$copy_instance_variables(self);
4888 copy.$initialize_dup(self);
4892 $def(self, '$initialize_dup', function $$initialize_dup(other) {
4893 var self = this;
4895 return self.$initialize_copy(other)
4898 $def(self, '$enum_for', function $$enum_for($a, $b) {
4899 var block = $$enum_for.$$p || nil, $post_args, method, args, self = this;
4908 return $send($$$('Enumerator'), 'for', [self, method].concat($to_a(args)), block.$to_proc());
4911 $def(self, '$equal?', function $Kernel_equal$ques$6(other) {
4912 var self = this;
4914 return self === other;
4917 $def(self, '$exit', function $$exit(status) {
4941 $def(self, '$extend', function $$extend($a) {
4942 var $post_args, mods, self = this;
4949 self.$raise($$$('ArgumentError'), "wrong number of arguments (given 0, expected 1+)")
4952 $deny_frozen_access(self);
4954 var singleton = self.$singleton_class();
4964 (mod).$extend_object(self);
4965 (mod).$extended(self);
4968 return self;
4971 $def(self, '$freeze', function $$freeze() {
4972 var self = this;
4975 if ($truthy(self['$frozen?']())) {
4976 return self
4979 if (typeof(self) === "object") {
4980 $freeze_props(self);
4981 return $freeze(self);
4983 return self;
4987 $def(self, '$frozen?', function $Kernel_frozen$ques$7() {
4988 var self = this;
4991 switch (typeof(self)) {
4998 return (self.$$frozen || false);
5005 $def(self, '$gets', function $$gets($a) {
5015 $def(self, '$hash', function $$hash() {
5016 var self = this;
5018 return self.$__id__()
5021 $def(self, '$initialize_copy', $return_val(nil));
5024 $def(self, '$inspect', function $$inspect() {
5025 var self = this, ivs = nil, id = nil, pushed = nil, e = nil;
5031 id = self.$__id__();
5038 …$send(self.$instance_variables(), 'each', [], function $$8(i){var self = $$8.$$s == null ? this : …
5042 ivar = self.$instance_variable_get(i);
5044 return (ivs = $rb_plus(ivs, " " + (i) + "=" + (inspect)));}, {$$s: self});
5046 return "#<" + (self.$class()) + ":0x" + (id.$to_s(16)) + (ivs) + ">";
5050 return "#<" + (self.$class()) + ":0x" + (id.$to_s(16)) + ">"
5059 $def(self, '$instance_of?', function $Kernel_instance_of$ques$9(klass) {
5060 var self = this;
5067 return self.$$class === klass;
5071 …$def(self, '$instance_variable_defined?', function $Kernel_instance_variable_defined$ques$10(name)…
5072 var self = this;
5076 return Opal.hasOwnProperty.call(self, name.substr(1));;
5079 $def(self, '$instance_variable_get', function $$instance_variable_get(name) {
5080 var self = this;
5085 var ivar = self[Opal.ivar(name.substr(1))];
5091 $def(self, '$instance_variable_set', function $$instance_variable_set(name, value) {
5092 var self = this;
5095 $deny_frozen_access(self);
5097 return self[Opal.ivar(name.substr(1))] = value;;
5100 $def(self, '$remove_instance_variable', function $$remove_instance_variable(name) {
5101 var self = this;
5108 if (self.hasOwnProperty(key)) {
5109 val = self[key];
5110 delete self[key];
5117 $def(self, '$instance_variables', function $$instance_variables() {
5118 var self = this;
5123 for (var name in self) {
5124 if (self.hasOwnProperty(name) && name.charAt(0) !== '$') {
5138 $def(self, '$Integer', function $$Integer(value, base) {
5233 $def(self, '$Float', function $$Float(value) {
5263 $def(self, '$Hash', function $$Hash(arg) {
5275 $def(self, '$is_a?', function $Kernel_is_a$ques$11(klass) {
5276 var self = this;
5283 return Opal.is_a(self, klass);
5287 $def(self, '$itself', $return_self);
5289 $def(self, '$lambda', function $$lambda() {
5298 $def(self, '$load', function $$load(file) {
5305 $def(self, '$loop', function $$loop() {
5306 var $yield = $$loop.$$p || nil, self = this, e = nil;
5311 return $send(self, 'enum_for', ["loop"], function $$12(){
5326 return self;
5329 $def(self, '$nil?', $return_val(false));
5331 $def(self, '$printf', function $$printf($a) {
5332 var $post_args, args, self = this;
5338 self.$print($send(self, 'format', $to_a(args)))
5343 $def(self, '$proc', function $$proc() {
5356 $def(self, '$puts', function $$puts($a) {
5366 $def(self, '$p', function $$p($a) {
5384 $def(self, '$print', function $$print($a) {
5394 $def(self, '$readline', function $$readline($a) {
5404 $def(self, '$warn', function $$warn($a, $b) {
5405 var $post_args, $kwargs, strs, uplevel, $c, $d, self = this, location = nil;
5422 …location = ($c = ($d = self.$caller($rb_plus(uplevel, 1), 1).$first(), ($d === nil || $d == null) …
5438 $def(self, '$raise', function $$raise(exception, string, backtrace) {
5482 $def(self, '$rand', function $$rand(max) {
5508 $def(self, '$respond_to?', function $Kernel_respond_to$ques$15(name, include_all) {
5509 var self = this;
5514 var body = self[$jsid(name)];
5520 if (self['$respond_to_missing?'].$$pristine === true) {
5523 return self['$respond_to_missing?'](name, include_all);
5528 …$def(self, '$respond_to_missing?', function $Kernel_respond_to_missing$ques$16(method_name, includ…
5534 $Opal.$pristine(self, "respond_to?", "respond_to_missing?");
5536 $def(self, '$require', function $$require(file) {
5548 $def(self, '$require_relative', function $$require_relative(file) {
5556 $def(self, '$require_tree', function $$require_tree(path, $kwargs) {
5583 $def(self, '$singleton_class', function $$singleton_class() {
5584 var self = this;
5586 return Opal.get_singleton_class(self);
5589 $def(self, '$sleep', function $$sleep(seconds) {
5613 $def(self, '$srand', function $$srand(seed) {
5620 $def(self, '$String', function $$String(str) {
5630 $def(self, '$tap', function $$tap() {
5631 var block = $$tap.$$p || nil, self = this;
5636 Opal.yield1(block, self);
5637 return self;
5640 $def(self, '$to_proc', $return_self);
5642 $def(self, '$to_s', function $$to_s() {
5643 var self = this;
5645 return "#<" + (self.$class()) + ":0x" + (self.$__id__().$to_s(16)) + ">"
5648 $def(self, '$catch', function $Kernel_catch$17(tag) {
5671 $def(self, '$throw', function $Kernel_throw$18(tag, obj) {
5678 $def(self, '$open', function $$open($a) {
5689 $def(self, '$yield_self', function $$yield_self() {
5690 var $yield = $$yield_self.$$p || nil, self = this;
5695 return $send(self, 'enum_for', ["yield_self"], $return_val(1))
5697 return Opal.yield1($yield, self);;
5699 $alias(self, "fail", "raise");
5700 $alias(self, "kind_of?", "is_a?");
5701 $alias(self, "object_id", "__id__");
5702 $alias(self, "public_send", "__send__");
5703 $alias(self, "send", "__send__");
5704 $alias(self, "then", "yield_self");
5705 return $alias(self, "to_enum", "enum_for");
5708 var self = $klass($base, $super, 'Object');
5713 return self.$include($Kernel);
5718 …l.def, $Object = Opal.Object, $slice = Opal.slice, $Kernel = Opal.Kernel, self = Opal.top, $nestin…
5721 return (function(self, $parent_nesting) { argument
5725 $def(self, '$to_s', $return_val("main"));
5727 $def(self, '$include', function $$include(mod) {
5732 $def(self, '$autoload', function $$autoload($a) {
5740 return $def(self, '$using', function $$using(mod) {
5744 })(Opal.get_singleton_class(self), $nesting)
5753 var self = $module($base, 'Errno');
5755 var $nesting = [self].concat($parent_nesting), errors = nil, klass = nil;
5768 klass = Opal.klass(self, Opal.SystemCallError, class_name);
5771 (function(self, $parent_nesting) { argument
5773 return $def(self, '$new', function $new$1(name) {
5774 var $yield = $new$1.$$p || nil, self = this, message = nil;
5783 return $send2(self, $find_super(self, 'new', $new$1, false, true), 'new', [message], null);
5791 var self = $klass($base, $super, 'SystemCallError');
5793 var $nesting = [self].concat($parent_nesting);
5797 $def(self, '$errno', function $$errno() {
5798 var self = this;
5800 return self.$class().$errno()
5802 return (function(self, $parent_nesting) { argument
5804 return self.$attr_reader("errno")
5805 })(Opal.get_singleton_class(self), $nesting);
5815 var self = $klass($base, $super, 'Exception');
5817 … var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $proto = self.$$prototype;
5821 Opal.prop(self.$$prototype, '$$is_exception', true);
5824 $defs(self, '$new', function $Exception_new$1($a) {
5825 var $post_args, args, self = this;
5833 var error = new self.$$constructor(message);
5834 error.name = self.$$name;
5851 stack_trace_limit = self.$new;
5852 $defs(self, '$exception', function $$exception($a) {
5853 var $post_args, args, self = this;
5858 return $send(self, 'new', $to_a(args));
5861 $def(self, '$initialize', function $$initialize($a) {
5862 var $post_args, args, self = this;
5867 return self.message = (args.length > 0) ? args[0] : nil;;
5900 $def(self, '$backtrace', function $$backtrace() {
5901 var self = this;
5904 if (self.backtrace) {
5906 return self.backtrace;
5909 var backtrace = self.stack;
5912 return self.backtrace = correct_backtrace(backtrace.split("\n"));
5915 return self.backtrace = correct_backtrace(backtrace);
5922 $def(self, '$backtrace_locations', function $$backtrace_locations() {
5923 var $a, self = this;
5926 if (self.backtrace_locations) return self.backtrace_locations;
5927 …self.backtrace_locations = ($a = self.$backtrace(), ($a === nil || $a == null) ? nil : $send($a, '…
5931 return self.backtrace_locations;
5935 $def(self, '$cause', function $$cause() {
5936 var self = this;
5938 return self.cause || nil;
5941 $def(self, '$exception', function $$exception(str) {
5942 var self = this;
5947 if (str === nil || self === str) {
5948 return self;
5951 var cloned = self.$clone();
5953 if (self.backtrace) cloned.backtrace = self.backtrace.$dup();
5954 cloned.stack = self.stack;
5955 cloned.cause = self.cause;
5960 $def(self, '$message', function $$message() {
5961 var self = this;
5963 return self.$to_s()
5966 $def(self, '$full_message', function $$full_message(kwargs) {
5967 …var $a, $b, self = this, $ret_or_1 = nil, highlight = nil, order = nil, bold_underline = nil, bold…
5973 return "" + (self.message) + "\n" + (self.stack)
5991 bt = self.$backtrace().$dup();
5993 bt = self.$caller()
5997 …msg = $rb_plus(msg, "" + (bold) + (self.$to_s()) + " (" + (bold_underline) + (self.$class()) + (re…
6002 if ($truthy(self.$cause())) {
6003 … msg = $rb_plus(msg, self.$cause().$full_message($hash2(["highlight"], {"highlight": highlight})))
6013 $def(self, '$inspect', function $$inspect() {
6014 var self = this, as_str = nil;
6017 as_str = self.$to_s();
6019 return self.$class().$to_s()
6021 return "#<" + (self.$class().$to_s()) + ": " + (self.$to_s()) + ">"
6025 $def(self, '$set_backtrace', function $$set_backtrace(backtrace) {
6026 var self = this;
6032 self.backtrace = nil; field
6033 self.stack = '';
6035 self.backtrace = [backtrace]; field
6036 self.stack = ' from ' + backtrace;
6053 self.backtrace = backtrace;
6054 self.stack = $send((backtrace), 'map', [], function $$4(i){
6063 return $def(self, '$to_s', function $$to_s() {
6064 var self = this, $ret_or_1 = nil, $ret_or_2 = nil;
6066 …if ($truthy(($ret_or_1 = ($truthy(($ret_or_2 = self.message)) ? (self.message.$to_s()) : ($ret_or_…
6069 return self.$class().$to_s()
6108 var self = $klass($base, $super, 'FrozenError');
6112 self.$attr_reader("receiver");
6113 return $def(self, '$initialize', function $$initialize(message, $kwargs) {
6114 var receiver, $yield = $$initialize.$$p || nil, self = this;
6121 …$send2(self, $find_super(self, 'initialize', $$initialize, false, true), 'initialize', [message], …
6122 return (self.receiver = receiver);
6126 var self = $klass($base, $super, 'UncaughtThrowError');
6128 var $proto = self.$$prototype;
6132 self.$attr_reader("tag", "value");
6133 return $def(self, '$initialize', function $$initialize(tag, value) {
6134 var $yield = $$initialize.$$p || nil, self = this;
6139 self.tag = tag;
6140 self.value = value;
6141 …return $send2(self, $find_super(self, 'initialize', $$initialize, false, true), 'initialize', ["un…
6145 var self = $klass($base, $super, 'NameError');
6149 self.$attr_reader("name");
6150 return $def(self, '$initialize', function $$initialize(message, name) {
6151 var $yield = $$initialize.$$p || nil, self = this;
6156 …$send2(self, $find_super(self, 'initialize', $$initialize, false, true), 'initialize', [message], …
6157 return (self.name = name);
6161 var self = $klass($base, $super, 'NoMethodError');
6165 self.$attr_reader("args");
6166 return $def(self, '$initialize', function $$initialize(message, name, args) {
6167 var $yield = $$initialize.$$p || nil, self = this;
6173 …$send2(self, $find_super(self, 'initialize', $$initialize, false, true), 'initialize', [message, n…
6174 return (self.args = args);
6178 var self = $klass($base, $super, 'StopIteration');
6181 return self.$attr_reader("result")
6184 var self = $klass($base, $super, 'KeyError');
6186 var $proto = self.$$prototype;
6191 $def(self, '$initialize', function $$initialize(message, $kwargs) {
6192 var receiver, key, $yield = $$initialize.$$p || nil, self = this;
6201 …$send2(self, $find_super(self, 'initialize', $$initialize, false, true), 'initialize', [message], …
6202 self.receiver = receiver;
6203 return (self.key = key);
6206 $def(self, '$receiver', function $$receiver() {
6207 var self = this, $ret_or_1 = nil;
6209 if ($truthy(($ret_or_1 = self.receiver))) {
6215 return $def(self, '$key', function $$key() {
6216 var self = this, $ret_or_1 = nil;
6218 if ($truthy(($ret_or_1 = self.key))) {
6226 var self = $module($base, 'JS');
6228 var $nesting = [self].concat($parent_nesting);
6270 var self = $klass($base, $super, 'NilClass');
6272 var $nesting = [self].concat($parent_nesting);
6275 self.$$prototype.$$meta = self;
6276 (function(self, $parent_nesting) { argument
6280 $def(self, '$allocate', function $$allocate() {
6281 var self = this;
6283 return $Kernel.$raise($$$('TypeError'), "allocator undefined for " + (self.$name()))
6287 Opal.udef(self, '$' + "new");;
6289 })(Opal.get_singleton_class(self), $nesting);
6291 $def(self, '$!', $return_val(true));
6293 $def(self, '$&', $return_val(false));
6295 $def(self, '$|', function $NilClass_$$1(other) {
6300 $def(self, '$^', function $NilClass_$$2(other) {
6305 $def(self, '$==', function $NilClass_$eq_eq$3(other) {
6310 $def(self, '$dup', $return_val(nil));
6312 $def(self, '$clone', function $$clone($kwargs) {
6322 $def(self, '$inspect', $return_val("nil"));
6324 $def(self, '$nil?', $return_val(true));
6326 $def(self, '$singleton_class', function $$singleton_class() {
6331 $def(self, '$to_a', function $$to_a() {
6336 $def(self, '$to_h', function $$to_h() {
6341 $def(self, '$to_i', $return_val(0));
6343 $def(self, '$to_s', $return_val(""));
6345 $def(self, '$to_c', function $$to_c() {
6350 $def(self, '$rationalize', function $$rationalize($a) {
6362 $def(self, '$to_r', function $$to_r() {
6367 $def(self, '$instance_variables', function $$instance_variables() {
6371 return $alias(self, "to_f", "to_i");
6382 var self = $klass($base, $super, 'Boolean');
6384 var $nesting = [self].concat($parent_nesting);
6387 Opal.prop(self.$$prototype, '$$is_boolean', true);
6392 Object.defineProperty(self.$$prototype, properties[i], {
6403 Object.defineProperty(self.$$prototype, "$$id", {
6413 (function(self, $parent_nesting) { argument
6417 $def(self, '$allocate', function $$allocate() {
6418 var self = this;
6420 return $Kernel.$raise($$$('TypeError'), "allocator undefined for " + (self.$name()))
6424 Opal.udef(self, '$' + "new");;
6426 })(Opal.get_singleton_class(self), $nesting);
6428 $def(self, '$__id__', function $$__id__() {
6429 var self = this;
6431 return self.valueOf() ? 2 : 0;
6434 $def(self, '$!', function $Boolean_$excl$1() {
6435 var self = this;
6437 return self != true;
6440 $def(self, '$&', function $Boolean_$$2(other) {
6441 var self = this;
6443 return (self == true) ? (other !== false && other !== nil) : false;
6446 $def(self, '$|', function $Boolean_$$3(other) {
6447 var self = this;
6449 return (self == true) ? true : (other !== false && other !== nil);
6452 $def(self, '$^', function $Boolean_$$4(other) {
6453 var self = this;
6455 … return (self == true) ? (other === false || other === nil) : (other !== false && other !== nil);
6458 $def(self, '$==', function $Boolean_$eq_eq$5(other) {
6459 var self = this;
6461 return (self == true) === other.valueOf();
6464 $def(self, '$singleton_class', function $$singleton_class() {
6465 var self = this;
6467 return self.$$meta;
6470 $def(self, '$to_s', function $$to_s() {
6471 var self = this;
6473 return (self == true) ? 'true' : 'false';
6476 $def(self, '$dup', $return_self);
6478 $def(self, '$clone', function $$clone($kwargs) {
6479 var freeze, self = this;
6485 return self;
6488 $def(self, '$method_missing', function $$method_missing(method, $a) {
6489 var block = $$method_missing.$$p || nil, $post_args, args, self = this;
6496 var body = self.$$class.$$prototype[Opal.jsid(method)];
6498 …$send2(self, $find_super(self, 'method_missing', $$method_missing, false, true), 'method_missing',…
6500 return Opal.send(self, body, args, block);
6503 …$def(self, '$respond_to_missing?', function $Boolean_respond_to_missing$ques$6(method, _include_al…
6504 var self = this;
6508 var body = self.$$class.$$prototype[Opal.jsid(method)];
6511 $alias(self, "eql?", "==");
6512 $alias(self, "equal?", "==");
6513 $alias(self, "inspect", "to_s");
6514 return $alias(self, "object_id", "__id__");
6525 var self = $module($base, 'Comparable');
6552 $def(self, '$==', function $Comparable_$eq_eq$1(other) {
6553 var self = this, cmp = nil;
6556 if ($truthy(self['$equal?'](other))) {
6560 if (self["$<=>"] == Opal.Kernel["$<=>"]) {
6565 if (self.$$comparable) {
6566 self.$$comparable = false;
6570 if (!$truthy((cmp = self['$<=>'](other)))) {
6576 $def(self, '$>', function $Comparable_$gt$2(other) {
6577 var self = this;
6579 return cmp_or_fail(self, other) > 0;
6582 $def(self, '$>=', function $Comparable_$gt_eq$3(other) {
6583 var self = this;
6585 return cmp_or_fail(self, other) >= 0;
6588 $def(self, '$<', function $Comparable_$lt$4(other) {
6589 var self = this;
6591 return cmp_or_fail(self, other) < 0;
6594 $def(self, '$<=', function $Comparable_$lt_eq$5(other) {
6595 var self = this;
6597 return cmp_or_fail(self, other) <= 0;
6600 $def(self, '$between?', function $Comparable_between$ques$6(min, max) {
6601 var self = this;
6604 if ($rb_lt(self, min)) {
6607 if ($rb_gt(self, max)) {
6612 return $def(self, '$clamp', function $$clamp(min, max) {
6613 var self = this;
6642 c = cmp_or_fail(self, min);
6644 if (c == 0) return self;
6649 c = cmp_or_fail(self, max);
6654 return self;
6667 var self = $klass($base, $super, 'Regexp');
6669 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
6672 $const_set(self, 'IGNORECASE', 1);
6673 $const_set(self, 'EXTENDED', 2);
6674 $const_set(self, 'MULTILINE', 4);
6675 Opal.prop(self.$$prototype, '$$is_regexp', true);
6676 (function(self, $parent_nesting) { argument
6677 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
6681 $def(self, '$allocate', function $$allocate() {
6682 var $yield = $$allocate.$$p || nil, self = this, allocated = nil;
6686 …allocated = $send2(self, $find_super(self, 'allocate', $$allocate, false, true), 'allocate', [], $…
6691 $def(self, '$escape', function $$escape(string) {
6696 $def(self, '$last_match', function $$last_match(n) {
6710 $def(self, '$union', function $$union($a) {
6711 var $post_args, parts, self = this;
6739 quoted_validated.push(self.$escape(part));
6750 quoted_validated.push(self.$escape((part).$to_str()));
6754 return self.$new((quoted_validated).$join("|"), options);
6757 $def(self, '$new', function $new$1(regexp, options) {
6791 $alias(self, "compile", "new");
6792 return $alias(self, "quote", "escape");
6793 })(Opal.get_singleton_class(self), $nesting);
6795 $def(self, '$==', function $Regexp_$eq_eq$2(other) {
6796 var self = this;
6798 return other instanceof RegExp && self.toString() === other.toString();
6801 $def(self, '$===', function $Regexp_$eq_eq_eq$3(string) {
6802 var self = this;
6804 return self.$match($Opal['$coerce_to?'](string, $$$('String'), "to_str")) !== nil
6807 $def(self, '$=~', function $Regexp_$eq_tilde$4(string) {
6808 var self = this, $ret_or_1 = nil;
6811 if ($truthy(($ret_or_1 = self.$match(string)))) {
6818 $def(self, '$freeze', function $$freeze() {
6819 var self = this;
6822 if ($truthy(self['$frozen?']())) {
6823 return self
6826 if (!self.hasOwnProperty('$$g')) { $prop(self, '$$g', null); }
6827 if (!self.hasOwnProperty('$$gm')) { $prop(self, '$$gm', null); }
6829 return $freeze(self);
6833 $def(self, '$inspect', function $$inspect() {
6834 var self = this;
6838 var value = self.toString();
6871 $def(self, '$match', function $$match(string, pos) {
6872 var block = $$match.$$p || nil, self = this;
6880 if (self.uninitialized) {
6886 var m = self.exec($coerce_to(string, $$$('String'), 'to_str'));
6888 ($gvars["~"] = $$$('MatchData').$new(self, m));
6911 var md, re = Opal.global_regexp(self);
6927 $def(self, '$match?', function $Regexp_match$ques$5(string, pos) {
6928 var self = this;
6933 if (self.uninitialized) {
6938 return string === nil ? false : self.test($coerce_to(string, $$$('String'), 'to_str'));
6957 var md, re = Opal.global_regexp(self);
6968 $def(self, '$names', function $$names() {
6969 var self = this;
6971 …return $send(self.$source().$scan(/\(?<(\w+)>/, $hash2(["no_matchdata"], {"no_matchdata": true})),…
6974 $def(self, '$named_captures', function $$named_captures() {
6975 var self = this;
6977 …return $send($send($send(self.$source().$scan(/\(?<(\w+)>/, $hash2(["no_matchdata"], {"no_matchdat…
6986 $def(self, '$~', function $Regexp_$$8() {
6987 var self = this;
6990 return self['$=~']($gvars._)
6993 $def(self, '$source', function $$source() {
6994 var self = this;
6996 return self.source;
6999 $def(self, '$options', function $$options() {
7000 var self = this;
7003 if (self.uninitialized) {
7008 if (self.multiline) {
7011 if (self.ignoreCase) {
7018 $def(self, '$casefold?', function $Regexp_casefold$ques$9() {
7019 var self = this;
7021 return self.ignoreCase;
7023 $alias(self, "eql?", "==");
7024 return $alias(self, "to_s", "source");
7027 var self = $klass($base, $super, 'MatchData');
7029 … var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $proto = self.$$prototype;
7033 self.$attr_reader("post_match", "pre_match", "regexp", "string");
7035 $def(self, '$initialize', function $$initialize(regexp, match_groups, $kwargs) {
7036 var no_matchdata, self = this;
7043 $gvars["~"] = self
7045 self.regexp = regexp;
7046 self.begin = match_groups.index;
7047 self.string = match_groups.input;
7048 self.pre_match = match_groups.input.slice(0, match_groups.index);
7049 self.post_match = match_groups.input.slice(match_groups.index + match_groups[0].length);
7050 self.matches = [];
7056 self.matches.push(nil);
7059 self.matches.push(group);
7065 $def(self, '$match', function $$match(idx) {
7066 var self = this, match = nil;
7068 if ($truthy((match = self['$[]'](idx)))) {
7070 … } else if (($truthy(idx['$is_a?']($$('Integer'))) && ($truthy($rb_ge(idx, self.$length()))))) {
7077 $def(self, '$match_length', function $$match_length(idx) {
7078 var $a, self = this;
7080 return ($a = self.$match(idx), ($a === nil || $a == null) ? nil : $a.$length())
7083 $def(self, '$[]', function $MatchData_$$$10($a) {
7084 var $post_args, args, self = this;
7091 if (self.$regexp().$names()['$include?'](args['$[]'](0))['$!']()) {
7094 return self.$named_captures()['$[]'](args['$[]'](0))
7097 return $send(self.matches, '[]', $to_a(args))
7102 $def(self, '$offset', function $$offset(n) {
7103 var self = this;
7109 return [self.begin, self.begin + self.matches[n].length];
7113 $def(self, '$==', function $MatchData_$eq_eq$11(other) {
7114 var self = this, $ret_or_1 = nil, $ret_or_2 = nil, $ret_or_3 = nil, $ret_or_4 = nil;
7120 …self.string == other.string)) ? (self.regexp.toString() == other.regexp.toString()) : ($ret_or_4))…
7121 return self.begin == other.begin;
7127 $def(self, '$begin', function $$begin(n) {
7128 var self = this;
7134 return self.begin;
7138 $def(self, '$end', function $$end(n) {
7139 var self = this;
7145 return self.begin + self.matches[n].length;
7149 $def(self, '$captures', function $$captures() {
7150 var self = this;
7152 return self.matches.slice(1)
7155 $def(self, '$named_captures', function $$named_captures() {
7156 var self = this, matches = nil;
7159 matches = self.$captures();
7160 return $send(self.$regexp().$named_captures(), 'transform_values', [], function $$12(i){
7166 $def(self, '$names', function $$names() {
7167 var self = this;
7169 return self.$regexp().$names()
7172 $def(self, '$inspect', function $$inspect() {
7173 var self = this;
7176 var str = "#<MatchData " + (self.matches[0]).$inspect();
7178 if (self.$regexp().$names()['$empty?']()) {
7179 for (var i = 1, length = self.matches.length; i < length; i++) {
7180 str += " " + i + ":" + (self.matches[i]).$inspect();
7184 $send(self.$named_captures(), 'each', [], function $$13(k, v){
7195 $def(self, '$length', function $$length() {
7196 var self = this;
7198 return self.matches.length
7201 $def(self, '$to_a', $return_ivar("matches"));
7203 $def(self, '$to_s', function $$to_s() {
7204 var self = this;
7206 return self.matches[0]
7209 $def(self, '$values_at', function $$values_at($a) {
7210 var $post_args, args, self = this;
7229 index += self.matches.length;
7236 values.push(self.matches[index]);
7242 $alias(self, "eql?", "==");
7243 return $alias(self, "size", "length");
7248 …q, $hash2 = Opal.hash2, $alias = Opal.alias, $const_set = Opal.const_set, self = Opal.top, $nestin…
7252 self.$require("corelib/comparable");
7253 self.$require("corelib/regexp");
7255 var self = $klass($base, $super, 'String');
7257 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
7260 self.$include($$$('Comparable'));
7262 Opal.prop(self.$$prototype, '$$is_string', true);
7265 $def(self, '$__id__', function $$__id__() {
7266 var self = this;
7268 return self.toString();
7270 $defs(self, '$try_convert', function $$try_convert(what) {
7274 $defs(self, '$new', function $String_new$1($a) {
7275 var $post_args, args, self = this;
7287 str = new self.$$constructor(str);
7293 $def(self, '$initialize', function $$initialize($a, $b) {
7309 $def(self, '$%', function $String_$percent$2(data) {
7310 var self = this;
7313 return $send(self, 'format', [self].concat($to_a(data)))
7315 return self.$format(self, data)
7319 $def(self, '$*', function $String_$$3(count) {
7320 var self = this;
7334 string = self.toString();
7359 $def(self, '$+', function $String_$plus$4(other) {
7360 var self = this;
7365 if (other == "" && self.$$class === Opal.String) return self;
7366 if (self == "" && other.$$class === Opal.String) return other;
7367 var out = self + other;
7368 if (self.encoding === out.encoding && other.encoding === out.encoding) return out;
7369 if (self.encoding.name === "UTF-8" || other.encoding.name === "UTF-8") return out;
7370 return Opal.enc(out, self.encoding);
7374 $def(self, '$<=>', function $String_$lt_eq_gt$5(other) {
7375 var self = this;
7380 return self > other ? 1 : (self < other ? -1 : 0);;
7383 var cmp = other['$<=>'](self);
7395 $def(self, '$==', function $String_$eq_eq$6(other) {
7396 var self = this;
7400 return self.toString() === other.toString();
7403 return other['$=='](self);
7409 $def(self, '$=~', function $String_$eq_tilde$7(other) {
7410 var self = this;
7417 return other['$=~'](self);
7421 $def(self, '$[]', function $String_$$$8(index, length) {
7422 var self = this;
7427 var size = self.length, exclude, range;
7457 return self.substr(index, length);
7465 return self.indexOf(index) !== -1 ? index : nil;
7470 var match = self.match(index);
7507 return self.substr(index, 1);
7520 return self.substr(index, length);
7524 $def(self, '$b', function $$b() {
7525 var self = this;
7527 return (new String(self)).$force_encoding("binary")
7530 $def(self, '$capitalize', function $$capitalize() {
7531 var self = this;
7533 return self.charAt(0).toUpperCase() + self.substr(1).toLowerCase();
7536 $def(self, '$casecmp', function $$casecmp(other) {
7537 var self = this;
7546 if (ascii_only.test(self) && ascii_only.test(other)) {
7547 self = self.toLowerCase();
7551 return self['$<=>'](other);
7554 $def(self, '$casecmp?', function $String_casecmp$ques$9(other) {
7555 var self = this;
7558 var cmp = self.$casecmp(other);
7567 $def(self, '$center', function $$center(width, padstr) {
7568 var self = this;
7577 if ($truthy(width <= self.length)) {
7578 return self
7581 var ljustified = self.$ljust($rb_divide($rb_plus(width, self.length), 2).$ceil(), padstr),
7582 rjustified = self.$rjust($rb_divide($rb_plus(width, self.length), 2).$floor(), padstr);
7584 return rjustified + ljustified.slice(self.length);
7588 $def(self, '$chomp', function $$chomp(separator) {
7589 var self = this;
7594 if ($truthy(separator === nil || self.length === 0)) {
7595 return self
7602 result = self.replace(/\r?\n?$/, '');
7605 result = self.replace(/(\r?\n)+$/, '');
7607 else if (self.length >= separator.length) {
7608 var tail = self.substr(self.length - separator.length, separator.length);
7611 result = self.substr(0, self.length - separator.length);
7619 return self;
7622 $def(self, '$chop', function $$chop() {
7623 var self = this;
7626 var length = self.length, result;
7630 } else if (self.charAt(length - 1) === "\n" && self.charAt(length - 2) === "\r") {
7631 result = self.substr(0, length - 2);
7633 result = self.substr(0, length - 1);
7640 $def(self, '$chr', function $$chr() {
7641 var self = this;
7643 return self.charAt(0);
7646 $def(self, '$clone', function $$clone($kwargs) {
7647 var freeze, self = this, copy = nil;
7654 self.$raise($$('ArgumentError'), "unexpected value for freeze: " + (freeze.$class()))
7656 copy = new String(self);
7657 copy.$copy_singleton_methods(self);
7658 copy.$initialize_clone(self, $hash2(["freeze"], {"freeze": freeze}));
7662 if (self.$$frozen) { copy.$$frozen = true; }
7667 $def(self, '$dup', function $$dup() {
7668 var self = this, copy = nil;
7671 copy = new String(self);
7672 copy.$initialize_dup(self);
7676 $def(self, '$count', function $$count($a) {
7677 var $post_args, sets, self = this;
7690 return self.length - self.replace(new RegExp(char_class, 'g'), '').length;
7694 $def(self, '$delete', function $String_delete$10($a) {
7695 var $post_args, sets, self = this;
7706 return self;
7708 return self.replace(new RegExp(char_class, 'g'), '');
7712 $def(self, '$delete_prefix', function $$delete_prefix(prefix) {
7713 var self = this;
7720 if (self.slice(0, prefix.length) === prefix) {
7721 return self.slice(prefix.length);
7723 return self;
7728 $def(self, '$delete_suffix', function $$delete_suffix(suffix) {
7729 var self = this;
7736 if (self.slice(self.length - suffix.length) === suffix) {
7737 return self.slice(0, self.length - suffix.length);
7739 return self;
7744 $def(self, '$downcase', function $$downcase() {
7745 var self = this;
7747 return self.toLowerCase();
7750 $def(self, '$each_line', function $$each_line($a, $b) {
7751 var block = $$each_line.$$p || nil, $post_args, $kwargs, separator, chomp, self = this;
7765 return self.$enum_for("each_line", separator, $hash2(["chomp"], {"chomp": chomp}))
7769 Opal.yield1(block, self);
7771 return self;
7779 for (a = self.split(/((?:\r?\n){2})(?:(?:\r?\n)*)/), i = 0, n = a.length; i < n; i += 2) {
7789 return self;
7792 chomped = self.$chomp(separator);
7793 trailing = self.length != chomped.length;
7807 return self;
7810 $def(self, '$empty?', function $String_empty$ques$11() {
7811 var self = this;
7813 return self.length === 0;
7816 $def(self, '$end_with?', function $String_end_with$ques$12($a) {
7817 var $post_args, suffixes, self = this;
7826 if (self.length >= suffix.length &&
7827 self.substr(self.length - suffix.length, suffix.length) == suffix) {
7835 $def(self, '$gsub', function $$gsub(pattern, replacement) {
7836 var block = $$gsub.$$p || nil, self = this;
7844 return self.$enum_for("gsub", pattern);
7858 match = pattern.exec(self);
7862 result += self.slice(index);
7893 case "`": return slashes.slice(1) + self.slice(0, match.index);
7894 case "'": return slashes.slice(1) + self.slice(match.index + match[0].length);
8007 escaped = self.replace(escapable, function (chr) {
8010 … if (chr <= 0xff && (self.encoding["$binary?"]() || self.internal_encoding["$binary?"]())) {
8021 $def(self, '$intern', function $$intern() {
8022 var self = this;
8024 return self.toString();
8027 $def(self, '$length', function $$length() {
8028 var self = this;
8030 return self.length;
8032 $alias(self, "size", "length");
8034 $def(self, '$lines', function $$lines($a, $b) {
8035 var block = $$lines.$$p || nil, $post_args, $kwargs, separator, chomp, self = this, e = nil;
8048 … e = $send(self, 'each_line', [separator, $hash2(["chomp"], {"chomp": chomp})], block.$to_proc());
8050 return self
8056 $def(self, '$ljust', function $$ljust(width, padstr) {
8057 var self = this;
8066 if ($truthy(width <= self.length)) {
8067 return self
8073 width -= self.length;
8079 return self + result.slice(0, width);
8083 $def(self, '$lstrip', function $$lstrip() {
8084 var self = this;
8086 return self.replace(/^[\u0000\s]*/, '');
8089 $def(self, '$ascii_only?', function $String_ascii_only$ques$14() {
8090 var self = this;
8093 if (!self.encoding.ascii) return false;
8094 return /^[\x00-\x7F]*$/.test(self);
8098 $def(self, '$match', function $$match(pattern, pos) {
8099 var block = $$match.$$p || nil, self = this;
8111 return $send(pattern, 'match', [self, pos], block.$to_proc());
8114 $def(self, '$match?', function $String_match$ques$15(pattern, pos) {
8115 var self = this;
8125 return pattern['$match?'](self, pos);
8128 $def(self, '$next', function $$next() {
8129 var self = this;
8132 var i = self.length;
8136 var result = self;
8137 var first_alphanum_char_index = self.search(/[a-zA-Z0-9]/);
8141 code = self.charCodeAt(i);
8200 $def(self, '$oct', function $$oct() {
8201 var self = this;
8205 string = self,
8245 $def(self, '$ord', function $$ord() {
8246 var self = this;
8249 if (typeof self.codePointAt === "function") {
8250 return self.codePointAt(0);
8253 return self.charCodeAt(0);
8258 $def(self, '$partition', function $$partition(sep) {
8259 var self = this;
8265 m = sep.exec(self);
8275 i = self.indexOf(sep);
8279 return [self, '', ''];
8283 self.slice(0, i),
8284 self.slice(i, i + sep.length),
8285 self.slice(i + sep.length)
8290 $def(self, '$reverse', function $$reverse() {
8291 var self = this;
8293 return self.split('').reverse().join('');
8296 $def(self, '$rindex', function $$rindex(search, offset) {
8297 var self = this;
8305 offset = self.length;
8309 offset += self.length;
8320 _m = r.exec(self);
8336 i = self.lastIndexOf(search, offset);
8343 $def(self, '$rjust', function $$rjust(width, padstr) {
8344 var self = this;
8353 if ($truthy(width <= self.length)) {
8354 return self
8357 var chars = Math.floor(width - self.length),
8362 return result + padstr.slice(0, remaining) + self;
8366 $def(self, '$rpartition', function $$rpartition(sep) {
8367 var self = this;
8377 _m = r.exec(self);
8395 i = self.lastIndexOf(sep);
8399 return ['', '', self];
8403 self.slice(0, i),
8404 self.slice(i, i + sep.length),
8405 self.slice(i + sep.length)
8410 $def(self, '$rstrip', function $$rstrip() {
8411 var self = this;
8413 return self.replace(/[\s\u0000]*$/, '');
8416 $def(self, '$scan', function $$scan(pattern, $kwargs) {
8417 var block = $$scan.$$p || nil, no_matchdata, self = this;
8437 while ((match = pattern.exec(self)) != null) {
8451 return (block !== nil ? self : result);
8455 $def(self, '$singleton_class', function $$singleton_class() {
8456 var self = this;
8458 return Opal.get_singleton_class(self);
8461 $def(self, '$split', function $$split(pattern, limit) {
8462 var self = this, $ret_or_1 = nil;
8469 if (self.length === 0) {
8478 return [self];
8487 string = self.toString(),
8555 $def(self, '$squeeze', function $$squeeze($a) {
8556 var $post_args, sets, self = this;
8563 return self.replace(/(.)\1+/g, '$1');
8567 return self;
8569 return self.replace(new RegExp('(' + char_class + ')\\1+', 'g'), '$1');
8573 $def(self, '$start_with?', function $String_start_with$ques$16($a) {
8574 var $post_args, prefixes, self = this;
8583 var match = regexp.exec(self);
8594 if (self.indexOf(prefix) === 0) {
8604 $def(self, '$strip', function $$strip() {
8605 var self = this;
8607 return self.replace(/^[\s\u0000]*|[\s\u0000]*$/g, '');
8610 $def(self, '$sub', function $$sub(pattern, replacement) {
8611 var block = $$sub.$$p || nil, self = this;
8623 var result, match = pattern.exec(self);
8627 result = self.toString();
8636 … result = self.slice(0, match.index) + block(match[0]) + self.slice(match.index + match[0].length);
8640 …result = self.slice(0, match.index) + (replacement)['$[]'](match[0]).$to_s() + self.slice(match.in…
8659 case "`": return slashes.slice(1) + self.slice(0, match.index);
8660 case "'": return slashes.slice(1) + self.slice(match.index + match[0].length);
8709 $def(self, '$to_f', function $$to_f() {
8710 var self = this;
8713 if (self.charAt(0) === '_') {
8717 var result = parseFloat(self.replace(/_/g, ''));
8728 $def(self, '$to_i', function $$to_i(base) {
8729 var self = this;
8735 string = self.toLowerCase(),
8791 $def(self, '$to_proc', function $$to_proc() {
8792 var $yield = $$to_proc.$$p || nil, self = this, method_name = nil, jsid = nil, proc = nil;
8796 method_name = self.valueOf();
8837 $def(self, '$to_s', function $$to_s() {
8838 var self = this;
8840 return self.toString();
8843 $def(self, '$tr', function $$tr(from, to) {
8844 var self = this;
8851 return self;
8976 for (i = 0, length = self.length; i < length; i++) {
8977 ch = self.charAt(i);
8990 $def(self, '$tr_s', function $$tr_s(from, to) {
8991 var self = this;
8998 return self;
9123 for (i = 0, length = self.length; i < length; i++) {
9124 ch = self.charAt(i);
9155 $def(self, '$upcase', function $$upcase() {
9156 var self = this;
9158 return self.toUpperCase();
9161 $def(self, '$upto', function $$upto(stop, excl) {
9162 var block = $$upto.$$p || nil, self = this;
9169 return self.$enum_for("upto", stop, excl)
9172 var a, b, s = self.toString();
9219 return self;
9308 $def(self, '$instance_variables', function $$instance_variables() {
9312 $defs(self, '$_load', function $$_load($a) {
9313 var $post_args, args, self = this;
9318 return $send(self, 'new', $to_a(args));
9321 $def(self, '$unicode_normalize', function $$unicode_normalize(form) {
9322 var self = this;
9329 return self.normalize(form.$upcase());
9332 $def(self, '$unicode_normalized?', function $String_unicode_normalized$ques$18(form) {
9333 var self = this;
9337 return self.$unicode_normalize(form)['$=='](self);
9340 $def(self, '$unpack', function $$unpack(format) {
9345 $def(self, '$unpack1', function $$unpack1(format) {
9350 $def(self, '$freeze', function $$freeze() {
9351 var self = this;
9354 if (typeof self === 'string') { return self; }
9355 $prop(self, "$$frozen", true);
9356 return self;
9360 $def(self, '$-@', function $String_$minus$$19() {
9361 var self = this;
9364 if (typeof self === 'string') return self;
9365 if (self.$$frozen) return self;
9366 …if (self.encoding.name == 'UTF-8' && self.internal_encoding.name == 'UTF-8') return self.toString(…
9367 return self.$dup().$freeze();
9371 $def(self, '$frozen?', function $String_frozen$ques$20() {
9372 var self = this;
9374 return typeof self === 'string' || self.$$frozen === true;
9376 $alias(self, "+@", "dup");
9377 $alias(self, "===", "==");
9378 $alias(self, "byteslice", "[]");
9379 $alias(self, "eql?", "==");
9380 $alias(self, "equal?", "===");
9381 $alias(self, "object_id", "__id__");
9382 $alias(self, "slice", "[]");
9383 $alias(self, "succ", "next");
9384 $alias(self, "to_str", "to_s");
9385 $alias(self, "to_sym", "intern");
9386 return $Opal.$pristine(self, "initialize");
9396 var self = $module($base, 'Enumerable');
9398 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
9415 …$def(self, '$all?', function $Enumerable_all$ques$1(pattern) {try { var $t_return = $thrower('retu…
9416 var block = $Enumerable_all$ques$1.$$p || nil, self = this;
9423 $send(self, 'each', [], function $$2($a){var $post_args, value, comparable = nil;
9435 $send(self, 'each', [], function $$3($a){var $post_args, value;
9446 $send(self, 'each', [], function $$4($a){var $post_args, value;
9463 …$def(self, '$any?', function $Enumerable_any$ques$5(pattern) {try { var $t_return = $thrower('retu…
9464 var block = $Enumerable_any$ques$5.$$p || nil, self = this;
9471 $send(self, 'each', [], function $$6($a){var $post_args, value, comparable = nil;
9483 $send(self, 'each', [], function $$7($a){var $post_args, value;
9494 $send(self, 'each', [], function $$8($a){var $post_args, value;
9511 $def(self, '$chunk', function $$chunk() {
9512 var block = $$chunk.$$p || nil, self = this;
9518 …return $send(self, 'to_enum', ["chunk"], function $$9(){var self = $$9.$$s == null ? this : $$9.$$…
9520 return self.$enumerator_size()}, {$$s: self})
9522 …return $send($$$('Enumerator'), 'new', [], function $$10(yielder){var self = $$10.$$s == null ? th…
9535 self.$each.$$p = function(value) {
9554 self.$each();
9557 ;}, {$$s: self});
9560 $def(self, '$chunk_while', function $$chunk_while() {
9561 var block = $$chunk_while.$$p || nil, self = this;
9569 return $send(self, 'slice_when', [], function $$11(before, after){
9576 $def(self, '$collect', function $$collect() {
9577 var block = $$collect.$$p || nil, self = this;
9583 …return $send(self, 'enum_for', ["collect"], function $$12(){var self = $$12.$$s == null ? this : $…
9585 return self.$enumerator_size()}, {$$s: self})
9590 self.$each.$$p = function() {
9596 self.$each();
9602 $def(self, '$collect_concat', function $$collect_concat() {
9603 var block = $$collect_concat.$$p || nil, self = this;
9609 …return $send(self, 'enum_for', ["collect_concat"], function $$13(){var self = $$13.$$s == null ? t…
9611 return self.$enumerator_size()}, {$$s: self})
9613 return $send(self, 'map', [], block.$to_proc()).$flatten(1);
9616 $def(self, '$compact', function $$compact() {
9617 var self = this;
9619 return self.$to_a().$compact()
9622 $def(self, '$count', function $$count(object) {
9623 var block = $$count.$$p || nil, self = this, result = nil;
9632 self.$warn("warning: given block not used")
9645 $send(self, 'each', [], function $$15($a){var $post_args, args;
9658 $def(self, '$cycle', function $$cycle(n) {
9659 var block = $$cycle.$$p || nil, self = this;
9666 …return $send(self, 'enum_for', ["cycle", n], function $$16(){var self = $$16.$$s == null ? this : …
9669 if ($truthy(self['$respond_to?']("size"))) {
9678 return $rb_times(self.$enumerator_size(), n)
9682 }}, {$$s: self})
9694 self.$each.$$p = function() {
9701 self.$each();
9726 $def(self, '$detect', function $$detect(ifnone) {try { var $t_return = $thrower('return');
9727 var block = $$detect.$$p || nil, self = this;
9734 return self.$enum_for("detect", ifnone)
9736 $send(self, 'each', [], function $$17($a){var $post_args, args, value = nil;
9762 $def(self, '$drop', function $$drop(number) {
9763 var self = this;
9774 self.$each.$$p = function() {
9782 self.$each()
9788 $def(self, '$drop_while', function $$drop_while() {
9789 var block = $$drop_while.$$p || nil, self = this;
9795 return self.$enum_for("drop_while")
9801 self.$each.$$p = function() {
9817 self.$each();
9823 $def(self, '$each_cons', function $$each_cons(n) {
9824 var block = $$each_cons.$$p || nil, self = this;
9837 …return $send(self, 'enum_for', ["each_cons", n], function $$18(){var self = $$18.$$s == null ? thi…
9840 enum_size = self.$enumerator_size();
9847 };}, {$$s: self})
9852 self.$each.$$p = function() {
9863 self.$each();
9865 return self;
9869 $def(self, '$each_entry', function $$each_entry($a) {
9870 var block = $$each_entry.$$p || nil, $post_args, data, self = this;
9878 …return $send(self, 'to_enum', ["each_entry"].concat($to_a(data)), function $$19(){var self = $$19.…
9880 return self.$enumerator_size()}, {$$s: self})
9883 self.$each.$$p = function() {
9889 self.$each.apply(self, data);
9891 return self;
9895 $def(self, '$each_slice', function $$each_slice(n) {
9896 var block = $$each_slice.$$p || nil, self = this;
9906 …return $send(self, 'enum_for', ["each_slice", n], function $$20(){var self = $$20.$$s == null ? th…
9908 if ($truthy(self['$respond_to?']("size"))) {
9909 return $rb_divide(self.$size(), n).$ceil()
9912 }}, {$$s: self})
9917 self.$each.$$p = function() {
9928 self.$each();
9935 return self;
9938 $def(self, '$each_with_index', function $$each_with_index($a) {
9939 var block = $$each_with_index.$$p || nil, $post_args, args, self = this;
9947 …return $send(self, 'enum_for', ["each_with_index"].concat($to_a(args)), function $$21(){var self =…
9949 return self.$enumerator_size()}, {$$s: self})
9954 self.$each.$$p = function() {
9962 self.$each.apply(self, args);
9964 return self;
9967 $def(self, '$each_with_object', function $$each_with_object(object) {
9968 var block = $$each_with_object.$$p || nil, self = this;
9974 …return $send(self, 'enum_for', ["each_with_object", object], function $$22(){var self = $$22.$$s =…
9976 return self.$enumerator_size()}, {$$s: self})
9979 self.$each.$$p = function() {
9985 self.$each();
9990 $def(self, '$entries', function $$entries($a) {
9991 var $post_args, args, self = this;
9999 self.$each.$$p = function() {
10003 self.$each.apply(self, args);
10009 $def(self, '$filter_map', function $$filter_map() {
10010 var block = $$filter_map.$$p || nil, self = this;
10016 …return $send(self, 'enum_for', ["filter_map"], function $$23(){var self = $$23.$$s == null ? this …
10018 return self.$enumerator_size()}, {$$s: self})
10020 return $send($send(self, 'map', [], block.$to_proc()), 'select', [], "itself".$to_proc());
10023 $def(self, '$find_all', function $$find_all() {
10024 var block = $$find_all.$$p || nil, self = this;
10030 …return $send(self, 'enum_for', ["find_all"], function $$24(){var self = $$24.$$s == null ? this : …
10032 return self.$enumerator_size()}, {$$s: self})
10037 self.$each.$$p = function() {
10046 self.$each();
10052 …$def(self, '$find_index', function $$find_index(object) {try { var $t_return = $thrower('return');
10053 var block = $$find_index.$$p || nil, self = this, index = nil;
10060 return self.$enum_for("find_index")
10064 self.$warn("warning: given block not used")
10069 $send(self, 'each', [], function $$25($a){var $post_args, value;
10079 $send(self, 'each', [], function $$26($a){var $post_args, value;
10095 $def(self, '$first', function $$first(number) {try { var $t_return = $thrower('return');
10096 var self = this, result = nil, current = nil;
10101 return $send(self, 'each', [], function $$27(value){
10116 $send(self, 'each', [], function $$28($a){var $post_args, args;
10134 $def(self, '$grep', function $$grep(pattern) {
10135 var block = $$grep.$$p || nil, self = this, result = nil;
10141 $send(self, 'each', [], function $$29($a){var $post_args, value, cmp = nil;
10163 $def(self, '$grep_v', function $$grep_v(pattern) {
10164 var block = $$grep_v.$$p || nil, self = this, result = nil;
10170 $send(self, 'each', [], function $$30($a){var $post_args, value, cmp = nil;
10192 $def(self, '$group_by', function $$group_by() {
10193 var block = $$group_by.$$p || nil, $a, self = this, hash = nil, $ret_or_1 = nil;
10199 …return $send(self, 'enum_for', ["group_by"], function $$31(){var self = $$31.$$s == null ? this : …
10201 return self.$enumerator_size()}, {$$s: self})
10207 self.$each.$$p = function() {
10214 self.$each();
10223 …$def(self, '$include?', function $Enumerable_include$ques$32(obj) {try { var $t_return = $thrower(…
10224 var self = this;
10227 $send(self, 'each', [], function $$33($a){var $post_args, args;
10243 $def(self, '$inject', function $$inject(object, sym) {
10244 var block = $$inject.$$p || nil, self = this;
10255 self.$each.$$p = function() {
10278 self.$each.$$p = function() {
10290 self.$each();
10296 $def(self, '$lazy', function $$lazy() {
10297 var self = this;
10299 …return $send($$$($$$('Enumerator'), 'Lazy'), 'new', [self, self.$enumerator_size()], function $$34…
10308 $def(self, '$enumerator_size', function $$enumerator_size() {
10309 var self = this;
10311 if ($truthy(self['$respond_to?']("size"))) {
10312 return self.$size()
10318 $def(self, '$max', function $$max(n) {
10319 var block = $$max.$$p || nil, self = this;
10329 self.$each.$$p = function() {
10352 self.$each();
10363 return $send(self, 'sort', [], block.$to_proc()).$reverse().$first(n);
10366 $def(self, '$max_by', function $$max_by(n) {
10367 var block = $$max_by.$$p || nil, self = this;
10374 …return $send(self, 'enum_for', ["max_by", n], function $$35(){var self = $$35.$$s == null ? this :…
10376 return self.$enumerator_size()}, {$$s: self})
10379 return $send(self, 'sort_by', [], block.$to_proc()).$reverse().$take(n)
10385 self.$each.$$p = function() {
10401 self.$each();
10407 $def(self, '$min', function $$min(n) {
10408 var block = $$min.$$p || nil, self = this;
10416 return $send(self, 'sort', [], function $$36(a, b){
10422 return self.$sort().$take(n)
10429 self.$each.$$p = function() {
10449 self.$each.$$p = function() {
10463 self.$each();
10469 $def(self, '$min_by', function $$min_by(n) {
10470 var block = $$min_by.$$p || nil, self = this;
10477 …return $send(self, 'enum_for', ["min_by", n], function $$37(){var self = $$37.$$s == null ? this :…
10479 return self.$enumerator_size()}, {$$s: self})
10482 return $send(self, 'sort_by', [], block.$to_proc()).$take(n)
10488 self.$each.$$p = function() {
10504 self.$each();
10510 $def(self, '$minmax', function $$minmax() {
10511 var block = $$minmax.$$p || nil, self = this, $ret_or_1 = nil;
10524 self.$each.$$p = function() {
10548 self.$each();
10554 $def(self, '$minmax_by', function $$minmax_by() {
10555 var block = $$minmax_by.$$p || nil, self = this;
10561 …return $send(self, 'enum_for', ["minmax_by"], function $$39(){var self = $$39.$$s == null ? this :…
10563 return self.$enumerator_size()}, {$$s: self})
10571 self.$each.$$p = function() {
10586 self.$each();
10592 …$def(self, '$none?', function $Enumerable_none$ques$40(pattern) {try { var $t_return = $thrower('r…
10593 var block = $Enumerable_none$ques$40.$$p || nil, self = this;
10600 $send(self, 'each', [], function $$41($a){var $post_args, value, comparable = nil;
10612 $send(self, 'each', [], function $$42($a){var $post_args, value;
10623 $send(self, 'each', [], function $$43($a){var $post_args, value, item = nil;
10641 …$def(self, '$one?', function $Enumerable_one$ques$44(pattern) {try { var $t_return = $thrower('ret…
10642 var block = $Enumerable_one$ques$44.$$p || nil, self = this, count = nil;
10650 $send(self, 'each', [], function $$45($a){var $post_args, value, comparable = nil;
10668 $send(self, 'each', [], function $$46($a){var $post_args, value;
10683 $send(self, 'each', [], function $$47($a){var $post_args, value;
10704 $def(self, '$partition', function $$partition() {
10705 var block = $$partition.$$p || nil, self = this;
10711 …return $send(self, 'enum_for', ["partition"], function $$48(){var self = $$48.$$s == null ? this :…
10713 return self.$enumerator_size()}, {$$s: self})
10718 self.$each.$$p = function() {
10730 self.$each();
10736 $def(self, '$reject', function $$reject() {
10737 var block = $$reject.$$p || nil, self = this;
10743 …return $send(self, 'enum_for', ["reject"], function $$49(){var self = $$49.$$s == null ? this : $$…
10745 return self.$enumerator_size()}, {$$s: self})
10750 self.$each.$$p = function() {
10759 self.$each();
10765 $def(self, '$reverse_each', function $$reverse_each() {
10766 var block = $$reverse_each.$$p || nil, self = this;
10772 …return $send(self, 'enum_for', ["reverse_each"], function $$50(){var self = $$50.$$s == null ? thi…
10774 return self.$enumerator_size()}, {$$s: self})
10779 self.$each.$$p = function() {
10783 self.$each();
10793 $def(self, '$slice_before', function $$slice_before(pattern) {
10794 var block = $$slice_before.$$p || nil, self = this;
10806 …return $send($$$('Enumerator'), 'new', [], function $$51(e){var self = $$51.$$s == null ? this : $…
10815 self.$each.$$p = function() {
10828 self.$each.$$p = function() {
10842 self.$each.$$p = function() {
10855 self.$each();
10860 ;}, {$$s: self});
10863 $def(self, '$slice_after', function $$slice_after(pattern) {
10864 var block = $$slice_after.$$p || nil, self = this;
10882 …return $send($$$('Enumerator'), 'new', [], function $$53(yielder){var self = $$53.$$s == null ? th…
10889 self.$each.$$p = function() {
10906 self.$each();
10911 ;}, {$$s: self});
10914 $def(self, '$slice_when', function $$slice_when() {
10915 var block = $$slice_when.$$p || nil, self = this;
10923 …return $send($$$('Enumerator'), 'new', [], function $$54(yielder){var self = $$54.$$s == null ? th…
10930 self.$each_cons.$$p = function() {
10951 self.$each_cons(2);
10957 ;}, {$$s: self});
10960 $def(self, '$sort', function $$sort() {
10961 var block = $$sort.$$p || nil, self = this, ary = nil;
10966 ary = self.$to_a();
10977 $def(self, '$sort_by', function $$sort_by() {
10978 var block = $$sort_by.$$p || nil, self = this, dup = nil;
10984 …return $send(self, 'enum_for', ["sort_by"], function $$56(){var self = $$56.$$s == null ? this : $…
10986 return self.$enumerator_size()}, {$$s: self})
10988 dup = $send(self, 'map', [], function $$57(){var arg = nil;
11004 $def(self, '$sum', function $$sum(initial) {
11005 var $yield = $$sum.$$p || nil, self = this, result = nil, compensation = nil;
11012 $send(self, 'each', [], function $$60($a){var $post_args, args, item = nil, y = nil, t = nil;
11030 $def(self, '$take', function $$take(num) {
11031 var self = this;
11033 return self.$first(num)
11036 $def(self, '$take_while', function $$take_while() {try { var $t_return = $thrower('return');
11037 var block = $$take_while.$$p || nil, self = this, result = nil;
11043 return self.$enum_for("take_while")
11046 return $send(self, 'each', [], function $$61($a){var $post_args, args, value = nil;
11061 $def(self, '$uniq', function $$uniq() {
11062 var block = $$uniq.$$p || nil, self = this, hash = nil;
11068 … $send(self, 'each', [], function $$62($a){var $post_args, args, $b, value = nil, produced = nil;
11083 $def(self, '$tally', function $$tally(hash) {
11084 var self = this, out = nil;
11089 …out = $send($send(self, 'group_by', [], "itself".$to_proc()), 'transform_values', [], "count".$to_…
11104 $def(self, '$to_h', function $$to_h($a) {
11105 var block = $$to_h.$$p || nil, $post_args, args, self = this;
11113 return $send($send(self, 'map', [], block.$to_proc()), 'to_h', $to_a(args))
11118 self.$each.$$p = function() {
11133 self.$each.apply(self, args);
11139 $def(self, '$to_set', function $$to_set($a, $b) {
11140 var block = $$to_set.$$p || nil, $post_args, klass, args, self = this;
11149 return $send(klass, 'new', [self].concat($to_a(args)), block.$to_proc());
11152 $def(self, '$zip', function $$zip($a) {
11153 var block = $$zip.$$p || nil, $post_args, others, self = this;
11160 return $send(self.$to_a(), 'zip', $to_a(others));
11162 $alias(self, "find", "detect");
11163 $alias(self, "filter", "find_all");
11164 $alias(self, "flat_map", "collect_concat");
11165 $alias(self, "map", "collect");
11166 $alias(self, "member?", "include?");
11167 $alias(self, "reduce", "inject");
11168 $alias(self, "select", "find_all");
11169 return $alias(self, "to_a", "entries");
11178 var self = $klass($base, $super, 'Enumerator');
11180 var $nesting = [self].concat($parent_nesting);
11183 var self = $klass($base, $super, 'ArithmeticSequence');
11185 … var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $proto = self.$$prototype;
11189 Opal.prop(self.$$prototype, '$$is_arithmetic_seq', true);
11192 $def(self, '$initialize', function $$initialize(range, step, creation_method) {
11193 var $a, self = this, $ret_or_1 = nil;
11198 self.creation_method = creation_method;
11201 …(self.step_arg1 = ($a[0] == null ? nil : $a[0])), (self.step_arg2 = ($a[1] == null ? nil : $a[1]))…
11202 self.receiver_num = step;
11203 self.step = 1;
11204 …self.range = ($truthy(self.step_arg2) ? (((self.step = self.step_arg2), Opal.Range.$new(self.recei…
11208 self.skipped_arg = true
11210 …= [range, ($truthy(($ret_or_1 = step)) ? ($ret_or_1) : (1))], (self.range = $a[0]), (self.step = $…
11212 self.object = self;
11213 if ($eqeq(self.step, 0)) {
11216 if ($truthy(self.step['$respond_to?']("to_int"))) {
11219 …return $Kernel.$raise($$('ArgumentError'), "" + ("no implicit conversion of " + (self.step.$class(…
11222 self.$attr_reader("step");
11224 $def(self, '$begin', function $$begin() {
11225 var self = this;
11227 return self.range.$begin()
11230 $def(self, '$end', function $$end() {
11231 var self = this;
11233 return self.range.$end()
11236 $def(self, '$exclude_end?', function $ArithmeticSequence_exclude_end$ques$1() {
11237 var self = this;
11239 return self.range['$exclude_end?']()
11242 $def(self, '$_lesser_than_end?', function $ArithmeticSequence__lesser_than_end$ques$2(val) {
11243 var self = this, end_ = nil, $ret_or_1 = nil;
11246 end_ = ($truthy(($ret_or_1 = self.$end())) ? ($ret_or_1) : (inf));
11247 if ($truthy($rb_gt(self.$step(), 0))) {
11248 if ($truthy(self['$exclude_end?']())) {
11253 } else if ($truthy(self['$exclude_end?']())) {
11260 … $def(self, '$_greater_than_begin?', function $ArithmeticSequence__greater_than_begin$ques$3(val) {
11261 var self = this, begin_ = nil, $ret_or_1 = nil;
11264 begin_ = ($truthy(($ret_or_1 = self.$begin())) ? ($ret_or_1) : ((inf)['$-@']()));
11265 if ($truthy($rb_gt(self.$step(), 0))) {
11272 $def(self, '$first', function $$first(count) {
11273 var self = this, iter = nil, $ret_or_1 = nil, out = nil;
11277 iter = ($truthy(($ret_or_1 = self.$begin())) ? ($ret_or_1) : ((inf)['$-@']()));
11279 return ($truthy(self['$_lesser_than_end?'](iter)) ? (iter) : (nil))
11282 …while ($truthy(($truthy(($ret_or_1 = self['$_lesser_than_end?'](iter))) ? ($rb_gt(count, 0)) : ($r…
11285 iter = $rb_plus(iter, self.$step());
11291 $def(self, '$each', function $$each() {
11292 var block = $$each.$$p || nil, self = this, $ret_or_1 = nil, iter = nil;
11298 return self
11300 if ($eqeqeq(nil, ($ret_or_1 = self.$begin()))) {
11305 iter = ($truthy(($ret_or_1 = self.$begin())) ? ($ret_or_1) : ((inf)['$-@']()));
11306 while ($truthy(self['$_lesser_than_end?'](iter))) {
11309 iter = $rb_plus(iter, self.$step());
11311 return self;
11314 $def(self, '$last', function $$last(count) {
11315 var self = this, $ret_or_1 = nil, iter = nil, out = nil;
11319 if (($eqeqeq(inf, ($ret_or_1 = self.$end())) || ($eqeqeq((inf)['$-@'](), $ret_or_1)))) {
11320 $Kernel.$raise($$$('FloatDomainError'), self.$end())
11326 iter = $rb_minus(self.$end(), $rb_minus(self.$end(), self.$begin())['$%'](self.$step()));
11327 if (!$truthy(self['$_lesser_than_end?'](iter))) {
11328 iter = $rb_minus(iter, self.$step())
11331 return ($truthy(self['$_greater_than_begin?'](iter)) ? (iter) : (nil))
11334 …while ($truthy(($truthy(($ret_or_1 = self['$_greater_than_begin?'](iter))) ? ($rb_gt(count, 0)) : …
11337 iter = $rb_minus(iter, self.$step());
11343 $def(self, '$size', function $$size() {
11344 var self = this, step_sign = nil, iter = nil;
11347 step_sign = ($truthy($rb_gt(self.$step(), 0)) ? (1) : (-1));
11348 if ($not(self['$_lesser_than_end?'](self.$begin()))) {
11350 } else if ($truthy([(inf)['$-@'](), inf]['$include?'](self.$step()))) {
11352 …@'](), step_sign), nil]['$include?'](self.$begin())) || ($truthy([$rb_times(inf, step_sign), nil][…
11356 iter = $rb_minus(self.$end(), $rb_minus(self.$end(), self.$begin())['$%'](self.$step()));
11357 if (!$truthy(self['$_lesser_than_end?'](iter))) {
11358 iter = $rb_minus(iter, self.$step())
11360 … return $rb_plus($rb_divide($rb_minus(iter, self.$begin()), self.$step()).$abs().$to_i(), 1);
11364 $def(self, '$==', function $ArithmeticSequence_$eq_eq$4(other) {
11365 var self = this, $ret_or_1 = nil, $ret_or_2 = nil, $ret_or_3 = nil, $ret_or_4 = nil;
11367 …self.$class()['$=='](other.$class()))) ? (self.$begin()['$=='](other.$begin())) : ($ret_or_4)))) ?…
11368 return self['$exclude_end?']()['$=='](other['$exclude_end?']())
11374 $def(self, '$hash', function $$hash() {
11375 var self = this;
11377 return [self.$begin(), self.$end(), self.$step(), self['$exclude_end?']()].$hash()
11380 $def(self, '$inspect', function $$inspect() {
11381 var self = this, args = nil;
11383 if ($truthy(self.receiver_num)) {
11385 …self.step_arg2) ? ("(" + (self.topfx) + (self.step_arg1.$inspect()) + ", " + (self.bypfx) + (self.…
11386 return "(" + (self.receiver_num.$inspect()) + "." + (self.creation_method) + (args) + ")";
11389 args = ($truthy(self.skipped_arg) ? (nil) : ("(" + (self.step) + ")"));
11390 return "((" + (self.range.$inspect()) + ")." + (self.creation_method) + (args) + ")";
11393 $alias(self, "===", "==");
11394 return $alias(self, "eql?", "==");
11395 })(self, self, $nesting)
11404 var self = $klass($base, $super, 'Enumerator');
11408 var self = $klass($base, $super, 'Chain');
11410 var $proto = self.$$prototype;
11415 $def(self, '$initialize', function $$initialize($a) {
11416 var $post_args, enums, self = this;
11421 $deny_frozen_access(self);
11422 self.enums = enums;
11423 self.iterated = [];
11424 return (self.object = self);
11427 $def(self, '$each', function $$each($a) {
11428 var block = $$each.$$p || nil, $post_args, args, self = this;
11436 …return $send(self, 'to_enum', ["each"].concat($to_a(args)), function $$1(){var self = $$1.$$s == n…
11438 return self.$size()}, {$$s: self})
11440 … $send(self.enums, 'each', [], function $$2(enum$){var self = $$2.$$s == null ? this : $$2.$$s;
11441 if (self.iterated == null) self.iterated = nil;
11445 self.iterated['$<<'](enum$);
11446 return $send(enum$, 'each', $to_a(args), block.$to_proc());}, {$$s: self});
11447 return self;
11450 $def(self, '$size', function $$size($a) {try { var $t_return = $thrower('return');
11451 var $post_args, args, self = this, accum = nil;
11457 $send(self.enums, 'each', [], function $$3(enum$){var size = nil;
11472 $def(self, '$rewind', function $$rewind() {
11473 var self = this;
11476 $send(self.iterated, 'reverse_each', [], function $$4(enum$){
11484 self.iterated = [];
11485 return self;
11487 return $def(self, '$inspect', function $$inspect() {
11488 var self = this;
11490 return "#<Enumerator::Chain: " + (self.enums.$inspect()) + ">"
11492 })(self, self)
11501 var self = $klass($base, $super, 'Enumerator');
11503 var $nesting = [self].concat($parent_nesting);
11506 var self = $klass($base, $super, 'Generator');
11508 … var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $proto = self.$$prototype;
11512 self.$include($$$('Enumerable'));
11514 $def(self, '$initialize', function $$initialize() {
11515 var block = $$initialize.$$p || nil, self = this;
11520 $deny_frozen_access(self);
11524 return (self.block = block);
11526 return $def(self, '$each', function $$each($a) {
11527 var block = $$each.$$p || nil, $post_args, args, self = this, yielder = nil;
11539 Opal.yieldX(self.block, args);
11550 return self;
11561 var self = $klass($base, $super, 'Enumerator');
11563 var $nesting = [self].concat($parent_nesting);
11566 var self = $klass($base, $super, 'Lazy');
11568 … var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $proto = self.$$prototype;
11572 $klass(self, $$$('Exception'), 'StopLazyError');
11573 $defs(self, '$for', function $Lazy_for$1(object, $a) {
11574 var $post_args, $fwd_rest, $yield = $Lazy_for$1.$$p || nil, self = this, lazy = nil;
11580 …lazy = $send2(self, $find_super(self, 'for', $Lazy_for$1, false, true), 'for', [object].concat($to…
11585 $def(self, '$initialize', function $$initialize(object, size) {
11586 var block = $$initialize.$$p || nil, self = this;
11592 $deny_frozen_access(self);
11596 self.enumerator = object;
11597 …return $send2(self, $find_super(self, 'initialize', $$initialize, false, true), 'initialize', [siz…
11623 $def(self, '$lazy', $return_self);
11625 $def(self, '$collect', function $$collect() {
11626 var block = $$collect.$$p || nil, self = this;
11634 …return $send($$('Lazy'), 'new', [self, self.$enumerator_size()], function $$4(enum$, $a){var $post…
11647 $def(self, '$collect_concat', function $$collect_concat() {
11648 var block = $$collect_concat.$$p || nil, self = this;
11656 return $send($$('Lazy'), 'new', [self, nil], function $$5(enum$, $a){var $post_args, args;
11687 $def(self, '$drop', function $$drop(n) {
11688 var self = this, current_size = nil, set_size = nil, dropped = nil;
11695 current_size = self.$enumerator_size();
11698 … return $send($$('Lazy'), 'new', [self, set_size], function $$8(enum$, $a){var $post_args, args;
11711 $def(self, '$drop_while', function $$drop_while() {
11712 var block = $$drop_while.$$p || nil, self = this, succeeding = nil;
11721 return $send($$('Lazy'), 'new', [self, nil], function $$9(enum$, $a){var $post_args, args;
11742 $def(self, '$enum_for', function $$enum_for($a, $b) {
11743 var block = $$enum_for.$$p || nil, $post_args, method, args, self = this;
11752 return $send(self.$class(), 'for', [self, method].concat($to_a(args)), block.$to_proc());
11755 $def(self, '$find_all', function $$find_all() {
11756 var block = $$find_all.$$p || nil, self = this;
11764 return $send($$('Lazy'), 'new', [self, nil], function $$10(enum$, $a){var $post_args, args;
11779 $def(self, '$grep', function $$grep(pattern) {
11780 var block = $$grep.$$p || nil, self = this;
11786 … return $send($$('Lazy'), 'new', [self, nil], function $$11(enum$, $a){var $post_args, args;
11803 … return $send($$('Lazy'), 'new', [self, nil], function $$12(enum$, $a){var $post_args, args;
11820 $def(self, '$reject', function $$reject() {
11821 var block = $$reject.$$p || nil, self = this;
11829 return $send($$('Lazy'), 'new', [self, nil], function $$13(enum$, $a){var $post_args, args;
11844 $def(self, '$take', function $$take(n) {
11845 var self = this, current_size = nil, set_size = nil, taken = nil;
11852 current_size = self.$enumerator_size();
11855 … return $send($$('Lazy'), 'new', [self, set_size], function $$14(enum$, $a){var $post_args, args;
11870 $def(self, '$take_while', function $$take_while() {
11871 var block = $$take_while.$$p || nil, self = this;
11879 return $send($$('Lazy'), 'new', [self, nil], function $$15(enum$, $a){var $post_args, args;
11897 $def(self, '$inspect', function $$inspect() {
11898 var self = this;
11900 return "#<" + (self.$class()) + ": " + (self.enumerator.$inspect()) + ">"
11902 $alias(self, "force", "to_a");
11903 $alias(self, "filter", "find_all");
11904 $alias(self, "flat_map", "collect_concat");
11905 $alias(self, "map", "collect");
11906 $alias(self, "select", "find_all");
11907 return $alias(self, "to_enum", "enum_for");
11908 })(self, self, $nesting)
11917 var self = $klass($base, $super, 'Enumerator');
11919 var $nesting = [self].concat($parent_nesting);
11922 var self = $klass($base, $super, 'Yielder');
11924 var $proto = self.$$prototype;
11929 $def(self, '$initialize', function $$initialize() {
11930 var block = $$initialize.$$p || nil, self = this;
11935 self.block = block;
11936 return self;
11939 $def(self, '$yield', function $Yielder_yield$1($a) {
11940 var $post_args, values, self = this;
11946 var value = Opal.yieldX(self.block, values);
11956 $def(self, '$<<', function $Yielder_$lt$lt$2(value) {
11957 var self = this;
11960 self.$yield(value);
11961 return self;
11963 return $def(self, '$to_proc', function $$to_proc() {
11964 var self = this;
11966 …return $send(self, 'proc', [], function $$3($a){var $post_args, values, self = $$3.$$s == null ? t…
11971 return $send(self, 'yield', $to_a(values));}, {$$arity: -1, $$s: self})
11978 …l.rb_ge, $Kernel = Opal.Kernel, $rb_le = Opal.rb_le, $alias = Opal.alias, self = Opal.top, $nestin…
11982 self.$require("corelib/enumerable");
11984 var self = $klass($base, $super, 'Enumerator');
11986 … var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $proto = self.$$prototype;
11990 self.$include($$$('Enumerable'));
11991 self.$$prototype.$$is_enumerator = true;
11992 $defs(self, '$for', function $Enumerator_for$1(object, $a, $b) {
11993 var block = $Enumerator_for$1.$$p || nil, $post_args, method, args, self = this;
12003 var obj = self.$allocate();
12015 $def(self, '$initialize', function $$initialize($a) {
12016 var block = $$initialize.$$p || nil, $post_args, $fwd_rest, self = this;
12023 $deny_frozen_access(self);
12024 self.cursor = 0;
12027 self.object = $send($$('Generator'), 'new', [], block.$to_proc());
12028 self.method = "each";
12029 self.args = [];
12030 self.size = arguments[0] || nil;
12031 if (($truthy(self.size) && ($not(self.size['$respond_to?']("call"))))) {
12032 return (self.size = $coerce_to(self.size, $$$('Integer'), 'to_int'))
12038 self.object = arguments[0];
12039 self.method = arguments[1] || "each";
12040 self.args = $slice(arguments, 2);
12041 return (self.size = nil);
12045 $def(self, '$each', function $$each($a) {
12046 var block = $$each.$$p || nil, $post_args, args, self = this;
12054 return self
12056 args = $rb_plus(self.args, args);
12058 return $send(self.$class(), 'new', [self.object, self.method].concat($to_a(args)))
12060 return $send(self.object, '__send__', [self.method].concat($to_a(args)), block.$to_proc());
12063 $def(self, '$size', function $$size() {
12064 var self = this;
12066 if ($truthy(self.size['$respond_to?']("call"))) {
12067 return $send(self.size, 'call', $to_a(self.args))
12069 return self.size
12073 $def(self, '$with_index', function $$with_index(offset) {
12074 var block = $$with_index.$$p || nil, self = this;
12082 …return $send(self, 'enum_for', ["with_index", offset], function $$2(){var self = $$2.$$s == null ?…
12084 return self.$size()}, {$$s: self})
12089 self.$each.$$p = function() {
12098 return self.$each();
12102 $def(self, '$each_with_index', function $$each_with_index() {
12103 var block = $$each_with_index.$$p || nil, self = this;
12109 …return $send(self, 'enum_for', ["each_with_index"], function $$3(){var self = $$3.$$s == null ? th…
12111 return self.$size()}, {$$s: self})
12113 …$send2(self, $find_super(self, 'each_with_index', $$each_with_index, false, true), 'each_with_inde…
12114 return self.object;
12117 $def(self, '$rewind', function $$rewind() {
12118 var self = this;
12121 self.cursor = 0;
12122 return self;
12125 $def(self, '$peek_values', function $$peek_values() {
12126 var self = this, $ret_or_1 = nil;
12129 …self.values = ($truthy(($ret_or_1 = self.values)) ? ($ret_or_1) : ($send(self, 'map', [], function…
12135 if ($truthy($rb_ge(self.cursor, self.values.$length()))) {
12138 return self.values['$[]'](self.cursor);
12141 $def(self, '$peek', function $$peek() {
12142 var self = this, values = nil;
12145 values = self.$peek_values();
12153 $def(self, '$next_values', function $$next_values() {
12154 var self = this, out = nil;
12157 out = self.$peek_values();
12158 self.cursor = $rb_plus(self.cursor, 1);
12162 $def(self, '$next', function $$next() {
12163 var self = this, values = nil;
12166 values = self.$next_values();
12174 $def(self, '$feed', function $$feed(arg) {
12175 var self = this;
12177 return self.$raise($$('NotImplementedError'), "Opal doesn't support Enumerator#feed")
12180 $def(self, '$+', function $Enumerator_$plus$5(other) {
12181 var self = this;
12183 return $$$($$$('Enumerator'), 'Chain').$new(self, other)
12186 $def(self, '$inspect', function $$inspect() {
12187 var self = this, result = nil;
12190 result = "#<" + (self.$class()) + ": " + (self.object.$inspect()) + ":" + (self.method);
12191 if ($truthy(self.args['$any?']())) {
12192 … result = $rb_plus(result, "(" + (self.args.$inspect()['$[]']($$$('Range').$new(1, -2))) + ")")
12196 $alias(self, "with_object", "each_with_object");
12197 self.$autoload("ArithmeticSequence", "corelib/enumerator/arithmetic_sequence");
12198 self.$autoload("Chain", "corelib/enumerator/chain");
12199 self.$autoload("Generator", "corelib/enumerator/generator");
12200 self.$autoload("Lazy", "corelib/enumerator/lazy");
12201 return self.$autoload("Yielder", "corelib/enumerator/yielder");
12206 …rb_le, $rb_plus = Opal.rb_plus, $rb_gt = Opal.rb_gt, $alias = Opal.alias, self = Opal.top, nil = O…
12210 self.$require("corelib/comparable");
12212 var self = $klass($base, $super, 'Numeric');
12216 self.$include($$$('Comparable'));
12218 $def(self, '$coerce', function $$coerce(other) {
12219 var self = this;
12222 if ($truthy(other['$instance_of?'](self.$class()))) {
12223 return [other, self]
12225 return [$Kernel.$Float(other), $Kernel.$Float(self)];
12228 $def(self, '$__coerced__', function $$__coerced__(method, other) {
12229 var $a, $b, self = this, a = nil, b = nil;
12233 …$b = other.$coerce(self), $a = $to_ary($b), (a = ($a[0] == null ? nil : $a[0])), (b = ($a[1] == nu…
12252 …return $Kernel.$raise($$$('ArgumentError'), "comparison of " + (self.$class()) + " with " + (other…
12258 $def(self, '$<=>', function $Numeric_$lt_eq_gt$1(other) {
12259 var self = this;
12262 if ($truthy(self['$equal?'](other))) {
12268 $def(self, '$+@', $return_self);
12270 $def(self, '$-@', function $Numeric_$minus$$2() {
12271 var self = this;
12273 return $rb_minus(0, self)
12276 $def(self, '$%', function $Numeric_$percent$3(other) {
12277 var self = this;
12279 return $rb_minus(self, $rb_times(other, self.$div(other)))
12282 $def(self, '$abs', function $$abs() {
12283 var self = this;
12285 if ($rb_lt(self, 0)) {
12286 return self['$-@']()
12288 return self
12292 $def(self, '$abs2', function $$abs2() {
12293 var self = this;
12295 return $rb_times(self, self)
12298 $def(self, '$angle', function $$angle() {
12299 var self = this;
12301 if ($rb_lt(self, 0)) {
12308 $def(self, '$ceil', function $$ceil(ndigits) {
12309 var self = this;
12313 return self.$to_f().$ceil(ndigits);
12316 $def(self, '$conj', $return_self);
12318 $def(self, '$denominator', function $$denominator() {
12319 var self = this;
12321 return self.$to_r().$denominator()
12324 $def(self, '$div', function $$div(other) {
12325 var self = this;
12331 return $rb_divide(self, other).$floor();
12334 $def(self, '$divmod', function $$divmod(other) {
12335 var self = this;
12337 return [self.$div(other), self['$%'](other)]
12340 $def(self, '$fdiv', function $$fdiv(other) {
12341 var self = this;
12343 return $rb_divide(self.$to_f(), other)
12346 $def(self, '$floor', function $$floor(ndigits) {
12347 var self = this;
12351 return self.$to_f().$floor(ndigits);
12354 $def(self, '$i', function $$i() {
12355 var self = this;
12357 return $Kernel.$Complex(0, self)
12360 $def(self, '$imag', $return_val(0));
12362 $def(self, '$integer?', $return_val(false));
12364 $def(self, '$nonzero?', function $Numeric_nonzero$ques$4() {
12365 var self = this;
12367 if ($truthy(self['$zero?']())) {
12370 return self
12374 $def(self, '$numerator', function $$numerator() {
12375 var self = this;
12377 return self.$to_r().$numerator()
12380 $def(self, '$polar', function $$polar() {
12381 var self = this;
12383 return [self.$abs(), self.$arg()]
12386 $def(self, '$quo', function $$quo(other) {
12387 var self = this;
12389 return $rb_divide($Opal['$coerce_to!'](self, $$$('Rational'), "to_r"), other)
12392 $def(self, '$real', $return_self);
12394 $def(self, '$real?', $return_val(true));
12396 $def(self, '$rect', function $$rect() {
12397 var self = this;
12399 return [self, 0]
12402 $def(self, '$round', function $$round(digits) {
12403 var self = this;
12407 return self.$to_f().$round(digits);
12410 $def(self, '$step', function $$step($a, $b, $c) {
12411 …var block = $$step.$$p || nil, $post_args, $kwargs, limit, step, to, by, self = this, counter = ni…
12471 $Opal.$compare(self, limit)
12475 if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
12481 … err = (abs(self) + abs(limit) + abs(limit - self)) / abs(step) * $$$($$$('Float'), 'EPSILON');
12490 return floor((limit - self) / step + err) + 1
12504 } else if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
12508 lhs = abs(self - limit) + 1,
12518 …equence').$new([limit, step, ($truthy(to) ? ("to: ") : nil), ($truthy(by) ? ("by: ") : nil)], self)
12520 return $send(self, 'enum_for', ["step", limit, step], (stepSize).$to_proc())
12531 if (self.$$is_number && step.$$is_number && limit.$$is_number) {
12532 if (self % 1 === 0 && (isInf || limit % 1 === 0) && step % 1 === 0) {
12533 var value = self;
12549 return self;
12551 var begin = self.$to_f().valueOf();
12565 var d = i * step + self;
12573 return self;
12577 counter = self;
12585 $def(self, '$to_c', function $$to_c() {
12586 var self = this;
12588 return $Kernel.$Complex(self, 0)
12591 $def(self, '$to_int', function $$to_int() {
12592 var self = this;
12594 return self.$to_i()
12597 $def(self, '$truncate', function $$truncate(ndigits) {
12598 var self = this;
12602 return self.$to_f().$truncate(ndigits);
12605 $def(self, '$zero?', function $Numeric_zero$ques$5() {
12606 var self = this;
12608 return self['$=='](0)
12611 $def(self, '$positive?', function $Numeric_positive$ques$6() {
12612 var self = this;
12614 return $rb_gt(self, 0)
12617 $def(self, '$negative?', function $Numeric_negative$ques$7() {
12618 var self = this;
12620 return $rb_lt(self, 0)
12623 $def(self, '$dup', $return_self);
12625 $def(self, '$clone', function $$clone($kwargs) {
12626 var freeze, self = this;
12632 return self;
12635 $def(self, '$finite?', $return_val(true));
12637 $def(self, '$infinite?', $return_val(nil));
12638 $alias(self, "arg", "angle");
12639 $alias(self, "conjugate", "conj");
12640 $alias(self, "imaginary", "imag");
12641 $alias(self, "magnitude", "abs");
12642 $alias(self, "modulo", "%");
12643 $alias(self, "phase", "arg");
12644 return $alias(self, "rectangular", "rect");
12649 …return_self = Opal.return_self, $neqeq = Opal.neqeq, $alias = Opal.alias, self = Opal.top, $nestin…
12653 self.$require("corelib/enumerable");
12654 self.$require("corelib/numeric");
12656 var self = $klass($base, $super, 'Array');
12658 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
12661 self.$include($$$('Enumerable'));
12662 Opal.prop(self.$$prototype, '$$is_array', true);
12697 function filterIf(self, filter, block) { argument
12698 var value, raised = null, updated = new Array(self.length);
12700 for (var i = 0, i2 = 0, length = self.length; i < length; i++) {
12703 value = $yield1(block, self[i])
12710 updated[i2] = self[i]
12716 self.splice.apply(self, [0, updated.length].concat(updated));
12717 self.splice(i2, updated.length);
12723 $defs(self, '$[]', function $Array_$$$1($a) {
12724 var $post_args, objects, self = this;
12729 return toArraySubclass(objects, self);;
12732 $def(self, '$initialize', function $$initialize(size, obj) {
12733 var block = $$initialize.$$p || nil, self = this;
12741 $deny_frozen_access(self);
12756 self.splice(0, self.length);
12757 return self;
12762 self.$replace(size.$to_a())
12763 return self;
12765 self.$replace(size.$to_ary())
12766 return self;
12776 self.splice(0, self.length);
12781 self.push(obj);
12787 self[i] = value;
12791 return self;
12794 $defs(self, '$try_convert', function $$try_convert(obj) {
12799 $def(self, '$&', function $Array_$$2(other) {
12800 var self = this;
12811 for (i = 0, length = self.length; i < length; i++) {
12812 item = self[i];
12822 $def(self, '$|', function $Array_$$3(other) {
12823 var self = this;
12830 for (i = 0, length = self.length; i < length; i++) {
12831 $hash_put(hash, self[i], true);
12842 $def(self, '$*', function $Array_$$4(other) {
12843 var self = this;
12847 return self.$join(other.$to_str())
12855 converted = self.$to_a();
12865 $def(self, '$+', function $Array_$plus$5(other) {
12866 var self = this;
12870 return self.concat(other);;
12873 $def(self, '$-', function $Array_$minus$6(other) {
12874 var self = this;
12878 if ($truthy(self.length === 0)) {
12882 return self.slice()
12891 for (i = 0, length = self.length; i < length; i++) {
12892 item = self[i];
12902 $def(self, '$<<', function $Array_$lt$lt$7(object) {
12903 var self = this;
12906 $deny_frozen_access(self);
12907 self.push(object);
12908 return self;
12911 $def(self, '$<=>', function $Array_$lt_eq_gt$8(other) {
12912 var self = this;
12923 if (self.$hash() === other.$hash()) {
12927 var count = Math.min(self.length, other.length);
12930 var tmp = (self[i])['$<=>'](other[i]);
12937 return (self.length)['$<=>'](other.length);
12941 $def(self, '$==', function $Array_$eq_eq$9(other) {
12942 var self = this;
12994 return _eqeq(self, other);
12998 function $array_slice_range(self, index) { argument
12999 var size = self.length,
13034 result = self.slice(from, to);
13038 function $array_slice_arithmetic_seq(self, index) { argument
13048 array = $array_slice_range(self, pseudorange).$reverse();
13051 array = $array_slice_range(self, index.range);
13062 function $array_slice_index_length(self, index, length) { argument
13063 var size = self.length,
13081 return self[index];
13090 result = self.slice(index, index + length);
13096 $def(self, '$[]', function $Array_$$$10(index, length) {
13097 var self = this;
13103 return $array_slice_range(self, index);
13106 return $array_slice_arithmetic_seq(self, index);
13109 return $array_slice_index_length(self, index, length);
13114 $def(self, '$[]=', function $Array_$$$eq$11(index, value, extra) {
13115 var self = this, data = nil, length = nil;
13119 $deny_frozen_access(self);
13122 var i, size = self.length;
13154 self[i] = nil;
13159 self.splice.apply(self, [from, 0].concat(data));
13162 self.splice.apply(self, [from, to - from].concat(data));
13191 …el.$raise($$$('IndexError'), "index " + (old) + " too small for array; minimum " + (-self.length));
13201 self[i] = nil;
13206 self[index] = value;
13209 self.splice.apply(self, [index, length].concat(data));
13217 $def(self, '$any?', function $Array_any$ques$12(pattern) {
13218 var block = $Array_any$ques$12.$$p || nil, self = this;
13224 if (self.length === 0) return false;
13225 …return $send2(self, $find_super(self, 'any?', $Array_any$ques$12, false, true), 'any?', [pattern],…
13228 $def(self, '$assoc', function $$assoc(object) {
13229 var self = this;
13232 for (var i = 0, length = self.length, item; i < length; i++) {
13233 if (item = self[i], item.length && (item[0])['$=='](object)) {
13242 $def(self, '$at', function $$at(index) {
13243 var self = this;
13249 index += self.length;
13252 if (index < 0 || index >= self.length) {
13256 return self[index];
13260 $def(self, '$bsearch_index', function $$bsearch_index() {
13261 var block = $$bsearch_index.$$p || nil, self = this;
13267 return self.$enum_for("bsearch_index")
13271 max = self.length,
13280 val = self[mid];
13305 $def(self, '$bsearch', function $$bsearch() {
13306 var block = $$bsearch.$$p || nil, self = this, index = nil;
13312 return self.$enum_for("bsearch")
13314 index = $send(self, 'bsearch_index', [], block.$to_proc());
13317 return self[index];
13324 $def(self, '$cycle', function $$cycle(n) {
13325 var block = $$cycle.$$p || nil, self = this;
13332 …return $send(self, 'enum_for', ["cycle", n], function $$13(){var self = $$13.$$s == null ? this : …
13340 return $rb_times(self.$enumerator_size(), n)
13344 }}, {$$s: self})
13346 if (($truthy(self['$empty?']()) || ($eqeq(n, 0)))) {
13354 for (i = 0, length = self.length; i < length; i++) {
13355 value = $yield1(block, self[i]);
13362 return self;
13366 for (i = 0, length = self.length; i < length; i++) {
13367 value = $yield1(block, self[i]);
13374 return self;
13377 $def(self, '$clear', function $$clear() {
13378 var self = this;
13381 $deny_frozen_access(self);
13382 self.splice(0, self.length);
13383 return self;
13386 $def(self, '$count', function $$count(object) {
13387 var block = $$count.$$p || nil, self = this;
13394 … return $send2(self, $find_super(self, 'count', $$count, false, true), 'count', [object], block)
13396 return self.$size()
13400 $def(self, '$initialize_copy', function $$initialize_copy(other) {
13401 var self = this;
13403 return self.$replace(other)
13406 $def(self, '$collect', function $$collect() {
13407 var block = $$collect.$$p || nil, self = this;
13413 …return $send(self, 'enum_for', ["collect"], function $$14(){var self = $$14.$$s == null ? this : $…
13415 return self.$size()}, {$$s: self})
13420 for (var i = 0, length = self.length; i < length; i++) {
13421 var value = $yield1(block, self[i]);
13429 $def(self, '$collect!', function $Array_collect$excl$15() {
13430 var block = $Array_collect$excl$15.$$p || nil, self = this;
13436 …return $send(self, 'enum_for', ["collect!"], function $$16(){var self = $$16.$$s == null ? this : …
13438 return self.$size()}, {$$s: self})
13441 $deny_frozen_access(self);
13443 for (var i = 0, length = self.length; i < length; i++) {
13444 var value = $yield1(block, self[i]);
13445 self[i] = value;
13448 return self;
13464 $def(self, '$combination', function $$combination(n) {
13465 var $yield = $$combination.$$p || nil, self = this, num = nil;
13471 …return $send(self, 'enum_for', ["combination", num], function $$17(){var self = $$17.$$s == null ?…
13473 return binomial_coefficient(self.length, num)}, {$$s: self})
13481 for (i = 0, length = self.length; i < length; i++) {
13482 Opal.yield1($yield, [self[i]])
13485 else if (num === self.length) {
13486 Opal.yield1($yield, self.slice())
13488 else if (num >= 0 && num < self.length) {
13500 chosen[lev] = self[stack[lev+1]];
13504 chosen[lev] = self[next];
13512 } while ( stack[lev+1] + num === self.length + lev + 1 );
13516 return self;
13519 $def(self, '$repeated_combination', function $$repeated_combination(n) {
13520 var $yield = $$repeated_combination.$$p || nil, self = this, num = nil;
13526 …return $send(self, 'enum_for', ["repeated_combination", num], function $$18(){var self = $$18.$$s …
13528 return binomial_coefficient(self.length + num - 1, num);}, {$$s: self})
13531 function iterate(max, from, buffer, self) { argument
13537 for (var i = from; i < self.length; i++) {
13538 buffer.push(self[i]);
13539 iterate(max, i, buffer, self);
13545 iterate(num, 0, [], self);
13548 return self;
13551 $def(self, '$compact', function $$compact() {
13552 var self = this;
13557 for (var i = 0, length = self.length, item; i < length; i++) {
13558 if ((item = self[i]) !== nil) {
13567 $def(self, '$compact!', function $Array_compact$excl$19() {
13568 var self = this;
13571 $deny_frozen_access(self);
13573 var original = self.length;
13575 for (var i = 0, length = self.length; i < length; i++) {
13576 if (self[i] === nil) {
13577 self.splice(i, 1);
13584 return self.length === original ? nil : self;
13588 $def(self, '$concat', function $$concat($a) {
13589 var $post_args, others, self = this;
13594 $deny_frozen_access(self);
13595 …others = $send(others, 'map', [], function $$20(other){var self = $$20.$$s == null ? this : $$20.$…
13600 if ($truthy(other['$equal?'](self))) {
13603 return other;}, {$$s: self});
13604 $send(others, 'each', [], function $$21(other){var self = $$21.$$s == null ? this : $$21.$$s;
13610 self.push(other[i]);
13612 ;}, {$$s: self});
13613 return self;
13616 $def(self, '$delete', function $Array_delete$22(object) {
13617 var $yield = $Array_delete$22.$$p || nil, self = this;
13621 var original = self.length;
13624 if ((self[i])['$=='](object)) {
13625 $deny_frozen_access(self);
13627 self.splice(i, 1);
13634 if (self.length === original) {
13644 $def(self, '$delete_at', function $$delete_at(index) {
13645 var self = this;
13648 $deny_frozen_access(self);
13653 index += self.length;
13656 if (index < 0 || index >= self.length) {
13660 var result = self[index];
13662 self.splice(index, 1);
13668 $def(self, '$delete_if', function $$delete_if() {
13669 var block = $$delete_if.$$p || nil, self = this;
13675 …return $send(self, 'enum_for', ["delete_if"], function $$23(){var self = $$23.$$s == null ? this :…
13677 return self.$size()}, {$$s: self})
13680 $deny_frozen_access(self);
13682 filterIf(self, $falsy, block)
13684 return self;
13687 $def(self, '$difference', function $$difference($a) {
13688 var $post_args, arrays, self = this;
13693 return $send(arrays, 'reduce', [self.$to_a().$dup()], function $$24(a, b){
13700 $def(self, '$dig', function $$dig(idx, $a) {
13701 var $post_args, idxs, self = this, item = nil;
13706 item = self['$[]'](idx);
13718 $def(self, '$drop', function $$drop(number) {
13719 var self = this;
13728 return self.slice(number);
13732 $def(self, '$dup', function $$dup() {
13733 var $yield = $$dup.$$p || nil, self = this;
13738 if (self.$$class === Opal.Array &&
13739 self.$$class.$allocate.$$pristine &&
13740 self.$copy_instance_variables.$$pristine &&
13741 self.$initialize_dup.$$pristine) {
13742 return self.slice(0);
13745 return $send2(self, $find_super(self, 'dup', $$dup, false, true), 'dup', [], $yield);
13748 $def(self, '$each', function $$each() {
13749 var block = $$each.$$p || nil, self = this;
13755 …return $send(self, 'enum_for', ["each"], function $$25(){var self = $$25.$$s == null ? this : $$25…
13757 return self.$size()}, {$$s: self})
13760 for (var i = 0, length = self.length; i < length; i++) {
13761 var value = $yield1(block, self[i]);
13764 return self;
13767 $def(self, '$each_index', function $$each_index() {
13768 var block = $$each_index.$$p || nil, self = this;
13774 …return $send(self, 'enum_for', ["each_index"], function $$26(){var self = $$26.$$s == null ? this …
13776 return self.$size()}, {$$s: self})
13779 for (var i = 0, length = self.length; i < length; i++) {
13783 return self;
13786 $def(self, '$empty?', function $Array_empty$ques$27() {
13787 var self = this;
13789 return self.length === 0;
13792 $def(self, '$eql?', function $Array_eql$ques$28(other) {
13793 var self = this;
13835 return _eql(self, other);
13839 $def(self, '$fetch', function $$fetch(index, defaults) {
13840 var block = $$fetch.$$p || nil, self = this;
13852 index += self.length;
13855 if (index >= 0 && index < self.length) {
13856 return self[index];
13860 self.$warn("warning: block supersedes default value argument")
13871 if (self.length === 0) {
13875 …r'), "index " + (original) + " outside of array bounds: -" + (self.length) + "..." + (self.length)…
13880 $def(self, '$fill', function $$fill($a) {
13881 …var block = $$fill.$$p || nil, $post_args, args, $b, $c, self = this, one = nil, two = nil, obj = …
13889 $deny_frozen_access(self);
13928 return self
13943 return self
13957 self[i] = nil;
13968 self[left] = value;
13974 self[left] = obj;
13978 return self;
13981 $def(self, '$first', function $$first(count) {
13982 var self = this;
13988 return self.length === 0 ? nil : self[0];
13997 return self.slice(0, count);
14001 $def(self, '$flatten', function $$flatten(level) {
14002 var self = this;
14033 if (ary === self) {
14055 return _flatten(self, level);
14059 $def(self, '$flatten!', function $Array_flatten$excl$29(level) {
14060 var self = this;
14065 $deny_frozen_access(self);
14067 var flattened = self.$flatten(level);
14069 if (self.length == flattened.length) {
14070 for (var i = 0, length = self.length; i < length; i++) {
14071 if (self[i] !== flattened[i]) {
14081 self.$replace(flattened);
14083 return self;
14086 $def(self, '$freeze', function $$freeze() {
14087 var self = this;
14090 if ($truthy(self['$frozen?']())) {
14091 return self
14093 return $freeze(self);;
14096 $def(self, '$hash', function $$hash() {
14097 var self = this;
14102 hash_id = self.$object_id(),
14117 if (self['$eql?'](item)) {
14122 $hash_ids[hash_id] = self;
14124 for (i = 0; i < self.length; i++) {
14125 item = self[i];
14138 $def(self, '$include?', function $Array_include$ques$30(member) {
14139 var self = this;
14142 for (var i = 0, length = self.length; i < length; i++) {
14143 if ((self[i])['$=='](member)) {
14152 $def(self, '$index', function $$index(object) {
14153 var block = $$index.$$p || nil, self = this;
14163 self.$warn("warning: given block not used")
14167 for (i = 0, length = self.length; i < length; i++) {
14168 if ((self[i])['$=='](object)) {
14174 for (i = 0, length = self.length; i < length; i++) {
14175 value = block(self[i]);
14183 return self.$enum_for("index");
14190 $def(self, '$insert', function $$insert(index, $a) {
14191 var $post_args, objects, self = this;
14197 $deny_frozen_access(self);
14203 index += self.length + 1;
14209 if (index > self.length) {
14210 for (var i = self.length; i < index; i++) {
14211 self.push(nil);
14215 self.splice.apply(self, [index, 0].concat(objects));
14218 return self;
14222 $def(self, '$inspect', function $$inspect() {
14223 var self = this;
14228 id = self.$__id__(),
14241 for (var i = 0, length = self.length; i < length; i++) {
14242 var item = self['$[]'](i);
14255 $def(self, '$intersection', function $$intersection($a) {
14256 var $post_args, arrays, self = this;
14261 return $send(arrays, 'reduce', [self.$to_a().$dup()], function $$31(a, b){
14268 $def(self, '$intersect?', function $Array_intersect$ques$32(other) {
14269 var self = this;
14271 return self.$intersection(other)['$empty?']()['$!']()
14274 $def(self, '$join', function $$join(sep) {
14275 var self = this;
14280 if ($truthy(self.length === 0)) {
14290 for (i = 0, length = self.length; i < length; i++) {
14291 item = self[i];
14306 if (tmp === self) {
14327 …$Kernel.$raise($$$('NoMethodError').$new("" + ($$('Opal').$inspect(self.$item())) + " doesn't resp…
14339 $def(self, '$keep_if', function $$keep_if() {
14340 var block = $$keep_if.$$p || nil, self = this;
14346 …return $send(self, 'enum_for', ["keep_if"], function $$33(){var self = $$33.$$s == null ? this : $…
14348 return self.$size()}, {$$s: self})
14351 $deny_frozen_access(self);
14353 filterIf(self, $truthy, block)
14355 return self;
14358 $def(self, '$last', function $$last(count) {
14359 var self = this;
14365 return self.length === 0 ? nil : self[self.length - 1];
14374 if (count > self.length) {
14375 count = self.length;
14378 return self.slice(self.length - count, self.length);
14382 $def(self, '$length', function $$length() {
14383 var self = this;
14385 return self.length;
14388 $def(self, '$max', function $$max(n) {
14389 var block = $$max.$$p || nil, self = this;
14395 return $send(self.$each(), 'max', [n], block.$to_proc());
14398 $def(self, '$min', function $$min() {
14399 var block = $$min.$$p || nil, self = this;
14404 return $send(self.$each(), 'min', [], block.$to_proc());
14419 $def(self, '$permutation', function $$permutation(num) {
14420 var block = $$permutation.$$p || nil, self = this, perm = nil, used = nil;
14427 …return $send(self, 'enum_for', ["permutation", num], function $$34(){var self = $$34.$$s == null ?…
14429 … return descending_factorial(self.length, num === undefined ? self.length : num);}, {$$s: self})
14435 num = self.length;
14441 if (num < 0 || self.length < num) {
14450 for (var i = 0; i < self.length; i++) {
14451 Opal.yield1(block, [self[i]])
14457 (used = $$('Array').$new(self.length, false));
14460 self = this;
14461 for(var i = 0; i < self.length; i++){
14466 permute.call(self, num, perm, index + 1, used, blk);
14472 output.push(self[perm[j]]);
14482 offensive = self.slice();
14486 permute.call(self, num, perm, 0, used, block);
14490 return self;
14493 $def(self, '$repeated_permutation', function $$repeated_permutation(n) {
14494 var $yield = $$repeated_permutation.$$p || nil, self = this, num = nil;
14500 …return $send(self, 'enum_for', ["repeated_permutation", num], function $$35(){var self = $$35.$$s …
14503 return self.$size()['$**'](num)
14506 }}, {$$s: self})
14509 function iterate(max, buffer, self) { argument
14515 for (var i = 0; i < self.length; i++) {
14516 buffer.push(self[i]);
14517 iterate(max, buffer, self);
14522 iterate(num, [], self.slice());
14524 return self;
14527 $def(self, '$pop', function $$pop(count) {
14528 var self = this;
14532 $deny_frozen_access(self);
14535 if ($truthy(self.length === 0)) {
14538 return self.pop();
14544 if ($truthy(self.length === 0)) {
14548 return [self.pop()];
14549 } else if ($truthy(count > self.length)) {
14550 return self.splice(0, self.length);
14552 return self.splice(self.length - count, self.length);
14556 $def(self, '$product', function $$product($a) {
14557 var block = $$product.$$p || nil, $post_args, args, self = this;
14572 arrays[0] = self;
14580 return result || self;
14609 return result || self;
14613 $def(self, '$push', function $$push($a) {
14614 var $post_args, objects, self = this;
14620 $deny_frozen_access(self);
14623 self.push(objects[i]);
14626 return self;
14629 $def(self, '$rassoc', function $$rassoc(object) {
14630 var self = this;
14633 for (var i = 0, length = self.length, item; i < length; i++) {
14634 item = self[i];
14647 $def(self, '$reject', function $$reject() {
14648 var block = $$reject.$$p || nil, self = this;
14654 …return $send(self, 'enum_for', ["reject"], function $$36(){var self = $$36.$$s == null ? this : $$…
14656 return self.$size()}, {$$s: self})
14661 for (var i = 0, length = self.length, value; i < length; i++) {
14662 value = block(self[i]);
14665 result.push(self[i]);
14672 $def(self, '$reject!', function $Array_reject$excl$37() {
14673 var block = $Array_reject$excl$37.$$p || nil, self = this, original = nil;
14679 …return $send(self, 'enum_for', ["reject!"], function $$38(){var self = $$38.$$s == null ? this : $…
14681 return self.$size()}, {$$s: self})
14683 $deny_frozen_access(self);
14684 original = self.$length();
14685 $send(self, 'delete_if', [], block.$to_proc());
14686 if ($eqeq(self.$length(), original)) {
14689 return self
14693 $def(self, '$replace', function $$replace(other) {
14694 var self = this;
14697 $deny_frozen_access(self);
14700 self.splice(0, self.length);
14701 self.push.apply(self, other);
14703 return self;
14706 $def(self, '$reverse', function $$reverse() {
14707 var self = this;
14709 return self.slice(0).reverse();
14712 $def(self, '$reverse!', function $Array_reverse$excl$39() {
14713 var self = this;
14716 $deny_frozen_access(self);
14717 return self.reverse();;
14720 $def(self, '$reverse_each', function $$reverse_each() {
14721 var block = $$reverse_each.$$p || nil, self = this;
14727 …return $send(self, 'enum_for', ["reverse_each"], function $$40(){var self = $$40.$$s == null ? thi…
14729 return self.$size()}, {$$s: self})
14731 $send(self.$reverse(), 'each', [], block.$to_proc());
14732 return self;
14735 $def(self, '$rindex', function $$rindex(object) {
14736 var block = $$rindex.$$p || nil, self = this;
14746 self.$warn("warning: given block not used")
14750 for (i = self.length - 1; i >= 0; i--) {
14751 if (i >= self.length) {
14754 if ((self[i])['$=='](object)) {
14760 for (i = self.length - 1; i >= 0; i--) {
14761 if (i >= self.length) {
14765 value = block(self[i]);
14773 return self.$enum_for("rindex");
14780 $def(self, '$rotate', function $$rotate(n) {
14781 var self = this;
14790 if (self.length === 1) {
14791 return self.slice();
14793 if (self.length === 0) {
14797 ary = self.slice();
14806 $def(self, '$rotate!', function $Array_rotate$excl$41(cnt) {
14807 var self = this, ary = nil;
14812 $deny_frozen_access(self);
14814 if (self.length === 0 || self.length === 1) {
14815 return self;
14819 ary = self.$rotate(cnt);
14820 return self.$replace(ary);
14823 var self = $klass($base, $super, 'SampleRandom');
14825 var $proto = self.$$prototype;
14830 $def(self, '$initialize', $assign_ivar("rng"));
14831 return $def(self, '$rand', function $$rand(size) {
14832 var self = this, random = nil;
14835 random = $coerce_to(self.rng.$rand(size), $$$('Integer'), 'to_int');
14844 })(self, null);
14846 $def(self, '$sample', function $$sample(count, options) {
14847 var self = this, o = nil, rng = nil;
14853 return self.$at($Kernel.$rand(self.length))
14878 return self[rng.$rand(self.length)]
14884 if (count > self.length) {
14885 count = self.length;
14893 return [self[rng.$rand(self.length)]];
14896 i = rng.$rand(self.length);
14897 j = rng.$rand(self.length - 1);
14901 return [self[i], self[j]];
14904 if (self.length / count > 3) {
14911 result[0] = rng.$rand(self.length);
14913 k = rng.$rand(self.length);
14923 k = rng.$rand(self.length);
14940 result[i] = self[result[i]];
14948 result = self.slice();
14951 targetIndex = rng.$rand(self.length - c) + c;
14957 return count === self.length ? result : (result)['$[]'](0, count);
14962 $def(self, '$select', function $$select() {
14963 var block = $$select.$$p || nil, self = this;
14969 …return $send(self, 'enum_for', ["select"], function $$42(){var self = $$42.$$s == null ? this : $$…
14971 return self.$size()}, {$$s: self})
14976 for (var i = 0, length = self.length, item, value; i < length; i++) {
14977 item = self[i];
14990 $def(self, '$select!', function $Array_select$excl$43() {
14991 var block = $Array_select$excl$43.$$p || nil, self = this;
14997 …return $send(self, 'enum_for', ["select!"], function $$44(){var self = $$44.$$s == null ? this : $…
14999 return self.$size()}, {$$s: self})
15002 $deny_frozen_access(self)
15004 var original = self.length;
15005 $send(self, 'keep_if', [], block.$to_proc());
15006 return self.length === original ? nil : self;
15010 $def(self, '$shift', function $$shift(count) {
15011 var self = this;
15015 $deny_frozen_access(self);
15018 if ($truthy(self.length === 0)) {
15021 return shiftNoArg(self);
15027 if ($truthy(self.length === 0)) {
15030 return self.splice(0, count);;
15033 $def(self, '$shuffle', function $$shuffle(rng) {
15034 var self = this;
15038 return self.$dup().$to_a()['$shuffle!'](rng);
15041 $def(self, '$shuffle!', function $Array_shuffle$excl$45(rng) {
15042 var self = this;
15047 $deny_frozen_access(self);
15049 var randgen, i = self.length, j, tmp;
15076 j = self.$rand(i);
15079 tmp = self[--i];
15080 self[i] = self[j];
15081 self[j] = tmp;
15084 return self;
15088 $def(self, '$slice!', function $Array_slice$excl$46(index, length) {
15089 var self = this, result = nil, range = nil, range_start = nil, range_end = nil, start = nil;
15093 $deny_frozen_access(self);
15099 result = self['$[]'](range);
15104 range_start += self.length;
15108 range_end += self.length;
15109 } else if (range_end >= self.length) {
15110 range_end = self.length - 1;
15123 …if (range_start < self.length && range_start >= 0 && range_end < self.length && range_end >= 0 && …
15124 self.splice(range_start, range_length);
15132 start += self.length;
15135 if (start < 0 || start >= self.length) {
15139 result = self[start];
15142 self.shift();
15144 self.splice(start, 1);
15159 result = self['$[]'](start, length);
15162 start += self.length;
15165 if (start + length > self.length) {
15166 length = self.length - start;
15169 if (start < self.length && start >= 0) {
15170 self.splice(start, length);
15177 $def(self, '$sort', function $$sort() {
15178 var block = $$sort.$$p || nil, self = this;
15183 if (!$truthy(self.length > 1)) {
15184 return self
15193 return self.slice().sort(function(x, y) {
15205 $def(self, '$sort!', function $Array_sort$excl$47() {
15206 var block = $Array_sort$excl$47.$$p || nil, self = this;
15212 $deny_frozen_access(self)
15217 result = $send((self.slice()), 'sort', [], block.$to_proc());
15220 result = (self.slice()).$sort();
15223 self.length = 0;
15225 self.push(result[i]);
15228 return self;
15232 $def(self, '$sort_by!', function $Array_sort_by$excl$48() {
15233 var block = $Array_sort_by$excl$48.$$p || nil, self = this;
15239 …return $send(self, 'enum_for', ["sort_by!"], function $$49(){var self = $$49.$$s == null ? this : …
15241 return self.$size()}, {$$s: self})
15243 $deny_frozen_access(self);
15244 return self.$replace($send(self, 'sort_by', [], block.$to_proc()));
15247 $def(self, '$take', function $$take(count) {
15248 var self = this;
15255 return self.slice(0, count);
15259 $def(self, '$take_while', function $$take_while() {
15260 var block = $$take_while.$$p || nil, self = this;
15268 for (var i = 0, length = self.length, item, value; i < length; i++) {
15269 item = self[i];
15284 $def(self, '$to_a', function $$to_a() {
15285 var self = this;
15288 if (self.$$class === Opal.Array) {
15289 return self;
15292 return Opal.Array.$new(self);
15297 $def(self, '$to_ary', $return_self);
15299 $def(self, '$to_h', function $$to_h() {
15300 var block = $$to_h.$$p || nil, self = this, array = nil;
15305 array = self;
15329 $def(self, '$transpose', function $$transpose() {
15330 var self = this, result = nil, max = nil;
15333 if ($truthy(self['$empty?']())) {
15338 $send(self, 'each', [], function $$50(row){var $ret_or_1 = nil;
15356 $def(self, '$union', function $$union($a) {
15357 var $post_args, arrays, self = this;
15362 return $send(arrays, 'reduce', [self.$uniq()], function $$52(a, b){
15369 $def(self, '$uniq', function $$uniq() {
15370 var block = $$uniq.$$p || nil, self = this;
15379 for (i = 0, length = self.length; i < length; i++) {
15380 item = self[i];
15387 for (i = 0, length = self.length; i < length; i++) {
15388 item = self[i];
15400 $def(self, '$uniq!', function $Array_uniq$excl$53() {
15401 var block = $Array_uniq$excl$53.$$p || nil, self = this;
15407 $deny_frozen_access(self);
15409 var original_length = self.length, hash = $hash2([], {}), i, length, item, key;
15412 item = self[i];
15420 self.splice(i, 1);
15425 return self.length === original_length ? nil : self;
15429 $def(self, '$unshift', function $$unshift($a) {
15430 var $post_args, objects, self = this;
15436 $deny_frozen_access(self);
15438 var selfLength = self.length
15440 if (objectsLength == 0) return self;
15443 self.push(self[index + i])
15447 self[len] = self[len - objectsLength]
15451 self[j] = objects[j]
15453 return self;
15457 $def(self, '$values_at', function $$values_at($a) {
15458 var $post_args, args, self = this, out = nil;
15464 …$send(args, 'each', [], function $$54(elem){var self = $$54.$$s == null ? this : $$54.$$s, finish …
15474 start = start + self.length;
15480 finish = finish + self.length;
15489 …return $send(start, 'upto', [finish], function $$55(i){var self = $$55.$$s == null ? this : $$55.$…
15493 return out['$<<'](self.$at(i));}, {$$s: self});
15497 return out['$<<'](self.$at(i));
15498 };}, {$$s: self});
15502 $def(self, '$zip', function $$zip($a) {
15503 var block = $$zip.$$p || nil, $post_args, others, self = this, $ret_or_1 = nil;
15511 var result = [], size = self.length, part, o, i, j, jj;
15526 part = [self[i]];
15552 $defs(self, '$inherited', function $$inherited(klass) {
15561 $def(self, '$instance_variables', function $$instance_variables() {
15562 var $yield = $$instance_variables.$$p || nil, self = this;
15565 …return $send($send2(self, $find_super(self, 'instance_variables', $$instance_variables, false, tru…
15576 $def(self, '$pack', function $$pack($a) {
15584 $alias(self, "append", "push");
15585 $alias(self, "filter", "select");
15586 $alias(self, "filter!", "select!");
15587 $alias(self, "map", "collect");
15588 $alias(self, "map!", "collect!");
15589 $alias(self, "prepend", "unshift");
15590 $alias(self, "size", "length");
15591 $alias(self, "slice", "[]");
15592 $alias(self, "to_s", "inspect");
15593 $Opal.$pristine(self.$singleton_class(), "allocate");
15594 return $Opal.$pristine(self, "copy_instance_variables", "initialize_dup");
15599 … $to_a = Opal.to_a, $return_self = Opal.return_self, $alias = Opal.alias, self = Opal.top, $nestin…
15603 self.$require("corelib/enumerable");
15605 var self = $klass($base, $super, 'Hash');
15607 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
15610 self.$include($$$('Enumerable'));
15611 self.$$prototype.$$is_hash = true;
15612 $defs(self, '$[]', function $Hash_$$$1($a) {
15613 var $post_args, argv, self = this;
15624 return self.$allocate()['$merge!'](hash);
15633 hash = self.$allocate();
15656 hash = self.$allocate();
15665 $defs(self, '$allocate', function $$allocate() {
15666 var self = this;
15669 var hash = new self.$$constructor();
15679 $defs(self, '$try_convert', function $$try_convert(obj) {
15684 $def(self, '$initialize', function $$initialize(defaults) {
15685 var block = $$initialize.$$p || nil, self = this;
15692 $deny_frozen_access(self);
15697 self.$$none = (defaults === undefined ? nil : defaults);
15698 self.$$proc = block;
15700 return self;
15704 $def(self, '$==', function $Hash_$eq_eq$2(other) {
15705 var self = this;
15708 if (self === other) {
15716 if (self.$$keys.length !== other.$$keys.length) {
15720 …for (var i = 0, keys = self.$$keys, length = keys.length, key, value, other_value; i < length; i++…
15724 value = self.$$smap[key];
15740 $def(self, '$>=', function $Hash_$gt_eq$3(other) {
15741 var self = this, result = nil;
15746 if (self.$$keys.length < other.$$keys.length) {
15751 …$send(other, 'each', [], function $$4(other_key, other_val){var self = $$4.$$s == null ? this : $$…
15756 val = self.$fetch(other_key, null);
15762 ;}, {$$s: self});
15766 $def(self, '$>', function $Hash_$gt$5(other) {
15767 var self = this;
15772 if (self.$$keys.length <= other.$$keys.length) {
15776 return $rb_ge(self, other);
15779 $def(self, '$<', function $Hash_$lt$6(other) {
15780 var self = this;
15784 return $rb_gt(other, self);
15787 $def(self, '$<=', function $Hash_$lt_eq$7(other) {
15788 var self = this;
15792 return $rb_ge(other, self);
15795 $def(self, '$[]', function $Hash_$$$8(key) {
15796 var self = this;
15799 var value = $hash_get(self, key);
15805 return self.$default(key);
15809 $def(self, '$[]=', function $Hash_$$$eq$9(key, value) {
15810 var self = this;
15813 $deny_frozen_access(self);
15815 $hash_put(self, key, value);
15820 $def(self, '$assoc', function $$assoc(object) {
15821 var self = this;
15824 for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
15829 return [key, self.$$smap[key]];
15842 $def(self, '$clear', function $$clear() {
15843 var self = this;
15846 $deny_frozen_access(self);
15848 $hash_init(self);
15849 return self;
15853 $def(self, '$clone', function $$clone() {
15854 var self = this;
15857 var hash = new self.$$class();
15860 Opal.hash_clone(self, hash);
15866 $def(self, '$compact', function $$compact() {
15867 var self = this;
15872 for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
15876 value = self.$$smap[key];
15891 $def(self, '$compact!', function $Hash_compact$excl$10() {
15892 var self = this;
15895 $deny_frozen_access(self);
15899 for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
15903 value = self.$$smap[key];
15910 if ($hash_delete(self, key) !== undefined) {
15918 return changes_were_made ? self : nil;
15922 $def(self, '$compare_by_identity', function $$compare_by_identity() {
15923 var self = this;
15926 $deny_frozen_access(self);
15928 var i, ii, key, keys = self.$$keys, identity_hash;
15930 if (self.$$by_identity) return self;
15931 if (self.$$keys.length === 0) {
15932 self.$$by_identity = true field
15933 return self;
15940 $hash_put(identity_hash, key, $hash_get(self, key));
15943 self.$$by_identity = true;
15944 self.$$map = identity_hash.$$map;
15945 self.$$smap = identity_hash.$$smap;
15946 return self;
15950 $def(self, '$compare_by_identity?', function $Hash_compare_by_identity$ques$11() {
15951 var self = this;
15953 return self.$$by_identity === true;
15956 $def(self, '$default', function $Hash_default$12(key) {
15957 var self = this;
15962 if (key !== undefined && self.$$proc !== nil && self.$$proc !== undefined) {
15963 return self.$$proc.$call(self, key);
15965 if (self.$$none === undefined) {
15968 return self.$$none;
15972 $def(self, '$default=', function $Hash_default$eq$13(object) {
15973 var self = this;
15976 $deny_frozen_access(self);
15978 self.$$proc = nil;
15979 self.$$none = object;
15985 $def(self, '$default_proc', function $$default_proc() {
15986 var self = this;
15989 if (self.$$proc !== undefined) {
15990 return self.$$proc;
15996 $def(self, '$default_proc=', function $Hash_default_proc$eq$14(default_proc) {
15997 var self = this;
16000 $deny_frozen_access(self);
16012 self.$$none = nil;
16013 self.$$proc = proc;
16019 $def(self, '$delete', function $Hash_delete$15(key) {
16020 var block = $Hash_delete$15.$$p || nil, self = this;
16026 $deny_frozen_access(self);
16027 var value = $hash_delete(self, key);
16041 $def(self, '$delete_if', function $$delete_if() {
16042 var block = $$delete_if.$$p || nil, self = this;
16048 …return $send(self, 'enum_for', ["delete_if"], function $$16(){var self = $$16.$$s == null ? this :…
16050 return self.$size()}, {$$s: self})
16053 $deny_frozen_access(self);
16055 for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
16059 value = self.$$smap[key];
16068 if ($hash_delete(self, key) !== undefined) {
16075 return self;
16079 $def(self, '$dig', function $$dig(key, $a) {
16080 var $post_args, keys, self = this, item = nil;
16085 item = self['$[]'](key);
16097 $def(self, '$each', function $$each() {
16098 var block = $$each.$$p || nil, self = this;
16104 …return $send(self, 'enum_for', ["each"], function $$17(){var self = $$17.$$s == null ? this : $$17…
16106 return self.$size()}, {$$s: self})
16109 … for (var i = 0, keys = self.$$keys.slice(), length = keys.length, key, value; i < length; i++) {
16113 value = self.$$smap[key];
16122 return self;
16126 $def(self, '$each_key', function $$each_key() {
16127 var block = $$each_key.$$p || nil, self = this;
16133 …return $send(self, 'enum_for', ["each_key"], function $$18(){var self = $$18.$$s == null ? this : …
16135 return self.$size()}, {$$s: self})
16138 for (var i = 0, keys = self.$$keys.slice(), length = keys.length, key; i < length; i++) {
16144 return self;
16148 $def(self, '$each_value', function $$each_value() {
16149 var block = $$each_value.$$p || nil, self = this;
16155 …return $send(self, 'enum_for', ["each_value"], function $$19(){var self = $$19.$$s == null ? this …
16157 return self.$size()}, {$$s: self})
16160 for (var i = 0, keys = self.$$keys.slice(), length = keys.length, key; i < length; i++) {
16163 block(key.$$is_string ? self.$$smap[key] : key.value);
16166 return self;
16170 $def(self, '$empty?', function $Hash_empty$ques$20() {
16171 var self = this;
16173 return self.$$keys.length === 0;
16176 $def(self, '$except', function $$except($a) {
16177 var $post_args, keys, self = this;
16182 return $send(self.$dup(), 'except!', $to_a(keys));
16185 $def(self, '$except!', function $Hash_except$excl$21($a) {
16186 var $post_args, keys, self = this;
16191 $send(keys, 'each', [], function $$22(key){var self = $$22.$$s == null ? this : $$22.$$s;
16195 return self.$delete(key);}, {$$s: self});
16196 return self;
16199 $def(self, '$fetch', function $$fetch(key, defaults) {
16200 var block = $$fetch.$$p || nil, self = this;
16207 var value = $hash_get(self, key);
16221 …key not found: " + (key.$inspect()), $hash2(["key", "receiver"], {"key": key, "receiver": self})));
16224 $def(self, '$fetch_values', function $$fetch_values($a) {
16225 var block = $$fetch_values.$$p || nil, $post_args, keys, self = this;
16232 … return $send(keys, 'map', [], function $$23(key){var self = $$23.$$s == null ? this : $$23.$$s;
16236 return $send(self, 'fetch', [key], block.$to_proc());}, {$$s: self});
16239 $def(self, '$flatten', function $$flatten(level) {
16240 var self = this;
16248 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
16252 value = self.$$smap[key];
16277 $def(self, '$freeze', function $$freeze() {
16278 var self = this;
16281 if ($truthy(self['$frozen?']())) {
16282 return self
16284 return $freeze(self);;
16287 $def(self, '$has_key?', function $Hash_has_key$ques$24(key) {
16288 var self = this;
16290 return $hash_get(self, key) !== undefined;
16293 $def(self, '$has_value?', function $Hash_has_value$ques$25(value) {
16294 var self = this;
16297 for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
16300 if (((key.$$is_string ? self.$$smap[key] : key.value))['$=='](value)) {
16309 $def(self, '$hash', function $$hash() {
16310 var self = this;
16314 hash_id = self.$object_id(),
16329 if (self['$eql?'](item)) {
16334 Opal.hash_ids[hash_id] = self;
16336 for (var i = 0, keys = self.$$keys, length = keys.length; i < length; i++) {
16340 result.push([key, self.$$smap[key].$hash()]);
16356 $def(self, '$index', function $$index(object) {
16357 var self = this;
16360 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
16364 value = self.$$smap[key];
16379 $def(self, '$indexes', function $$indexes($a) {
16380 var $post_args, args, self = this;
16390 value = $hash_get(self, key);
16393 result.push(self.$default());
16405 $def(self, '$inspect', function $$inspect() {
16406 var self = this;
16411 hash_id = self.$object_id(),
16428 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
16432 value = self.$$smap[key];
16452 $def(self, '$invert', function $$invert() {
16453 var self = this;
16458 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
16462 value = self.$$smap[key];
16475 $def(self, '$keep_if', function $$keep_if() {
16476 var block = $$keep_if.$$p || nil, self = this;
16482 …return $send(self, 'enum_for', ["keep_if"], function $$26(){var self = $$26.$$s == null ? this : $…
16484 return self.$size()}, {$$s: self})
16487 $deny_frozen_access(self);
16489 for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
16493 value = self.$$smap[key];
16502 if ($hash_delete(self, key) !== undefined) {
16509 return self;
16513 $def(self, '$keys', function $$keys() {
16514 var self = this;
16519 for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
16533 $def(self, '$length', function $$length() {
16534 var self = this;
16536 return self.$$keys.length;
16539 $def(self, '$merge', function $$merge($a) {
16540 var block = $$merge.$$p || nil, $post_args, others, self = this;
16547 return $send(self.$dup(), 'merge!', $to_a(others), block.$to_proc());
16550 $def(self, '$merge!', function $Hash_merge$excl$27($a) {
16551 var block = $Hash_merge$excl$27.$$p || nil, $post_args, others, self = this;
16559 $deny_frozen_access(self);
16576 $hash_put(self, key, other_value);
16589 value = $hash_get(self, key);
16592 $hash_put(self, key, other_value);
16596 $hash_put(self, key, block(key, value, other_value));
16601 return self;
16605 $def(self, '$rassoc', function $$rassoc(object) {
16606 var self = this;
16609 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
16613 value = self.$$smap[key];
16628 $def(self, '$rehash', function $$rehash() {
16629 var self = this;
16632 $deny_frozen_access(self);
16633 Opal.hash_rehash(self);
16634 return self;
16638 $def(self, '$reject', function $$reject() {
16639 var block = $$reject.$$p || nil, self = this;
16645 …return $send(self, 'enum_for', ["reject"], function $$28(){var self = $$28.$$s == null ? this : $$…
16647 return self.$size()}, {$$s: self})
16652 for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
16656 value = self.$$smap[key];
16673 $def(self, '$reject!', function $Hash_reject$excl$29() {
16674 var block = $Hash_reject$excl$29.$$p || nil, self = this;
16680 …return $send(self, 'enum_for', ["reject!"], function $$30(){var self = $$30.$$s == null ? this : $…
16682 return self.$size()}, {$$s: self})
16685 $deny_frozen_access(self);
16689 for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
16693 value = self.$$smap[key];
16702 if ($hash_delete(self, key) !== undefined) {
16710 return changes_were_made ? self : nil;
16714 $def(self, '$replace', function $$replace(other) {
16715 var self = this;
16718 $deny_frozen_access(self);;
16721 $hash_init(self);
16733 $hash_put(self, key, other_value);
16737 self['$default_proc='](other.$default_proc())
16739 self['$default='](other.$default())
16741 return self;
16744 $def(self, '$select', function $$select() {
16745 var block = $$select.$$p || nil, self = this;
16751 …return $send(self, 'enum_for', ["select"], function $$31(){var self = $$31.$$s == null ? this : $$…
16753 return self.$size()}, {$$s: self})
16758 for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
16762 value = self.$$smap[key];
16779 $def(self, '$select!', function $Hash_select$excl$32() {
16780 var block = $Hash_select$excl$32.$$p || nil, self = this;
16786 …return $send(self, 'enum_for', ["select!"], function $$33(){var self = $$33.$$s == null ? this : $…
16788 return self.$size()}, {$$s: self})
16791 $deny_frozen_access(self);
16795 for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
16799 value = self.$$smap[key];
16808 if ($hash_delete(self, key) !== undefined) {
16812 result = self;
16820 $def(self, '$shift', function $$shift() {
16821 var self = this;
16824 $deny_frozen_access(self);
16825 var keys = self.$$keys,
16833 return [key, $hash_delete(self, key)];
16840 $def(self, '$slice', function $$slice($a) {
16841 var $post_args, keys, self = this;
16850 var key = keys[i], value = $hash_get(self, key);
16861 $def(self, '$to_a', function $$to_a() {
16862 var self = this;
16867 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
16871 value = self.$$smap[key];
16884 $def(self, '$to_h', function $$to_h() {
16885 var block = $$to_h.$$p || nil, self = this;
16891 return $send(self, 'map', [], block.$to_proc()).$to_h()
16894 if (self.$$class === Opal.Hash) {
16895 return self;
16901 Opal.hash_clone(self, hash);
16907 $def(self, '$to_hash', $return_self);
16909 $def(self, '$to_proc', function $$to_proc() {
16910 var self = this;
16912 … return $send(self, 'proc', [], function $$34(key){var self = $$34.$$s == null ? this : $$34.$$s;
16921 return self['$[]'](key);}, {$$arity: -1, $$s: self})
16924 $def(self, '$transform_keys', function $$transform_keys() {
16925 var block = $$transform_keys.$$p || nil, self = this;
16931 …return $send(self, 'enum_for', ["transform_keys"], function $$35(){var self = $$35.$$s == null ? t…
16933 return self.$size()}, {$$s: self})
16938 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
16942 value = self.$$smap[key];
16957 $def(self, '$transform_keys!', function $Hash_transform_keys$excl$36() {
16958 var block = $Hash_transform_keys$excl$36.$$p || nil, self = this;
16964 …return $send(self, 'enum_for', ["transform_keys!"], function $$37(){var self = $$37.$$s == null ? …
16966 return self.$size()}, {$$s: self})
16969 $deny_frozen_access(self);
16971 var keys = Opal.slice(self.$$keys),
16978 value = self.$$smap[key];
16986 $hash_delete(self, key);
16987 $hash_put(self, new_key, value);
16990 return self;
16994 $def(self, '$transform_values', function $$transform_values() {
16995 var block = $$transform_values.$$p || nil, self = this;
17001 …return $send(self, 'enum_for', ["transform_values"], function $$38(){var self = $$38.$$s == null ?…
17003 return self.$size()}, {$$s: self})
17008 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
17012 value = self.$$smap[key];
17027 $def(self, '$transform_values!', function $Hash_transform_values$excl$39() {
17028 var block = $Hash_transform_values$excl$39.$$p || nil, self = this;
17034 …return $send(self, 'enum_for', ["transform_values!"], function $$40(){var self = $$40.$$s == null …
17036 return self.$size()}, {$$s: self})
17039 $deny_frozen_access(self);
17041 for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
17045 value = self.$$smap[key];
17053 $hash_put(self, key, value);
17056 return self;
17060 $def(self, '$values', function $$values() {
17061 var self = this;
17066 for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
17070 result.push(self.$$smap[key]);
17079 $alias(self, "dup", "clone");
17080 $alias(self, "each_pair", "each");
17081 $alias(self, "eql?", "==");
17082 $alias(self, "filter", "select");
17083 $alias(self, "filter!", "select!");
17084 $alias(self, "include?", "has_key?");
17085 $alias(self, "indices", "indexes");
17086 $alias(self, "key", "index");
17087 $alias(self, "key?", "has_key?");
17088 $alias(self, "member?", "has_key?");
17089 $alias(self, "size", "length");
17090 $alias(self, "store", "[]=");
17091 $alias(self, "to_s", "inspect");
17092 $alias(self, "update", "merge!");
17093 $alias(self, "value?", "has_value?");
17094 return $alias(self, "values_at", "indexes");
17099 …= Opal.rb_ge, $return_val = Opal.return_val, $const_set = Opal.const_set, self = Opal.top, $nestin…
17103 self.$require("corelib/numeric");
17105 var self = $klass($base, $super, 'Number');
17107 var $nesting = [self].concat($parent_nesting);
17110 $Opal.$bridge(Number, self);
17111 Opal.prop(self.$$prototype, '$$is_number', true);
17112 self.$$is_number_class = true;
17113 (function(self, $parent_nesting) { argument
17117 $def(self, '$allocate', function $$allocate() {
17118 var self = this;
17120 return $Kernel.$raise($$$('TypeError'), "allocator undefined for " + (self.$name()))
17124 Opal.udef(self, '$' + "new");;
17126 })(Opal.get_singleton_class(self), $nesting);
17128 $def(self, '$coerce', function $$coerce(other) {
17129 var self = this;
17136 return [$Kernel.$Float(other), self];
17139 return [$Opal['$coerce_to!'](other, $$$('Float'), "to_f"), self];
17142 return [other, self];
17150 $def(self, '$__id__', function $$__id__() {
17151 var self = this;
17153 return (self * 2) + 1;
17156 $def(self, '$+', function $Number_$plus$1(other) {
17157 var self = this;
17161 return self + other;
17164 return self.$__coerced__("+", other);
17169 $def(self, '$-', function $Number_$minus$2(other) {
17170 var self = this;
17174 return self - other;
17177 return self.$__coerced__("-", other);
17182 $def(self, '$*', function $Number_$$3(other) {
17183 var self = this;
17187 return self * other;
17190 return self.$__coerced__("*", other);
17195 $def(self, '$/', function $Number_$slash$4(other) {
17196 var self = this;
17200 return self / other;
17203 return self.$__coerced__("/", other);
17208 $def(self, '$%', function $Number_$percent$5(other) {
17209 var self = this;
17219 else if (other < 0 || self < 0) {
17220 return (self % other + other) % other;
17223 return self % other;
17227 return self.$__coerced__("%", other);
17232 $def(self, '$&', function $Number_$$6(other) {
17233 var self = this;
17237 return self & other;
17240 return self.$__coerced__("&", other);
17245 $def(self, '$|', function $Number_$$7(other) {
17246 var self = this;
17250 return self | other;
17253 return self.$__coerced__("|", other);
17258 $def(self, '$^', function $Number_$$8(other) {
17259 var self = this;
17263 return self ^ other;
17266 return self.$__coerced__("^", other);
17271 $def(self, '$<', function $Number_$lt$9(other) {
17272 var self = this;
17276 return self < other;
17279 return self.$__coerced__("<", other);
17284 $def(self, '$<=', function $Number_$lt_eq$10(other) {
17285 var self = this;
17289 return self <= other;
17292 return self.$__coerced__("<=", other);
17297 $def(self, '$>', function $Number_$gt$11(other) {
17298 var self = this;
17302 return self > other;
17305 return self.$__coerced__(">", other);
17310 $def(self, '$>=', function $Number_$gt_eq$12(other) {
17311 var self = this;
17315 return self >= other;
17318 return self.$__coerced__(">=", other);
17323 var spaceship_operator = function(self, other) { argument
17325 if (isNaN(self) || isNaN(other)) {
17329 if (self > other) {
17331 } else if (self < other) {
17338 return self.$__coerced__("<=>", other);
17343 $def(self, '$<=>', function $Number_$lt_eq_gt$13(other) {
17344 var self = this;
17347 return spaceship_operator(self, other);
17357 $def(self, '$<<', function $Number_$lt$lt$14(count) {
17358 var self = this;
17362 return count > 0 ? self << count : self >> -count;
17365 $def(self, '$>>', function $Number_$gt$gt$15(count) {
17366 var self = this;
17370 return count > 0 ? self >> count : self << -count;
17373 $def(self, '$[]', function $Number_$$$16(bit) {
17374 var self = this;
17383 return self < 0 ? 1 : 0;
17385 return (self >> bit) & 1;
17389 $def(self, '$+@', function $Number_$plus$$17() {
17390 var self = this;
17392 return +self;
17395 $def(self, '$-@', function $Number_$minus$$18() {
17396 var self = this;
17398 return -self;
17401 $def(self, '$~', function $Number_$$19() {
17402 var self = this;
17404 return ~self;
17407 $def(self, '$**', function $Number_$$$20(other) {
17408 var self = this;
17411 if (($not($$$('Integer')['$==='](self)) || ($truthy($rb_gt(other, 0))))) {
17412 return Math.pow(self, other);
17414 return $$$('Rational').$new(self, 1)['$**'](other)
17416 …} else if (($rb_lt(self, 0) && (($eqeqeq($$$('Float'), other) || ($eqeqeq($$$('Rational'), other))…
17417 return $$$('Complex').$new(self, 0)['$**'](other.$to_f())
17419 return Math.pow(self, other);
17421 return self.$__coerced__("**", other)
17425 $def(self, '$==', function $Number_$eq_eq$21(other) {
17426 var self = this;
17430 return self.valueOf() === other.valueOf();
17433 return other['$=='](self);
17440 $alias(self, "===", "==");
17442 $def(self, '$abs', function $$abs() {
17443 var self = this;
17445 return Math.abs(self);
17448 $def(self, '$abs2', function $$abs2() {
17449 var self = this;
17451 return Math.abs(self * self);
17454 $def(self, '$allbits?', function $Number_allbits$ques$22(mask) {
17455 var self = this;
17459 return (self & mask) == mask;;
17462 $def(self, '$anybits?', function $Number_anybits$ques$23(mask) {
17463 var self = this;
17467 return (self & mask) !== 0;;
17470 $def(self, '$angle', function $$angle() {
17471 var self = this;
17474 if ($truthy(self['$nan?']())) {
17475 return self
17478 if (self == 0) {
17479 if (1 / self > 0) {
17486 else if (self < 0) {
17495 $def(self, '$bit_length', function $$bit_length() {
17496 var self = this;
17499 if (!$eqeqeq($$$('Integer'), self)) {
17500 …$Kernel.$raise($$$('NoMethodError').$new("undefined method `bit_length` for " + (self) + ":Float",…
17503 if (self === 0 || self === -1) {
17508 value = self < 0 ? ~self : self;
17519 $def(self, '$ceil', function $$ceil(ndigits) {
17520 var self = this;
17525 var f = self.$to_f();
17542 $def(self, '$chr', function $$chr(encoding) {
17543 var self = this;
17547 return Opal.enc(String.fromCharCode(self), encoding || "BINARY");;
17550 $def(self, '$denominator', function $$denominator() {
17551 var $yield = $$denominator.$$p || nil, self = this;
17554 if (($truthy(self['$nan?']()) || ($truthy(self['$infinite?']())))) {
17557 …return $send2(self, $find_super(self, 'denominator', $$denominator, false, true), 'denominator', […
17561 $def(self, '$downto', function $$downto(stop) {
17562 var block = $$downto.$$p || nil, self = this;
17568 …return $send(self, 'enum_for', ["downto", stop], function $$24(){var self = $$24.$$s == null ? thi…
17572 …$Kernel.$raise($$$('ArgumentError'), "comparison of " + (self.$class()) + " with " + (stop.$class(…
17574 if ($truthy($rb_gt(stop, self))) {
17577 return $rb_plus($rb_minus(self, stop), 1)
17578 };}, {$$s: self})
17582 …$Kernel.$raise($$$('ArgumentError'), "comparison of " + (self.$class()) + " with " + (stop.$class(…
17584 for (var i = self; i >= stop; i--) {
17588 return self;
17591 $def(self, '$equal?', function $Number_equal$ques$25(other) {
17592 var self = this, $ret_or_1 = nil;
17594 if ($truthy(($ret_or_1 = self['$=='](other)))) {
17597 return isNaN(self) && isNaN(other);
17601 $def(self, '$even?', function $Number_even$ques$26() {
17602 var self = this;
17604 return self % 2 === 0;
17607 $def(self, '$floor', function $$floor(ndigits) {
17608 var self = this;
17613 var f = self.$to_f();
17630 $def(self, '$gcd', function $$gcd(other) {
17631 var self = this;
17638 var min = Math.abs(self),
17652 $def(self, '$gcdlcm', function $$gcdlcm(other) {
17653 var self = this;
17655 return [self.$gcd(other), self.$lcm(other)]
17658 $def(self, '$integer?', function $Number_integer$ques$27() {
17659 var self = this;
17661 return self % 1 === 0;
17664 $def(self, '$is_a?', function $Number_is_a$ques$28(klass) {
17665 var $yield = $Number_is_a$ques$28.$$p || nil, self = this;
17669 if (($eqeq(klass, $$$('Integer')) && ($eqeqeq($$$('Integer'), self)))) {
17672 if (($eqeq(klass, $$$('Integer')) && ($eqeqeq($$$('Integer'), self)))) {
17675 if (($eqeq(klass, $$$('Float')) && ($eqeqeq($$$('Float'), self)))) {
17678 …return $send2(self, $find_super(self, 'is_a?', $Number_is_a$ques$28, false, true), 'is_a?', [klass…
17681 $def(self, '$instance_of?', function $Number_instance_of$ques$29(klass) {
17682 var $yield = $Number_instance_of$ques$29.$$p || nil, self = this;
17686 if (($eqeq(klass, $$$('Integer')) && ($eqeqeq($$$('Integer'), self)))) {
17689 if (($eqeq(klass, $$$('Integer')) && ($eqeqeq($$$('Integer'), self)))) {
17692 if (($eqeq(klass, $$$('Float')) && ($eqeqeq($$$('Float'), self)))) {
17695 …return $send2(self, $find_super(self, 'instance_of?', $Number_instance_of$ques$29, false, true), '…
17698 $def(self, '$lcm', function $$lcm(other) {
17699 var self = this;
17706 if (self == 0 || other == 0) {
17710 return Math.abs(self * other / self.$gcd(other));
17715 $def(self, '$next', function $$next() {
17716 var self = this;
17718 return self + 1;
17721 $def(self, '$nobits?', function $Number_nobits$ques$30(mask) {
17722 var self = this;
17726 return (self & mask) == 0;;
17729 $def(self, '$nonzero?', function $Number_nonzero$ques$31() {
17730 var self = this;
17732 return self == 0 ? nil : self;
17735 $def(self, '$numerator', function $$numerator() {
17736 var $yield = $$numerator.$$p || nil, self = this;
17739 if (($truthy(self['$nan?']()) || ($truthy(self['$infinite?']())))) {
17740 return self
17742 …return $send2(self, $find_super(self, 'numerator', $$numerator, false, true), 'numerator', [], $yi…
17746 $def(self, '$odd?', function $Number_odd$ques$32() {
17747 var self = this;
17749 return self % 2 !== 0;
17752 $def(self, '$ord', $return_self);
17754 $def(self, '$pow', function $$pow(b, m) {
17755 var self = this;
17760 if (self == 0) {
17765 return self['$**'](b);
17783 return self['$**'](b)['$%'](m)
17788 $def(self, '$pred', function $$pred() {
17789 var self = this;
17791 return self - 1;
17794 $def(self, '$quo', function $$quo(other) {
17795 var $yield = $$quo.$$p || nil, self = this;
17798 if ($eqeqeq($$$('Integer'), self)) {
17799 return $send2(self, $find_super(self, 'quo', $$quo, false, true), 'quo', [other], $yield)
17801 return $rb_divide(self, other)
17805 $def(self, '$rationalize', function $$rationalize(eps) {
17806 var $a, $b, self = this, f = nil, n = nil;
17815 if ($eqeqeq($$$('Integer'), self)) {
17816 return $$$('Rational').$new(self, 1)
17817 } else if ($truthy(self['$infinite?']())) {
17819 } else if ($truthy(self['$nan?']())) {
17823 …$b = $$$('Math').$frexp(self), $a = $to_ary($b), (f = ($a[0] == null ? nil : $a[0])), (n = ($a[1] …
17828 return self.$to_r().$rationalize(eps)
17832 $def(self, '$remainder', function $$remainder(y) {
17833 var self = this;
17835 return $rb_minus(self, $rb_times(y, $rb_divide(self, y).$truncate()))
17838 $def(self, '$round', function $$round(ndigits) {
17839 var $a, $b, self = this, _ = nil, exp = nil;
17843 if ($eqeqeq($$$('Integer'), self)) {
17846 return self
17856 return self
17860 if (0.415241 * ndigits - 0.125 > self.$size()) {
17865 x = Math.floor((Math.abs(self) + f / 2) / f) * f;
17867 return self < 0 ? -x : x;
17871 if (($truthy(self['$nan?']()) && ($truthy(ndigits == null)))) {
17876 if ($truthy(self['$nan?']())) {
17878 } else if ($truthy(self['$infinite?']())) {
17882 return Math.round(self)
17883 } else if (($truthy(self['$nan?']()) || ($truthy(self['$infinite?']())))) {
17884 return self
17886 …$b = $$$('Math').$frexp(self), $a = $to_ary($b), (_ = ($a[0] == null ? nil : $a[0])), (exp = ($a[1…
17888 return self
17893 return Math.round(self * Math.pow(10, ndigits)) / Math.pow(10, ndigits);;
17897 $def(self, '$times', function $$times() {
17898 var block = $$times.$$p || nil, self = this;
17904 …return $send(self, 'enum_for', ["times"], function $$33(){var self = $$33.$$s == null ? this : $$3…
17906 return self}, {$$s: self})
17909 for (var i = 0; i < self; i++) {
17913 return self;
17916 $def(self, '$to_f', $return_self);
17918 $def(self, '$to_i', function $$to_i() {
17919 var self = this;
17921 return self < 0 ? Math.ceil(self) : Math.floor(self);
17924 $def(self, '$to_r', function $$to_r() {
17925 var $a, $b, self = this, f = nil, e = nil;
17927 if ($eqeqeq($$$('Integer'), self)) {
17928 return $$$('Rational').$new(self, 1)
17931 …$b = $$$('Math').$frexp(self), $a = $to_ary($b), (f = ($a[0] == null ? nil : $a[0])), (e = ($a[1] …
17938 $def(self, '$to_s', function $$to_s(base) {
17939 var self = this;
17947 if (($eqeq(self, 0) && ($truthy(1/self === -Infinity)))) {
17950 return self.toString(base);;
17953 $def(self, '$truncate', function $$truncate(ndigits) {
17954 var self = this;
17959 var f = self.$to_f();
17976 $def(self, '$digits', function $$digits(base) {
17977 var self = this;
17981 if ($rb_lt(self, 0)) {
17989 …if (self != parseInt(self)) $Kernel.$raise($$$('NoMethodError'), "undefined method `digits' for " …
17991 var value = self, result = [];
17993 if (self == 0) {
18006 $def(self, '$divmod', function $$divmod(other) {
18007 var $yield = $$divmod.$$p || nil, self = this;
18010 if (($truthy(self['$nan?']()) || ($truthy(other['$nan?']())))) {
18012 } else if ($truthy(self['$infinite?']())) {
18015 … return $send2(self, $find_super(self, 'divmod', $$divmod, false, true), 'divmod', [other], $yield)
18019 $def(self, '$upto', function $$upto(stop) {
18020 var block = $$upto.$$p || nil, self = this;
18026 …return $send(self, 'enum_for', ["upto", stop], function $$34(){var self = $$34.$$s == null ? this …
18030 …$Kernel.$raise($$$('ArgumentError'), "comparison of " + (self.$class()) + " with " + (stop.$class(…
18032 if ($truthy($rb_lt(stop, self))) {
18035 return $rb_plus($rb_minus(stop, self), 1)
18036 };}, {$$s: self})
18040 …$Kernel.$raise($$$('ArgumentError'), "comparison of " + (self.$class()) + " with " + (stop.$class(…
18042 for (var i = self; i <= stop; i++) {
18046 return self;
18049 $def(self, '$zero?', function $Number_zero$ques$35() {
18050 var self = this;
18052 return self == 0;
18055 $def(self, '$size', $return_val(4));
18057 $def(self, '$nan?', function $Number_nan$ques$36() {
18058 var self = this;
18060 return isNaN(self);
18063 $def(self, '$finite?', function $Number_finite$ques$37() {
18064 var self = this;
18066 return self != Infinity && self != -Infinity && !isNaN(self);
18069 $def(self, '$infinite?', function $Number_infinite$ques$38() {
18070 var self = this;
18073 if (self == Infinity) {
18076 else if (self == -Infinity) {
18085 $def(self, '$positive?', function $Number_positive$ques$39() {
18086 var self = this;
18088 return self != 0 && (self == Infinity || 1 / self > 0);
18091 $def(self, '$negative?', function $Number_negative$ques$40() {
18092 var self = this;
18094 return self == -Infinity || 1 / self < 0;
18134 $def(self, '$next_float', function $$next_float() {
18135 var self = this;
18138 if ($eqeq(self, $$$($$$('Float'), 'INFINITY'))) {
18141 if ($truthy(self['$nan?']())) {
18144 if ($rb_ge(self, 0)) {
18145 return incrementNumberBit(Math.abs(self));
18147 return decrementNumberBit(self);
18151 $def(self, '$prev_float', function $$prev_float() {
18152 var self = this;
18155 if ($eqeq(self, $$$($$$('Float'), 'INFINITY')['$-@']())) {
18158 if ($truthy(self['$nan?']())) {
18161 if ($rb_gt(self, 0)) {
18162 return decrementNumberBit(self);
18164 return -incrementNumberBit(Math.abs(self));
18167 $alias(self, "arg", "angle");
18168 $alias(self, "eql?", "==");
18169 $alias(self, "fdiv", "/");
18170 $alias(self, "inspect", "to_s");
18171 $alias(self, "kind_of?", "is_a?");
18172 $alias(self, "magnitude", "abs");
18173 $alias(self, "modulo", "%");
18174 $alias(self, "object_id", "__id__");
18175 $alias(self, "phase", "angle");
18176 $alias(self, "succ", "next");
18177 return $alias(self, "to_int", "to_i");
18181 var self = $klass($base, $super, 'Integer');
18183 var $nesting = [self].concat($parent_nesting);
18186 self.$$is_number_class = true;
18187 self.$$is_integer_class = true;
18188 (function(self, $parent_nesting) { argument
18189 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
18193 $def(self, '$allocate', function $$allocate() {
18194 var self = this;
18196 return $Kernel.$raise($$$('TypeError'), "allocator undefined for " + (self.$name()))
18199 Opal.udef(self, '$' + "new");;
18201 $def(self, '$sqrt', function $$sqrt(n) {
18213 return $def(self, '$try_convert', function $$try_convert(object) {
18214 var self = this;
18216 return $$('Opal')['$coerce_to?'](object, self, "to_int")
18218 })(Opal.get_singleton_class(self), $nesting);
18219 $const_set(self, 'MAX', Math.pow(2, 30) - 1);
18220 return $const_set(self, 'MIN', -Math.pow(2, 30));
18223 var self = $klass($base, $super, 'Float');
18225 var $nesting = [self].concat($parent_nesting);
18228 self.$$is_number_class = true;
18229 (function(self, $parent_nesting) { argument
18233 $def(self, '$allocate', function $$allocate() {
18234 var self = this;
18236 return $Kernel.$raise($$$('TypeError'), "allocator undefined for " + (self.$name()))
18239 Opal.udef(self, '$' + "new");;
18240 return $def(self, '$===', function $eq_eq_eq$41(other) {
18244 })(Opal.get_singleton_class(self), $nesting);
18245 $const_set(self, 'INFINITY', Infinity);
18246 $const_set(self, 'MAX', Number.MAX_VALUE);
18247 $const_set(self, 'MIN', Number.MIN_VALUE);
18248 $const_set(self, 'NAN', NaN);
18249 $const_set(self, 'DIG', 15);
18250 $const_set(self, 'MANT_DIG', 53);
18251 $const_set(self, 'RADIX', 2);
18252 return $const_set(self, 'EPSILON', Number.EPSILON || 2.2204460492503130808472633361816E-16);
18257 …times, $rb_ge = Opal.rb_ge, $thrower = Opal.thrower, $alias = Opal.alias, self = Opal.top, $nestin…
18261 self.$require("corelib/enumerable");
18263 var self = $klass($base, $super, 'Range');
18265 … var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $proto = self.$$prototype;
18269 self.$include($$$('Enumerable'));
18270 self.$$prototype.$$is_range = true;
18271 self.$attr_reader("begin", "end");
18273 $def(self, '$initialize', function $$initialize(first, last, exclude) {
18274 var self = this;
18278 if ($truthy(self.begin)) {
18284 self.begin = first;
18285 self.end = last;
18286 return (self.excl = exclude);
18289 $def(self, '$===', function $Range_$eq_eq_eq$1(value) {
18290 var self = this;
18292 return self['$include?'](value)
18295 function is_infinite(self) { argument
18296 if (self.begin === nil || self.end === nil ||
18297 self.begin === -Infinity || self.end === Infinity ||
18298 self.begin === Infinity || self.end === -Infinity) return true;
18303 $def(self, '$count', function $$count() {
18304 var block = $$count.$$p || nil, self = this;
18309 if (($not((block !== nil)) && ($truthy(is_infinite(self))))) {
18312 return $send2(self, $find_super(self, 'count', $$count, false, true), 'count', [], block);
18315 $def(self, '$to_a', function $$to_a() {
18316 var $yield = $$to_a.$$p || nil, self = this;
18320 if ($truthy(is_infinite(self))) {
18323 return $send2(self, $find_super(self, 'to_a', $$to_a, false, true), 'to_a', [], $yield);
18326 $def(self, '$cover?', function $Range_cover$ques$2(value) {
18327 … var self = this, beg_cmp = nil, $ret_or_1 = nil, $ret_or_2 = nil, $ret_or_3 = nil, end_cmp = nil;
18330 …truthy(($ret_or_2 = ($truthy(($ret_or_3 = self.begin['$nil?']())) ? (-1) : ($ret_or_3)))) ? ($ret_…
18331 …(($ret_or_2 = ($truthy(($ret_or_3 = self.end['$nil?']())) ? (-1) : ($ret_or_3)))) ? ($ret_or_2) : …
18332 …if ($truthy(($ret_or_1 = ($truthy(($ret_or_2 = ($truthy(self.excl) ? (($truthy(($ret_or_3 = end_cm…
18339 $def(self, '$each', function $$each() {
18340 var block = $$each.$$p || nil, self = this, current = nil, last = nil, $ret_or_1 = nil;
18346 …return $send(self, 'enum_for', ["each"], function $$3(){var self = $$3.$$s == null ? this : $$3.$$…
18348 return self.$size()}, {$$s: self})
18353 if (self.begin.$$is_number && self.end.$$is_number) {
18354 if (self.begin % 1 !== 0 || self.end % 1 !== 0) {
18358 for (i = self.begin, limit = self.end + ($truthy(self.excl) ? (0) : (1)); i < limit; i++) {
18362 return self;
18365 if (self.begin.$$is_string && self.end.$$is_string) {
18366 $send(self.begin, 'upto', [self.end, self.excl], block.$to_proc())
18367 return self;
18370 current = self.begin;
18371 last = self.end;
18375 …while ($truthy(($truthy(($ret_or_1 = self.end['$nil?']())) ? ($ret_or_1) : ($rb_lt(current['$<=>']…
18380 if (($not(self.excl) && ($eqeq(current, last)))) {
18383 return self;
18386 $def(self, '$eql?', function $Range_eql$ques$4(other) {
18387 var self = this, $ret_or_1 = nil, $ret_or_2 = nil;
18393 …if ($truthy(($ret_or_1 = ($truthy(($ret_or_2 = self.excl['$==='](other['$exclude_end?']()))) ? (se…
18394 return self.end['$eql?'](other.$end())
18400 $def(self, '$exclude_end?', $return_ivar("excl"));
18402 $def(self, '$first', function $$first(n) {
18403 var $yield = $$first.$$p || nil, self = this;
18408 if ($truthy(self.begin['$nil?']())) {
18412 return self.begin
18414 return $send2(self, $find_super(self, 'first', $$first, false, true), 'first', [n], $yield);
18417 $def(self, '$last', function $$last(n) {
18418 var self = this;
18422 if ($truthy(self.end['$nil?']())) {
18426 return self.end
18428 return self.$to_a().$last(n);
18431 $def(self, '$max', function $$max() {
18432 var $yield = $$max.$$p || nil, self = this;
18435 if ($truthy(self.end['$nil?']())) {
18438 return $send2(self, $find_super(self, 'max', $$max, false, true), 'max', [], $yield)
18439 …} else if (($not(self.begin['$nil?']()) && (($truthy($rb_gt(self.begin, self.end)) || (($truthy(se…
18442 return self.excl ? self.end - 1 : self.end
18446 $def(self, '$min', function $$min() {
18447 var $yield = $$min.$$p || nil, self = this;
18450 if ($truthy(self.begin['$nil?']())) {
18453 return $send2(self, $find_super(self, 'min', $$min, false, true), 'min', [], $yield)
18454 …} else if (($not(self.end['$nil?']()) && (($truthy($rb_gt(self.begin, self.end)) || (($truthy(self…
18457 return self.begin
18461 $def(self, '$size', function $$size() {
18462 var self = this, infinity = nil, range_begin = nil, range_end = nil;
18466 …if ((($eqeq(self.begin, infinity) && ($not(self.end['$nil?']()))) || (($eqeq(self.end, infinity['$…
18469 if ($truthy(is_infinite(self))) {
18472 if (!($eqeqeq($$$('Numeric'), self.begin) && ($eqeqeq($$$('Numeric'), self.end)))) {
18475 range_begin = self.begin;
18476 range_end = self.end;
18477 if ($truthy(self.excl)) {
18486 $def(self, '$step', function $$step(n) {
18487 var $yield = $$step.$$p || nil, self = this, $ret_or_1 = nil, i = nil;
18509 if (!self.begin['$respond_to?']("succ")) {
18513 if (self.begin.$$is_string && self.end.$$is_string) {
18518 return $rb_divide(self.$size(), n).$ceil();
18521 var begin = self.begin, end = self.end,
18530 if (self.excl) {
18544 …self.begin['$is_a?']($$('Numeric'))) || ($truthy(self.begin['$nil?']()))) && (($truthy(self.end['$…
18545 return $$$($$$('Enumerator'), 'ArithmeticSequence').$new(self, n, "step")
18547 return $send(self, 'enum_for', ["step", n], function $$5(){
18555 if ($truthy(self.begin.$$is_number && self.end.$$is_number)) {
18558 …(){try { var $t_break = $thrower('break'); return $send(self, 'loop', [], function $$6(){var self …
18559 if (self.begin == null) self.begin = nil;
18560 if (self.excl == null) self.excl = nil;
18561 if (self.end == null) self.end = nil;
18564 current = $rb_plus(self.begin, $rb_times(i, n));
18565 if ($truthy(self.excl)) {
18566 if ($truthy($rb_ge(current, self.end))) {
18569 } else if ($truthy($rb_gt(current, self.end))) {
18573 return (i = $rb_plus(i, 1));}, {$$s: self})} catch($e) {
18580 if (self.begin.$$is_string && self.end.$$is_string && n % 1 !== 0) {
18584 $send(self, 'each_with_index', [], function $$7(value, idx){
18594 return self;
18597 $def(self, '$%', function $Range_$percent$8(n) {
18598 var self = this;
18600 …if (($truthy(self.begin['$is_a?']($$('Numeric'))) && ($truthy(self.end['$is_a?']($$('Numeric')))))…
18601 return $$$($$$('Enumerator'), 'ArithmeticSequence').$new(self, n, "%")
18603 return self.$step(n)
18607 $def(self, '$bsearch', function $$bsearch() {
18608 var block = $$bsearch.$$p || nil, self = this;
18614 return self.$enum_for("bsearch")
18616 if ($truthy(is_infinite(self) && (self.begin.$$is_number || self.end.$$is_number))) {
18619 if (!$truthy(self.begin.$$is_number && self.end.$$is_number)) {
18620 $Kernel.$raise($$$('TypeError'), "can't do binary search for " + (self.begin.$class()))
18622 return $send(self.$to_a(), 'bsearch', [], block.$to_proc());
18625 $def(self, '$to_s', function $$to_s() {
18626 var self = this, $ret_or_1 = nil;
18628 …($truthy(($ret_or_1 = self.begin)) ? ($ret_or_1) : (""))) + (($truthy(self.excl) ? ("...") : (".."…
18631 $def(self, '$inspect', function $$inspect() {
18632 var self = this, $ret_or_1 = nil;
18634 …_1 = self.begin)) ? (self.begin.$inspect()) : ($ret_or_1))) + (($truthy(self.excl) ? ("...") : (".…
18637 $def(self, '$marshal_load', function $$marshal_load(args) {
18638 var self = this;
18641 self.begin = args['$[]']("begin");
18642 self.end = args['$[]']("end");
18643 return (self.excl = args['$[]']("excl"));
18646 $def(self, '$hash', function $$hash() {
18647 var self = this;
18649 return [self.begin, self.end, self.excl].$hash()
18651 $alias(self, "==", "eql?");
18652 $alias(self, "include?", "cover?");
18653 return $alias(self, "member?", "cover?");
18662 var self = $klass($base, $super, 'Proc');
18666 Opal.prop(self.$$prototype, '$$is_proc', true);
18667 Opal.prop(self.$$prototype, '$$is_lambda', false);
18668 $defs(self, '$new', function $Proc_new$1() {
18680 $def(self, '$call', function $$call($a) {
18681 var block = $$call.$$p || nil, $post_args, args, self = this;
18690 self.$$p = block;
18693 var result, $brk = self.$$brk, $ret = self.$$ret;
18695 if ($brk || ($ret && self.$$is_lambda)) {
18697 if (self.$$is_lambda) {
18698 result = self.apply(null, args);
18701 result = Opal.yieldX(self, args);
18707 else if (self.$$is_lambda && err === $ret) {
18716 if (self.$$is_lambda) {
18717 result = self.apply(null, args);
18720 result = Opal.yieldX(self, args);
18728 $def(self, '$>>', function $Proc_$gt$gt$2(other) {
18729 var $yield = $Proc_$gt$gt$2.$$p || nil, self = this;
18732 …proc', [], function $$3($a){var block = $$3.$$p || nil, $post_args, args, self = $$3.$$s == null ?…
18739 out = $send(self, 'call', $to_a(args), block.$to_proc());
18740 return other.$call(out);}, {$$arity: -1, $$s: self})
18743 $def(self, '$<<', function $Proc_$lt$lt$4(other) {
18744 var $yield = $Proc_$lt$lt$4.$$p || nil, self = this;
18747 …proc', [], function $$5($a){var block = $$5.$$p || nil, $post_args, args, self = $$5.$$s == null ?…
18755 return self.$call(out);}, {$$arity: -1, $$s: self})
18758 $def(self, '$to_proc', $return_self);
18760 $def(self, '$lambda?', function $Proc_lambda$ques$6() {
18761 var self = this;
18763 return !!self.$$is_lambda;
18766 $def(self, '$arity', function $$arity() {
18767 var self = this;
18770 if (self.$$is_curried) {
18772 } else if (self.$$arity != null) {
18773 return self.$$arity;
18775 return self.length;
18780 $def(self, '$source_location', function $$source_location() {
18781 var self = this, $ret_or_1 = nil;
18784 if (self.$$is_curried) { return nil; };
18785 if ($truthy(($ret_or_1 = self.$$source_location))) {
18792 $def(self, '$binding', function $$binding() {
18793 var $a, self = this;
18796 if (self.$$is_curried) { $Kernel.$raise($$$('ArgumentError'), "Can't create Binding") };
18798 return $$$('Binding').$new(nil, [], self.$$s, self.$source_location())
18804 $def(self, '$parameters', function $$parameters($kwargs) {
18805 var lambda, self = this;
18812 if (self.$$is_curried) {
18814 } else if (self.$$parameters) {
18815 if (lambda == null ? self.$$is_lambda : lambda) {
18816 return self.$$parameters;
18820 for (i = 0, length = self.$$parameters.length; i < length; i++) {
18821 var parameter = self.$$parameters[i];
18839 $def(self, '$curry', function $$curry(arity) {
18840 var self = this;
18846 arity = self.length;
18850 if (self.$$is_lambda && arity !== self.length) {
18851 …aise($$$('ArgumentError'), "wrong number of arguments (" + (arity) + " for " + (self.length) + ")")
18860 if (length > arity && self.$$is_lambda && !self.$$is_curried) {
18865 return self.$call.apply(self, args);
18872 result.$$is_lambda = self.$$is_lambda;
18878 curried.$$is_lambda = self.$$is_lambda;
18884 $def(self, '$dup', function $$dup() {
18885 var self = this;
18888 var original_proc = self.$$original_proc || self,
18893 for (var prop in self) {
18894 if (self.hasOwnProperty(prop)) {
18895 proc[prop] = self[prop];
18902 $alias(self, "===", "call");
18903 $alias(self, "clone", "dup");
18904 $alias(self, "yield", "call");
18905 return $alias(self, "[]", "call");
18915 var self = $klass($base, $super, 'Method');
18917 var $proto = self.$$prototype;
18921 self.$attr_reader("owner", "receiver", "name");
18923 $def(self, '$initialize', function $$initialize(receiver, owner, method, name) {
18924 var self = this;
18927 self.receiver = receiver;
18928 self.owner = owner;
18929 self.name = name;
18930 return (self.method = method);
18933 $def(self, '$arity', function $$arity() {
18934 var self = this;
18936 return self.method.$arity()
18939 $def(self, '$parameters', function $$parameters() {
18940 var self = this;
18942 return self.method.$$parameters
18945 $def(self, '$source_location', function $$source_location() {
18946 var self = this, $ret_or_1 = nil;
18948 if ($truthy(($ret_or_1 = self.method.$$source_location))) {
18955 $def(self, '$comments', function $$comments() {
18956 var self = this, $ret_or_1 = nil;
18958 if ($truthy(($ret_or_1 = self.method.$$comments))) {
18965 $def(self, '$call', function $$call($a) {
18966 var block = $$call.$$p || nil, $post_args, args, self = this;
18974 self.method.$$p = block;
18976 return self.method.apply(self.receiver, args);
18980 $def(self, '$curry', function $$curry(arity) {
18981 var self = this;
18985 return self.method.$curry(arity);
18988 $def(self, '$>>', function $Method_$gt$gt$1(other) {
18989 var self = this;
18991 return self.method['$>>'](other)
18994 $def(self, '$<<', function $Method_$lt$lt$2(other) {
18995 var self = this;
18997 return self.method['$<<'](other)
19000 $def(self, '$unbind', function $$unbind() {
19001 var self = this;
19003 return $$$('UnboundMethod').$new(self.receiver.$class(), self.owner, self.method, self.name)
19006 $def(self, '$to_proc', function $$to_proc() {
19007 var self = this;
19010 var proc = self.$call.bind(self);
19011 proc.$$unbound = self.method;
19013 proc.$$arity = self.method.$$arity == null ? self.method.length : self.method.$$arity;
19014 proc.$$parameters = self.method.$$parameters;
19019 $def(self, '$inspect', function $$inspect() {
19020 var self = this;
19022 …return "#<" + (self.$class()) + ": " + (self.receiver.$class()) + "#" + (self.name) + " (defined i…
19024 $alias(self, "[]", "call");
19025 return $alias(self, "===", "call");
19028 var self = $klass($base, $super, 'UnboundMethod');
19030 var $proto = self.$$prototype;
19034 self.$attr_reader("source", "owner", "name");
19036 $def(self, '$initialize', function $$initialize(source, owner, method, name) {
19037 var self = this;
19040 self.source = source;
19041 self.owner = owner;
19042 self.method = method;
19043 return (self.name = name);
19046 $def(self, '$arity', function $$arity() {
19047 var self = this;
19049 return self.method.$arity()
19052 $def(self, '$parameters', function $$parameters() {
19053 var self = this;
19055 return self.method.$$parameters
19058 $def(self, '$source_location', function $$source_location() {
19059 var self = this, $ret_or_1 = nil;
19061 if ($truthy(($ret_or_1 = self.method.$$source_location))) {
19068 $def(self, '$comments', function $$comments() {
19069 var self = this, $ret_or_1 = nil;
19071 if ($truthy(($ret_or_1 = self.method.$$comments))) {
19078 $def(self, '$bind', function $$bind(object) {
19079 var self = this;
19082 if (self.owner.$$is_module || Opal.is_a(object, self.owner)) {
19083 return $$$('Method').$new(object, self.owner, self.method, self.name);
19086 …eton method to a different class (expected " + (object) + ".kind_of?(" + (self.owner) + " to be tr…
19091 $def(self, '$bind_call', function $$bind_call(object, $a) {
19092 var block = $$bind_call.$$p || nil, $post_args, args, self = this;
19099 return $send(self.$bind(object), 'call', $to_a(args), block.$to_proc());
19101 return $def(self, '$inspect', function $$inspect() {
19102 var self = this;
19104 …return "#<" + (self.$class()) + ": " + (self.source) + "#" + (self.name) + " (defined in " + (self…
19133 var self = $klass($base, $super, 'IO');
19135 var $proto = self.$$prototype;
19139 $const_set(self, 'SEEK_SET', 0);
19140 $const_set(self, 'SEEK_CUR', 1);
19141 $const_set(self, 'SEEK_END', 2);
19142 $const_set(self, 'SEEK_DATA', 3);
19143 $const_set(self, 'SEEK_HOLE', 4);
19144 $const_set(self, 'READABLE', 1);
19145 $const_set(self, 'WRITABLE', 4);
19146 self.$attr_reader("eof");
19147 self.$attr_accessor("read_proc", "sync", "tty", "write_proc");
19149 $def(self, '$initialize', function $$initialize(fd, flags) {
19150 var self = this;
19154 self.fd = fd;
19155 self.flags = flags;
19156 self.eof = false;
19158 return (self.closed = "write")
19160 return (self.closed = "read")
19166 $def(self, '$fileno', $return_ivar("fd"));
19168 $def(self, '$tty?', function $IO_tty$ques$1() {
19169 var self = this;
19171 return self.tty == true;
19174 $def(self, '$write', function $$write(string) {
19175 var self = this;
19178 self.write_proc(string);
19182 $def(self, '$flush', $return_val(nil));
19184 $def(self, '$<<', function $IO_$lt$lt$2(string) {
19185 var self = this;
19188 self.$write(string);
19189 return self;
19192 $def(self, '$print', function $$print($a) {
19193 var $post_args, args, self = this;
19203 self.$write(args.join($gvars[","]));
19208 $def(self, '$puts', function $$puts($a) {
19209 var $post_args, args, self = this;
19217 self.$write("\n");
19223 if (ary.length > 0) $send(self, 'puts', $to_a((ary)))
19231 self.$write(line)
19239 $def(self, '$getc', function $$getc() {
19240 var self = this, $ret_or_1 = nil, parts = nil, ret = nil;
19243 self.read_buffer = ($truthy(($ret_or_1 = self.read_buffer)) ? ($ret_or_1) : (""));
19247 self.read_buffer = $rb_plus(self.read_buffer, parts);
19248 if ($neqeq(self.read_buffer, "")) {
19250 ret = self.read_buffer['$[]'](0);
19251 self.read_buffer = self.read_buffer['$[]']($range(1, -1, false));
19254 } while ($truthy((parts = self.$sysread_noraise(1))));;
19258 $def(self, '$getbyte', function $$getbyte() {
19259 var $a, self = this;
19261 return ($a = self.$getc(), ($a === nil || $a == null) ? nil : $a.$ord())
19264 $def(self, '$readbyte', function $$readbyte() {
19265 var self = this;
19267 return self.$readchar().$ord()
19270 $def(self, '$readchar', function $$readchar() {
19271 var self = this, $ret_or_1 = nil;
19273 if ($truthy(($ret_or_1 = self.$getc()))) {
19280 $def(self, '$readline', function $$readline($a) {
19281 var $post_args, args, self = this, $ret_or_1 = nil;
19286 if ($truthy(($ret_or_1 = $send(self, 'gets', $to_a(args))))) {
19293 $def(self, '$gets', function $$gets(sep, limit, opts) {
19294 …var $a, $b, self = this, orig_sep = nil, $ret_or_1 = nil, seplen = nil, data = nil, ret = nil, ori…
19324 self.read_buffer = ($truthy(($ret_or_1 = self.read_buffer)) ? ($ret_or_1) : (""));
19329 self.read_buffer = $rb_plus(self.read_buffer, data); field
19330 …neqeq(sep, "") && ($truthy(($truthy(sep.$$is_regexp) ? (self.read_buffer['$match?'](sep)) : (self.…
19332 orig_buffer = self.read_buffer;
19333 …$b = self.read_buffer.$split(sep, 2), $a = $to_ary($b), (ret = ($a[0] == null ? nil : $a[0])), (se…
19339 } while ($truthy((data = self.$sysread_noraise(($eqeq(sep, "") ? (65536) : (1))))));;
19342 …$a = [($truthy(($ret_or_1 = self.read_buffer)) ? ($ret_or_1) : ("")), ""], (ret = $a[0]), (self.re…
19352 … self.read_buffer = $rb_plus(ret['$[]'](Opal.Range.$new(limit, -1, false)), self.read_buffer);
19367 $def(self, '$sysread', function $$sysread(integer) {
19368 var self = this, $ret_or_1 = nil;
19370 if ($truthy(($ret_or_1 = self.read_proc(integer)))) {
19374 self.eof = true;
19379 $def(self, '$sysread_noraise', function $$sysread_noraise(integer) {
19380 var self = this;
19383 return self.$sysread(integer)
19393 $def(self, '$readpartial', function $$readpartial(integer) {
19394 var $a, self = this, $ret_or_1 = nil, part = nil, ret = nil;
19397 self.read_buffer = ($truthy(($ret_or_1 = self.read_buffer)) ? ($ret_or_1) : (""));
19398 part = self.$sysread(integer);
19399 …$a = [$rb_plus(self.read_buffer, ($truthy(($ret_or_1 = part)) ? ($ret_or_1) : (""))), ""], (ret = …
19406 $def(self, '$read', function $$read(integer) {
19407 var $a, self = this, $ret_or_1 = nil, parts = nil, ret = nil;
19411 self.read_buffer = ($truthy(($ret_or_1 = self.read_buffer)) ? ($ret_or_1) : (""));
19416 self.read_buffer = $rb_plus(self.read_buffer, parts);
19417 if (($truthy(integer) && ($truthy($rb_gt(self.read_buffer.$length(), integer))))) {
19419 …a = [self.read_buffer['$[]'](Opal.Range.$new(0,integer, true)), self.read_buffer['$[]'](Opal.Range…
19422 …} while ($truthy((parts = self.$sysread_noraise(($truthy(($ret_or_1 = integer)) ? ($ret_or_1) : (6…
19423 $a = [self.read_buffer, ""], (ret = $a[0]), (self.read_buffer = $a[1]), $a;
19427 $def(self, '$readlines', function $$readlines(separator) {
19428 var self = this;
19433 return self.$each_line(separator).$to_a();
19436 $def(self, '$each', function $$each($a, $b) {
19437 var block = $$each.$$p || nil, $post_args, sep, args, self = this, s = nil;
19448 return $send(self, 'enum_for', ["each", sep].concat($to_a(args)))
19450 while ($truthy((s = $send(self, 'gets', [sep].concat($to_a(args)))))) {
19453 return self;
19456 $def(self, '$each_byte', function $$each_byte() {
19457 var block = $$each_byte.$$p || nil, self = this, s = nil;
19463 return self.$enum_for("each_byte")
19465 while ($truthy((s = self.$getbyte()))) {
19468 return self;
19471 $def(self, '$each_char', function $$each_char() {
19472 var block = $$each_char.$$p || nil, self = this, s = nil;
19478 return self.$enum_for("each_char")
19480 while ($truthy((s = self.$getc()))) {
19483 return self;
19486 $def(self, '$close', $assign_ivar_val("closed", "both"));
19488 $def(self, '$close_read', function $$close_read() {
19489 var self = this;
19491 if ($eqeq(self.closed, "write")) {
19492 return (self.closed = "both")
19494 return (self.closed = "read")
19498 $def(self, '$close_write', function $$close_write() {
19499 var self = this;
19501 if ($eqeq(self.closed, "read")) {
19502 return (self.closed = "both")
19504 return (self.closed = "write")
19508 $def(self, '$closed?', function $IO_closed$ques$3() {
19509 var self = this;
19511 return self.closed['$==']("both")
19514 $def(self, '$closed_read?', function $IO_closed_read$ques$4() {
19515 var self = this, $ret_or_1 = nil;
19517 if ($truthy(($ret_or_1 = self.closed['$==']("read")))) {
19520 return self.closed['$==']("both")
19524 $def(self, '$closed_write?', function $IO_closed_write$ques$5() {
19525 var self = this, $ret_or_1 = nil;
19527 if ($truthy(($ret_or_1 = self.closed['$==']("write")))) {
19530 return self.closed['$==']("both")
19534 $def(self, '$check_writable', function $$check_writable() {
19535 var self = this;
19537 if ($truthy(self['$closed_write?']())) {
19544 $def(self, '$check_readable', function $$check_readable() {
19545 var self = this;
19547 if ($truthy(self['$closed_read?']())) {
19553 $alias(self, "each_line", "each");
19554 return $alias(self, "eof?", "eof");
19570 var self = $module($base, 'Opal');
19572 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
19575 $const_set(self, 'REGEXP_START', "^");
19576 $const_set(self, 'REGEXP_END', "$");
19577 …$const_set(self, 'FORBIDDEN_STARTING_IDENTIFIER_CHARS', "\\u0001-\\u002F\\u003A-\\u0040\\u005B-\\u…
19578 …$const_set(self, 'FORBIDDEN_ENDING_IDENTIFIER_CHARS', "\\u0001-\\u0020\\u0022-\\u002F\\u003A-\\u00…
19579 …$const_set(self, 'INLINE_IDENTIFIER_REGEXP', $$('Regexp').$new("[^" + ($$$(self, 'FORBIDDEN_STARTI…
19580 …$const_set(self, 'FORBIDDEN_CONST_NAME_CHARS', "\\u0001-\\u0020\\u0021-\\u002F\\u003B-\\u003F\\u00…
19581 …self, 'CONST_NAME_REGEXP', $$('Regexp').$new("" + ($$$(self, 'REGEXP_START')) + "(::)?[A-Z][^" + (…
19614 var self = $module($base, 'Kernel');
19619 $def(self, '$format', function $$format(format_string, $a) {
20170 return $alias(self, "sprintf", "format");
20175 …slice, $Kernel = Opal.Kernel, $Opal = Opal.Opal, $rb_lt = Opal.rb_lt, $a, self = Opal.top, $nestin…
20179 self.$require("corelib/string");
20181 var self = $klass($base, $super, 'Encoding');
20183 var $proto = self.$$prototype;
20187 $defs(self, '$register', function $$register(name, options) {
20188 …var block = $$register.$$p || nil, self = this, names = nil, $ret_or_1 = nil, ascii = nil, dummy =…
20202 encoding = self.$new(name, names, ascii, dummy)
20208 …return $send(names, 'each', [], function $$1(encoding_name){var self = $$1.$$s == null ? this : $$…
20212 self.$const_set(encoding_name.$tr("-", "_"), encoding);
20213 return register[encoding_name] = encoding;}, {$$s: self});
20215 $defs(self, '$find', function $$find(name) {
20216 var self = this;
20220 return self.$default_external()
20224 self.$singleton_class().$attr_accessor("default_external");
20225 self.$attr_reader("name", "names");
20227 $def(self, '$initialize', function $$initialize(name, names, ascii, dummy) {
20228 var self = this;
20231 self.name = name;
20232 self.names = names;
20233 self.ascii = ascii;
20234 return (self.dummy = dummy);
20237 $def(self, '$ascii_compatible?', $return_ivar("ascii"));
20239 $def(self, '$dummy?', $return_ivar("dummy"));
20241 $def(self, '$binary?', $return_val(false));
20243 $def(self, '$to_s', $return_ivar("name"));
20245 $def(self, '$inspect', function $$inspect() {
20246 var self = this;
20248 return "#<Encoding:" + (self.name) + (($truthy(self.dummy) ? (" (dummy)") : nil)) + ">"
20251 $def(self, '$charsize', function $$charsize(string) {
20265 $def(self, '$each_char', function $$each_char(string) {
20292 $def(self, '$each_byte', function $$each_byte($a) {
20301 $def(self, '$bytesize', function $$bytesize($a) {
20312 …, "ascii"], {"aliases": ["CP65001"], "ascii": true})], function $$2(){var self = $$2.$$s == null ?…
20316 $def(self, '$each_byte', function $$each_byte(string) {
20410 return $def(self, '$bytesize', function $$bytesize(string) {
20413 });}, {$$s: self});
20414 …$send($$$('Encoding'), 'register', ["UTF-16LE"], function $$3(){var self = $$3.$$s == null ? this …
20418 $def(self, '$each_byte', function $$each_byte(string) {
20433 return $def(self, '$bytesize', function $$bytesize(string) {
20436 });}, {$$s: self});
20437 …s"], {"inherits": $$$($$$('Encoding'), 'UTF_16LE')})], function $$4(){var self = $$4.$$s == null ?…
20439 return $def(self, '$each_byte', function $$each_byte(string) {
20453 })}, {$$s: self});
20454 …$send($$$('Encoding'), 'register', ["UTF-32LE"], function $$5(){var self = $$5.$$s == null ? this …
20458 $def(self, '$each_byte', function $$each_byte(string) {
20475 return $def(self, '$bytesize', function $$bytesize(string) {
20478 });}, {$$s: self});
20479 …s"], {"inherits": $$$($$$('Encoding'), 'UTF_32LE')})], function $$6(){var self = $$6.$$s == null ?…
20481 return $def(self, '$each_byte', function $$each_byte(string) {
20497 })}, {$$s: self});
20498 …", "ascii"], {"aliases": ["BINARY"], "ascii": true})], function $$7(){var self = $$7.$$s == null ?…
20502 $def(self, '$each_char', function $$each_char(string) {
20517 $def(self, '$charsize', function $$charsize(string) {
20522 $def(self, '$each_byte', function $$each_byte(string) {
20536 $def(self, '$bytesize', function $$bytesize(string) {
20540 return $def(self, '$binary?', $return_val(true));}, {$$s: self});
20544 var self = $klass($base, $super, 'String');
20546 var $proto = self.$$prototype;
20550 self.$attr_reader("encoding");
20551 self.$attr_reader("internal_encoding");
20556 $def(self, '$b', function $$b() {
20557 var self = this;
20559 return self.$dup().$force_encoding("binary")
20562 $def(self, '$bytesize', function $$bytesize() {
20563 var self = this;
20565 return self.internal_encoding.$bytesize(self)
20568 $def(self, '$each_byte', function $$each_byte() {
20569 var block = $$each_byte.$$p || nil, self = this;
20575 …return $send(self, 'enum_for', ["each_byte"], function $$8(){var self = $$8.$$s == null ? this : $…
20577 return self.$bytesize()}, {$$s: self})
20579 $send(self.internal_encoding, 'each_byte', [self], block.$to_proc());
20580 return self;
20583 $def(self, '$bytes', function $$bytes() {
20584 var self = this, $ret_or_1 = nil;
20588 if (typeof self === 'string') {
20589 return (new String(self)).$each_byte().$to_a();
20592 self.bytes = ($truthy(($ret_or_1 = self.bytes)) ? ($ret_or_1) : (self.$each_byte().$to_a()));
20593 return self.bytes.$dup();
20596 $def(self, '$each_char', function $$each_char() {
20597 var block = $$each_char.$$p || nil, self = this;
20603 …return $send(self, 'enum_for', ["each_char"], function $$9(){var self = $$9.$$s == null ? this : $…
20605 return self.$length()}, {$$s: self})
20607 $send(self.encoding, 'each_char', [self], block.$to_proc());
20608 return self;
20611 $def(self, '$chars', function $$chars() {
20612 var block = $$chars.$$p || nil, self = this;
20618 return self.$each_char().$to_a()
20620 return $send(self, 'each_char', [], block.$to_proc());
20623 $def(self, '$each_codepoint', function $$each_codepoint() {
20624 var block = $$each_codepoint.$$p || nil, self = this;
20630 return self.$enum_for("each_codepoint")
20633 for (var i = 0, length = self.length; i < length; i++) {
20634 Opal.yield1(block, self.codePointAt(i));
20637 return self;
20640 $def(self, '$codepoints', function $$codepoints() {
20641 var block = $$codepoints.$$p || nil, self = this;
20647 return $send(self, 'each_codepoint', [], block.$to_proc())
20649 return self.$each_codepoint().$to_a();
20652 $def(self, '$encode', function $$encode(encoding) {
20653 var self = this;
20655 return Opal.enc(self, encoding);
20658 $def(self, '$force_encoding', function $$force_encoding(encoding) {
20659 var self = this;
20662 var str = self;
20677 $def(self, '$getbyte', function $$getbyte(idx) {
20678 var self = this, string_bytes = nil;
20681 string_bytes = self.$bytes();
20689 $def(self, '$initialize_copy', function $$initialize_copy(other) {
20693 return $def(self, '$valid_encoding?', $return_val(true));
20703 var self = $module($base, 'Math');
20705 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
20708 $const_set(self, 'E', Math.E);
20709 $const_set(self, 'PI', Math.PI);
20710 $const_set(self, 'DomainError', $Class.$new($$$('StandardError')));
20711 $defs(self, '$checked', function $$checked(method, $a) {
20731 $defs(self, '$float!', function $Math_float$excl$1(value) {
20743 $defs(self, '$integer!', function $Math_integer$excl$2(value) {
20755 self.$module_function();
20809 … "sin", "sinh", "sqrt", "tanh"], 'each', [], function $Math$3(method){var self = $Math$3.$$s == nu…
20813 return $send(self, 'define_method', [method], function $$4(x){
20816 return $$$('Math').$checked(method, $$$('Math')['$float!'](x));});}, {$$s: self});
20818 $def(self, '$atan2', function $$atan2(y, x) {
20823 $def(self, '$hypot', function $$hypot(x, y) {
20828 $def(self, '$frexp', function $$frexp(x) {
20844 $def(self, '$gamma', function $$gamma(n) {
20941 $def(self, '$ldexp', function $$ldexp(mantissa, exponent) {
20955 $def(self, '$lgamma', function $$lgamma(n) {
20967 $def(self, '$log', function $$log(x, base) {
20985 $def(self, '$log10', function $$log10(x) {
20994 $def(self, '$log2', function $$log2(x) {
21002 return $def(self, '$tan', function $$tan(x) {
21020 var self = $module($base, 'Kernel');
21022 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
21024 return $def(self, '$Complex', function $$Complex(real, imag) {
21036 var self = $klass($base, $super, 'String');
21038 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
21040 return $def(self, '$to_c', function $$to_c() {
21041 var self = this;
21043 return $$('Complex').$from_string(self)
21049 …_val = Opal.return_val, $const_set = Opal.const_set, $alias = Opal.alias, self = Opal.top, $nestin…
21053 self.$require("corelib/numeric");
21054 self.$require("corelib/complex/base");
21056 var self = $klass($base, $super, 'Complex');
21058 … var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $proto = self.$$prototype;
21062 $defs(self, '$rect', function $$rect(real, imag) {
21063 var self = this;
21070 return self.$new(real, imag);
21072 $defs(self, '$polar', function $$polar(r, theta) {
21073 var self = this;
21080 … return self.$new($rb_times(r, $$$('Math').$cos(theta)), $rb_times(r, $$$('Math').$sin(theta)));
21082 self.$attr_reader("real", "imag");
21084 $def(self, '$initialize', function $$initialize(real, imag) {
21085 var self = this;
21089 self.real = real;
21090 self.imag = imag;
21091 return self.$freeze();
21094 $def(self, '$coerce', function $$coerce(other) {
21095 var self = this;
21098 return [other, self]
21100 return [$$$('Complex').$new(other, 0), self]
21106 $def(self, '$==', function $Complex_$eq_eq$1(other) {
21107 var self = this, $ret_or_1 = nil;
21110 if ($truthy(($ret_or_1 = self.real['$=='](other.$real())))) {
21111 return self.imag['$=='](other.$imag())
21116 if ($truthy(($ret_or_1 = self.real['$=='](other)))) {
21117 return self.imag['$=='](0)
21122 return other['$=='](self)
21126 $def(self, '$-@', function $Complex_$minus$$2() {
21127 var self = this;
21129 return $Kernel.$Complex(self.real['$-@'](), self.imag['$-@']())
21132 $def(self, '$+', function $Complex_$plus$3(other) {
21133 var self = this;
21136 … return $Kernel.$Complex($rb_plus(self.real, other.$real()), $rb_plus(self.imag, other.$imag()))
21138 return $Kernel.$Complex($rb_plus(self.real, other), self.imag)
21140 return self.$__coerced__("+", other)
21144 $def(self, '$-', function $Complex_$minus$4(other) {
21145 var self = this;
21148 … return $Kernel.$Complex($rb_minus(self.real, other.$real()), $rb_minus(self.imag, other.$imag()))
21150 return $Kernel.$Complex($rb_minus(self.real, other), self.imag)
21152 return self.$__coerced__("-", other)
21156 $def(self, '$*', function $Complex_$$5(other) {
21157 var self = this;
21160 …nus($rb_times(self.real, other.$real()), $rb_times(self.imag, other.$imag())), $rb_plus($rb_times(…
21162 return $Kernel.$Complex($rb_times(self.real, other), $rb_times(self.imag, other))
21164 return self.$__coerced__("*", other)
21168 $def(self, '$/', function $Complex_$slash$6(other) {
21169 var self = this;
21172 …(($eqeqeq($$$('Number'), self.real) && ($truthy(self.real['$nan?']()))) || (($eqeqeq($$$('Number')…
21175 return $rb_divide($rb_times(self, other.$conj()), other.$abs2())
21178 return $Kernel.$Complex(self.real.$quo(other), self.imag.$quo(other))
21180 return self.$__coerced__("/", other)
21184 $def(self, '$**', function $Complex_$$$7(other) {
21185 …var $a, $b, self = this, r = nil, theta = nil, ore = nil, oim = nil, nr = nil, ntheta = nil, x = n…
21193 …$b = self.$polar(), $a = $to_ary($b), (r = ($a[0] == null ? nil : $a[0])), (theta = ($a[1] == null…
21202 x = self;
21219 return $rb_divide($$$('Rational').$new(1, 1), self)['$**'](other['$-@']())
21223 …$b = self.$polar(), $a = $to_ary($b), (r = ($a[0] == null ? nil : $a[0])), (theta = ($a[1] == null…
21226 return self.$__coerced__("**", other)
21230 $def(self, '$abs', function $$abs() {
21231 var self = this;
21233 return $$$('Math').$hypot(self.real, self.imag)
21236 $def(self, '$abs2', function $$abs2() {
21237 var self = this;
21239 return $rb_plus($rb_times(self.real, self.real), $rb_times(self.imag, self.imag))
21242 $def(self, '$angle', function $$angle() {
21243 var self = this;
21245 return $$$('Math').$atan2(self.imag, self.real)
21248 $def(self, '$conj', function $$conj() {
21249 var self = this;
21251 return $Kernel.$Complex(self.real, self.imag['$-@']())
21254 $def(self, '$denominator', function $$denominator() {
21255 var self = this;
21257 return self.real.$denominator().$lcm(self.imag.$denominator())
21260 $def(self, '$eql?', function $Complex_eql$ques$8(other) {
21261 var self = this, $ret_or_1 = nil, $ret_or_2 = nil;
21263 …_1 = ($truthy(($ret_or_2 = $$('Complex')['$==='](other))) ? (self.real.$class()['$=='](self.imag.$…
21264 return self['$=='](other)
21270 $def(self, '$fdiv', function $$fdiv(other) {
21271 var self = this;
21277 return $rb_divide(self, other);
21280 $def(self, '$finite?', function $Complex_finite$ques$9() {
21281 var self = this, $ret_or_1 = nil;
21283 if ($truthy(($ret_or_1 = self.real['$finite?']()))) {
21284 return self.imag['$finite?']()
21290 $def(self, '$hash', function $$hash() {
21291 var self = this;
21293 return "Complex:" + (self.real) + ":" + (self.imag)
21296 $def(self, '$infinite?', function $Complex_infinite$ques$10() {
21297 var self = this, $ret_or_1 = nil;
21299 if ($truthy(($ret_or_1 = self.real['$infinite?']()))) {
21302 return self.imag['$infinite?']()
21306 $def(self, '$inspect', function $$inspect() {
21307 var self = this;
21309 return "(" + (self) + ")"
21312 $def(self, '$numerator', function $$numerator() {
21313 var self = this, d = nil;
21316 d = self.$denominator();
21317 …omplex($rb_times(self.real.$numerator(), $rb_divide(d, self.real.$denominator())), $rb_times(self.…
21320 $def(self, '$polar', function $$polar() {
21321 var self = this;
21323 return [self.$abs(), self.$arg()]
21326 $def(self, '$rationalize', function $$rationalize(eps) {
21327 var self = this;
21336 if ($neqeq(self.imag, 0)) {
21337 $Kernel.$raise($$$('RangeError'), "can't convert " + (self) + " into Rational")
21339 return self.$real().$rationalize(eps);
21342 $def(self, '$real?', $return_val(false));
21344 $def(self, '$rect', function $$rect() {
21345 var self = this;
21347 return [self.real, self.imag]
21350 $def(self, '$to_f', function $$to_f() {
21351 var self = this;
21354 if (!$eqeq(self.imag, 0)) {
21355 $Kernel.$raise($$$('RangeError'), "can't convert " + (self) + " into Float")
21357 return self.real.$to_f();
21360 $def(self, '$to_i', function $$to_i() {
21361 var self = this;
21364 if (!$eqeq(self.imag, 0)) {
21365 $Kernel.$raise($$$('RangeError'), "can't convert " + (self) + " into Integer")
21367 return self.real.$to_i();
21370 $def(self, '$to_r', function $$to_r() {
21371 var self = this;
21374 if (!$eqeq(self.imag, 0)) {
21375 $Kernel.$raise($$$('RangeError'), "can't convert " + (self) + " into Rational")
21377 return self.real.$to_r();
21380 $def(self, '$to_s', function $$to_s() {
21381 var self = this, result = nil;
21384 result = self.real.$inspect();
21385 …($eqeqeq($$$('Number'), self.imag) && ($truthy(self.imag['$nan?']()))) || ($truthy(self.imag['$pos…
21386 result = $rb_plus(result, self.imag.$abs().$inspect());
21387 …if (($eqeqeq($$$('Number'), self.imag) && (($truthy(self.imag['$nan?']()) || ($truthy(self.imag['$…
21392 $const_set($nesting[0], 'I', self.$new(0, 1));
21393 $defs(self, '$from_string', function $$from_string(str) {
21471 (function(self, $parent_nesting) { argument
21473 return $alias(self, "rectangular", "rect")
21474 })(Opal.get_singleton_class(self), $nesting);
21475 $alias(self, "arg", "angle");
21476 $alias(self, "conjugate", "conj");
21477 $alias(self, "divide", "/");
21478 $alias(self, "imaginary", "imag");
21479 $alias(self, "magnitude", "abs");
21480 $alias(self, "phase", "arg");
21481 $alias(self, "quo", "/");
21482 $alias(self, "rectangular", "rect");
21484 Opal.udef(self, '$' + "negative?");;
21486 Opal.udef(self, '$' + "positive?");;
21489 Opal.udef(self, '$' + "step");;
21500 var self = $module($base, 'Kernel');
21503 return $def(self, '$Rational', function $$Rational(numerator, denominator) {
21511 var self = $klass($base, $super, 'String');
21514 return $def(self, '$to_r', function $$to_r() {
21515 var self = this;
21517 return $$$('Rational').$from_string(self)
21523 …rb_le = Opal.rb_le, $return_self = Opal.return_self, $alias = Opal.alias, self = Opal.top, nil = O…
21527 self.$require("corelib/numeric");
21528 self.$require("corelib/rational/base");
21530 var self = $klass($base, $super, 'Rational');
21532 var $proto = self.$$prototype;
21536 $defs(self, '$reduce', function $$reduce(num, den) {
21537 var self = this, gcd = nil;
21549 return self.$new(num, den)
21552 return self.$new($rb_divide(num, gcd), $rb_divide(den, gcd));
21554 $defs(self, '$convert', function $$convert(num, den) {
21555 var self = this;
21562 return self.$reduce(num, den)
21575 return self.$reduce(num, den)
21579 $def(self, '$initialize', function $$initialize(num, den) {
21580 var self = this;
21583 self.num = num;
21584 self.den = den;
21585 return self.$freeze();
21588 $def(self, '$numerator', $return_ivar("num"));
21590 $def(self, '$denominator', $return_ivar("den"));
21592 $def(self, '$coerce', function $$coerce(other) {
21593 var self = this, $ret_or_1 = nil;
21596 return [other, self]
21598 return [other.$to_r(), self]
21600 return [other, self.$to_f()]
21606 $def(self, '$==', function $Rational_$eq_eq$1(other) {
21607 var self = this, $ret_or_1 = nil, $ret_or_2 = nil;
21610 if ($truthy(($ret_or_2 = self.num['$=='](other.$numerator())))) {
21611 return self.den['$=='](other.$denominator())
21616 if ($truthy(($ret_or_2 = self.num['$=='](other)))) {
21617 return self.den['$=='](1)
21622 return self.$to_f()['$=='](other)
21624 return other['$=='](self)
21628 $def(self, '$<=>', function $Rational_$lt_eq_gt$2(other) {
21629 var self = this, $ret_or_1 = nil;
21632 …return $rb_minus($rb_times(self.num, other.$denominator()), $rb_times(self.den, other.$numerator()…
21634 return $rb_minus(self.num, $rb_times(self.den, other))['$<=>'](0)
21636 return self.$to_f()['$<=>'](other)
21638 return self.$__coerced__("<=>", other)
21642 $def(self, '$+', function $Rational_$plus$3(other) {
21643 var self = this, $ret_or_1 = nil, num = nil, den = nil;
21647 …num = $rb_plus($rb_times(self.num, other.$denominator()), $rb_times(self.den, other.$numerator()));
21648 den = $rb_times(self.den, other.$denominator());
21651 return $Kernel.$Rational($rb_plus(self.num, $rb_times(other, self.den)), self.den)
21653 return $rb_plus(self.$to_f(), other)
21655 return self.$__coerced__("+", other)
21659 $def(self, '$-', function $Rational_$minus$4(other) {
21660 var self = this, $ret_or_1 = nil, num = nil, den = nil;
21664 …num = $rb_minus($rb_times(self.num, other.$denominator()), $rb_times(self.den, other.$numerator())…
21665 den = $rb_times(self.den, other.$denominator());
21668 return $Kernel.$Rational($rb_minus(self.num, $rb_times(other, self.den)), self.den)
21670 return $rb_minus(self.$to_f(), other)
21672 return self.$__coerced__("-", other)
21676 $def(self, '$*', function $Rational_$$5(other) {
21677 var self = this, $ret_or_1 = nil, num = nil, den = nil;
21681 num = $rb_times(self.num, other.$numerator());
21682 den = $rb_times(self.den, other.$denominator());
21685 return $Kernel.$Rational($rb_times(self.num, other), self.den)
21687 return $rb_times(self.$to_f(), other)
21689 return self.$__coerced__("*", other)
21693 $def(self, '$/', function $Rational_$slash$6(other) {
21694 var self = this, $ret_or_1 = nil, num = nil, den = nil;
21698 num = $rb_times(self.num, other.$denominator());
21699 den = $rb_times(self.den, other.$numerator());
21703 return $rb_divide(self.$to_f(), 0.0)
21705 return $Kernel.$Rational(self.num, $rb_times(self.den, other))
21708 return $rb_divide(self.$to_f(), other)
21710 return self.$__coerced__("/", other)
21714 $def(self, '$**', function $Rational_$$$7(other) {
21715 var self = this, $ret_or_1 = nil;
21718 if (($eqeq(self, 0) && ($truthy($rb_lt(other, 0))))) {
21721 return $Kernel.$Rational(self.num['$**'](other), self.den['$**'](other))
21723 return $Kernel.$Rational(self.den['$**'](other['$-@']()), self.num['$**'](other['$-@']()))
21728 return self.$to_f()['$**'](other)
21734 …return $Kernel.$Rational(self.den['$**'](other.$numerator().$abs()), self.num['$**'](other.$numera…
21736 … return $Kernel.$Rational(self.num['$**'](other.$numerator()), self.den['$**'](other.$numerator()))
21738 } else if (($eqeq(self, 0) && ($truthy($rb_lt(other, 0))))) {
21741 return self.$to_f()['$**'](other)
21744 return self.$__coerced__("**", other)
21748 $def(self, '$abs', function $$abs() {
21749 var self = this;
21751 return $Kernel.$Rational(self.num.$abs(), self.den.$abs())
21754 $def(self, '$ceil', function $$ceil(precision) {
21755 var self = this;
21760 return $rb_divide(self.num['$-@'](), self.den)['$-@']().$ceil()
21762 return self.$with_precision("ceil", precision)
21766 $def(self, '$floor', function $$floor(precision) {
21767 var self = this;
21772 return $rb_divide(self.num['$-@'](), self.den)['$-@']().$floor()
21774 return self.$with_precision("floor", precision)
21778 $def(self, '$hash', function $$hash() {
21779 var self = this;
21781 return "Rational:" + (self.num) + ":" + (self.den)
21784 $def(self, '$inspect', function $$inspect() {
21785 var self = this;
21787 return "(" + (self) + ")"
21790 $def(self, '$rationalize', function $$rationalize(eps) {
21791 var self = this;
21801 return self;
21805 a = $rb_minus(self, e),
21806 b = $rb_plus(self, e);
21840 $def(self, '$round', function $$round(precision) {
21841 var self = this, num = nil, den = nil, approx = nil;
21846 return self.$with_precision("round", precision)
21848 if ($eqeq(self.num, 0)) {
21851 if ($eqeq(self.den, 1)) {
21852 return self.num
21854 num = $rb_plus($rb_times(self.num.$abs(), 2), self.den);
21855 den = $rb_times(self.den, 2);
21857 if ($truthy($rb_lt(self.num, 0))) {
21864 $def(self, '$to_f', function $$to_f() {
21865 var self = this;
21867 return $rb_divide(self.num, self.den)
21870 $def(self, '$to_i', function $$to_i() {
21871 var self = this;
21873 return self.$truncate()
21876 $def(self, '$to_r', $return_self);
21878 $def(self, '$to_s', function $$to_s() {
21879 var self = this;
21881 return "" + (self.num) + "/" + (self.den)
21884 $def(self, '$truncate', function $$truncate(precision) {
21885 var self = this;
21890 if ($truthy($rb_lt(self.num, 0))) {
21891 return self.$ceil()
21893 return self.$floor()
21896 return self.$with_precision("truncate", precision)
21900 $def(self, '$with_precision', function $$with_precision(method, precision) {
21901 var self = this, p = nil, s = nil;
21908 s = $rb_times(self, p);
21915 $defs(self, '$from_string', function $$from_string(string) {
21955 $alias(self, "divide", "/");
21956 return $alias(self, "quo", "/");
21961 … Opal.neqeq, $rb_le = Opal.rb_le, $eqeq = Opal.eqeq, $alias = Opal.alias, self = Opal.top, $nestin…
21965 self.$require("corelib/comparable");
21967 var self = $klass($base, $super, 'Time');
21969 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
21972 self.$include($$$('Comparable'));
21979 $defs(self, '$at', function $$at(seconds, frac) {
22101 $defs(self, '$new', function $Time_new$1(year, month, day, hour, min, sec, utc_offset) {
22102 var self = this;
22135 timezone = self.$_parse_offset(utc_offset);
22147 $defs(self, '$_parse_offset', function $$_parse_offset(utc_offset) {
22177 …$defs(self, '$local', function $$local(year, month, day, hour, min, sec, millisecond, _dummy1, _du…
22217 …$defs(self, '$gm', function $$gm(year, month, day, hour, min, sec, millisecond, _dummy1, _dummy2, …
22258 $defs(self, '$now', function $$now() {
22259 var self = this;
22261 return self.$new()
22264 $def(self, '$+', function $Time_$plus$2(other) {
22265 var self = this;
22275 var result = new Date(self.getTime() + (other * 1000));
22276 result.timezone = self.timezone;
22281 $def(self, '$-', function $Time_$minus$3(other) {
22282 var self = this;
22286 return (self.getTime() - other.getTime()) / 1000
22292 var result = new Date(self.getTime() - (other * 1000));
22293 result.timezone = self.timezone;
22298 $def(self, '$<=>', function $Time_$lt_eq_gt$4(other) {
22299 var self = this, r = nil;
22302 return self.$to_f()['$<=>'](other.$to_f())
22305 r = other['$<=>'](self);
22318 $def(self, '$==', function $Time_$eq_eq$5(other) {
22319 var self = this, $ret_or_1 = nil;
22322 return self.$to_f() === other.$to_f()
22328 $def(self, '$asctime', function $$asctime() {
22329 var self = this;
22331 return self.$strftime("%a %b %e %H:%M:%S %Y")
22333 …, 'each', [], function $Time$6(method, getter, utcgetter, difference){var self = $Time$6.$$s == nu…
22340 …return $send(self, 'define_method', [method], function $$7(){var self = $$7.$$s == null ? this : $…
22343 return difference + ((self.timezone != null) ?
22344 (new Date(self.getTime() + self.timezone * 3600000))[utcgetter]() :
22345 self[getter]())
22346 }, {$$s: self});}, {$$arity: -4, $$s: self});
22348 $def(self, '$yday', function $$yday() {
22349 var self = this, start_of_year = nil, start_of_day = nil, one_day = nil;
22352 start_of_year = $$('Time').$new(self.$year()).$to_i();
22353 start_of_day = $$('Time').$new(self.$year(), self.$month(), self.$day()).$to_i();
22358 $def(self, '$isdst', function $$isdst() {
22359 var self = this;
22362 var jan = new Date(self.getFullYear(), 0, 1),
22363 jul = new Date(self.getFullYear(), 6, 1);
22364 return self.getTimezoneOffset() < Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
22368 $def(self, '$dup', function $$dup() {
22369 var self = this, copy = nil;
22372 copy = new Date(self.getTime());
22373 copy.$copy_instance_variables(self);
22374 copy.$initialize_dup(self);
22378 $def(self, '$eql?', function $Time_eql$ques$8(other) {
22379 var self = this, $ret_or_1 = nil;
22382 return self['$<=>'](other)['$zero?']()
22387 … 5], ["saturday?", 6]], 'each', [], function $Time$9(method, weekday){var self = $Time$9.$$s == nu…
22392 …return $send(self, 'define_method', [method], function $$10(){var self = $$10.$$s == null ? this :…
22394 return self.$wday() === weekday}, {$$s: self});}, {$$s: self});
22396 $def(self, '$hash', function $$hash() {
22397 var self = this;
22399 return 'Time:' + self.getTime();
22402 $def(self, '$inspect', function $$inspect() {
22403 var self = this;
22405 if ($truthy(self['$utc?']())) {
22406 return self.$strftime("%Y-%m-%d %H:%M:%S UTC")
22408 return self.$strftime("%Y-%m-%d %H:%M:%S %z")
22412 $def(self, '$succ', function $$succ() {
22413 var self = this;
22416 var result = new Date(self.getTime() + 1000);
22417 result.timezone = self.timezone;
22422 $def(self, '$usec', function $$usec() {
22423 var self = this;
22425 return self.getMilliseconds() * 1000;
22428 $def(self, '$zone', function $$zone() {
22429 var self = this;
22432 if (self.timezone === 0) return "UTC";
22433 else if (self.timezone != null) return nil;
22435 var string = self.toString(),
22454 $def(self, '$getgm', function $$getgm() {
22455 var self = this;
22458 var result = new Date(self.getTime());
22464 $def(self, '$gmtime', function $$gmtime() {
22465 var self = this;
22468 if (self.timezone !== 0) {
22469 $deny_frozen_access(self);
22470 self.timezone = 0;
22472 return self;
22476 $def(self, '$gmt?', function $Time_gmt$ques$11() {
22477 var self = this;
22479 return self.timezone === 0;
22482 $def(self, '$gmt_offset', function $$gmt_offset() {
22483 var self = this;
22485 return (self.timezone != null) ? self.timezone * 60 : -self.getTimezoneOffset() * 60;
22488 $def(self, '$strftime', function $$strftime(format) {
22489 var self = this;
22514 result += self.$year();
22519 result += Math.round(self.$year() / 100);
22524 result += (self.$year() % 100);
22529 result += self.$mon();
22533 result += long_months[self.$mon() - 1];
22539 result += short_months[self.$mon() - 1];
22544 result += self.$day();
22549 result += self.$day();
22555 result += self.$yday();
22560 result += self.$hour();
22565 result += self.$hour();
22570 result += (self.$hour() % 12 || 12);
22575 result += (self.$hour() % 12 || 12);
22579 result += (self.$hour() >= 12 ? "pm" : "am");
22583 result += (self.$hour() >= 12 ? "PM" : "AM");
22588 result += self.$min();
22593 result += self.$sec()
22599 result += self.getMilliseconds();
22604 result += (self.getMilliseconds().toString()).$rjust(3, "0");
22609 … var offset = (self.timezone == null) ? self.getTimezoneOffset() : (-self.timezone * 60),
22631 result += self.$zone();
22635 result += days_of_week[self.$wday()];
22639 result += short_days[self.$wday()];
22643 result += (self.$wday() + 1);
22647 result += self.$wday();
22651 result += self.$cweek_cyear()['$[]'](0).$to_s().$rjust(2, "0");
22655 result += self.$cweek_cyear()['$[]'](1);
22659 result += self.$cweek_cyear()['$[]'](1)['$[]']($range(-2, -1, false));
22663 result += self.$to_i();
22679 result += self.$strftime("%a %b %e %T %Y");
22684 result += self.$strftime("%m/%d/%y");
22688 result += self.$strftime("%Y-%m-%d");
22692 result += self.$strftime("%e-%^b-%4Y");
22696 result += self.$strftime("%I:%M:%S %p");
22700 result += self.$strftime("%H:%M");
22705 result += self.$strftime("%H:%M:%S");
22710 jd = self.$to_date().$jd();
22712 result += self.$strftime("%Y-%m-%d");
22726 result += self.$format("%c%02d", c, $rb_minus(self.$year(), s));
22727 result += self.$strftime("-%m-%d");
22752 $def(self, '$to_a', function $$to_a() {
22753 var self = this;
22755 …return [self.$sec(), self.$min(), self.$hour(), self.$day(), self.$month(), self.$year(), self.$wd…
22758 $def(self, '$to_f', function $$to_f() {
22759 var self = this;
22761 return self.getTime() / 1000;
22764 $def(self, '$to_i', function $$to_i() {
22765 var self = this;
22767 return parseInt(self.getTime() / 1000, 10);
22770 $def(self, '$cweek_cyear', function $$cweek_cyear() {
22771 …var self = this, jan01 = nil, jan01_wday = nil, first_monday = nil, year = nil, offset = nil, week…
22774 jan01 = $$$('Time').$new(self.$year(), 1, 1);
22777 year = self.$year();
22787 week = $rb_divide($rb_plus(self.$yday(), offset), 7.0).$ceil();
22789 return $$$('Time').$new($rb_minus(self.$year(), 1), 12, 31).$cweek_cyear()
22792 dec31 = $$$('Time').$new(self.$year(), 12, 31);
22802 (function(self, $parent_nesting) { argument
22805 $alias(self, "mktime", "local");
22806 return $alias(self, "utc", "gm");
22807 })(Opal.get_singleton_class(self), $nesting);
22808 $alias(self, "ctime", "asctime");
22809 $alias(self, "dst?", "isdst");
22810 $alias(self, "getutc", "getgm");
22811 $alias(self, "gmtoff", "gmt_offset");
22812 $alias(self, "mday", "day");
22813 $alias(self, "month", "mon");
22814 $alias(self, "to_s", "inspect");
22815 $alias(self, "tv_sec", "to_i");
22816 $alias(self, "tv_usec", "usec");
22817 $alias(self, "utc", "gmtime");
22818 $alias(self, "utc?", "gmt?");
22819 return $alias(self, "utc_offset", "gmt_offset");
22824 …rb_lt, $rb_ge = Opal.rb_ge, $rb_plus = Opal.rb_plus, $alias = Opal.alias, self = Opal.top, $nestin…
22828 self.$require("corelib/enumerable");
22830 var self = $klass($base, $super, 'Struct');
22832 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
22835 self.$include($$$('Enumerable'));
22836 $defs(self, '$new', function $Struct_new$1(const_name, $a, $b) {
22837 …var block = $Struct_new$1.$$p || nil, $post_args, $kwargs, args, keyword_init, self = this, klass …
22872 … klass = $send($Class, 'new', [self], function $$3(){var self = $$3.$$s == null ? this : $$3.$$s;
22875 $send(args, 'each', [], function $$4(arg){var self = $$4.$$s == null ? this : $$4.$$s;
22879 return self.$define_struct_attribute(arg);}, {$$s: self});
22880 return (function(self, $parent_nesting) { argument
22884 $def(self, '$new', function $new$5($a) {
22885 var $post_args, args, self = this, instance = nil;
22890 instance = self.$allocate();
22895 return self.$alias_method("[]", "new");
22896 })(Opal.get_singleton_class(self), $nesting);}, {$$s: self});
22906 $defs(self, '$define_struct_attribute', function $$define_struct_attribute(name) {
22907 var self = this;
22910 if ($eqeq(self, $$$('Struct'))) {
22913 self.$members()['$<<'](name);
22914 … $send(self, 'define_method', [name], function $$6(){var self = $$6.$$s == null ? this : $$6.$$s;
22916 return self.$$data[name];}, {$$s: self});
22917 …return $send(self, 'define_method', ["" + (name) + "="], function $$7(value){var self = $$7.$$s ==…
22921 return self.$$data[name] = value;;}, {$$s: self});
22923 $defs(self, '$members', function $$members() {
22924 var self = this, $ret_or_1 = nil;
22925 if (self.members == null) self.members = nil;
22928 if ($eqeq(self, $$$('Struct'))) {
22931 return (self.members = ($truthy(($ret_or_1 = self.members)) ? ($ret_or_1) : ([])));
22933 $defs(self, '$inherited', function $$inherited(klass) {
22934 var self = this, members = nil;
22935 if (self.members == null) self.members = nil;
22938 members = self.members;
22939 …return $send(klass, 'instance_eval', [], function $$8(){var self = $$8.$$s == null ? this : $$8.$$…
22941 return (self.members = members)}, {$$s: self});
22944 $def(self, '$initialize', function $$initialize($a) {
22945 var $post_args, args, self = this, kwargs = nil, $ret_or_1 = nil, extra = nil;
22950 if ($truthy(self.$class().$$keyword_init)) {
22956 extra = $rb_minus(kwargs.$keys(), self.$class().$members());
22960 …return $send(self.$class().$members(), 'each', [], function $$9(name){var $b, self = $$9.$$s == nu…
22964 …return ($b = [name, kwargs['$[]'](name)], $send(self, '[]=', $b), $b[$b.length - 1]);}, {$$s: self…
22967 if ($truthy($rb_gt(args.$length(), self.$class().$members().$length()))) {
22970 …return $send(self.$class().$members(), 'each_with_index', [], function $$10(name, index){var $b, s…
22975 …return ($b = [name, args['$[]'](index)], $send(self, '[]=', $b), $b[$b.length - 1]);}, {$$s: self}…
22979 $def(self, '$initialize_copy', function $$initialize_copy(from) {
22980 var self = this;
22983 self.$$data = {}
22987 self.$$data[name] = from.$$data[name];
22991 $defs(self, '$keyword_init?', function $Struct_keyword_init$ques$11() {
22992 var self = this;
22994 return self.$$keyword_init;
22997 $def(self, '$members', function $$members() {
22998 var self = this;
23000 return self.$class().$members()
23003 $def(self, '$hash', function $$hash() {
23004 var self = this;
23006 return $$('Hash').$new(self.$$data).$hash()
23009 $def(self, '$[]', function $Struct_$$$12(name) {
23010 var self = this;
23015 if ($truthy($rb_lt(name, self.$class().$members().$size()['$-@']()))) {
23016 …($$$('IndexError'), "offset " + (name) + " too small for struct(size:" + (self.$class().$members()…
23018 if ($truthy($rb_ge(name, self.$class().$members().$size()))) {
23019 …($$$('IndexError'), "offset " + (name) + " too large for struct(size:" + (self.$class().$members()…
23021 name = self.$class().$members()['$[]'](name);
23024 if(!self.$$data.hasOwnProperty(name)) {
23032 return self.$$data[name];;
23035 $def(self, '$[]=', function $Struct_$$$eq$13(name, value) {
23036 var self = this;
23041 if ($truthy($rb_lt(name, self.$class().$members().$size()['$-@']()))) {
23042 …($$$('IndexError'), "offset " + (name) + " too small for struct(size:" + (self.$class().$members()…
23044 if ($truthy($rb_ge(name, self.$class().$members().$size()))) {
23045 …($$$('IndexError'), "offset " + (name) + " too large for struct(size:" + (self.$class().$members()…
23047 name = self.$class().$members()['$[]'](name);
23049 if (!$truthy(self.$class().$members()['$include?'](name.$to_sym()))) {
23056 return self.$$data[name] = value;;
23059 $def(self, '$==', function $Struct_$eq_eq$14(other) {
23060 var self = this;
23063 if (!$truthy(other['$instance_of?'](self.$class()))) {
23095 return _eqeq(self, other);
23099 $def(self, '$eql?', function $Struct_eql$ques$15(other) {
23100 var self = this;
23103 if (!$truthy(other['$instance_of?'](self.$class()))) {
23135 return _eqeq(self, other);
23139 $def(self, '$each', function $$each() {
23140 var $yield = $$each.$$p || nil, self = this;
23145 …return $send(self, 'enum_for', ["each"], function $$16(){var self = $$16.$$s == null ? this : $$16…
23147 return self.$size()}, {$$s: self})
23149 …$send(self.$class().$members(), 'each', [], function $$17(name){var self = $$17.$$s == null ? this…
23153 return Opal.yield1($yield, self['$[]'](name));;}, {$$s: self});
23154 return self;
23157 $def(self, '$each_pair', function $$each_pair() {
23158 var $yield = $$each_pair.$$p || nil, self = this;
23163 …return $send(self, 'enum_for', ["each_pair"], function $$18(){var self = $$18.$$s == null ? this :…
23165 return self.$size()}, {$$s: self})
23167 …$send(self.$class().$members(), 'each', [], function $$19(name){var self = $$19.$$s == null ? this…
23171 return Opal.yield1($yield, [name, self['$[]'](name)]);;}, {$$s: self});
23172 return self;
23175 $def(self, '$length', function $$length() {
23176 var self = this;
23178 return self.$class().$members().$length()
23181 $def(self, '$to_a', function $$to_a() {
23182 var self = this;
23184 …return $send(self.$class().$members(), 'map', [], function $$20(name){var self = $$20.$$s == null …
23188 return self['$[]'](name);}, {$$s: self})
23192 $def(self, '$inspect', function $$inspect() {
23193 var self = this, result = nil, pushed = nil;
23198 if ($truthy((inspect_stack)['$include?'](self.$__id__()))) {
23202 (inspect_stack)['$<<'](self.$__id__());
23204 if (($eqeqeq($$$('Struct'), self) && ($truthy(self.$class().$name())))) {
23205 result = $rb_plus(result, "" + (self.$class()) + " ")
23207 result = $rb_plus(result, $send(self.$each_pair(), 'map', [], function $$21(name, value){
23220 $def(self, '$to_h', function $$to_h() {
23221 var block = $$to_h.$$p || nil, self = this;
23227 return $send($send(self, 'map', [], block.$to_proc()), 'to_h', $to_a(self.$args()))
23229 …return $send(self.$class().$members(), 'each_with_object', [$hash2([], {})], function $$22(name, h…
23234 … return ($a = [name, self['$[]'](name)], $send(h, '[]=', $a), $a[$a.length - 1]);}, {$$s: self});
23237 $def(self, '$values_at', function $$values_at($a) {
23238 var $post_args, args, self = this;
23253 result.push(self['$[]'](args[i]));
23259 $def(self, '$dig', function $$dig(key, $a) {
23260 var $post_args, keys, self = this, item = nil;
23265 …item = ($truthy(key.$$is_string && self.$$data.hasOwnProperty(key)) ? (self.$$data[key] || nil) : …
23276 $alias(self, "size", "length");
23277 $alias(self, "to_s", "inspect");
23278 return $alias(self, "values", "to_a");
23287 var self = $klass($base, $super, 'Set');
23289 …var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting), $ret_or_1 = nil, $proto = s…
23293 self.$include($$$('Enumerable'));
23294 $defs(self, '$[]', function $Set_$$$1($a) {
23295 var $post_args, ary, self = this;
23300 return self.$new(ary);
23303 $def(self, '$initialize', function $$initialize(enum$) {
23304 var block = $$initialize.$$p || nil, self = this;
23310 self.hash = $hash2([], {});
23318 … return $send(enum$, 'each', [], function $$2(item){var self = $$2.$$s == null ? this : $$2.$$s;
23322 return self.$add(Opal.yield1(block, item));}, {$$s: self})
23324 return self.$merge(enum$)
23328 $def(self, '$dup', function $$dup() {
23329 var self = this, result = nil;
23332 result = self.$class().$new();
23333 return result.$merge(self);
23336 $def(self, '$-', function $Set_$minus$3(enum$) {
23337 var self = this;
23343 return self.$dup().$subtract(enum$);
23346 $def(self, '$inspect', function $$inspect() {
23347 var self = this;
23349 return "#<Set: {" + (self.$to_a().$join(",")) + "}>"
23352 $def(self, '$==', function $Set_$eq_eq$4(other) {
23353 var self = this;
23355 if ($truthy(self['$equal?'](other))) {
23357 } else if ($truthy(other['$instance_of?'](self.$class()))) {
23358 return self.hash['$=='](other.$instance_variable_get("@hash"))
23359 } else if (($truthy(other['$is_a?']($$$('Set'))) && ($eqeq(self.$size(), other.$size())))) {
23360 return $send(other, 'all?', [], function $$5(o){var self = $$5.$$s == null ? this : $$5.$$s;
23361 if (self.hash == null) self.hash = nil;
23365 return self.hash['$include?'](o);}, {$$s: self})
23371 $def(self, '$add', function $$add(o) {
23372 var self = this;
23375 self.hash['$[]='](o, true);
23376 return self;
23379 $def(self, '$classify', function $$classify() {
23380 var block = $$classify.$$p || nil, self = this, result = nil;
23386 return self.$enum_for("classify")
23388 …result = $send($$$('Hash'), 'new', [], function $$6(h, k){var $a, self = $$6.$$s == null ? this : …
23393 … return ($a = [k, self.$class().$new()], $send(h, '[]=', $a), $a[$a.length - 1]);}, {$$s: self});
23394 $send(self, 'each', [], function $$7(item){
23401 $def(self, '$collect!', function $Set_collect$excl$8() {
23402 var block = $Set_collect$excl$8.$$p || nil, self = this, result = nil;
23408 return self.$enum_for("collect!")
23410 result = self.$class().$new();
23411 $send(self, 'each', [], function $$9(item){
23415 return self.$replace(result);
23418 $def(self, '$compare_by_identity', function $$compare_by_identity() {
23419 var self = this;
23421 if ($truthy(self.hash['$respond_to?']("compare_by_identity"))) {
23423 self.hash.$compare_by_identity();
23424 return self;
23426 …return self.$raise($$('NotImplementedError'), "" + (self.$class().$name()) + "#" + ("compare_by_id…
23430 $def(self, '$compare_by_identity?', function $Set_compare_by_identity$ques$10() {
23431 var self = this, $ret_or_1 = nil;
23433 if ($truthy(($ret_or_1 = self.hash['$respond_to?']("compare_by_identity?")))) {
23434 return self.hash['$compare_by_identity?']()
23440 $def(self, '$delete', function $Set_delete$11(o) {
23441 var self = this;
23444 self.hash.$delete(o);
23445 return self;
23448 $def(self, '$delete?', function $Set_delete$ques$12(o) {
23449 var self = this;
23451 if ($truthy(self['$include?'](o))) {
23453 self.$delete(o);
23454 return self;
23460 $def(self, '$delete_if', function $$delete_if() {
23461 var $yield = $$delete_if.$$p || nil, self = this;
23466 return self.$enum_for("delete_if")
23468 $send($send(self, 'select', [], function $$13(o){
23471 …return Opal.yield1($yield, o);;}), 'each', [], function $$14(o){var self = $$14.$$s == null ? this…
23472 if (self.hash == null) self.hash = nil;
23476 return self.hash.$delete(o);}, {$$s: self});
23477 return self;
23480 $def(self, '$freeze', function $$freeze() {
23481 var self = this;
23484 if ($truthy(self['$frozen?']())) {
23485 return self
23487 self.hash.$freeze();
23488 return $freeze(self);;
23491 $def(self, '$keep_if', function $$keep_if() {
23492 var $yield = $$keep_if.$$p || nil, self = this;
23497 return self.$enum_for("keep_if")
23499 $send($send(self, 'reject', [], function $$15(o){
23502 …return Opal.yield1($yield, o);;}), 'each', [], function $$16(o){var self = $$16.$$s == null ? this…
23503 if (self.hash == null) self.hash = nil;
23507 return self.hash.$delete(o);}, {$$s: self});
23508 return self;
23511 $def(self, '$reject!', function $Set_reject$excl$17() {
23512 var block = $Set_reject$excl$17.$$p || nil, self = this, before = nil;
23518 return self.$enum_for("reject!")
23520 before = self.$size();
23521 $send(self, 'delete_if', [], block.$to_proc());
23522 if ($eqeq(self.$size(), before)) {
23525 return self
23529 $def(self, '$select!', function $Set_select$excl$18() {
23530 var block = $Set_select$excl$18.$$p || nil, self = this, before = nil;
23536 return self.$enum_for("select!")
23538 before = self.$size();
23539 $send(self, 'keep_if', [], block.$to_proc());
23540 if ($eqeq(self.$size(), before)) {
23543 return self
23547 $def(self, '$add?', function $Set_add$ques$19(o) {
23548 var self = this;
23550 if ($truthy(self['$include?'](o))) {
23553 return self.$add(o)
23557 $def(self, '$each', function $$each() {
23558 var block = $$each.$$p || nil, self = this;
23564 return self.$enum_for("each")
23566 $send(self.hash, 'each_key', [], block.$to_proc());
23567 return self;
23570 $def(self, '$empty?', function $Set_empty$ques$20() {
23571 var self = this;
23573 return self.hash['$empty?']()
23576 $def(self, '$eql?', function $Set_eql$ques$21(other) {
23577 var self = this;
23579 …return self.hash['$eql?']($send(other, 'instance_eval', [], function $$22(){var self = $$22.$$s ==…
23580 if (self.hash == null) self.hash = nil;
23582 return self.hash}, {$$s: self}))
23585 $def(self, '$clear', function $$clear() {
23586 var self = this;
23589 self.hash.$clear();
23590 return self;
23593 $def(self, '$include?', function $Set_include$ques$23(o) {
23594 var self = this;
23596 return self.hash['$include?'](o)
23599 $def(self, '$merge', function $$merge(enum$) {
23600 var self = this;
23603 $send(enum$, 'each', [], function $$24(item){var self = $$24.$$s == null ? this : $$24.$$s;
23607 return self.$add(item);}, {$$s: self});
23608 return self;
23611 $def(self, '$replace', function $$replace(enum$) {
23612 var self = this;
23615 self.$clear();
23616 self.$merge(enum$);
23617 return self;
23620 $def(self, '$size', function $$size() {
23621 var self = this;
23623 return self.hash.$size()
23626 $def(self, '$subtract', function $$subtract(enum$) {
23627 var self = this;
23630 $send(enum$, 'each', [], function $$25(item){var self = $$25.$$s == null ? this : $$25.$$s;
23634 return self.$delete(item);}, {$$s: self});
23635 return self;
23638 $def(self, '$|', function $Set_$$26(enum$) {
23639 var self = this;
23645 return self.$dup().$merge(enum$);
23653 $def(self, '$superset?', function $Set_superset$ques$27(set) {
23654 var self = this;
23658 if ($truthy($rb_lt(self.$size(), set.$size()))) {
23661 return $send(set, 'all?', [], function $$28(o){var self = $$28.$$s == null ? this : $$28.$$s;
23665 return self['$include?'](o);}, {$$s: self});
23668 $def(self, '$proper_superset?', function $Set_proper_superset$ques$29(set) {
23669 var self = this;
23673 if ($truthy($rb_le(self.$size(), set.$size()))) {
23676 return $send(set, 'all?', [], function $$30(o){var self = $$30.$$s == null ? this : $$30.$$s;
23680 return self['$include?'](o);}, {$$s: self});
23683 $def(self, '$subset?', function $Set_subset$ques$31(set) {
23684 var self = this;
23688 if ($truthy($rb_lt(set.$size(), self.$size()))) {
23691 return $send(self, 'all?', [], function $$32(o){
23697 $def(self, '$proper_subset?', function $Set_proper_subset$ques$33(set) {
23698 var self = this;
23702 if ($truthy($rb_le(set.$size(), self.$size()))) {
23705 return $send(self, 'all?', [], function $$34(o){
23711 $def(self, '$intersect?', function $Set_intersect$ques$35(set) {
23712 var self = this;
23716 if ($truthy($rb_lt(self.$size(), set.$size()))) {
23717 return $send(self, 'any?', [], function $$36(o){
23722 … return $send(set, 'any?', [], function $$37(o){var self = $$37.$$s == null ? this : $$37.$$s;
23726 return self['$include?'](o);}, {$$s: self})
23730 $def(self, '$disjoint?', function $Set_disjoint$ques$38(set) {
23731 var self = this;
23733 return self['$intersect?'](set)['$!']()
23736 $def(self, '$to_a', function $$to_a() {
23737 var self = this;
23739 return self.hash.$keys()
23741 $alias(self, "+", "|");
23742 $alias(self, "<", "proper_subset?");
23743 $alias(self, "<<", "add");
23744 $alias(self, "<=", "subset?");
23745 $alias(self, ">", "proper_superset?");
23746 $alias(self, ">=", "superset?");
23747 $alias(self, "difference", "-");
23748 $alias(self, "filter!", "select!");
23749 $alias(self, "length", "size");
23750 $alias(self, "map!", "collect!");
23751 $alias(self, "member?", "include?");
23752 return $alias(self, "union", "|");
23761 var self = $klass($base, $super, 'Dir');
23763 var $nesting = [self].concat($parent_nesting);
23765 return (function(self, $parent_nesting) { argument
23769 $def(self, '$chdir', function $$chdir(dir) {
23783 $def(self, '$pwd', function $$pwd() {
23788 $def(self, '$home', function $$home() {
23797 return $alias(self, "getwd", "pwd");
23798 })(Opal.get_singleton_class(self), $nesting)
23807 var self = $klass($base, $super, 'File');
23809 var $nesting = [self].concat($parent_nesting), windows_root_rx = nil;
23817 return (function(self, $parent_nesting) { argument
23818 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
23822 $def(self, '$absolute_path', function $$absolute_path(path, basedir) {
23876 $def(self, '$expand_path', function $$expand_path(path, basedir) {
23877 …var self = this, sep = nil, sep_chars = nil, home = nil, leading_sep = nil, home_path_regexp = nil;
23900 return self.$absolute_path(path, basedir);
23924 $def(self, '$dirname', function $$dirname(path, level) {
23925 var self = this, sep_chars = nil;
23955 return self.$dirname(out, $rb_minus(level, 1))
23960 $def(self, '$basename', function $$basename(name, suffix) {
23992 $def(self, '$extname', function $$extname(path) {
23993 var self = this, filename = nil, last_dot_idx = nil;
23997 filename = self.$basename(path);
24009 $def(self, '$exist?', function $exist$ques$1(path) {
24014 $def(self, '$directory?', function $directory$ques$2(path) {
24031 $def(self, '$join', function $$join($a) {
24071 $def(self, '$split', function $$split(path) {
24075 $alias(self, "realpath", "expand_path");
24076 return $alias(self, "exists?", "exist?");
24077 })(Opal.get_singleton_class(self), $nesting);
24086 var self = $klass($base, $super, 'Signal');
24089 return $defs(self, '$trap', function $$trap($a) {
24099 var self = $klass($base, $super, 'GC');
24102 return $defs(self, '$start', $return_val(nil))
24111 var self = $module($base, 'Process');
24116 self.__clocks__ = [];
24117 $defs(self, '$__register_clock__', function $$__register_clock__(name, func) {
24118 var self = this;
24119 if (self.__clocks__ == null) self.__clocks__ = nil;
24122 self.$const_set(name, self.__clocks__.$size());
24123 return self.__clocks__['$<<'](func);
24125 self.$__register_clock__("CLOCK_REALTIME", function() { return Date.now() });
24145 self.$__register_clock__("CLOCK_MONOTONIC", monotonic)
24147 $defs(self, '$pid', $return_val(0));
24148 $defs(self, '$times', function $$times() {
24155 return $defs(self, '$clock_gettime', function $$clock_gettime(clock_id, unit) {
24156 var self = this, $ret_or_1 = nil, clock = nil;
24157 if (self.__clocks__ == null) self.__clocks__ = nil;
24161 if ($truthy(($ret_or_1 = (clock = self.__clocks__['$[]'](clock_id))))) {
24164 …$Kernel.$raise($$$($$$('Errno'), 'EINVAL'), "clock_gettime(" + (clock_id) + ") " + (self.__clocks_…
24188 var self = $klass($base, $super, 'Random');
24190 var $nesting = [self].concat($parent_nesting);
24194 var self = $module($base, 'Formatter');
24196 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
24200 $def(self, '$hex', function $$hex(count) {
24201 var self = this;
24207 var bytes = self.$bytes(count);
24216 $def(self, '$random_bytes', function $$random_bytes(count) {
24217 var self = this;
24221 return self.$bytes(count);
24224 $def(self, '$base64', function $$base64(count) {
24225 var self = this;
24229 return $$$('Base64').$strict_encode64(self.$random_bytes(count)).$encode("US-ASCII");
24232 $def(self, '$urlsafe_base64', function $$urlsafe_base64(count, padding) {
24233 var self = this;
24238 … return $$$('Base64').$urlsafe_encode64(self.$random_bytes(count), padding).$encode("US-ASCII");
24241 $def(self, '$uuid', function $$uuid() {
24242 var self = this, str = nil;
24245 str = self.$hex(16).$split("");
24253 $def(self, '$random_float', function $$random_float() {
24254 var self = this, bs = nil, num = nil;
24257 bs = self.$bytes(4);
24267 $def(self, '$random_number', function $$random_number(limit) {
24268 var self = this;
24274 return self.$random_float();
24332 return $def(self, '$alphanumeric', function $$alphanumeric(count) {
24333 var self = this, map = nil;
24339 …return $send($$$('Array'), 'new', [count], function $$2(i){var self = $$2.$$s == null ? this : $$2…
24343 return map['$[]'](self.$random_number(map.$length()));}, {$$s: self}).$join();
24345 })(self, $nesting);
24346 self.$include($$$($$$('Random'), 'Formatter'));
24347 return self.$extend($$$($$$('Random'), 'Formatter'));
24438 var self = $klass($base, $super, 'Random');
24444 $const_set(self, 'MERSENNE_TWISTER_GENERATOR', {
24449 …return ($a = [$$$(self, 'MERSENNE_TWISTER_GENERATOR')], $send(self, 'generator=', $a), $a[$a.lengt…
24454 …l = Opal.Opal, $def = Opal.def, $eqeqeq = Opal.eqeqeq, $send = Opal.send, self = Opal.top, nil = O…
24458 self.$require("corelib/random/formatter");
24460 var self = $klass($base, $super, 'Random');
24464 self.$attr_reader("seed", "state");
24465 $defs(self, '$_verify_count', function $$_verify_count(count) {
24476 $def(self, '$initialize', function $$initialize(seed) {
24477 var self = this;
24482 self.state = seed;
24483 return self.$reseed(seed);
24486 $def(self, '$reseed', function $$reseed(seed) {
24487 var self = this;
24490 self.seed = seed;
24491 return self.$rng = Opal.$$rand.reseed(seed);;
24493 $defs(self, '$new_seed', function $$new_seed() {
24497 $defs(self, '$rand', function $$rand(limit) {
24498 var self = this;
24502 return $$$(self, 'DEFAULT').$rand(limit);
24504 $defs(self, '$srand', function $$srand(n) {
24505 var self = this, previous_seed = nil;
24510 previous_seed = $$$(self, 'DEFAULT').$seed();
24511 $$$(self, 'DEFAULT').$reseed(n);
24514 $defs(self, '$urandom', function $$urandom(size) {
24519 $def(self, '$==', function $Random_$eq_eq$1(other) {
24520 var self = this, $ret_or_1 = nil;
24526 if ($truthy(($ret_or_1 = self.$seed()['$=='](other.$seed())))) {
24527 return self.$state()['$=='](other.$state())
24533 $def(self, '$bytes', function $$bytes(length) {
24534 var self = this;
24538 …return $send($$$('Array'), 'new', [length], function $$2(){var self = $$2.$$s == null ? this : $$2…
24540 return self.$rand(255).$chr()}, {$$s: self}).$join().$encode("ASCII-8BIT");
24542 $defs(self, '$bytes', function $$bytes(length) {
24543 var self = this;
24545 return $$$(self, 'DEFAULT').$bytes(length)
24548 $def(self, '$rand', function $$rand(limit) {
24549 var self = this;
24553 return self.$random_number(limit);
24556 $def(self, '$random_float', function $$random_float() {
24557 var self = this;
24560 self.state++;
24561 return Opal.$$rand.rand(self.$rng);
24564 $defs(self, '$random_float', function $$random_float() {
24565 var self = this;
24567 return $$$(self, 'DEFAULT').$random_float()
24569 return $defs(self, '$generator=', function $Random_generator$eq$3(generator) {
24570 var self = this;
24574 if ($truthy(self['$const_defined?']("DEFAULT"))) {
24575 return $$$(self, 'DEFAULT').$reseed()
24577 return self.$const_set("DEFAULT", self.$new(self.$new_seed()))
24581 return self.$require("corelib/random/mersenne_twister");
24585 …f, $return_val = Opal.return_val, $alias = Opal.alias, $defs = Opal.defs, self = Opal.top, $nestin…
24611 self.$warn(string);
24615 var self = $klass($base, $super, 'String');
24620 …", "unicode_normalize!"], 'each', [], function $String$1(method_name){var self = $String$1.$$s == …
24624 return $send(self, 'define_method', [method_name], function $$2($a){var $post_args, $fwd_rest;
24629 …turn $Kernel.$raise($$$('NotImplementedError'), (ERROR)['$%'](method_name));}, -1);}, {$$s: self});
24632 var self = $module($base, 'Kernel');
24638 $def(self, '$taint', function $$taint() {
24639 var self = this;
24643 return self;
24646 $def(self, '$untaint', function $$untaint() {
24647 var self = this;
24651 return self;
24653 return $def(self, '$tainted?', function $Kernel_tainted$ques$3() {
24661 var self = $klass($base, $super, 'Module');
24666 $def(self, '$public', function $Module_public$4($a) {
24667 var $post_args, methods, self = this;
24674 self.$$module_function = false;
24681 $def(self, '$private_class_method', function $$private_class_method($a) {
24690 $def(self, '$private_method_defined?', $return_val(false));
24692 $def(self, '$private_constant', function $$private_constant($a) {
24700 $alias(self, "nesting", "public");
24701 $alias(self, "private", "public");
24702 $alias(self, "protected", "public");
24703 $alias(self, "protected_method_defined?", "private_method_defined?");
24704 $alias(self, "public_class_method", "private_class_method");
24705 $alias(self, "public_instance_method", "instance_method");
24706 $alias(self, "public_instance_methods", "instance_methods");
24707 return $alias(self, "public_method_defined?", "method_defined?");
24710 var self = $module($base, 'Kernel');
24715 $def(self, '$private_methods', function $$private_methods($a) {
24723 $alias(self, "protected_methods", "private_methods");
24724 $alias(self, "private_instance_methods", "private_methods");
24725 return $alias(self, "protected_instance_methods", "private_methods");
24728 var self = $module($base, 'Kernel');
24730 var $nesting = [self].concat($parent_nesting), $$ = Opal.$r($nesting);
24732 return $def(self, '$eval', function $Kernel_eval$5($a) {
24741 $defs(self, '$public', function $public$6($a) {
24749 return $defs(self, '$private', function $private$7($a) {