resin 0.2.1 → 0.2.2

data/amber/st/Kernel-Announcements.st

@@ -1,7 +1,7 @@
 Smalltalk current createPackage: 'Kernel-Announcements' properties: #{}!
 Object subclass: #AnnouncementSubscription
 	instanceVariableNames: 'block announcementClass'
-	category: 'Kernel-Announcements'!
+	package: 'Kernel-Announcements'!
 
 !AnnouncementSubscription methodsFor: 'accessing'!
 
@@ -34,7 +34,7 @@ handlesAnnouncement: anAnnouncement
 
 Object subclass: #Announcer
 	instanceVariableNames: 'registry subscriptions'
-	category: 'Kernel-Announcements'!
+	package: 'Kernel-Announcements'!
 
 !Announcer methodsFor: 'announcing'!
 

data/amber/st/Kernel-Classes.st

@@ -1,7 +1,7 @@
 Smalltalk current createPackage: 'Kernel-Classes' properties: #{}!
 Object subclass: #Behavior
 	instanceVariableNames: ''
-	category: 'Kernel-Classes'!
+	package: 'Kernel-Classes'!
 !Behavior commentStamp!
 Behavior is the superclass of all class objects. 
 
@@ -13,16 +13,12 @@ Behavior also  provides methods for compiling methods, examining the method dict
 
 !Behavior methodsFor: 'accessing'!
 
-name
-	<return self.className || nil>
-!
-
-superclass
-	<return self.superclass || nil>
-!
-
-subclasses
-	<return smalltalk.subclasses(self)>
+allInstanceVariableNames
+	| result |
+	result := self instanceVariableNames copy.
+	self superclass ifNotNil: [
+	    result addAll: self superclass allInstanceVariableNames].
+	^result
 !
 
 allSubclasses
@@ -33,12 +29,30 @@ allSubclasses
 	^result
 !
 
-withAllSubclasses
-	^(Array with: self) addAll: self allSubclasses; yourself
+comment
+    ^(self basicAt: 'comment') ifNil: ['']
 !
 
-prototype
-	<return self.fn.prototype>
+comment: aString
+    self basicAt: 'comment' put: aString
+!
+
+commentStamp
+    ^ClassCommentReader new
+	class: self;
+	yourself
+!
+
+commentStamp: aStamp prior: prior
+        ^self commentStamp
+!
+
+instanceVariableNames
+	<return self.iVarNames>
+!
+
+methodAt: aString
+	<return smalltalk.methods(self)[aString]>
 !
 
 methodDictionary
@@ -58,22 +72,13 @@ methodsFor: aString
 	    yourself
 !
 
-instanceVariableNames
-	<return self.iVarNames>
-!
-
-comment
-    ^(self basicAt: 'comment') ifNil: ['']
-!
-
-comment: aString
-    self basicAt: 'comment' put: aString
+methodsFor: aString stamp: aStamp
+	"Added for compatibility, right now ignores stamp."
+	^self methodsFor: aString
 !
 
-commentStamp
-    ^ClassCommentReader new
-	class: self;
-	yourself
+name
+	<return self.className || nil>
 !
 
 protocols
@@ -98,25 +103,20 @@ protocolsDo: aBlock
 		aBlock value: category value: (methodsByCategory at: category)]
 !
 
-allInstanceVariableNames
-	| result |
-	result := self instanceVariableNames copy.
-	self superclass ifNotNil: [
-	    result addAll: self superclass allInstanceVariableNames].
-	^result
+prototype
+	<return self.fn.prototype>
 !
 
-methodAt: aString
-	<return smalltalk.methods(self)[aString]>
+subclasses
+	<return smalltalk.subclasses(self)>
 !
 
-methodsFor: aString stamp: aStamp
-	"Added for compatibility, right now ignores stamp."
-	^self methodsFor: aString
+superclass
+	<return self.superclass || nil>
 !
 
-commentStamp: aStamp prior: prior
-        ^self commentStamp
+withAllSubclasses
+	^(Array with: self) addAll: self allSubclasses; yourself
 ! !
 
 !Behavior methodsFor: 'compiling'!
@@ -125,42 +125,46 @@ addCompiledMethod: aMethod
 	<smalltalk.addMethod(aMethod.selector._asSelector(), aMethod, self)>
 !
 
-removeCompiledMethod: aMethod
-	<delete self.fn.prototype[aMethod.selector._asSelector()];
-	delete self.fn.prototype.methods[aMethod.selector];
-	smalltalk.init(self);>
-!
-
 compile: aString
 	self compile: aString category: ''
 !
 
 compile: aString category: anotherString
-	| method |
-	method := Compiler new load: aString forClass: self.
-	method category: anotherString.
-	self addCompiledMethod: method
+	Compiler new
+		install: aString forClass: self category: anotherString;
+		setupClass: self
+!
+
+removeCompiledMethod: aMethod
+	<delete self.fn.prototype[aMethod.selector._asSelector()];
+	delete self.fn.prototype.methods[aMethod.selector];
+	smalltalk.init(self);>
 ! !
 
 !Behavior methodsFor: 'instance creation'!
 
-new
-	^self basicNew initialize
-!
-
 basicNew
 	<return new self.fn()>
+!
+
+new
+	^self basicNew initialize
 ! !
 
 !Behavior methodsFor: 'testing'!
 
+canUnderstand: aSelector
+	^(self methodDictionary keys includes: aSelector asString) or: [
+		self superclass notNil and: [self superclass canUnderstand: aSelector]]
+!
+
 inheritsFrom: aClass
 	^aClass allSubclasses includes: self
 ! !
 
 Behavior subclass: #Class
 	instanceVariableNames: ''
-	category: 'Kernel-Classes'!
+	package: 'Kernel-Classes'!
 !Class commentStamp!
 Class is __the__ class object. 
 
@@ -173,20 +177,20 @@ category
 	^self package ifNil: ['Unclassified'] ifNotNil: [self package name]
 !
 
-rename: aString
-	<
-		smalltalk[aString] = self;
-		delete smalltalk[self.className];
-		self.className = aString;
-	>
-!
-
 package
 	<return self.pkg>
 !
 
 package: aPackage
 	<self.pkg = aPackage>
+!
+
+rename: aString
+	<
+		smalltalk[aString] = self;
+		delete smalltalk[self.className];
+		self.className = aString;
+	>
 ! !
 
 !Class methodsFor: 'class creation'!
@@ -226,7 +230,7 @@ isClass
 
 Behavior subclass: #Metaclass
 	instanceVariableNames: ''
-	category: 'Kernel-Classes'!
+	package: 'Kernel-Classes'!
 !Metaclass commentStamp!
 Metaclass is the root of the class hierarchy.
 
@@ -258,7 +262,7 @@ isMetaclass
 
 Object subclass: #ClassBuilder
 	instanceVariableNames: ''
-	category: 'Kernel-Classes'!
+	package: 'Kernel-Classes'!
 !ClassBuilder commentStamp!
 ClassBuilder is responsible for compiling new classes or modifying existing classes in the system.
 
@@ -266,16 +270,16 @@ Rather than using ClassBuilder directly to compile a class, use `Class >> subcla
 
 !ClassBuilder methodsFor: 'class creation'!
 
-superclass: aClass subclass: aString
-	^self superclass: aClass subclass: aString instanceVariableNames: '' package: nil
-!
-
 class: aClass instanceVariableNames: aString
 	aClass isMetaclass ifFalse: [self error: aClass name, ' is not a metaclass'].
 	aClass basicAt: 'iVarNames' put: (self instanceVariableNamesFor: aString).
 	self setupClass: aClass
 !
 
+superclass: aClass subclass: aString
+	^self superclass: aClass subclass: aString instanceVariableNames: '' package: nil
+!
+
 superclass: aClass subclass: aString instanceVariableNames: aString2 package: aString3
 	| newClass |
 	newClass := self addSubclassOf: aClass
@@ -287,19 +291,11 @@ superclass: aClass subclass: aString instanceVariableNames: aString2 package: aS
 
 !ClassBuilder methodsFor: 'private'!
 
-instanceVariableNamesFor: aString
-	^(aString tokenize: ' ') reject: [:each | each isEmpty]
-!
-
 addSubclassOf: aClass named: aString instanceVariableNames: aCollection
 	<smalltalk.addClass(aString, aClass, aCollection);
 	    return smalltalk[aString]>
 !
 
-setupClass: aClass
-	<smalltalk.init(aClass);>
-!
-
 addSubclassOf: aClass named: aString instanceVariableNames: aCollection package: packageName
 	<smalltalk.addClass(aString, aClass, aCollection, packageName);
 	    return smalltalk[aString]>
@@ -317,20 +313,26 @@ copyClass: aClass named: aString
 	self setupClass: newClass.
 
 	aClass methodDictionary values do: [:each |
-		newClass addCompiledMethod: (Compiler new load: each source forClass: newClass).
-		(newClass methodDictionary at: each selector) category: each category].
+		Compiler new install: each source forClass: newClass category: each category].
 
 	aClass class methodDictionary values do: [:each |
-		newClass class addCompiledMethod: (Compiler new load: each source forClass: newClass class).
-		(newClass class methodDictionary at: each selector) category: each category].
+		Compiler new install: each source forClass: newClass class category: each category].
 
 	self setupClass: newClass.
 	^newClass
+!
+
+instanceVariableNamesFor: aString
+	^(aString tokenize: ' ') reject: [:each | each isEmpty]
+!
+
+setupClass: aClass
+	<smalltalk.init(aClass);>
 ! !
 
 Object subclass: #ClassCategoryReader
 	instanceVariableNames: 'class category chunkParser'
-	category: 'Kernel-Classes'!
+	package: 'Kernel-Classes'!
 !ClassCategoryReader commentStamp!
 ClassCategoryReader represents a mechanism for retrieving class descriptions stored on a file.!
 
@@ -347,7 +349,8 @@ scanFrom: aChunkParser
 	| chunk |
 	[chunk := aChunkParser nextChunk.
 	chunk isEmpty] whileFalse: [
-	    self compileMethod: chunk]
+	    self compileMethod: chunk].
+	Compiler new setupClass: class
 ! !
 
 !ClassCategoryReader methodsFor: 'initialization'!
@@ -360,15 +363,12 @@ initialize
 !ClassCategoryReader methodsFor: 'private'!
 
 compileMethod: aString
-	| method |
-	method := Compiler new load: aString forClass: class.
-	method category: category.
-	class addCompiledMethod: method
+	Compiler new install: aString forClass: class category: category
 ! !
 
 Object subclass: #ClassCommentReader
 	instanceVariableNames: 'class chunkParser'
-	category: 'Kernel-Classes'!
+	package: 'Kernel-Classes'!
 !ClassCommentReader commentStamp!
 ClassCommentReader represents a mechanism for retrieving class descriptions stored on a file.
 See `ClassCategoryReader` too.!
@@ -401,3 +401,61 @@ setComment: aString
     class comment: aString
 ! !
 
+Object subclass: #ClassSorterNode
+	instanceVariableNames: 'theClass level nodes'
+	package: 'Kernel-Classes'!
+
+!ClassSorterNode methodsFor: 'accessing'!
+
+getNodesFrom: aCollection
+	| children others |
+	children := #().
+	others := #().
+	aCollection do: [:each |
+		(each superclass = self theClass)
+			ifTrue: [children add: each]
+			ifFalse: [others add: each]].
+	nodes:= children collect: [:each |
+		ClassSorterNode on: each classes: others level: self level + 1]
+!
+
+level
+	^level
+!
+
+level: anInteger
+	level := anInteger
+!
+
+nodes
+	^nodes
+!
+
+theClass
+	^theClass
+!
+
+theClass: aClass
+	theClass := aClass
+! !
+
+!ClassSorterNode methodsFor: 'visiting'!
+
+traverseClassesWith: aCollection
+	"sort classes alphabetically Issue #143"
+
+	aCollection add: self theClass.
+	(self nodes sorted: [:a :b | a theClass name <= b theClass name ]) do: [:aNode |
+		aNode traverseClassesWith: aCollection ].
+! !
+
+!ClassSorterNode class methodsFor: 'instance creation'!
+
+on: aClass classes: aCollection level: anInteger
+	^self new
+		theClass: aClass;
+		level: anInteger;
+		getNodesFrom: aCollection;
+		yourself
+! !
+

data/amber/st/Kernel-Collections.st

@@ -1,24 +1,24 @@
 Smalltalk current createPackage: 'Kernel-Collections' properties: #{}!
 Object subclass: #Association
 	instanceVariableNames: 'key value'
-	category: 'Kernel-Collections'!
+	package: 'Kernel-Collections'!
 
 !Association methodsFor: 'accessing'!
 
-key: aKey
-	key := aKey
-!
-
 key
 	^key
 !
 
-value: aValue
-	value := aValue
+key: aKey
+	key := aKey
 !
 
 value
 	^value
+!
+
+value: aValue
+	value := aValue
 ! !
 
 !Association methodsFor: 'comparing'!
@@ -48,183 +48,18 @@ key: aKey value: aValue
 		yourself
 ! !
 
-Object subclass: #Stream
-	instanceVariableNames: 'collection position streamSize'
-	category: 'Kernel-Collections'!
-
-!Stream methodsFor: 'accessing'!
-
-collection
-	^collection
-!
-
-setCollection: aCollection
-	collection := aCollection
-!
-
-position
-	^position ifNil: [position := 0]
-!
-
-position: anInteger
-	position := anInteger
-!
-
-streamSize
-	^streamSize
-!
-
-setStreamSize: anInteger
-	streamSize := anInteger
-!
-
-contents
-	^self collection
-	    copyFrom: 1 
-	    to: self streamSize
-!
-
-size
-	^self streamSize
-! !
-
-!Stream methodsFor: 'actions'!
-
-reset
-	self position: 0
-!
-
-close
-!
-
-flush
-!
-
-resetContents
-	self reset.
-	self setStreamSize: 0
-! !
-
-!Stream methodsFor: 'enumerating'!
-
-do: aBlock
-	[self atEnd] whileFalse: [aBlock value: self next]
-! !
-
-!Stream methodsFor: 'positioning'!
-
-setToEnd
-	self position: self size
-!
-
-skip: anInteger
-	self position: ((self position + anInteger) min: self size max: 0)
-! !
-
-!Stream methodsFor: 'reading'!
-
-next
-	^self atEnd 
-		ifTrue: [nil]
-		ifFalse: [
-			self position: self position + 1. 
-			collection at: self position]
-!
-
-next: anInteger
-	| tempCollection |
-	tempCollection := self collection class new.
-	anInteger timesRepeat: [
-	    self atEnd ifFalse: [
-		tempCollection add: self next]].
-	^tempCollection
-!
-
-peek
-	^self atEnd ifFalse: [
-	    self collection at: self position + 1]
-! !
-
-!Stream methodsFor: 'testing'!
-
-atEnd
-	^self position = self size
-!
-
-atStart
-	^self position = 0
-!
-
-isEmpty
-	^self size = 0
-! !
-
-!Stream methodsFor: 'writing'!
-
-nextPut: anObject
-	self position: self position + 1.
-	self collection at: self position put: anObject.
-	self setStreamSize: (self streamSize max: self position)
-!
-
-nextPutAll: aCollection
-	aCollection do: [:each |
-	    self nextPut: each]
-! !
-
-!Stream class methodsFor: 'instance creation'!
-
-on: aCollection
-	    ^self new 
-		setCollection: aCollection;
-		setStreamSize: aCollection size;
-		yourself
-! !
-
-Object subclass: #RegularExpression
-	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
-
-!RegularExpression methodsFor: 'evaluating'!
-
-compile: aString
-	<return self.compile(aString)>
-!
-
-exec: aString
-	<return self.exec(aString) || nil>
-!
-
-test: aString
-	<return self.test(aString)>
-! !
-
-!RegularExpression class methodsFor: 'instance creation'!
-
-fromString: aString flag: anotherString
-	<return new RegExp(aString, anotherString)>
-!
-
-fromString: aString
-	    ^self fromString: aString flag: ''
-! !
-
 Object subclass: #Collection
 	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
+	package: 'Kernel-Collections'!
 
 !Collection methodsFor: 'accessing'!
 
-size
-	self subclassResponsibility
-!
-
 readStream
 	^self stream
 !
 
-writeStream
-	^self stream
+size
+	self subclassResponsibility
 !
 
 stream
@@ -233,6 +68,10 @@ stream
 
 streamClass
 	^self class streamClass
+!
+
+writeStream
+	^self stream
 ! !
 
 !Collection methodsFor: 'adding/removing'!
@@ -261,16 +100,16 @@ asArray
 	^Array withAll: self
 !
 
-asSet
-	^Set withAll: self
+asJSON
+	^self asArray collect: [:each | each asJSON]
 !
 
 asOrderedCollection
 	^self asArray
 !
 
-asJSON
-	^self asArray collect: [:each | each asJSON]
+asSet
+	^Set withAll: self
 ! !
 
 !Collection methodsFor: 'copying'!
@@ -298,10 +137,6 @@ copyWithoutAll: aCollection
 
 !Collection methodsFor: 'enumerating'!
 
-do: aBlock
-	<for(var i=0;i<self.length;i++){aBlock(self[i]);}>
-!
-
 collect: aBlock
 	| newCollection |
 	newCollection := self class new.
@@ -323,6 +158,10 @@ detect: aBlock ifNone: anotherBlock
 	>
 !
 
+do: aBlock
+	<for(var i=0;i<self.length;i++){aBlock(self[i]);}>
+!
+
 do: aBlock separatedBy: anotherBlock
 	| first |
 	first := true.
@@ -362,6 +201,18 @@ errorNotFound
 
 !Collection methodsFor: 'testing'!
 
+ifEmpty: aBlock
+	"Evaluate the given block with the receiver as argument, answering its value if the receiver is empty, otherwise answer the receiver. Note that the fact that this method returns its argument in case the receiver is not empty allows one to write expressions like the following ones: self classifyMethodAs: 
+		(myProtocol ifEmpty: ['As yet unclassified'])"
+	^ self isEmpty 
+		ifTrue: [ aBlock value ]
+		ifFalse: [ self ]
+!
+
+ifNotEmpty: aBlock
+	self notEmpty ifTrue: aBlock.
+!
+
 includes: anObject
 	<
 		var i = self.length;
@@ -372,24 +223,12 @@ includes: anObject
 	>
 !
 
-notEmpty
-	^self isEmpty not
-!
-
 isEmpty
 	^self size = 0
 !
 
-ifNotEmpty: aBlock
-	self notEmpty ifTrue: aBlock.
-!
-
-ifEmpty: aBlock
-	"Evaluate the given block with the receiver as argument, answering its value if the receiver is empty, otherwise answer the receiver. Note that the fact that this method returns its argument in case the receiver is not empty allows one to write expressions like the following ones: self classifyMethodAs: 
-		(myProtocol ifEmpty: ['As yet unclassified'])"
-	^ self isEmpty 
-		ifTrue: [ aBlock value ]
-		ifFalse: [ self ]
+notEmpty
+	^self isEmpty not
 ! !
 
 !Collection class methodsFor: 'accessing'!
@@ -400,6 +239,10 @@ streamClass
 
 !Collection class methodsFor: 'instance creation'!
 
+new: anInteger
+	^self new
+!
+
 with: anObject
 	    ^self new
 		add: anObject;
@@ -425,665 +268,488 @@ withAll: aCollection
 	    ^self new
 		addAll: aCollection;
 		yourself
-!
-
-new: anInteger
-	^self new
 ! !
 
-Collection subclass: #SequenceableCollection
+Collection subclass: #HashedCollection
 	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
+	package: 'Kernel-Collections'!
+!HashedCollection commentStamp!
+A HashedCollection is a traditional JavaScript object, or a Smalltalk Dictionary.
 
-!SequenceableCollection methodsFor: 'accessing'!
+Unlike a Dictionary, it can only have strings as keys.!
 
-at: anIndex
-	^self at: anIndex ifAbsent: [
-	    self errorNotFound]
+!HashedCollection methodsFor: 'accessing'!
+
+associations
+	| associations |
+	associations := #().
+	self keys do: [:each |
+	    associations add: (Association key: each value: (self at: each))].
+	^associations
 !
 
-at: anIndex ifAbsent: aBlock
-	self subclassResponsibility
+at: aKey
+	^self at: aKey ifAbsent: [self errorNotFound]
 !
 
-at: anIndex put: anObject
-	self subclassResponsibility
+at: aKey ifAbsent: aBlock
+	^(self includesKey: aKey)
+		ifTrue: [self basicAt: aKey]
+		ifFalse: aBlock
 !
 
-first
-	^self at: 1
+at: aKey ifAbsentPut: aBlock
+	^self at: aKey ifAbsent: [
+	    self at: aKey put: aBlock value]
 !
 
-fourth
-	^self at: 4
+at: aKey ifPresent: aBlock
+	^(self basicAt: aKey) ifNotNil: [aBlock value: (self at: aKey)]
 !
 
-last
-	^self at: self size
+at: aKey ifPresent: aBlock ifAbsent: anotherBlock
+	^(self basicAt: aKey)
+	    ifNil: anotherBlock
+	    ifNotNil: [aBlock value: (self at: aKey)]
 !
 
-second
-	^self at: 2
+at: aKey put: aValue
+	^self basicAt: aKey put: aValue
 !
 
-third
-	^self at: 3
+keys
+	<
+		if ('function'===typeof Object.keys) return Object.keys(self);
+		var keys = [];
+		for(var i in self) {
+			if(self.hasOwnProperty(i)) {
+				keys.push(i);
+			}
+		};
+		return keys;
+	>
 !
 
-allButFirst
-	^self copyFrom: 2 to: self size
+size
+	^self keys size
 !
 
-allButLast
-	^self copyFrom: 1 to: self size - 1
-!
+values
+	^self keys collect: [:each | self at: each]
+! !
 
-indexOf: anObject
-	^self indexOf: anObject ifAbsent: [self errorNotFound]
-!
+!HashedCollection methodsFor: 'adding/removing'!
 
-indexOf: anObject ifAbsent: aBlock
-	<
-		for(var i=0;i<self.length;i++){
-			if(self[i].__eq(anObject)) {return i+1}
-		}
-		return aBlock();
-	>
+add: anAssociation
+	self at: anAssociation key put: anAssociation value
 !
 
-indexOf: anObject startingAt: start ifAbsent: aBlock
-	<
-		for(var i=start-1;i<self.length;i++){
-			if(self[i].__eq(anObject)) {return i+1}
-		}
-		return aBlock();
-	>
+addAll: aHashedCollection
+	super addAll: aHashedCollection associations.
+	^aHashedCollection
 !
 
-indexOf: anObject startingAt: start
-	"Answer the index of the first occurence of anElement after start
-	within the receiver. If the receiver does not contain anElement, 
-	answer 0."
-	^self indexOf: anObject startingAt: start ifAbsent: [0]
+remove: aKey ifAbsent: aBlock
+    ^self removeKey: aKey ifAbsent: aBlock
 !
 
-atRandom
-	^ self at: self size atRandom
+removeKey: aKey
+    ^self remove: aKey
 !
 
-first: n
-	"Answer the first n elements of the receiver.
-	Raise an error if there are not enough elements."
-
-	^ self copyFrom: 1 to: n
+removeKey: aKey ifAbsent: aBlock
+	^(self includesKey: aKey) 
+		ifFalse: [aBlock value]
+		ifTrue: [self basicDelete: aKey]
 ! !
 
-!SequenceableCollection methodsFor: 'adding'!
-
-removeLast
-	self remove: self last
-!
+!HashedCollection methodsFor: 'comparing'!
 
-addLast: anObject
-	self add: anObject
+= aHashedCollection
+	self class = aHashedCollection class ifFalse: [^false].
+	self size = aHashedCollection size ifFalse: [^false].
+	^self associations = aHashedCollection associations
 ! !
 
-!SequenceableCollection methodsFor: 'comparing'!
-
-= aCollection
-	(self class = aCollection class and: [
-		self size = aCollection size]) ifFalse: [^false].
-	self withIndexDo: [:each :i |
-                 (aCollection at: i) = each ifFalse: [^false]].
-	^true
-! !
+!HashedCollection methodsFor: 'converting'!
 
-!SequenceableCollection methodsFor: 'converting'!
+asDictionary
+	^Dictionary fromPairs: self associations
+!
 
-reversed
-	self subclassResponsibility
+asJSON
+	| c |
+	c := self class new.
+	self keysAndValuesDo: [:key :value |
+		c at: key put: value asJSON].
+	^c
 ! !
 
-!SequenceableCollection methodsFor: 'copying'!
+!HashedCollection methodsFor: 'copying'!
 
-copyFrom: anIndex to: anotherIndex
-	| range newCollection |
-	range := anIndex to: anotherIndex.
-	newCollection := self class new: range size.
-	range withIndexDo: [:each :i |
-	    newCollection at: i put: (self at: each)].
-	^newCollection
+, aCollection
+	self shouldNotImplement
 !
 
-shallowCopy
-	| newCollection |
-	newCollection := self class new: self size.
-	self withIndexDo: [ :each :index | 
-		newCollection at: index put: each].
-	^newCollection
+copyFrom: anIndex to: anotherIndex
+	self shouldNotImplement
 !
 
 deepCopy
-	| newCollection |
-	newCollection := self class new: self size.
-	self withIndexDo: [:each :index | 
-		newCollection at: index put: each deepCopy].
-	^newCollection
-! !
-
-!SequenceableCollection methodsFor: 'enumerating'!
-
-withIndexDo: aBlock
-	<for(var i=0;i<self.length;i++){aBlock(self[i], i+1);}>
-! !
-
-!SequenceableCollection methodsFor: 'printing'!
-
-printString
-	| str |
-	str := '' writeStream.
-	str nextPutAll: super printString, ' ('.
-	self 
-		do: [:each | str nextPutAll: each printString]
-		separatedBy: [str nextPutAll: ' '].
-	str nextPutAll: ')'.
-	^str contents
-! !
-
-SequenceableCollection subclass: #CharacterArray
-	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
-
-!CharacterArray methodsFor: 'accessing'!
+	| copy |
+	copy := self class new.
+	self associationsDo: [:each |
+	    copy at: each key  put: each value deepCopy].
+	^copy
+!
 
-at: anIndex put: anObject
-	self errorReadOnly
+shallowCopy
+	| copy |
+	copy := self class new.
+	self associationsDo: [:each |
+	    copy at: each key  put: each value].
+	^copy
 ! !
 
-!CharacterArray methodsFor: 'adding'!
+!HashedCollection methodsFor: 'enumerating'!
 
-add: anObject
-	self errorReadOnly
+associationsDo: aBlock
+	self associations do: aBlock
 !
 
-remove: anObject
-	self errorReadOnly
-! !
-
-!CharacterArray methodsFor: 'converting'!
+collect: aBlock
+	| newDict |
+	newDict := self class new.
+	self keysAndValuesDo: [:key :value |
+	    newDict at: key put: (aBlock value: value)].
+	^newDict
+!
 
-asString
-	^self subclassResponsibility
+detect: aBlock ifNone: anotherBlock
+	^self values detect: aBlock ifNone: anotherBlock
 !
 
-asNumber
-	^self asString asNumber
+do: aBlock
+	self values do: aBlock
 !
 
-asUppercase
-	^self class fromString: self asString asUppercase
+includes: anObject
+	^self values includes: anObject
 !
 
-asSymbol
-	^self subclassResponsibility
+keysAndValuesDo: aBlock
+	self associationsDo: [:each |
+	    aBlock value: each key value: each value]
 !
 
-asLowercase
-	^self class fromString: self asString asLowercase
+select: aBlock
+	| newDict |
+	newDict := self class new.
+	self keysAndValuesDo: [:key :value |
+	    (aBlock value: value) ifTrue: [newDict at: key put: value]].
+	^newDict
 ! !
 
-!CharacterArray methodsFor: 'copying'!
+!HashedCollection methodsFor: 'printing'!
 
-, aString
-	^self asString, aString asString
+printString
+	^String streamContents: [:aStream|  
+		aStream 
+			nextPutAll: super printString;
+			nextPutAll: '('.
+				self associations 
+					do: [:anAssociation|  
+						aStream 
+							nextPutAll: anAssociation key printString;
+								nextPutAll: ' -> ';
+								nextPutAll: anAssociation value printString]
+							separatedBy: [aStream nextPutAll: ' , '].
+						aStream nextPutAll: ')']
+!
+
+storeOn: aStream
+	aStream nextPutAll: '#{'.
+	self associations
+		do: [:each | each storeOn: aStream]
+		separatedBy: [ aStream nextPutAll: '. '].
+	aStream nextPutAll: '}'
 ! !
 
-!CharacterArray methodsFor: 'error handling'!
+!HashedCollection methodsFor: 'testing'!
 
-errorReadOnly
-	self error: 'Object is read-only'
+includesKey: aKey
+	<return self.hasOwnProperty(aKey)>
 ! !
 
-!CharacterArray methodsFor: 'printing'!
+!HashedCollection class methodsFor: 'instance creation'!
 
-printString
-	^self asString printString
+fromPairs: aCollection
+	| dict |
+	dict := self new.
+	aCollection do: [:each | dict add: each].
+	^dict
 ! !
 
-!CharacterArray class methodsFor: 'instance creation'!
+HashedCollection subclass: #Dictionary
+	instanceVariableNames: 'keys values'
+	package: 'Kernel-Collections'!
 
-fromString: aString
-	self subclassResponsibility
-! !
+!Dictionary methodsFor: 'accessing'!
 
-CharacterArray subclass: #String
-	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
+at: aKey ifAbsent: aBlock
+	<
+		var index;
+		for(var i=0;i<self['@keys'].length;i++){
+			if(self['@keys'][i].__eq(aKey)) {index = i;}
+		};
+		if(typeof index === 'undefined') {
+			return aBlock();
+		} else {
+			return self['@values'][index];
+		}
+	>
+!
 
-!String methodsFor: 'accessing'!
+at: aKey put: aValue
+	<
+		var index = self['@keys'].indexOf(aKey);
+		if(index === -1) {
+			self['@values'].push(aValue);
+			self['@keys'].push(aKey);
+		} else {
+			self['@values'][index] = aValue;
+		};
 
-size
-	<return self.length>
+		return aValue;
+	>
 !
 
-at: anIndex ifAbsent: aBlock
-	<return self[anIndex - 1] || aBlock()>
+keys
+	^keys copy
 !
 
-escaped
-	<return escape(self)>
-!
+values
+	^values copy
+! !
 
-unescaped
-	<return unescape(self)>
-!
+!Dictionary methodsFor: 'adding/removing'!
 
-asciiValue
-	<return self.charCodeAt(0);>
+removeKey: aKey ifAbsent: aBlock
+    <
+            var index = self['@keys'].indexOf(aKey);
+            if(index === -1) {
+                return aBlock()
+            } else {
+                var value;
+                self['@keys'].splice(index, 1);
+                value = self['@values'].splice(index, 1);
+                return value[0];
+            };
+    >
 ! !
 
-!String methodsFor: 'comparing'!
+!Dictionary methodsFor: 'converting'!
 
-= aString
-	aString class = self class ifFalse: [^false].
-	<return String(self) === String(aString)>
+asHashedCollection
+	^HashedCollection fromPairs: self associations
 !
 
-> aString
-	<return String(self) >> aString._asString()>
-!
+asJSON
+	^self asHashedCollection asJSON
+! !
 
-< aString
-	<return String(self) < aString._asString()>
-!
+!Dictionary methodsFor: 'initialization'!
 
->= aString
-	<return String(self) >>= aString._asString()>
-!
+initialize
+	super initialize.
+	keys := #().
+	values := #()
+! !
 
-<= aString
-	<return String(self) <= aString._asString()>
+!Dictionary methodsFor: 'testing'!
+
+includesKey: aKey
+	^keys includes: aKey
 ! !
 
-!String methodsFor: 'converting'!
+Collection subclass: #SequenceableCollection
+	instanceVariableNames: ''
+	package: 'Kernel-Collections'!
 
-asSelector
-	"If you change this method, change smalltalk.convertSelector too (see js/boot.js file)"
+!SequenceableCollection methodsFor: 'accessing'!
 
-	| selector |
-	selector := '_', self.
-	selector := selector replace: ':' with: '_'.
-	selector := selector replace: '[+]' with: '_plus'.
-	selector := selector replace: '-' with: '_minus'.
-	selector := selector replace: '[*]' with: '_star'.
-	selector := selector replace: '[/]' with: '_slash'.
-	selector := selector replace: '>' with: '_gt'.
-	selector := selector replace: '<' with: '_lt'.
-	selector := selector replace: '=' with: '_eq'.
-	selector := selector replace: ',' with: '_comma'.
-	selector := selector replace: '[@]' with: '_at'.
-	^selector
+allButFirst
+	^self copyFrom: 2 to: self size
 !
 
-asJavascript
-	<
-		if(self.search(/^[a-zA-Z0-9_:.$ ]*$/) == -1)
-			return "unescape(\"" + escape(self) + "\")";
-		else
-			return "\"" + self + "\"";
-	>
+allButLast
+	^self copyFrom: 1 to: self size - 1
 !
 
-tokenize: aString
-	<return self.split(aString)>
+at: anIndex
+	^self at: anIndex ifAbsent: [
+	    self errorNotFound]
 !
 
-asString
-	^self
+at: anIndex ifAbsent: aBlock
+	self subclassResponsibility
 !
 
-asNumber
-	<return Number(self)>
+at: anIndex put: anObject
+	self subclassResponsibility
 !
 
-asLowercase
-	<return self.toLowerCase()>
+atRandom
+	^ self at: self size atRandom
 !
 
-asUppercase
-	<return self.toUpperCase()>
+first
+	^self at: 1
 !
 
-reversed
-	<return self.split("").reverse().join("")>
+first: n
+	"Answer the first n elements of the receiver.
+	Raise an error if there are not enough elements."
+
+	^ self copyFrom: 1 to: n
 !
 
-asJavaScriptSelector
-	^(self asSelector replace: '^_' with: '') replace: '_.*' with: ''.
+fourth
+	^self at: 4
 !
 
-asSymbol
-	^Symbol lookup: self
+indexOf: anObject
+	^self indexOf: anObject ifAbsent: [self errorNotFound]
 !
 
-asJSON
-	^self
-! !
+indexOf: anObject ifAbsent: aBlock
+	<
+		for(var i=0;i<self.length;i++){
+			if(self[i].__eq(anObject)) {return i+1}
+		}
+		return aBlock();
+	>
+!
 
-!String methodsFor: 'copying'!
+indexOf: anObject startingAt: start
+	"Answer the index of the first occurence of anElement after start
+	within the receiver. If the receiver does not contain anElement, 
+	answer 0."
+	^self indexOf: anObject startingAt: start ifAbsent: [0]
+!
 
-, aString
-	<return self + aString>
+indexOf: anObject startingAt: start ifAbsent: aBlock
+	<
+		for(var i=start-1;i<self.length;i++){
+			if(self[i].__eq(anObject)) {return i+1}
+		}
+		return aBlock();
+	>
 !
 
-copyFrom: anIndex to: anotherIndex
-	<return self.substring(anIndex - 1, anotherIndex)>
+last
+	^self at: self size
 !
 
-shallowCopy
-	^self class fromString: self
+second
+	^self at: 2
 !
 
-deepCopy
-	^self shallowCopy
+third
+	^self at: 3
 ! !
 
-!String methodsFor: 'printing'!
+!SequenceableCollection methodsFor: 'adding'!
 
-printString
-	^'''', self, ''''
+addLast: anObject
+	self add: anObject
 !
 
-printNl
-	<console.log(self)>
+removeLast
+	self remove: self last
 ! !
 
-!String methodsFor: 'regular expressions'!
-
-replace: aString with: anotherString
-	^self replaceRegexp: (RegularExpression fromString: aString flag: 'g') with: anotherString
-!
-
-replaceRegexp: aRegexp with: aString
-	<return self.replace(aRegexp, aString)>
-!
+!SequenceableCollection methodsFor: 'comparing'!
 
-match: aRegexp
-	<return self.search(aRegexp) !!= -1>
-!
+= aCollection
+	(self class = aCollection class and: [
+		self size = aCollection size]) ifFalse: [^false].
+	self withIndexDo: [:each :i |
+                 (aCollection at: i) = each ifFalse: [^false]].
+	^true
+! !
 
-trimLeft: separators
+!SequenceableCollection methodsFor: 'converting'!
 
-	^self replaceRegexp: (RegularExpression fromString: '^[', separators, ']+' flag: 'g') with: ''
-!
+reversed
+	self subclassResponsibility
+! !
 
-trimRight: separators
+!SequenceableCollection methodsFor: 'copying'!
 
-	^self replaceRegexp: (RegularExpression fromString: '[', separators, ']+$' flag: 'g') with: ''
+copyFrom: anIndex to: anotherIndex
+	| range newCollection |
+	range := anIndex to: anotherIndex.
+	newCollection := self class new: range size.
+	range withIndexDo: [:each :i |
+	    newCollection at: i put: (self at: each)].
+	^newCollection
 !
 
-trimLeft
-	^self trimLeft: '\s'
-!
-
-trimRight
-	^self trimRight: '\s'
-!
-
-trimBoth
-	^self trimBoth: '\s'
-!
-
-trimBoth: separators
-
-	^(self trimLeft: separators) trimRight: separators
-! !
-
-!String methodsFor: 'split join'!
-
-join: aCollection 
-	^ String
-		streamContents: [:stream | aCollection
-				do: [:each | stream nextPutAll: each asString] 
-				separatedBy: [stream nextPutAll: self]]
-!
-
-lineIndicesDo: aBlock
-	"execute aBlock with 3 arguments for each line:
-	- start index of line
-	- end index of line without line delimiter
-	- end index of line including line delimiter(s) CR, LF or CRLF"
-	
-	| cr lf start sz nextLF nextCR |
-	start := 1.
-	sz := self size.
-	cr := String cr.
-	nextCR := self indexOf: cr startingAt: 1.
-	lf := String lf.
-	nextLF := self indexOf: lf startingAt: 1.
-	[ start <= sz ] whileTrue: [
-		(nextLF = 0 and: [ nextCR = 0 ])
-			ifTrue: [ "No more CR, nor LF, the string is over"
-					aBlock value: start value: sz value: sz.
-					^self ].
-		(nextCR = 0 or: [ 0 < nextLF and: [ nextLF < nextCR ] ])
-			ifTrue: [ "Found a LF"
-					aBlock value: start value: nextLF - 1 value: nextLF.
-					start := 1 + nextLF.
-					nextLF := self indexOf: lf startingAt: start ]
-			ifFalse: [ 1 + nextCR = nextLF
-				ifTrue: [ "Found a CR-LF pair"
-					aBlock value: start value: nextCR - 1 value: nextLF.
-					start := 1 + nextLF.
-					nextCR := self indexOf: cr startingAt: start.
-					nextLF := self indexOf: lf startingAt: start ]
-				ifFalse: [ "Found a CR"
-					aBlock value: start value: nextCR - 1 value: nextCR.
-					start := 1 + nextCR.
-					nextCR := self indexOf: cr startingAt: start ]]]
-!
-
-linesDo: aBlock
-	"Execute aBlock with each line in this string. The terminating line
-	delimiters CR, LF or CRLF pairs are not included in what is passed to aBlock"
-
-	self lineIndicesDo: [:start :endWithoutDelimiters :end |
-		aBlock value: (self copyFrom: start to: endWithoutDelimiters)]
-!
-
-lines
-	"Answer an array of lines composing this receiver without the line ending delimiters."
-
-	| lines |
-	lines := Array new.
-	self linesDo: [:aLine | lines add: aLine].
-	^lines
-!
-
-lineNumber: anIndex
-	"Answer a string containing the characters in the given line number."
-
-	| lineCount |
-	lineCount := 0.
-	self lineIndicesDo: [:start :endWithoutDelimiters :end |
-		(lineCount := lineCount + 1) = anIndex ifTrue: [^self copyFrom: start to: endWithoutDelimiters]].
-	^nil
-! !
-
-!String methodsFor: 'testing'!
-
-isString
-	^true
-!
-
-includesSubString: subString
-	< return self.indexOf(subString) !!= -1 >
-! !
-
-!String class methodsFor: 'accessing'!
-
-streamClass
-	    ^StringStream
-!
-
-cr
-	<return '\r'>
-!
-
-lf
-	<return '\n'>
-!
-
-space
-	<return ' '>
-!
-
-tab
-	<return '\t'>
-!
-
-crlf
-	<return '\r\n'>
-! !
-
-!String class methodsFor: 'instance creation'!
-
-fromString: aString
-	    <return new self.fn(aString)>
-!
-
-streamContents: blockWithArg
-	|stream|
-	stream := (self streamClass on: String new).
-	blockWithArg value: stream.
-	^ stream contents
-!
-
-value: aUTFCharCode
-
-	<return String.fromCharCode(aUTFCharCode);>
-! !
-
-CharacterArray subclass: #Symbol
-	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
-
-!Symbol methodsFor: 'accessing'!
-
-at: anIndex ifAbsent: aBlock
-	^self asString at: anIndex ifAbsent: aBlock
-!
-
-size
-	^self asString size
-! !
-
-!Symbol methodsFor: 'comparing'!
-
-< aSymbol
-	^self asString < aSymbol asString
-!
-
-<= aSymbol
-	^self asString <= aSymbol asString
-!
-
->= aSymbol
-	^self asString >= aSymbol asString
-!
-
-= aSymbol
-	aSymbol class = self class ifFalse: [^false].
-	^self asString = aSymbol asString
-!
-
-> aSymbol
-	^self asString > aSymbol asString
-! !
-
-!Symbol methodsFor: 'converting'!
-
-asString
-	<return self.value>
-!
-
-asSymbol
-	^self
-!
-
-asJavascript
-	^'smalltalk.symbolFor("', self asString, '")'
-!
-
-asSelector
-	^self asString asSelector
-!
-
-asJSON
-	^self asString asJSON
-! !
-
-!Symbol methodsFor: 'copying'!
-
-copyFrom: anIndex to: anotherIndex
-	^self class fromString: (self asString copyFrom: anIndex to: anotherIndex)
-!
-
-deepCopy
-	^self
+deepCopy
+	| newCollection |
+	newCollection := self class new: self size.
+	self withIndexDo: [:each :index | 
+		newCollection at: index put: each deepCopy].
+	^newCollection
 !
 
 shallowCopy
-	^self
+	| newCollection |
+	newCollection := self class new: self size.
+	self withIndexDo: [ :each :index | 
+		newCollection at: index put: each].
+	^newCollection
 ! !
 
-!Symbol methodsFor: 'printing'!
-
-printString
-	^'#', self asString
-!
+!SequenceableCollection methodsFor: 'enumerating'!
 
-isSymbol
-	^true
+withIndexDo: aBlock
+	<for(var i=0;i<self.length;i++){aBlock(self[i], i+1);}>
 ! !
 
-!Symbol class methodsFor: 'instance creation'!
-
-lookup: aString
-	<return smalltalk.symbolFor(aString);>
-!
-
-basicNew
-	self shouldNotImplement
-!
+!SequenceableCollection methodsFor: 'printing'!
 
-fromString: aString
-	^self lookup: aString
+printString
+	| str |
+	str := '' writeStream.
+	str nextPutAll: super printString, ' ('.
+	self 
+		do: [:each | str nextPutAll: each printString]
+		separatedBy: [str nextPutAll: ' '].
+	str nextPutAll: ')'.
+	^str contents
 ! !
 
 SequenceableCollection subclass: #Array
 	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
+	package: 'Kernel-Collections'!
 
 !Array methodsFor: 'accessing'!
 
-size
-	<return self.length>
+at: anIndex ifAbsent: aBlock
+	<
+		if((anIndex < 1) || (self.length < anIndex)) {return aBlock()};
+		return self[anIndex - 1];
+	>
 !
 
 at: anIndex put: anObject
 	<return self[anIndex - 1] = anObject>
 !
 
-at: anIndex ifAbsent: aBlock
-	<
-	    var value = self[anIndex - 1];
-	    if(value === undefined) {
-		return aBlock();
-	    } else {
-		return value;
-	    }
-	>
+size
+	<return self.length>
 ! !
 
 !Array methodsFor: 'adding/removing'!
@@ -1178,540 +844,763 @@ withAll: aCollection
 	^instance
 ! !
 
-SequenceableCollection subclass: #Array
+SequenceableCollection subclass: #CharacterArray
 	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
+	package: 'Kernel-Collections'!
 
-!Array methodsFor: 'accessing'!
-
-size
-	<return self.length>
-!
+!CharacterArray methodsFor: 'accessing'!
 
 at: anIndex put: anObject
-	<return self[anIndex - 1] = anObject>
-!
-
-at: anIndex ifAbsent: aBlock
-	<
-	    var value = self[anIndex - 1];
-	    if(value === undefined) {
-		return aBlock();
-	    } else {
-		return value;
-	    }
-	>
+	self errorReadOnly
 ! !
 
-!Array methodsFor: 'adding/removing'!
+!CharacterArray methodsFor: 'adding'!
 
 add: anObject
-	<self.push(anObject); return anObject;>
+	self errorReadOnly
 !
 
 remove: anObject
-	<
-		for(var i=0;i<self.length;i++) {
-			if(self[i] == anObject) {
-				self.splice(i,1);
-				break;
-			}
-		}
-	>
-!
-
-removeFrom: aNumber to: anotherNumber
-	<self.splice(aNumber - 1,anotherNumber - 1)>
+	self errorReadOnly
 ! !
 
-!Array methodsFor: 'converting'!
+!CharacterArray methodsFor: 'converting'!
 
-asJavascript
-	^'[', ((self collect: [:each | each asJavascript]) join: ', '),  ']'
+asLowercase
+	^self class fromString: self asString asLowercase
 !
 
-reversed
-	<return self._copy().reverse()>
-! !
-
-!Array methodsFor: 'enumerating'!
-
-join: aString
-	<return self.join(aString)>
+asNumber
+	^self asString asNumber
 !
 
-sort
-    ^self basicPerform: 'sort'
+asString
+	^self subclassResponsibility
 !
 
-sort: aBlock
-	<
-		return self.sort(function(a, b) {
-			if(aBlock(a,b)) {return -1} else {return 1}
-		})
-	>
+asSymbol
+	^self subclassResponsibility
 !
 
-sorted
-	^self copy sort
-!
+asUppercase
+	^self class fromString: self asString asUppercase
+! !
 
-sorted: aBlock
-	^self copy sort: aBlock
+!CharacterArray methodsFor: 'copying'!
+
+, aString
+	^self asString, aString asString
 ! !
 
-!Array class methodsFor: 'instance creation'!
+!CharacterArray methodsFor: 'error handling'!
 
-new: anInteger
-	<return new Array(anInteger)>
-!
+errorReadOnly
+	self error: 'Object is read-only'
+! !
 
-with: anObject
-	    ^(self new: 1)
-		at: 1 put: anObject;
-		yourself
-!
+!CharacterArray methodsFor: 'printing'!
 
-with: anObject with: anObject2
-	    ^(self new: 2)
-		at: 1 put: anObject;
-		at: 2 put: anObject2;
-		yourself
-!
+printString
+	^self asString printString
+! !
 
-with: anObject with: anObject2 with: anObject3
-	    ^(self new: 3)
-		at: 1 put: anObject;
-		at: 2 put: anObject2;
-		at: 3 put: anObject3;
-		yourself
-!
+!CharacterArray class methodsFor: 'instance creation'!
 
-withAll: aCollection
-	| instance |
-	instance := self new: aCollection size.
-	aCollection withIndexDo: [:each :index  |
-		instance at: index put: each].
-	^instance
+fromString: aString
+	self subclassResponsibility
 ! !
 
-Stream subclass: #StringStream
+CharacterArray subclass: #String
 	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
+	package: 'Kernel-Collections'!
 
-!StringStream methodsFor: 'reading'!
+!String methodsFor: 'accessing'!
 
-next: anInteger
-	| tempCollection |
-	tempCollection := self collection class new.
-	anInteger timesRepeat: [
-	    self atEnd ifFalse: [
-		tempCollection := tempCollection, self next]].
-	^tempCollection
+asciiValue
+	<return self.charCodeAt(0);>
+!
+
+at: anIndex ifAbsent: aBlock
+	<return self[anIndex - 1] || aBlock()>
+!
+
+escaped
+	<return escape(self)>
+!
+
+size
+	<return self.length>
+!
+
+unescaped
+	<return unescape(self)>
 ! !
 
-!StringStream methodsFor: 'writing'!
+!String methodsFor: 'comparing'!
 
-nextPut: aString
-	self nextPutAll: aString
+< aString
+	<return String(self) < aString._asString()>
 !
 
-nextPutAll: aString
-	self setCollection: 
-	    (self collection copyFrom: 1 to: self position),
-	    aString,
-	    (self collection copyFrom: (self position + 1 + aString size) to: self collection size).
-	self position: self position + aString size.
-	self setStreamSize: (self streamSize max: self position)
+<= aString
+	<return String(self) <= aString._asString()>
 !
 
-cr
-	^self nextPutAll: String cr
+= aString
+	aString class = self class ifFalse: [^false].
+	<return String(self) === String(aString)>
 !
 
-crlf
-	^self nextPutAll: String crlf
+== aString
+	^self = aString
 !
 
-lf
-	^self nextPutAll: String lf
+> aString
+	<return String(self) >> aString._asString()>
 !
 
-space
-	self nextPut: ' '
+>= aString
+	<return String(self) >>= aString._asString()>
 ! !
 
-Collection subclass: #Set
-	instanceVariableNames: 'elements'
-	category: 'Kernel-Collections'!
-
-!Set methodsFor: 'accessing'!
+!String methodsFor: 'converting'!
 
-size
-	^elements size
-! !
+asJSON
+	^self
+!
 
-!Set methodsFor: 'adding/removing'!
+asJavaScriptSelector
+	^(self asSelector replace: '^_' with: '') replace: '_.*' with: ''.
+!
 
-add: anObject
+asJavascript
 	<
-		var found;
-		for(var i=0; i < self['@elements'].length; i++) {
-			if(anObject == self['@elements'][i]) {
-				found = true;
-				break;
-			}
-		}
-		if(!!found) {self['@elements'].push(anObject)}
+		if(self.search(/^[a-zA-Z0-9_:.$ ]*$/) == -1)
+			return "\"" + self.replace(/[\x00-\x1f"\\\x7f-\x9f]/g, function(ch){var c=ch.charCodeAt(0);return "\\x"+("0"+c.toString(16)).slice(-2)}) + "\"";
+		else
+			return "\"" + self + "\"";
 	>
 !
 
-remove: anObject
-	elements remove: anObject
-! !
+asLowercase
+	<return self.toLowerCase()>
+!
 
-!Set methodsFor: 'comparing'!
+asNumber
+	<return Number(self)>
+!
 
-= aCollection
-	^self class = aCollection class and: [
-		elements = aCollection asArray]
-! !
+asSelector
+	"If you change this method, change smalltalk.convertSelector too (see js/boot.js file)"
 
-!Set methodsFor: 'converting'!
+	| selector |
+	selector := '_', self.
+	selector := selector replace: ':' with: '_'.
+	selector := selector replace: '[+]' with: '_plus'.
+	selector := selector replace: '-' with: '_minus'.
+	selector := selector replace: '[*]' with: '_star'.
+	selector := selector replace: '[/]' with: '_slash'.
+	selector := selector replace: '>' with: '_gt'.
+	selector := selector replace: '<' with: '_lt'.
+	selector := selector replace: '=' with: '_eq'.
+	selector := selector replace: ',' with: '_comma'.
+	selector := selector replace: '[@]' with: '_at'.
+	^selector
+!
 
-asArray
-	^elements copy
-! !
+asString
+	^self
+!
 
-!Set methodsFor: 'enumerating'!
+asSymbol
+	^Symbol lookup: self
+!
 
-detect: aBlock ifNone: anotherBlock
-	^elements detect: aBlock ifNone: anotherBlock
+asUppercase
+	<return self.toUpperCase()>
 !
 
-do: aBlock
-	elements do: aBlock
+reversed
+	<return self.split("").reverse().join("")>
 !
 
-select: aBlock
-	| collection |
-	collection := self class new. 
-	self do: [:each |
-		(aBlock value: each) ifTrue: [
-			collection add: each]].
-	^collection
+tokenize: aString
+	<return self.split(aString)>
 ! !
 
-!Set methodsFor: 'initialization'!
+!String methodsFor: 'copying'!
 
-initialize
-	super initialize.
-	elements := #()
-! !
+, aString
+	<return self + aString>
+!
 
-!Set methodsFor: 'testing'!
+copyFrom: anIndex to: anotherIndex
+	<return self.substring(anIndex - 1, anotherIndex)>
+!
 
-includes: anObject
-	^elements includes: anObject
+deepCopy
+	^self shallowCopy
+!
+
+shallowCopy
+	^self class fromString: self
 ! !
 
-Collection subclass: #HashedCollection
-	instanceVariableNames: ''
-	category: 'Kernel-Collections'!
-!HashedCollection commentStamp!
-A HashedCollection is a traditional JavaScript object, or a Smalltalk Dictionary.
+!String methodsFor: 'printing'!
 
-Unlike a Dictionary, it can only have strings as keys.!
+printNl
+	<console.log(self)>
+!
 
-!HashedCollection methodsFor: 'accessing'!
+printString
+	^'''', self, ''''
+! !
 
-size
-	^self keys size
+!String methodsFor: 'regular expressions'!
+
+match: aRegexp
+	<return self.search(aRegexp) !!= -1>
 !
 
-associations
-	| associations |
-	associations := #().
-	self keys do: [:each |
-	    associations add: (Association key: each value: (self at: each))].
-	^associations
+matchesOf: aRegularExpression
+      <return self.match(aRegularExpression)>
 !
 
-keys
-	<
-		var keys = [];
-		for(var i in self) {
-			if(self.hasOwnProperty(i)) {
-				keys.push(i);
-			}
-		};
-		return keys;
-	>
+replace: aString with: anotherString
+	^self replaceRegexp: (RegularExpression fromString: aString flag: 'g') with: anotherString
 !
 
-values
-	^self keys collect: [:each | self at: each]
+replaceRegexp: aRegexp with: aString
+	<return self.replace(aRegexp, aString)>
 !
 
-at: aKey put: aValue
-	^self basicAt: aKey put: aValue
+trimBoth
+	^self trimBoth: '\s'
 !
 
-at: aKey ifAbsent: aBlock
-	^(self includesKey: aKey)
-		ifTrue: [self basicAt: aKey]
-		ifFalse: aBlock
+trimBoth: separators
+
+	^(self trimLeft: separators) trimRight: separators
 !
 
-at: aKey ifAbsentPut: aBlock
-	^self at: aKey ifAbsent: [
-	    self at: aKey put: aBlock value]
+trimLeft
+	^self trimLeft: '\s'
 !
 
-at: aKey ifPresent: aBlock
-	^(self basicAt: aKey) ifNotNil: [aBlock value: (self at: aKey)]
+trimLeft: separators
+
+	^self replaceRegexp: (RegularExpression fromString: '^[', separators, ']+' flag: 'g') with: ''
 !
 
-at: aKey ifPresent: aBlock ifAbsent: anotherBlock
-	^(self basicAt: aKey)
-	    ifNil: anotherBlock
-	    ifNotNil: [aBlock value: (self at: aKey)]
+trimRight
+	^self trimRight: '\s'
 !
 
-at: aKey
-	^self at: aKey ifAbsent: [self errorNotFound]
+trimRight: separators
+
+	^self replaceRegexp: (RegularExpression fromString: '[', separators, ']+$' flag: 'g') with: ''
 ! !
 
-!HashedCollection methodsFor: 'adding/removing'!
+!String methodsFor: 'split join'!
 
-add: anAssociation
-	self at: anAssociation key put: anAssociation value
+join: aCollection 
+	^ String
+		streamContents: [:stream | aCollection
+				do: [:each | stream nextPutAll: each asString] 
+				separatedBy: [stream nextPutAll: self]]
 !
 
-addAll: aHashedCollection
-	super addAll: aHashedCollection associations.
-	^aHashedCollection
+lineIndicesDo: aBlock
+	"execute aBlock with 3 arguments for each line:
+	- start index of line
+	- end index of line without line delimiter
+	- end index of line including line delimiter(s) CR, LF or CRLF"
+	
+	| cr lf start sz nextLF nextCR |
+	start := 1.
+	sz := self size.
+	cr := String cr.
+	nextCR := self indexOf: cr startingAt: 1.
+	lf := String lf.
+	nextLF := self indexOf: lf startingAt: 1.
+	[ start <= sz ] whileTrue: [
+		(nextLF = 0 and: [ nextCR = 0 ])
+			ifTrue: [ "No more CR, nor LF, the string is over"
+					aBlock value: start value: sz value: sz.
+					^self ].
+		(nextCR = 0 or: [ 0 < nextLF and: [ nextLF < nextCR ] ])
+			ifTrue: [ "Found a LF"
+					aBlock value: start value: nextLF - 1 value: nextLF.
+					start := 1 + nextLF.
+					nextLF := self indexOf: lf startingAt: start ]
+			ifFalse: [ 1 + nextCR = nextLF
+				ifTrue: [ "Found a CR-LF pair"
+					aBlock value: start value: nextCR - 1 value: nextLF.
+					start := 1 + nextLF.
+					nextCR := self indexOf: cr startingAt: start.
+					nextLF := self indexOf: lf startingAt: start ]
+				ifFalse: [ "Found a CR"
+					aBlock value: start value: nextCR - 1 value: nextCR.
+					start := 1 + nextCR.
+					nextCR := self indexOf: cr startingAt: start ]]]
 !
 
-removeKey: aKey
-    self remove: aKey
-!
+lineNumber: anIndex
+	"Answer a string containing the characters in the given line number."
 
-remove: aKey ifAbsent: aBlock
-    ^self removeKey: aKey ifAbsent: aBlock
+	| lineCount |
+	lineCount := 0.
+	self lineIndicesDo: [:start :endWithoutDelimiters :end |
+		(lineCount := lineCount + 1) = anIndex ifTrue: [^self copyFrom: start to: endWithoutDelimiters]].
+	^nil
 !
 
-removeKey: aKey ifAbsent: aBlock
-	^(self includesKey: aKey) 
-		ifFalse: [aBlock value]
-		ifTrue: [self basicDelete: aKey]
-! !
+lines
+	"Answer an array of lines composing this receiver without the line ending delimiters."
 
-!HashedCollection methodsFor: 'comparing'!
+	| lines |
+	lines := Array new.
+	self linesDo: [:aLine | lines add: aLine].
+	^lines
+!
 
-= aHashedCollection
-	self class = aHashedCollection class ifFalse: [^false].
-	self size = aHashedCollection size ifFalse: [^false].
-	^self associations = aHashedCollection associations
+linesDo: aBlock
+	"Execute aBlock with each line in this string. The terminating line
+	delimiters CR, LF or CRLF pairs are not included in what is passed to aBlock"
+
+	self lineIndicesDo: [:start :endWithoutDelimiters :end |
+		aBlock value: (self copyFrom: start to: endWithoutDelimiters)]
 ! !
 
-!HashedCollection methodsFor: 'converting'!
+!String methodsFor: 'testing'!
 
-asDictionary
-	^Dictionary fromPairs: self associations
+includesSubString: subString
+	< return self.indexOf(subString) !!= -1 >
 !
 
-asJSON
-	| c |
-	c := self class new.
-	self keysAndValuesDo: [:key :value |
-		c at: key put: value asJSON].
-	^c
+isString
+	^true
 ! !
 
-!HashedCollection methodsFor: 'copying'!
+!String class methodsFor: 'accessing'!
 
-shallowCopy
-	| copy |
-	copy := self class new.
-	self associationsDo: [:each |
-	    copy at: each key  put: each value].
-	^copy
+cr
+	<return '\r'>
 !
 
-, aCollection
-	self shouldNotImplement
+crlf
+	<return '\r\n'>
 !
 
-copyFrom: anIndex to: anotherIndex
-	self shouldNotImplement
+lf
+	<return '\n'>
 !
 
-deepCopy
-	| copy |
-	copy := self class new.
-	self associationsDo: [:each |
-	    copy at: each key  put: each value deepCopy].
-	^copy
-! !
-
-!HashedCollection methodsFor: 'enumerating'!
-
-associationsDo: aBlock
-	self associations do: aBlock
+space
+	<return ' '>
 !
 
-keysAndValuesDo: aBlock
-	self associationsDo: [:each |
-	    aBlock value: each key value: each value]
+streamClass
+	    ^StringStream
 !
 
-do: aBlock
-	self values do: aBlock
-!
+tab
+	<return '\t'>
+! !
 
-select: aBlock
-	| newDict |
-	newDict := self class new.
-	self keysAndValuesDo: [:key :value |
-	    (aBlock value: value) ifTrue: [newDict at: key put: value]].
-	^newDict
-!
+!String class methodsFor: 'instance creation'!
 
-collect: aBlock
-	| newDict |
-	newDict := self class new.
-	self keysAndValuesDo: [:key :value |
-	    newDict at: key put: (aBlock value: value)].
-	^newDict
+fromString: aString
+	    <return new self.fn(aString)>
 !
 
-detect: aBlock ifNone: anotherBlock
-	^self values detect: aBlock ifNone: anotherBlock
+streamContents: blockWithArg
+	|stream|
+	stream := (self streamClass on: String new).
+	blockWithArg value: stream.
+	^ stream contents
 !
 
-includes: anObject
-	^self values includes: anObject
-! !
+value: aUTFCharCode
 
-!HashedCollection methodsFor: 'printing'!
+	<return String.fromCharCode(aUTFCharCode);>
+! !
 
-printString
-	^String streamContents: [:aStream|  
-		aStream 
-			nextPutAll: super printString;
-			nextPutAll: '('.
-				self associations 
-					do: [:anAssociation|  
-						aStream 
-							nextPutAll: anAssociation key printString;
-								nextPutAll: ' -> ';
-								nextPutAll: anAssociation value printString]
-							separatedBy: [aStream nextPutAll: ' , '].
-						aStream nextPutAll: ')']
+CharacterArray subclass: #Symbol
+	instanceVariableNames: ''
+	package: 'Kernel-Collections'!
+
+!Symbol methodsFor: 'accessing'!
+
+at: anIndex ifAbsent: aBlock
+	^self asString at: anIndex ifAbsent: aBlock
 !
 
-storeOn: aStream
-	aStream nextPutAll: '#{'.
-	self associations
-		do: [:each | each storeOn: aStream]
-		separatedBy: [ aStream nextPutAll: '. '].
-	aStream nextPutAll: '}'
+size
+	^self asString size
 ! !
 
-!HashedCollection methodsFor: 'testing'!
+!Symbol methodsFor: 'comparing'!
 
-includesKey: aKey
-	<return self.hasOwnProperty(aKey)>
+< aSymbol
+	^self asString < aSymbol asString
+!
+
+<= aSymbol
+	^self asString <= aSymbol asString
+!
+
+= aSymbol
+	aSymbol class = self class ifFalse: [^false].
+	^self asString = aSymbol asString
+!
+
+> aSymbol
+	^self asString > aSymbol asString
+!
+
+>= aSymbol
+	^self asString >= aSymbol asString
 ! !
 
-!HashedCollection class methodsFor: 'instance creation'!
+!Symbol methodsFor: 'converting'!
 
-fromPairs: aCollection
-	| dict |
-	dict := self new.
-	aCollection do: [:each | dict add: each].
-	^dict
+asJSON
+	^self asString asJSON
+!
+
+asJavascript
+	^'smalltalk.symbolFor("', self asString, '")'
+!
+
+asSelector
+	^self asString asSelector
+!
+
+asString
+	<return self.value>
+!
+
+asSymbol
+	^self
 ! !
 
-HashedCollection subclass: #Dictionary
-	instanceVariableNames: 'keys values'
-	category: 'Kernel-Collections'!
+!Symbol methodsFor: 'copying'!
 
-!Dictionary methodsFor: 'accessing'!
+copyFrom: anIndex to: anotherIndex
+	^self class fromString: (self asString copyFrom: anIndex to: anotherIndex)
+!
 
-at: aKey ifAbsent: aBlock
-	<
-		var index;
-		for(var i=0;i<self['@keys'].length;i++){
-			if(self['@keys'][i].__eq(aKey)) {index = i;}
-		};
-		if(typeof index === 'undefined') {
-			return aBlock();
-		} else {
-			return self['@values'][index];
-		}
-	>
+deepCopy
+	^self
 !
 
-keys
-	^keys copy
+shallowCopy
+	^self
+! !
+
+!Symbol methodsFor: 'printing'!
+
+isSymbol
+	^true
 !
 
-values
-	^values copy
+printString
+	^'#', self asString
+! !
+
+!Symbol class methodsFor: 'instance creation'!
+
+basicNew
+	self shouldNotImplement
 !
 
-at: aKey put: aValue
-	<
-		var index = self['@keys'].indexOf(aKey);
-		if(index === -1) {
-			self['@values'].push(aValue);
-			self['@keys'].push(aKey);
-		} else {
-			self['@values'][index] = aValue;
-		};
+fromString: aString
+	^self lookup: aString
+!
 
-		return aValue;
-	>
+lookup: aString
+	<return smalltalk.symbolFor(aString);>
 ! !
 
-!Dictionary methodsFor: 'adding/removing'!
+Collection subclass: #Set
+	instanceVariableNames: 'elements'
+	package: 'Kernel-Collections'!
 
-removeKey: aKey ifAbsent: aBlock
+!Set methodsFor: 'accessing'!
+
+size
+	^elements size
+! !
+
+!Set methodsFor: 'adding/removing'!
+
+add: anObject
 	<
-		var index = self['@keys'].indexOf(aKey);
-		if(index === -1) {
-			return aBlock()
-		} else {
-			self['@keys'].splice(i, 1);
-			self['@values'].splice(i, 1);
-			return aKey
-		};
+		var found;
+		for(var i=0; i < self['@elements'].length; i++) {
+			if(anObject == self['@elements'][i]) {
+				found = true;
+				break;
+			}
+		}
+		if(!!found) {self['@elements'].push(anObject)}
 	>
+!
+
+remove: anObject
+	elements remove: anObject
 ! !
 
-!Dictionary methodsFor: 'converting'!
+!Set methodsFor: 'comparing'!
 
-asHashedCollection
-	^HashedCollection fromPairs: self associations
+= aCollection
+	^self class = aCollection class and: [
+		elements = aCollection asArray]
+! !
+
+!Set methodsFor: 'converting'!
+
+asArray
+	^elements copy
+! !
+
+!Set methodsFor: 'enumerating'!
+
+detect: aBlock ifNone: anotherBlock
+	^elements detect: aBlock ifNone: anotherBlock
 !
 
-asJSON
-	^self asHashedCollection asJSON
+do: aBlock
+	elements do: aBlock
+!
+
+select: aBlock
+	| collection |
+	collection := self class new. 
+	self do: [:each |
+		(aBlock value: each) ifTrue: [
+			collection add: each]].
+	^collection
 ! !
 
-!Dictionary methodsFor: 'initialization'!
+!Set methodsFor: 'initialization'!
 
 initialize
 	super initialize.
-	keys := #().
-	values := #()
+	elements := #()
 ! !
 
-!Dictionary methodsFor: 'testing'!
+!Set methodsFor: 'testing'!
 
-includesKey: aKey
-	^keys includes: aKey
+includes: anObject
+	^elements includes: anObject
+! !
+
+Object subclass: #RegularExpression
+	instanceVariableNames: ''
+	package: 'Kernel-Collections'!
+
+!RegularExpression methodsFor: 'evaluating'!
+
+compile: aString
+	<return self.compile(aString)>
+!
+
+exec: aString
+	<return self.exec(aString) || nil>
+!
+
+test: aString
+	<return self.test(aString)>
+! !
+
+!RegularExpression class methodsFor: 'instance creation'!
+
+fromString: aString
+	    ^self fromString: aString flag: ''
+!
+
+fromString: aString flag: anotherString
+	<return new RegExp(aString, anotherString)>
+! !
+
+Object subclass: #Stream
+	instanceVariableNames: 'collection position streamSize'
+	package: 'Kernel-Collections'!
+
+!Stream methodsFor: 'accessing'!
+
+collection
+	^collection
+!
+
+contents
+	^self collection
+	    copyFrom: 1 
+	    to: self streamSize
+!
+
+position
+	^position ifNil: [position := 0]
+!
+
+position: anInteger
+	position := anInteger
+!
+
+setCollection: aCollection
+	collection := aCollection
+!
+
+setStreamSize: anInteger
+	streamSize := anInteger
+!
+
+size
+	^self streamSize
+!
+
+streamSize
+	^streamSize
+! !
+
+!Stream methodsFor: 'actions'!
+
+close
+!
+
+flush
+!
+
+reset
+	self position: 0
+!
+
+resetContents
+	self reset.
+	self setStreamSize: 0
+! !
+
+!Stream methodsFor: 'enumerating'!
+
+do: aBlock
+	[self atEnd] whileFalse: [aBlock value: self next]
+! !
+
+!Stream methodsFor: 'positioning'!
+
+setToEnd
+	self position: self size
+!
+
+skip: anInteger
+	self position: ((self position + anInteger) min: self size max: 0)
+! !
+
+!Stream methodsFor: 'reading'!
+
+next
+	^self atEnd 
+		ifTrue: [nil]
+		ifFalse: [
+			self position: self position + 1. 
+			collection at: self position]
+!
+
+next: anInteger
+	| tempCollection |
+	tempCollection := self collection class new.
+	anInteger timesRepeat: [
+	    self atEnd ifFalse: [
+		tempCollection add: self next]].
+	^tempCollection
+!
+
+peek
+	^self atEnd ifFalse: [
+	    self collection at: self position + 1]
+! !
+
+!Stream methodsFor: 'testing'!
+
+atEnd
+	^self position = self size
+!
+
+atStart
+	^self position = 0
+!
+
+isEmpty
+	^self size = 0
+! !
+
+!Stream methodsFor: 'writing'!
+
+nextPut: anObject
+	self position: self position + 1.
+	self collection at: self position put: anObject.
+	self setStreamSize: (self streamSize max: self position)
+!
+
+nextPutAll: aCollection
+	aCollection do: [:each |
+	    self nextPut: each]
+! !
+
+!Stream class methodsFor: 'instance creation'!
+
+on: aCollection
+	    ^self new 
+		setCollection: aCollection;
+		setStreamSize: aCollection size;
+		yourself
+! !
+
+Stream subclass: #StringStream
+	instanceVariableNames: ''
+	package: 'Kernel-Collections'!
+
+!StringStream methodsFor: 'reading'!
+
+next: anInteger
+	| tempCollection |
+	tempCollection := self collection class new.
+	anInteger timesRepeat: [
+	    self atEnd ifFalse: [
+		tempCollection := tempCollection, self next]].
+	^tempCollection
+! !
+
+!StringStream methodsFor: 'writing'!
+
+cr
+	^self nextPutAll: String cr
+!
+
+crlf
+	^self nextPutAll: String crlf
+!
+
+lf
+	^self nextPutAll: String lf
+!
+
+nextPut: aString
+	self nextPutAll: aString
+!
+
+nextPutAll: aString
+	self setCollection: 
+	    (self collection copyFrom: 1 to: self position),
+	    aString,
+	    (self collection copyFrom: (self position + 1 + aString size) to: self collection size).
+	self position: self position + aString size.
+	self setStreamSize: (self streamSize max: self position)
+!
+
+space
+	self nextPut: ' '
 ! !