public ModuleScope(Scriptable prototype, Uri uri, Uri @base)
		{
			this.uri = uri;
			[email protected] = @base;
			SetPrototype(prototype);
			CacheBuiltins();
		}

		public virtual object Action(Context cx, Scriptable scope, Scriptable thisObj, object[] args, int actionType)
		{
			GlobData data = new GlobData();
			data.mode = actionType;
			switch (actionType)
			{
				case RegExpProxyConstants.RA_MATCH:
				{
					object rval;
					data.optarg = 1;
					rval = MatchOrReplace(cx, scope, thisObj, args, this, data, false);
					return data.arrayobj == null ? rval : data.arrayobj;
				}

				case RegExpProxyConstants.RA_SEARCH:
				{
					data.optarg = 1;
					return MatchOrReplace(cx, scope, thisObj, args, this, data, false);
				}

				case RegExpProxyConstants.RA_REPLACE:
				{
					object arg1 = args.Length < 2 ? Undefined.instance : args[1];
					string repstr = null;
					Function lambda = null;
					if (arg1 is Function)
					{
						lambda = (Function)arg1;
					}
					else
					{
						repstr = ScriptRuntime.ToString(arg1);
					}
					data.optarg = 2;
					data.lambda = lambda;
					data.repstr = repstr;
					data.dollar = repstr == null ? -1 : repstr.IndexOf('$');
					data.charBuf = null;
					data.leftIndex = 0;
					object val = MatchOrReplace(cx, scope, thisObj, args, this, data, true);
					if (data.charBuf == null)
					{
						if (data.global || val == null || !val.Equals(true))
						{
							return data.str;
						}
						SubString lc = this.leftContext;
						Replace_glob(data, cx, scope, this, lc.index, lc.length);
					}
					SubString rc = this.rightContext;
					data.charBuf.AppendRange(rc.str, rc.index, rc.index + rc.length);
					return data.charBuf.ToString();
				}

				default:
				{
					throw Kit.CodeBug();
				}
			}
		}

		/// <summary>Create function compiled from Function(...) constructor.</summary>
		/// <remarks>Create function compiled from Function(...) constructor.</remarks>
		internal static Rhino.InterpretedFunction CreateFunction(Context cx, Scriptable scope, InterpreterData idata, object staticSecurityDomain)
		{
			Rhino.InterpretedFunction f;
			f = new Rhino.InterpretedFunction(idata, staticSecurityDomain);
			f.InitScriptFunction(cx, scope);
			return f;
		}

		public override Scriptable Construct(Context cx, Scriptable scope, object[] args)
		{
			NativeRegExp re = new NativeRegExp();
			re.Compile(cx, scope, args);
			ScriptRuntime.SetBuiltinProtoAndParent(re, scope, TopLevel.Builtins.RegExp);
			return re;
		}

		private static void RunFileIfExists(Context cx, Scriptable global, FilePath f)
		{
			if (f.IsFile())
			{
				Main.ProcessFileNoThrow(cx, global, f.GetPath());
			}
		}

		/// <exception cref="System.IO.IOException"></exception>
		private ModuleSource LoadFromPathArray(string moduleId, Scriptable paths, object validator)
		{
			long llength = ScriptRuntime.ToUint32(ScriptableObject.GetProperty(paths, "length"));
			// Yeah, I'll ignore entries beyond Integer.MAX_VALUE; so sue me.
			int ilength = llength > int.MaxValue ? int.MaxValue : (int)llength;
			for (int i = 0; i < ilength; ++i)
			{
				string path = EnsureTrailingSlash(ScriptableObject.GetTypedProperty<string>(paths, i));
				try
				{
					Uri uri = new Uri(path);
					if (!uri.IsAbsoluteUri)
					{
						uri = new FilePath(path).ToURI().Resolve(string.Empty);
					}
					ModuleSource moduleSource = LoadFromUri(uri.Resolve(moduleId), uri, validator);
					if (moduleSource != null)
					{
						return moduleSource;
					}
				}
				catch (URISyntaxException e)
				{
					throw new UriFormatException(e.Message);
				}
			}
			return null;
		}

		internal static void Init(Scriptable scope, bool @sealed)
		{
			Rhino.BaseFunction obj = new Rhino.BaseFunction();
			// Function.prototype attributes: see ECMA 15.3.3.1
			obj.prototypePropertyAttributes = DONTENUM | READONLY | PERMANENT;
			obj.ExportAsJSClass(MAX_PROTOTYPE_ID, scope, @sealed);
		}

		internal static void Init(Scriptable scope, bool @sealed)
		{
			Rhino.NativeDate obj = new Rhino.NativeDate();
			// Set the value of the prototype Date to NaN ('invalid date');
			obj.date = ScriptRuntime.NaN;
			obj.ExportAsJSClass(MAX_PROTOTYPE_ID, scope, @sealed);
		}

		internal void Initialize(XMLLibImpl lib, Scriptable scope, XMLObject prototype)
		{
			SetParentScope(scope);
			SetPrototype(prototype);
			prototypeFlag = (prototype == null);
			this.lib = lib;
		}

		public override object Call(Context cx, Scriptable scope, Scriptable thisObj, object[] args)
		{
			if (args.Length > 0 && args[0] is NativeRegExp && (args.Length == 1 || args[1] == Undefined.instance))
			{
				return args[0];
			}
			return Construct(cx, scope, args);
		}

		public override bool HasInstance(Scriptable instance)
		{
			if (targetFunction is Function)
			{
				return ((Function)targetFunction).HasInstance(instance);
			}
			throw ScriptRuntime.TypeError0("msg.not.ctor");
		}

		public override Scriptable Construct(Context cx, Scriptable scope, object[] extraArgs)
		{
			if (targetFunction is Function)
			{
				return ((Function)targetFunction).Construct(cx, scope, Concat(boundArgs, extraArgs));
			}
			throw ScriptRuntime.TypeError0("msg.not.ctor");
		}

		public override object Call(Context cx, Scriptable scope, Scriptable thisObj, object[] args)
		{
			if (script != null)
			{
				return script.Exec(cx, scope);
			}
			return Undefined.instance;
		}

		public virtual object Get(string id, Scriptable start)
		{
			if (start == this)
			{
				start = prototype;
			}
			return prototype.Get(id, start);
		}

		public override bool Has(string name, Scriptable start)
		{
			if (this == thePrototypeInstance)
			{
				return base.Has(name, start);
			}
			return (Runtime.GetProperty(name) != null);
		}

		/// <seealso cref="Function.Call(Context, Scriptable, Scriptable, object[])">Function.Call(Context, Scriptable, Scriptable, object[])</seealso>
		public override object Call(Context cx, Scriptable scope, Scriptable thisObj, object[] args)
		{
			object sync = syncObject != null ? syncObject : thisObj;
			lock (sync is Wrapper ? ((Wrapper)sync).Unwrap() : sync)
			{
				return ((Function)obj).Call(cx, scope, thisObj, args);
			}
		}

		/// <summary>Search for ClassCache object in the given scope.</summary>
		/// <remarks>
		/// Search for ClassCache object in the given scope.
		/// The method first calls
		/// <see cref="ScriptableObject.GetTopLevelScope(Scriptable)">ScriptableObject.GetTopLevelScope(Scriptable)</see>
		/// to get the top most scope and then tries to locate associated
		/// ClassCache object in the prototype chain of the top scope.
		/// </remarks>
		/// <param name="scope">scope to search for ClassCache object.</param>
		/// <returns>
		/// previously associated ClassCache object or a new instance of
		/// ClassCache if no ClassCache object was found.
		/// </returns>
		/// <seealso cref="Associate(ScriptableObject)">Associate(ScriptableObject)</seealso>
		public static ClassCache Get(Scriptable scope)
		{
			ClassCache cache = (ClassCache)ScriptableObject.GetTopScopeValue(scope, AKEY);
			if (cache == null)
			{
				throw new Exception("Can't find top level scope for " + "ClassCache.get");
			}
			return cache;
		}

		internal static void Init(Scriptable scope, bool @sealed)
		{
			NativeError obj = new NativeError();
			ScriptableObject.PutProperty(obj, "name", "Error");
			ScriptableObject.PutProperty(obj, "message", string.Empty);
			ScriptableObject.PutProperty(obj, "fileName", string.Empty);
			ScriptableObject.PutProperty(obj, "lineNumber", Sharpen.Extensions.ValueOf(0));
			obj.ExportAsJSClass(MAX_PROTOTYPE_ID, scope, @sealed);
		}

		internal static Rhino.Xmlimpl.Namespace Create(Scriptable scope, Rhino.Xmlimpl.Namespace prototype, Rhino.Xmlimpl.XmlNode.Namespace @namespace)
		{
			Rhino.Xmlimpl.Namespace rv = new Rhino.Xmlimpl.Namespace();
			rv.SetParentScope(scope);
			rv.prototype = prototype;
			rv.SetPrototype(prototype);
			rv.ns = @namespace;
			return rv;
		}

		/// <summary>Implements the instanceof operator for JavaScript Function objects.</summary>
		/// <remarks>
		/// Implements the instanceof operator for JavaScript Function objects.
		/// <p>
		/// <code>
		/// foo = new Foo();<br />
		/// foo instanceof Foo;  // true<br />
		/// </code>
		/// </remarks>
		/// <param name="instance">
		/// The value that appeared on the LHS of the instanceof
		/// operator
		/// </param>
		/// <returns>
		/// true if the "prototype" property of "this" appears in
		/// value's prototype chain
		/// </returns>
		public override bool HasInstance(Scriptable instance)
		{
			object protoProp = ScriptableObject.GetProperty(this, "prototype");
			if (protoProp is Scriptable)
			{
				return ScriptRuntime.JsDelegatesTo(instance, (Scriptable)protoProp);
			}
			throw ScriptRuntime.TypeError1("msg.instanceof.bad.prototype", GetFunctionName());
		}