This only works well on the JSCocoa side, as on the ObjC side you'll have to get the class with objc_getClass([@"ファイナンス" UTF8String]). I can't get it to call selectors yet. Still looks nice though !

try
{
	var outOfRangeObject = [[NSArray arrayWithObjects:@"a", @"b", nil] objectAtIndex:-1]
}
catch(e)
{
	// Prints NSRangeException
	log(e.name)
}

// Standard Javascript way
NSApplication.sharedApplication.delegate = myDelegate
// ObjJ way
[[NSApplication sharedApplication] setDelegate:myDelegate]
// Mixed way
[NSApplication sharedApplication].delegate = myDelegate

// Multi param call
var url = [NSURL instanceFileURLWithPath:@"/tmp" isDirectory:true]

// Create a Javascript array containing an NSURL
var array = [[NSURL instanceFileURLWithPath:@"/tmp" isDirectory:true]]

Here's some colored code with lintex :

• JSCocoa.classes list all Cocoa classes
• JSCocoa.protocols all protocols
• JSCocoa.imageNames all loaded frameworks

• MyClass.__subclasses a list of all classes inheriting from MyClass. Use MyClass.__subclassTree for a human readable version
• MyClass.__classImage name of framework defining the class
• MyClass.__derivationPath list superclasses
• MyClass.__methods, MyClass.__ivars, MyClass.__properties, MyClass.__protocols pretty much everything you wanted to know about a class ! These methods list all data from a class and from its superclasses. To get only this class' data, use the own-prefixed methods : MyClass.__ownMethods lists only methods defined by MyClass.

// Find all NSArray methods starting with 'init'
log(NSArray.__methods.filter(function (method) { return method.name.match(/^init/) }))
// Same code, but only print method name
log(NSArray.__methods.filter(function (method) { return method.name.match(/^init/) }).map(function(o){return o.name}))
// Find NSObject methods defined in the AppKit framework
log(NSObject.__methods.filter(function (method) { return method.framework.match(/AppKit/) } ))

// Show NSButton superclasses
log('NSButton superclasses=' + NSButton.__derivationPath)
>NSObject,
>NSResponder,
>NSView,
>NSControl,
>NSButton

// Show all CALayer subclasses in human readable form
log('CALayer.subclassTree=\n' + CALayer.__subclassTree)
> CALayer
>  CAEmitterLayer
>  CAGradientLayer
>  CALayerHost
>  CAOpenGLLayer
>   NSOpenGLLayer
>   _NSOpenGLLayer
>  CAReplicatorLayer
(snip)

By using initWithGlobalContext, JSCocoa can now be used inside a WebView in place of the WebKit bridge. This is the full JSCocoa monty in a webpage, with a small difference : there's a global OSX object to retrieve objects.

// This is JSCocoa called from inside a WebView !
var objCDate = OSX.NSDate.alloc.init
var point = new OSX.NSPoint(123, 456)
var delegate = OSX.NSApplication.sharedApplication.delegate
var array = delegate.testArray( ['hello', 'world', [4, 5, 6], 'end' ] )

Restricting access To prevent the webpage from calling certain methods, use JSCocoa's delegate methods. canGetGlobalProperty, canGetProperty, canCallFunction, canCallMethod will let you write anything from toll free passage to full lockdown.

Check out JSCocoa / WebView sample code, by Fabien Franzen.

Call JSCocoa.runningArchitecture to know what you're running on. JSCocoa runs on x86_64, i386, PPC, iPhone and iPhone simulator.

JSCocoa uses libffi-iphone internally. You may need it if you're porting a scripting language to the iPhone.

• the iPhone has no BridgeSupport files On the Mac, structures, enums, C functions can be used thanks to BridgeSupport files describing them : NSPoint, kCFAllocatorDefault, NSMakeRectRect are read by JSCocoa and made available in the Javascript context. On the iPhone, BridgeSupport files do not exist. You can still use structures, enums, C functions but they must be described in your own BridgeSupport file.
• the iPhone has no mprotect To create a new ObjC class in Javascript, JSCocoa must create a new ObjC method for each method your overload. These methods are stored in a static pool, but they can be reused by any number of methods at runtime.

Check out the iPhone sample on Github.

JSCocoa works on the iPhone thanks to Philippe Charrière, Tim Burks, Jay Freeman, and Gary Hayenga. Thank you guys !

This means any binding, notification request made can now be dismissed in dealloc, just like standard ObjC code.

// A class whose targetValue will be bound with Cocoa Bindings
class	BindingsTarget < NSObject
{
	// Dealloc will be called in the next run loop cycle right after JavascriptCore GC
	- (void)dealloc
	{
		this.unbind('targetValue')
	}
	// Declare a targetValue key
	Key targetValue
}

// Instantiate and bind to a source value
var target = BindingsTarget.instance()
target.bind_toObject_withKeyPath_options('targetValue', source, 'sourceValue', null)

// Register a load delegate
var loadDelegate = WebViewLoadDelegate.instance()
view.frameLoadDelegate = loadDelegate

// Load a web page
webView.mainFrameURL = 'http://google.com'

// Delegate class
class WebViewLoadDelegate < NSObject
{
	// WebKit will call this method upon page load completion
	- (void)webView:(WebView *)sender didFinishLoadForFrame:(WebFrame *)frame
	{
		// Global context is frame's window object
		var window = sender.mainFrame.globalContext

		// Change the background color of an element
		window.document.getElementById('someElement').style.backgroundColor = 'lime'

		// Call a Javascript method defined in the page
		window.callSomeJavascriptMethod('hello', 8)
	}
}

Also check out Narwhal-jsc, a JSCocoa loader for Narwhal (server side Javascript).

class NSButton
{
	// Swizzle an instance method of an existing class
	Swizzle- (void)drawRect:(NSRect)rect
	{
	    // Draw something behind the button
	    ...
	    // Call original swizzled method, this will call NSButton's drawRect:
	    this.Original(arguments)
	    // Draw something in front of the button
	    NSBezierPath.bezierPathWithOvalInRect(rect).stroke
	}
}

swizzling is replacing a method's implementation with our own. This example swizzles NSButton's drawRect: with a Javascript function : each time a button must be drawn, the ObjC runtime will call this Javascript function. If you want to modify the behaviour of existing classes without deriving, swizzling is the way to go ! Thanks to JRSwizzle for the code.

Add Swizzle in front of a method definition to swizzle it. To call the original method, call this.Original(arguments).

// JSTalk-enable your application
[JSTalk listen];

// From the JSTalk editor you can then script it in Javascript
var sketch = JSTalk.application("Sketch");
var doc = sketch.orderedDocuments()[0];
var rectangle = doc.makeNewBox();
rectangle.setWidth(100);
rectangle.setHeight(100);

// Or use an ObjC syntax
var bezierPath = [NSBezierPath bezierPath];
[bezierPath curveToPoint:pointA controlPoint1:pointB controlPoint2:pointC];
[bezierPath fill];

// Check if getting property is allowed
- (BOOL) JSCocoa:(JSCocoaController*)controller 
canGetProperty:(NSString*)propertyName ofObject:(id)object inContext:(JSContextRef)ctx exception:(JSValueRef*)exception;
// Custom handler for getting properties
//	Return a custom JSValueRef to bypass JSCocoa
//	Return NULL to let JSCocoa handle getProperty
//	Return JSValueMakeNull() to return a Javascript null
- (JSValueRef) JSCocoa:(JSCocoaController*)controller 
getProperty:(NSString*)propertyName ofObject:(id)object inContext:(JSContextRef)ctx exception:(JSValueRef*)exception;

After restricting access with the can* methods, you can use getProperty, setProperty, callMethod to bypass JSCocoa and implement custom behaviour to return custom values to Javascript.

canLoadJSFile, canEvaluateScript restrict script loading. willEvaluateScript gives you a change to transform the input script before evaluation : use it to implement a custom syntax or expand your own macros.

	// Define a new class
	class MyClass < NSObject
	{
		// instance method
		- (int)addX:(int)x andY:(int)y
		{
			return x + y
		}
		// class method
		+ (float)addFloatX:(float)x andFloatY:(float)y
		{
			return x + y
		}

		// Interface Builder outlet		
		IBOutlet outlet1
		// Interface Builder outlet using a Javacript notification
		IBOutlet outlet2 (newValue)
		{
			log('new value of outlet2=' + newValue)
		}

		// Interface Builder action, using sender as default parameter
		IBAction clickMe
		{
			log('Button clicked=' + sender)
		}
		// Interface Builder action, using custom parameter name
		IBAction clickMeToo(notifier)
		{
			log('Button clicked=' + notifier)
		}
	}

	// Functions like NSOpenGLGetVersion(int*, int*) expect two pointers to int
	// JSCocoa detects pointer types and auto allocs required size
	var major = new outArgument
	var minor = new outArgument
	NSOpenGLGetVersion(major, minor)
	log('OpenGL version : ' + major + '.' + minor)

	// Using with structures
	var rect = new NSRect(10, 20, 30, 40)
	var rect1 = new outArgument
	var rect2 = new outArgument

	NSDivideRect(rect, rect1, rect2, 5, NSMinXEdge)
	log('Divided rect1=' + rect1)

	// Using with ObjC methods : scanning a string with NSScanner
	var scanner = NSScanner.scannerWithString('4.56 123')
	var extractedFloat = new outArgument
	scanner.scanFloat(extractedFloat)
	log('extracted=' + extractedFloat)

	// 
	// Memory buffers : manually allocating memory and using it as data source or sink
	// 

	// Data source : copy color components into our buffer
	// Allocate room for 4 floats
	var buffer = new memoryBuffer('ffff')

	// Extract components of a NSColor into our buffer
	color.get({	red : new outArgument(buffer, 0), 
			green : new outArgument(buffer, 1), 
			blue : new outArgument(buffer, 2),
			alpha : new outArgument(buffer, 3) })
	log('Extracted red=' + buffer[0])

	// Data sink : copy point coordinates into a NSBezierPath element
	// Allocate room for 3 points
	var buffer = new memoryBuffer('ffffff')
	// Set new point values
	buffer[0] = 10.0
	buffer[1] = 5.0
	...
	...

	// Fill a NSBezierPath element with our new coordinates
	path.setAssociatedPoints_atIndex(buffer, 1)

• Create an iPhone app and classes in ObjC then use JSCocoa to script these classes
• Create dummy derived classes with dummy methods each calling their Javascript counterpart
• Somehow make mprotect work

I love Git, it's really a "what's changed" manager for directories used as source control. Files referenced once will exist only once, files moved will keep refering to the same object, and it's easy to use :
git add . to add the current directory,
git commit -a -m "new version!"; git push to send the new version to Github.
You can tag releases, easily branch from them, all of that locally !