open pdf and draw c# : Add hyperlinks to pdf application software tool html windows azure online %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D34-part1564

completes. If an event handler performs a computationally intensive task, the browser
may become nonresponsive, possibly causing the user to think that it has crashed.
2
If your application must perform enough computation to cause a noticeable delay, you
should allow the document to load fully before performing that computation, and you
should be sure to notify the user that computation is underway and that the browser
is not hung. If it is possible to break your computation down into discrete subtasks,
you can use methods such as 
setTimeout()
and 
setInterval()
to run the subtasks in
the background while updating a progress indicator that displays feedback to the user.
HTML5 defines a controlled form of concurrency called a “web worker.” A web worker
is a background thread for performing computationally intensive tasks without freezing
the user interface. The code that runs in a web worker thread does not have access to
document content, does not share any state with the main thread or with other workers,
and can only communicate with the main thread and other workers through asyn-
chronous events, so the concurrency is not detectable to the main thread, and web
workers do not alter the basic single-threaded execution model of JavaScript programs.
See §22.4 for full details on web workers.
13.3.4  Client-Side JavaScript Timeline
We’ve already seen that JavaScript programs begin in a script execution phase and then
transition to an event-handling phase. This section explains the timeline of JavaScript
program execution in more detail.
1.The web browser creates a Document object and begins parsing the web page,
adding Element objects and Text nodes to the document as it parses HTML ele-
ments and their textual content. The 
document.readyState
property has the value
“loading” at this stage.
2.When the HTML parser encounters 
<script>
elements that have neither the
async
nor 
defer
attributes, it adds those elements to the document and then exe-
cutes the inline or external script. These scripts are executed synchronously, and
the parser pauses while the script downloads (if necessary) and runs. Scripts like
these can use 
document.write()
to insert text into the input stream. That text will
become part of the document when the parser resumes. Synchronous scripts often
simply define functions and register event handlers for later use, but they can tra-
verse and manipulate the document tree as it exists when they run. That is, syn-
chronous scripts can see their own 
<script>
element and document content that
comes before it.
3.When the parser encounters a 
<script>
element that has the 
async
attribute set, it
begins downloading the script text and continues parsing the document. The script
will be executed as soon as possible after it has downloaded, but the parser does
not stop and wait for it to download. Asynchronous scripts must not use the
2.Some browsers guard against denial-of-service attacks and accidental infinite loops by prompting the user
if a script or event handler takes too long to run. This gives the user the chance to abort a runaway script.
13.3  Execution of JavaScript Programs | 323
Client-Side
JavaScript
Add hyperlinks to pdf - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
add hyperlink to pdf online; clickable pdf links
Add hyperlinks to pdf - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
adding hyperlinks to a pdf; add hyperlink to pdf in
document.write()
method. They can see their own 
<script>
element and all docu-
ment elements that come before it, and may or may not have access to additional
document content.
4.When the document is completely parsed, the 
document.readyState
property
changes to “interactive”.
5.Any scripts that had the 
defer
attribute set are executed, in the order in which they
appeared in the document. Async scripts may also be executed at this time. De-
ferred scripts have access to the complete document tree and must not use the
document.write()
method.
6.The browser fires a DOMContentLoaded event on the Document object. This
marks the transition from synchronous script execution phase to the asynchronous
event-driven phase of program execution. Note, however, that there may still be
async
scripts that have not yet executed at this point.
7.The document is completely parsed at this point, but the browser may still be
waiting for additional content, such as images, to load. When all such content
finishes loading, and when all 
async
scripts have loaded and executed, the
document.readyState
property changes to “complete” and the web browser fires a
load event on the Window object.
8.From this point on, event handlers are invoked asynchronously in response to user
input events, network events, timer expirations, and so on.
This is an idealized timeline and all browsers do not support all of its details. The load
event is universally supported: all browsers fire it, and it is the most common technique
for determining that the document is completely loaded and ready to manipulate. The
DOMContentLoaded event fires before the load event and is supported by all current
browsers except IE. The 
document.readyState
property is implemented by most brows-
ers at the time of this writing, but the values of this property differ slightly from browser
to browser. The 
defer
attribute is supported by all current versions of IE, but it is only
now being implemented by other browsers. Support for the 
async
attribute is not yet
common at the time of this writing, but asynchronous script execution via the technique
shown in Example 13-4 is supported by all current browsers. (Notice, though, that the
ability to dynamically load scripts with functions like 
loadasync()
blurs the boundary
between the script loading and event-driven phases of program execution.)
This timeline does not specify when the document becomes visible to the user or when
the web browser must start responding to user input events. Those are implementation
details. For very long documents or very slow network connections, it is theoretically
possible that a web browser will render part of a document and allow the user to start
interacting with it before all the scripts have executed. In that case, user input events
might be fired before the event-driven phase of program execution has formally started.
324 | Chapter 13: JavaScript in Web Browsers
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Embed PDF hyperlinks to HTML links. How to Use C#.NET Demo Code to Convert PDF Document to HTML5 Files in C#.NET Class. Add necessary references:
add links to pdf online; convert doc to pdf with hyperlinks
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Turn PDF images to HTML images in VB.NET. Embed PDF hyperlinks to HTML links in VB.NET. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
add links to pdf acrobat; change link in pdf
13.4  Compatibility and Interoperability
The web browser is the operating system for web apps, but the web is a heterogeneous
environment and your web documents and applications will be viewed and run in
browsers of different ages (from cutting-edge beta releases to decade-old browsers like
IE6) from different vendors (Microsoft, Mozilla, Apple, Google, Opera) running on
different operating systems (Windows, Mac OS, Linux, iPhone OS, Android). It is
challenging to write nontrivial client-side JavaScript programs that run correctly on
such a wide variety of platforms.
Client-side JavaScript compatibility and interoperability issues fall into three general
categories:
Evolution
The web platform is always evolving and expanding. A standards body proposes
a new feature or API. If the feature seems useful, browser vendors implement it. If
enough vendors implement it interoperably, developers begin to use and depend
on the feature, and it secures a permanent place in the web platform. Sometimes
browser vendors and web developers take the lead and standards bodies write the
official version well after the feature is already a de facto standard. In either case,
a new feature has been added to the Web. New browsers support it and old brows-
ers do not. Web developers are pulled between wanting to use powerful new
features and wanting their web pages to be usable by the largest number of
visitors—even those who are not using the latest browsers.
Nonimplementation
Sometimes browser vendors differ in their opinions of whether a particular feature
is useful enough to implement. Some vendors implement it and others do not. This
is not a matter of current browsers with the feature versus older browsers without
it, but a matter of browser implementors who prioritized the feature versus those
who did not. IE8, for example, does not support the 
<canvas>
element, though all
other browsers have embraced it. A more egregious example is Microsoft’s decision
not to implement the DOM Level 2 Events specification (which defines
addEventListener()
and related methods). This specification was standardized al-
most a decade ago, and other browser vendors have long since supported it.
3
Bugs
Every browser has bugs, and none implement all of the client-side JavaScript APIs
exactly as specified. Sometimes, writing compatible client-side JavaScript code is
a matter of being aware of, and knowing how to work around, the bugs in existing
browsers.
Fortunately, the JavaScript language itself is interoperably implemented by all browser
vendors and is not a source of compatibility problems. All browsers have interoperable
implementations of ES3, and, at the time of this writing, all vendors are working on
3.To Microsoft’s credit, IE9 now supports both the 
<canvas>
element and the 
addEventListener()
method.
13.4  Compatibility and Interoperability | 325
Client-Side
JavaScript
VB.NET PDF Page Replace Library: replace PDF pages in C#.net, ASP.
all PDF page contents in VB.NET, including text, image, hyperlinks, etc. Replace a Page (in a PDFDocument Object) by a PDF Page Object. Add necessary references:
add hyperlinks pdf file; clickable links in pdf
VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in
PDF document is an easy work and gives quick access to PDF page and file, or even hyperlinks. How to VB.NET: Create Thumbnail for PDF. Add necessary references:
add hyperlink to pdf; active links in pdf
implementing ES5. The transition between ES3 and ES5 may be the source of compat-
ibility problems, because some browsers will support strict mode while others do not,
but the expectation is that browser vendors will implement ES5 interoperably.
The first step in addressing compatibility issues in client-side JavaScript is to be aware
of what those issues are. The web browser release cycle is about three times as rapid as
the release cycle for this book, which means that this book cannot reliably tell you
which versions of which browser implement which features, much less describe the
bugs in or the quality of implementation of the features in various browsers. Details
like this are best left to the Web. The HTML5 standardization effort aims to eventually
produce a test suite. At the time of this writing, no such tests exist, but once they do,
they ought to provide a wealth of browser compatibility information. In the meantime,
here are some websites you might find useful:
https://developer.mozilla.org
The Mozilla Developer Center
http://msdn.microsoft.com
The Microsoft Developer Network
http://developer.apple.com/safari
The Safari Dev Center at the Apple Developer Connection
http://code.google.com/doctype
Google describes its Doctype project as “an encyclopedia of the open web.” This
user-editable site includes extensive compatibility tables for client-side JavaScript.
At the time of this writing, these tables report only on the existence of various
properties and methods in each browser: they do not actually say whether those
features work correctly.
http://en.wikipedia.org/wiki/Comparison_of_layout_engines_(HTML_5)
A Wikipedia article tracking the implementation status of HTML5 features and
APIs in various browsers.
http://en.wikipedia.org/wiki/Comparison_of_layout_engines_(Document_Object_Mod
el)
A similar article that tracks the implementation status of DOM features.
http://a.deveria.com/caniuse
The “When can I use...” website tracks the implementation status of important
web features, allows them to be filtered according to various criteria, and recom-
mends their use once there are few remaining deployed browsers that do not sup-
port the feature.
http://www.quirksmode.org/dom
Tables that list the compatibility of various browsers with the W3C DOM.
http://webdevout.net/browser-support
Another site that attempts to track the implementation of web standards by
browser vendors.
326 | Chapter 13: JavaScript in Web Browsers
.NET PDF SDK | Read & Processing PDF files
by this .NET Imaging PDF Reader Add-on. Include extraction of text, hyperlinks, bookmarks and metadata; Annotate and redact in PDF documents; Fully support all
add hyperlink to pdf in preview; add hyperlinks to pdf online
PDF Image Viewer| What is PDF
advanced capabilities, such as text extraction, hyperlinks, bookmarks and Note: PDF processing and conversion is excluded in NET Imaging SDK, you may add it on
pdf link open in new window; adding a link to a pdf
Note that the last three sites listed are maintained by individuals. Despite the dedication
of these client-side JavaScript heroes, these sites may not always be up to date.
Awareness of the incompatibilities between browsers is only the first step, of course.
Next, you must decide how to address the incompatibilities. One strategy is to restrict
yourself to using only those features that are universally supported (or easily emulated)
by all of the browsers that you choose to support. The “When can I use...” website
mentioned previously (http://a.deveria.com/caniuse) is based around this strategy: it
lists a number of features that will become usable as soon as IE6 has been phased out
and no longer has a significant market share. The subsections that follow explain a few
less passive strategies you can use to work around client-side incompatibilities.
A Word about “Current Browsers”
Client-side JavaScript is a moving target, especially with the advent of ES5 and HTML5.
Because the platform is evolving rapidly, I shy away from making narrow statements
about particular versions of particular browsers: any such claims are likely to be out-
dated well before a new edition of this book appears. You’ll find, therefore, that I often
hedge my statements with purposely vague language like “all current browsers” (or
sometimes “all current browsers except IE”). To put this in context, while I was writing
this chapter, the current (non-beta) browsers were:
• Internet Explorer 8
• Firefox 3.6
• Safari 5
• Chrome 5
• Opera 10.10
When this book reaches bookstores, the current browsers will likely be Internet Ex-
plorer 9, Firefox 4, Safari 5, Chrome 11, and Opera 11.
This is not a guarantee that every statement in this book about “current browsers” is
true for each of these specific browsers. However, it allows you to know what browsers
were current technology when this book was written.
The fifth edition of this book used the phrase “modern browsers” instead of “current
browsers.” That edition was published in 2006, when the current browsers were
Firefox 1.5, IE6, Safari 2, and Opera 8.5 (the Chrome browser from Google did not
exist yet). Any references to “modern browsers” remaining in this book can now be
taken to mean “all browsers,” since browsers older than those are now quite rare.
Many of the newest client-side features described in this book (in Chapter 22 particu-
larly) are not yet implemented by all browsers. The features that I’ve chosen to docu-
ment in this edition are being developed under an open standards process, have been
implemented in at least one released browser, are under development in at least one
more, and seem likely to be adopted by all browser vendors (with the possible exception
of Microsoft).
13.4  Compatibility and Interoperability | 327
Client-Side
JavaScript
13.4.1  Compatibility Libraries
One of the easiest ways to deal with incompatibilities is to use libraries of code that
work around them for you. Consider the 
<canvas>
element for client-side graphics (the
topic of Chapter 21), for example. IE is the only current browser that does not support
this feature. It does support an obscure proprietary client-side graphics language called
VML, however, and the canvas element can be emulated on top of that. The open source
“explorercanvas” project at http://code.google.com/p/explorercanvas has released a li-
brary that does just that: you include a single file of JavaScript code named excan-
vas.js and IE will behave as if it supports the 
<canvas>
element.
excanvas.js is a particularly pure example of a compatibility library. It is possible to
write similar libraries for certain features. The ES5 Array methods (§7.9), such as
forEach()
map()
, and 
reduce()
, can be almost perfectly emulated in ES3, and by adding
the appropriate library to your pages, you can treat these powerfully useful methods as
part of the baseline platform of all browsers.
Sometimes, however, it is not possible to completely (or efficiently) implement a feature
on browsers that do not support it. As already mentioned, IE is the only browser that
does  not  implement  the  standard  event-handling  API,  including  the
addEventListener()
method for registering event handlers. IE supports a similar meth-
od called 
attachEvent()
attachEvent()
is not as powerful as 
addEventListener()
and
it is not really feasible to transparently implement the entire standard on top of what
IE offers. Instead, developers sometimes define a compromise event handling
method—often called 
addEvent()
—that can be portably implemented using either
addEventListener()
or 
attachEvent()
. Then, they write all their code  to use
addEvent()
instead of either 
addEventListener()
or 
attachEvent()
.
In practice, many web developers today use client-side JavaScript frameworks such as
jQuery (see Chapter 19) on all their web pages. One of the functions that makes these
frameworks so indispensable is that they define a new client-side API and implement
it compatibly for you across all browsers. In jQuery, for example, event handler regis-
tration is done with a method named 
bind()
. If you adopt jQuery for all your web
development, you’ll never need to think about the incompatibilities between
addEventListener()
and 
attachEvent()
. See §13.7 for more on client-side frameworks.
13.4.2  Graded Browser Support
Graded browser support is a testing and QA technique pioneered and championed by
Yahoo! that brings some sanity to the otherwise unmanageable proliferation of vendor/
version/OS browser variants. Briefly, graded browser support involves choosing
“A-grade” browsers that receive full support and testing and identifying “C-grade”
browsers that are not powerful enough. A-grade browsers get full-featured web pages,
and C-grade browsers are served minimal HTML-only versions of the pages that require
no JavaScript or CSS. Browsers that are not A-grade or C-grade are called X-grade: these
are usually brand-new or particularly rare browsers. They are assumed to be capable
328 | Chapter 13: JavaScript in Web Browsers
and are served the full-featured web pages, but they are not officially supported
or tested.
You can read more about Yahoo!’s system of graded browser support at http://developer
.yahoo.com/yui/articles/gbs. That web page also includes Yahoo!’s current list of A-
grade and C-grade browsers (the list is updated quarterly). Even if you don’t adopt
graded browser support techniques yourself, Yahoo!’s list of A-grade browsers is a
useful way to determine which browsers are current and have significant market share.
13.4.3  Feature Testing
Feature testing (sometimes called capability testing) is a powerful technique for coping
with incompatibilities. If you want to use a feature or capability that may not be sup-
ported by all browsers, include code in your script that tests to see whether that feature
is supported. If the desired feature is not supported on the current platform, either do
not use it on that platform or provide alternative code that works on all platforms.
You’ll see feature testing again and again in the chapters that follow. In Chapter 17, for
example, we use code that looks like this:
if (element.addEventListener) { // Test for this W3C method before using it
element.addEventListener("keydown", handler, false);
element.addEventListener("keypress", handler, false);
}
else if (element.attachEvent) { // Test for this IE method before using it
element.attachEvent("onkeydown", handler);
element.attachEvent("onkeypress", handler);
}
else {  // Otherwise, fall back on a universally supported technique
element.onkeydown = element.onkeypress = handler;
}
The important thing about the feature-testing technique is that it results in code that
is not tied to a specific list of browser vendors or browser version numbers. It works
with the set of browsers that exists today and should continue to work with future
browsers, whatever feature sets they implement. Note, however, that it requires brows-
er vendors not to define a property or method unless that property or method is fully
functional. If Microsoft were to define an 
addEventListener()
method that only parti-
ally implemented the W3C specification, it would break a lot of code that uses feature
testing before calling 
addEventListener()
.
13.4.4  Quirks Mode and Standards Mode
When Microsoft released IE6, it added support for a number of standard CSS features
that were not supported in IE5. In order to ensure backward compatibility with existing
web content, however, it had to define two distinct rendering modes. In “standards
mode” or “CSS compatibility mode,” the browser would follow CSS standards. In
“quirks mode,” the browser would behave in the quirky nonstandard manner that IE4
and IE5 had. The choice of rendering modes depended on the 
DOCTYPE
declaration at
13.4  Compatibility and Interoperability | 329
Client-Side
JavaScript
the top of the HTML file. Pages with no DOCTYPE at all and pages that declared certain
permissive doctypes that were in common use during the IE5 era were rendered in
quirks mode. Pages with strict doctypes (or, for forward compatibility, pages with un-
recognized doctypes) were rendered in standards mode. Pages with an HTML5 doctype
(
<!DOCTYPE html>
) are rendered in standards mode in all modern browsers.
This distinction between quirks mode and standards mode has stood the test of time.
New versions of IE still implement it, other modern browsers do too, and the existence
of these two modes is recognized by the HTML5 specification. The differences between
quirks mode and standards mode usually matter most to people writing HTML and
CSS. But client-side JavaScript code sometimes needs to know which mode a document
is rendered in. To perform this kind of rendering mode feature testing, check the
document.compatMode
property. If it has the value “CSS1Compat,” the browser is using
standards mode. If the value is “BackCompat” (or 
undefined
if the property doesn’t
exist at all), the browser is using quirks mode. All modern browsers implement the
compatMode
property, and the HTML5 specification standardizes it.
It is not often necessary to test 
compatMode
Example 15-8 illustrates one case where this
test is necessary, however.
13.4.5  Browser Testing
Feature testing is well suited to checking for support of large functional areas. You can
use it to determine whether a browser supports the W3C event-handling model or the
IE event-handling model, for example. On the other hand, sometimes you may need
to work around individual bugs or quirks in a particular browser, and there may be no
easy way to test for the existence of the bug. In this case, you need to create a platform-
specific workaround that is tied to a particular browser vendor, version, or operating
system (or some combination of the three).
The way to do this in client-side JavaScript is with the Navigator object, which you’ll
learn about in Chapter 14. Code that determines the vendor and version of the current
browser is often called a browser sniffer or a client sniffer. A simple example is shown
in Example 14-3. Client sniffing was a common programming technique in the early
days of the Web, when the Netscape and IE platforms were incompatible and diverging.
Client sniffing has now fallen out of favor and should be used only when absolutely
necessary.
Note that client sniffing can be done on the server side as well, with the web server
choosing what JavaScript code to send based on how the browser identifies itself in its
User-Agent
header.
13.4.6  Conditional Comments in Internet Explorer
In practice, you’ll find that many of the incompatibilities in client-side JavaScript pro-
gramming turn out to be IE-specific. That is, you must write code in one way for IE
and in another way for all other browsers. IE supports conditional comments
330 | Chapter 13: JavaScript in Web Browsers
(introduced in IE5) that are completely nonstandard but can be quite useful for working
around incompatibilities.
Here is what IE’s conditional comments look like in HTML. Notice the tricks played
with the closing delimiter of HTML comments:
<!--[if IE 6]>
This content is actually inside an HTML comment.
It will only be displayed in IE 6.
<![endif]-->
<!--[if lte IE 7]>
This content will only be displayed by IE 5, 6 and 7 and earlier.
lte stands for "less than or equal".  You can also use "lt", "gt" and "gte".
<![endif]-->
<!--[if !IE]> <-->
This is normal HTML content, but IE will not display it
because of the comment above and the comment below.
<!--> <![endif]-->
This is normal content, displayed by all browsers.
As a concrete example, consider the excanvas.js library described above to implement
the 
<canvas>
element in Internet Explorer. Since this library is required only in IE (and
works only in IE), it is reasonable to include it on your pages within a conditional
comment so that other browsers never load it:
<!--[if IE]><script src="excanvas.js"></script><![endif]-->
Conditional comments are also supported by IE’s JavaScript interpreter, and C and
C++ programmers may find them similar to the 
#ifdef/#endif
functionality of the C
preprocessor. A JavaScript conditional comment in IE begins with the text 
/*@cc_on
and ends with the text 
@*/
. (The 
cc
in 
cc_on stands
for conditional compilation.) The
following conditional comment includes code that is executed only in IE:
/*@cc_on
@if (@_jscript)
// This code is inside a JS comment but is executed in IE.
alert("In IE");
@end
@*/
Inside a conditional comment, the keywords 
@if
@else
, and 
@end
delimit the code that
is to be conditionally executed by IE’s JavaScript interpreter. Most of the time, you
need only the simple conditional shown above: 
@if (@_jscript)
. JScript is Microsoft’s
name for its JavaScript interpreter, and the 
@_jscript
variable is always 
true
in IE.
With clever interleaving of conditional comments and regular JavaScript comments,
you can set up one block of code to run in IE and a different block to run in all other
browsers:
/*@cc_on
@if (@_jscript)
13.4  Compatibility and Interoperability | 331
Client-Side
JavaScript
// This code is inside a conditional comment, which is also a
// regular JavaScript comment. IE runs it but other browsers ignore it.
alert('You are using Internet Explorer);
@else*/
// This code is no longer inside a JavaScript comment, but is still
// inside the IE conditional comment.  This means that all browsers
// except IE will run this code.
alert('You are not using Internet Explorer');
/*@end
@*/
13.5  Accessibility
The Web is a wonderful tool for disseminating information, and JavaScript programs
can enhance access to that information. JavaScript programmers must be careful, how-
ever: it is easy to write JavaScript code that inadvertently denies information to visitors
with visual or physical handicaps.
Blind users may use a form of “assistive technology” known as a screen reader to convert
written words to spoken words. Some screen readers are JavaScript-aware, and others
work best when JavaScript is turned off. If you design a website that requires JavaScript
to display its information, you exclude the users of these screen readers. (And you have
also excluded anyone who intentionally disables JavaScript in her browser.) The proper
role of JavaScript is to enhance the presentation of information, not to take over the
presentation of that information. A cardinal rule of JavaScript accessibility is to design
your code so that the web page on which it is used will still function (at least in some
form) with the JavaScript interpreter turned off.
Another important accessibility concern is for users who can use the keyboard but
cannot use (or choose not to use) a pointing device such as a mouse. If you write
JavaScript code that relies on mouse-specific events, you exclude users who do not use
the mouse. Web browsers allow keyboard traversal and activation of UI elements with-
in a web page, and your JavaScript code should as well. As shown in Chapter 17,
JavaScript supports device-independent events, such as 
onfocus
and 
onchange
, as well
as device-dependent events, such as 
onmouseover
and 
onmousedown
. For accessibility,
you should favor the device-independent events whenever possible.
Creating accessible web pages is a nontrivial problem and a full discussion of accessi-
bility is beyond the scope of this book. Web application developers who are concerned
about accessibility should familiarize themselves with the WAI-ARIA (Web Accessi-
bility Initiative–Accessible Rich Internet Applications) standards at http://www.w3.org/
WAI/intro/aria.
13.6  Security
The introduction of JavaScript interpreters into web browsers means that loading a
web page can cause arbitrary JavaScript code to be executed on your computer. This
332 | Chapter 13: JavaScript in Web Browsers
Documents you may be interested
Documents you may be interested