This is an automated email from the ASF dual-hosted git repository.

joshtynjala pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/royale-docs.git

commit 102ce7710b427f52fab508423caceda98ffcc5de
Author: Josh Tynjala <[email protected]>
AuthorDate: Tue Apr 9 14:03:02 2024 -0700

    more cross-linking
---
 compiler/compiler-options.md                                      | 6 +++---
 component-sets/jewel.md                                           | 2 +-
 component-sets/jewel/jewel-alert.md                               | 2 +-
 component-sets/jewel/jewel-button.md                              | 2 +-
 component-sets/jewel/jewel-checkbox.md                            | 2 +-
 component-sets/mxroyale.md                                        | 2 +-
 component-sets/sparkroyale.md                                     | 2 +-
 create-an-application/application-tutorial/build.md               | 2 +-
 create-an-application/application-tutorial/data-model.md          | 2 +-
 create-an-application/application-tutorial/deploy.md              | 2 +-
 create-an-application/application-tutorial/view.md                | 2 +-
 .../optimizations/compiler-configuration-settings.md              | 2 +-
 create-an-application/optimizations/doc-comment-directives.md     | 2 +-
 features-and-concepts.md                                          | 2 +-
 features/data-binding.md                                          | 2 +-
 features/mxml.md                                                  | 2 +-
 features/routing.md                                               | 2 +-
 features/styles-skins-themes.md                                   | 2 +-
 formatter.md                                                      | 2 +-
 formatter/formatter-options.md                                    | 2 +-
 get-started.md                                                    | 2 +-
 get-started/development-tools.md                                  | 4 ++--
 get-started/frameworks.md                                         | 2 +-
 get-started/hello-world.md                                        | 2 +-
 get-started/royale-cli.md                                         | 2 +-
 index.md                                                          | 2 +-
 libraries/compiled-code-libraries.md                              | 8 ++++----
 libraries/crux/dependency-injection.md                            | 2 +-
 libraries/library-basics.md                                       | 4 ++--
 linter.md                                                         | 2 +-
 linter/linter-options.md                                          | 2 +-
 migrate-an-existing-app/migrate-from-js.md                        | 4 ++--
 testing/royaleunit/create-a-unit-test.md                          | 2 +-
 tutorials.md                                                      | 2 +-
 user-interface/components.md                                      | 4 ++--
 welcome/high-level-view.md                                        | 2 +-
 working-with-data/loading-external-data/httpservice.md            | 2 +-
 working-with-data/loading-external-data/remoteobject.md           | 2 +-
 38 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/compiler/compiler-options.md b/compiler/compiler-options.md
index 160be97..6c1c8dc 100644
--- a/compiler/compiler-options.md
+++ b/compiler/compiler-options.md
@@ -26,7 +26,7 @@ List of all available compiler options
 
 The [**mxmlc** and **compc** compilers](compiler) bundled with [Apache 
Royale](https://royale.apache.org/) have a number of useful configuration 
options. The list below is also available by running `mxmlc -help advanced` in 
a terminal.
 
-- `-allow-dynamic-bindings` -- Controls whether data binding may use 
reflection for dynamic access.
+- `-allow-dynamic-bindings` -- Controls whether [data 
binding](features/data-binding) may use reflection for dynamic access.
 - `-api-report` `<filename>` -- Used to generate a report of APIs used in a 
project.  
 - `-closure-lib` `<string>`  -- Customize the version of Google Closure 
Library used by the framework.
 - `-compiler.accessible`  -- Controls whether accessibility is enabled for a 
generated _.swf_ file.
@@ -97,7 +97,7 @@ The [**mxmlc** and **compc** compilers](compiler) bundled 
with [Apache Royale](h
 - `-compiler.report-missing-required-skin-parts-as-warnings`  
 - `-compiler.services` `<filename>`  
 - `-compiler.show-actionscript-warnings`  
-- 
[`-compiler.show-binding-warnings`](compiler/compiler-options#show-binding-warnings)
+- 
[`-compiler.show-binding-warnings`](compiler/compiler-options#show-binding-warnings)
 -- Determines if [data binding](features/data-binding) warnings are displayed 
or not
 - `-compiler.show-invalid-css-property-warnings`  
 - `-compiler.show-multiple-definition-warnings`  
 - `-compiler.show-shadowed-device-font-warnings`  
@@ -955,7 +955,7 @@ Tells the Apache Royale compiler to remove circular 
dependencies in the generate
 
 ### show-binding-warnings {#show-binding-warnings}
 
-Set to false to remove all binding warnings.
+Set to false to remove all [data binding](features/data-binding) warnings.
 
 ```sh
 -show-binding-warnings=false
diff --git a/component-sets/jewel.md b/component-sets/jewel.md
index c777e53..1d90736 100644
--- a/component-sets/jewel.md
+++ b/component-sets/jewel.md
@@ -24,7 +24,7 @@ permalink: /component-sets/jewel
 
 A set of modern UI components
 
-Jewel is a themeable and responsive set of user interface components for 
[Apache Royale](https://royale.apache.org/) to help you quickly build the front 
end of your applications with [ActionScript](features/as3) & 
[MXML](features/mxml).
+Jewel is a themeable and responsive set of [user interface](user-interface) 
components for [Apache Royale](https://royale.apache.org/) to help you quickly 
build the front end of your applications with [ActionScript](features/as3) & 
[MXML](features/mxml).
 
 It's based by design on [Basic](component-sets/basic) components. But while 
Basic is very strict with concepts like [PAYG](features/payg), in Jewel, while 
PAYG is important, when necessary we prioritize other things like 
responsiveness, themes and look and feel.
 
diff --git a/component-sets/jewel/jewel-alert.md 
b/component-sets/jewel/jewel-alert.md
index 413d0ca..6ab9e18 100644
--- a/component-sets/jewel/jewel-alert.md
+++ b/component-sets/jewel/jewel-alert.md
@@ -36,7 +36,7 @@ Available since version __0.9.4__
 ## Overview
 
 The `Alert` component displays a message and one or more buttons in a window 
that pops up over all other controls and views. 
-It uses the `AlertView` bead to display a [modal 
dialog](https://en.wikipedia.org/wiki/Modal_window){:target='_blank'} with a 
title and a variety of buttons configured through the flag property of its 
`show` static function.
+It uses the `AlertView` [beads](features/strands-and-beads) to display a 
[modal dialog](https://en.wikipedia.org/wiki/Modal_window){:target='_blank'} 
with a title and a variety of buttons configured through the flag property of 
its `show` static function.
 
 > `Alert` uses the HTML dialog element, which currently has very limited 
 > cross-browser support. To ensure support across all modern browsers, we use 
 > the dialogPolyfill [externs](features/externs).
 
diff --git a/component-sets/jewel/jewel-button.md 
b/component-sets/jewel/jewel-button.md
index 9d7a260..8653d38 100644
--- a/component-sets/jewel/jewel-button.md
+++ b/component-sets/jewel/jewel-button.md
@@ -122,7 +122,7 @@ parent.addElement(button);
 
 ## Relevant Beads
 
-Unlike other components in Royale, the Jewel `Button` does not have beads for 
_View_, _Controller_ or _Model_ in the JavaScript platform.
+Unlike other components in Royale, the Jewel `Button` does not have 
[beads](features/strands-and-beads) for _View_, _Controller_ or _Model_ in the 
JavaScript platform.
 
 On the other hand, you can add to it other common Jewel control beads to 
provide more functionality. Many Jewel controls share these beads.
 
diff --git a/component-sets/jewel/jewel-checkbox.md 
b/component-sets/jewel/jewel-checkbox.md
index 0727c08..cb1b63f 100644
--- a/component-sets/jewel/jewel-checkbox.md
+++ b/component-sets/jewel/jewel-checkbox.md
@@ -116,7 +116,7 @@ parent.addElement(checkBox);
 
 ## Relevant Beads
 
-Unlike other components in Royale, the Jewel `CheckBox` does not have beads 
for _View_, _Controller_ or _Model_ in the JavaScript platform.
+Unlike other components in Royale, the Jewel `CheckBox` does not have 
[beads](features/strands-and-beads) for _View_, _Controller_ or _Model_ in the 
JavaScript platform.
 
 On the other hand, you can add to it other common Jewel control beads to 
provide more functionality. Many Jewel controls share these beads.
 
diff --git a/component-sets/mxroyale.md b/component-sets/mxroyale.md
index 5bbdc3f..de5d09d 100644
--- a/component-sets/mxroyale.md
+++ b/component-sets/mxroyale.md
@@ -58,5 +58,5 @@ This component set has working emulations in these general 
areas:
 
 When you browse the components in the SDK, you will encounter some that seem 
to have no functioning code. This is a _stub_. We have created it so we can get 
an app migrating from Flex to compile, creating a class of the same package 
name and class name as the Flex component but removing all of the code and 
leaving a TODO note
 
-The application including this stub can compile but the component does not do 
anything yet. The next task will be to add the minimal code the component needs 
to perform its most basic functions, and put optional and special-case 
functions into beads a developer can add to the component strand.
+The application including this stub can compile but the component does not do 
anything yet. The next task will be to add the minimal code the component needs 
to perform its most basic functions, and put optional and special-case 
functions into [beads](features/strands-and-beads) a developer can add to the 
component strand.
 
diff --git a/component-sets/sparkroyale.md b/component-sets/sparkroyale.md
index ab20e03..7ddab94 100644
--- a/component-sets/sparkroyale.md
+++ b/component-sets/sparkroyale.md
@@ -42,4 +42,4 @@ This component set has working emulations in these general 
areas:
 
 When you browse the components in the SDK, you will encounter some that seem 
to have no functioning code. This is a _stub_. We have created it so we can get 
an app migrating from Flex to compile, creating a class of the same package 
name and class name as the Flex component but removing all of the code and 
leaving a TODO note
 
-The application including this stub can compile but the component does not do 
anything yet. The next task will be to add the minimal code the component needs 
to perform its most basic functions, and put optional and special-case 
functions into beads a developer can add to the component strand.
+The application including this stub can compile but the component does not do 
anything yet. The next task will be to add the minimal code the component needs 
to perform its most basic functions, and put optional and special-case 
functions into [beads](features/strands-and-beads) a developer can add to the 
component strand.
diff --git a/create-an-application/application-tutorial/build.md 
b/create-an-application/application-tutorial/build.md
index de90892..539e879 100644
--- a/create-an-application/application-tutorial/build.md
+++ b/create-an-application/application-tutorial/build.md
@@ -24,7 +24,7 @@ permalink: /create-an-application/application-tutorial/build
 
 Building the application
 
-In many other *HTML/JS/CSS* development models, you write the *JS* and then 
just view it in the browser. [Apache Royale](https://royale.apache.org/) uses a 
compiler to convert your *MXML* and *ActionScript* code into *HTML/JS/CSS*. 
Why? Because there is a philosophy that the sooner you catch a bug, the less 
expensive it is to fix it. The compiler scans your source code to make sure 
that it makes sense. The compiler checks that there aren't typos in property 
names, that if you are expecti [...]
+In many other *HTML/JS/CSS* development models, you write the *JS* and then 
just view it in the browser. [Apache Royale](https://royale.apache.org/) uses a 
compiler to convert your [*MXML*](features/mxml) and 
[*ActionScript*](features/as3) code into *HTML/JS/CSS*. Why? Because there is a 
philosophy that the sooner you catch a bug, the less expensive it is to fix it. 
The compiler scans your source code to make sure that it makes sense. The 
compiler checks that there aren't typos in proper [...]
 
 The main *MXML* file should now look like this:
 
diff --git a/create-an-application/application-tutorial/data-model.md 
b/create-an-application/application-tutorial/data-model.md
index 256d470..ab40d91 100644
--- a/create-an-application/application-tutorial/data-model.md
+++ b/create-an-application/application-tutorial/data-model.md
@@ -24,7 +24,7 @@ permalink: 
/create-an-application/application-tutorial/data-model
 
 Abstract model that organizes elements of data for easy use in the application
 
-Since the goal of this application is to display a list of commits to the 
[Apache Royale](https://royale.apache.org/) GitHub repositories (repos), the 
data the application will work with must include that list of commits. The 
application will query GitHub for the information, place what GitHub provides 
in a data structure, and then connect that data structure to components in the 
user interface that can display it.
+Since the goal of this application is to display a list of commits to the 
[Apache Royale](https://royale.apache.org/) GitHub repositories (repos), the 
data the application will work with must include that list of commits. The 
application will query GitHub for the information, place what GitHub provides 
in a data structure, and then connect that data structure to components in the 
[user interface](user-interface) that can display it.
 
 > For large projects, the model is often built in a separate class and source 
 > file so it can be separately developed, documented, and maintained (maybe by 
 > other team members). But to get something up quickly, we are going to just 
 > stick a few variables in the main application file in a script block.
 
diff --git a/create-an-application/application-tutorial/deploy.md 
b/create-an-application/application-tutorial/deploy.md
index 2c09a8f..31a0654 100644
--- a/create-an-application/application-tutorial/deploy.md
+++ b/create-an-application/application-tutorial/deploy.md
@@ -24,7 +24,7 @@ permalink: /create-an-application/application-tutorial/deploy
 
 Running the application in a browser
 
-Assuming you followed the typical directory and file pattern, and the MXML 
file was in a `src` directory, next to the `src` directory should be a `bin` 
directory with a `js-debug` directory inside it.
+Assuming you followed the typical directory and file pattern, and the 
[MXML](features/mxml) file was in a `src` directory, next to the `src` 
directory should be a `bin` directory with a `js-debug` directory inside it.
 
 Inside the `js-debug` directory is an `index.html` file. You can open it in 
your browser and you should see the list of commits appear.
 
diff --git a/create-an-application/application-tutorial/view.md 
b/create-an-application/application-tutorial/view.md
index 7b95545..9ac0730 100644
--- a/create-an-application/application-tutorial/view.md
+++ b/create-an-application/application-tutorial/view.md
@@ -24,7 +24,7 @@ permalink: /create-an-application/application-tutorial/view
 
 Contains the user interface elements that display data and accept user input
 
-In an 
[MVC](https://en.wikipedia.org/wiki/Model–view–controller){:target='_blank'} 
application the **View** contains the user interface elements that display data 
and accept user input. We want a way to display the list of commits and also 
some useful information about those commits. In [Apache 
Royale](https://royale.apache.org/) a popular way to do that is with a 
[DataGrid](https://royale.apache.org/asdoc/index.html#!org.apache.royale.html/DataGrid){:target='_blank'}.
+In an 
[MVC](https://en.wikipedia.org/wiki/Model–view–controller){:target='_blank'} 
application the **View** contains the [user interface](user-interface) elements 
that display data and accept user input. We want a way to display the list of 
commits and also some useful information about those commits. In [Apache 
Royale](https://royale.apache.org/) a popular way to do that is with a 
[DataGrid](https://royale.apache.org/asdoc/index.html#!org.apache.royale.html/DataGrid){:target='_blank'}.
 
 The main or initial view of an application is identified as its `initialView` 
property. We want our user interface elements to appear vertically so we use 
[VView](https://royale.apache.org/asdoc/index.html#!org.apache.royale.express/VView){:target='_blank'}
 as the view:
 
diff --git 
a/create-an-application/optimizations/compiler-configuration-settings.md 
b/create-an-application/optimizations/compiler-configuration-settings.md
index 430bea7..8c00fff 100644
--- a/create-an-application/optimizations/compiler-configuration-settings.md
+++ b/create-an-application/optimizations/compiler-configuration-settings.md
@@ -73,7 +73,7 @@ With true (the default setting), the above example will 
behave the same in javas
 
 In most cases this extra code can be eliminated in the output after the 
application has been validated to be error-free at runtime. There may however 
be cases with legacy actionscript that depend on error-handling for these 
situations and where refactoring that aspect is not a priority. In these cases 
it can be left on in the release build, or there is also the option to switch 
it off in general but force it to remain on for specific code scope, for 
example, using [@royalesuppresscomplex [...]
 
-Does this feature always catch implicit complex coercions? No, currently there 
can still be cases which are missing this level of runtime type safety. Notably 
this can occur in the processing of mxml instances or binding support.
+Does this feature always catch implicit complex coercions? No, currently there 
can still be cases which are missing this level of runtime type safety. Notably 
this can occur in the processing of MXML instances or [data 
binding](features/data-binding) support.
 
 **Pro tip:** How do I know how much of my code is being affected by this 
setting? In the javascript **js&#x2011;debug** output, you can do a ***search 
in files*** for the string **/* implicit cast */** which precedes the 
compiler-generated code the to support this parity with AVM. That will show you 
all the sites where it is being output. As with all other code, this can be 
minimized in the js-release output, but as mentioned earlier, if the 
application does not have runtime errors, then [...]
 
diff --git a/create-an-application/optimizations/doc-comment-directives.md 
b/create-an-application/optimizations/doc-comment-directives.md
index 789b73a..9537e1f 100644
--- a/create-an-application/optimizations/doc-comment-directives.md
+++ b/create-an-application/optimizations/doc-comment-directives.md
@@ -242,7 +242,7 @@ They may be helpful in specific cases *when used with 
caution* for library devel
 The above is used to prevent a public class member from having an exported 
setting in the release build.
 This can be used with classes that are used to emulate certain as3 language 
features in javascript, and often are intended only for output generated by the 
compiler and not used directly by a developer.
 It has the effect to making the annotated class member 'pay as you go' because 
if the compiler does not generate output that uses it, the code and any 
dependencies that are specific to it are eliminated from the release build 
output.
-They can also be used as another way to offer opt-in features, for a type of 
PAYG approach that works in regular actionscrip, and which could also be then 
supported in code via a bead for use in mxml.
+They can also be used as another way to offer opt-in features, for a type of 
[PAYG](features/PAYG) approach that works in regular actionscrip, and which 
could also be then supported in code via a [beads](features/strands-and-beads) 
for use in [MXML](features/mxml).
 An example of this is the ExtraData class in the Reflection library, which has 
static methods to add opt-in support for additional reflection data.
  
 ### @royalesuppressclosure {#royalesuppressclosure} 
diff --git a/features-and-concepts.md b/features-and-concepts.md
index 497f2df..0773ee8 100644
--- a/features-and-concepts.md
+++ b/features-and-concepts.md
@@ -42,7 +42,7 @@ The underlying component patterns in most Royale components 
rely on a plug-in mo
 
 Sometimes you may want your Royale application to call an external piece of 
JavaScript that is also hosted in your web page, or even for some extenal 
JavaScript from your page to call into the Royale application. In the Flex (and 
Flash) world, there was the possibility to use the `ExternalInterface` class to 
achieve this functionality. If you want this in Royale, there are some options 
available that you can [read about here](features/external-interface).
 
-Another option is externs, which use [Google Closure Compiler 
(GCC)](https://developers.google.com/closure/compiler){:target='_blank'} to 
declare that a name for a class, property or function is defined in external 
code and so should not be renamed when your application code is compiled. 
Apache Royale can use the properties of the external library, and you can even 
see them as options if you are using an __IDE__, with _code intelligence_ 
enabled. [Learn more about externs](features/externs).
+Another option is [externs](features/externs), which use [Google Closure 
Compiler 
(GCC)](https://developers.google.com/closure/compiler){:target='_blank'} to 
declare that a name for a class, property or function is defined in external 
code and so should not be renamed when your application code is compiled. 
Apache Royale can use the properties of the external library, and you can even 
see them as options if you are using an __IDE__, with _code intelligence_ 
enabled. [Learn more about ext [...]
 
 ## Data Binding
 
diff --git a/features/data-binding.md b/features/data-binding.md
index 78a3f05..4df2251 100644
--- a/features/data-binding.md
+++ b/features/data-binding.md
@@ -23,7 +23,7 @@ permalink: /features/data-binding
 
 Update the UI in real time as data changes
 
-[Apache Royale](https://royale.apache.org/), like Flex before it, makes it 
easy to pass data around your application. A change to data can automatically 
update the display of that data in the user interface, and potentially in 
calculations or other functions that use that data. The feature that makes this 
possible without having to write lots of code is *data binding*.
+[Apache Royale](https://royale.apache.org/), like Flex before it, makes it 
easy to pass data around your application. A change to data can automatically 
update the display of that data in the [user interface](user-interface), and 
potentially in calculations or other functions that use that data. The feature 
that makes this possible without having to write lots of code is *data binding*.
 
 Data binding requires
  - a **data binding bead** that adds this functionality to the whole 
application, or to the container in which the data binding happens. If you 
enable data binding for a container, it only applies to the componenents within 
that container; if you enable it at the application level, all application 
components inherit the ability to use data binding.
diff --git a/features/mxml.md b/features/mxml.md
index 414e89a..71df39c 100644
--- a/features/mxml.md
+++ b/features/mxml.md
@@ -24,7 +24,7 @@ permalink: /features/mxml
 
 The declarative XML-based user interface markup language
 
-MXML is an XML-based language introduced in 2004 by Macromedia. In [Apache 
Royale](https://royale.apache.org/) you use it to lay out user-interface 
components. You can create an application in Royale using only 
[ActionScript](features/as3), but it takes a lot more work.
+MXML is an XML-based language introduced in 2004 by Macromedia. In [Apache 
Royale](https://royale.apache.org/) you use it to lay out [user 
interface](user-interface) components. You can create an application in Royale 
using only [ActionScript](features/as3), but it takes a lot more work.
 
 Most Royale applications have an MXML file as the main file. It provides the 
structure of the application. The main MXML file from our very simple <a 
href="https://apache.github.io/royale-docs/get-started/hello-world"; 
target="_blank">hello world example</a> looks a bit like this:
 
diff --git a/features/routing.md b/features/routing.md
index 147b61c..e029743 100644
--- a/features/routing.md
+++ b/features/routing.md
@@ -44,7 +44,7 @@ On the most basic level, routers (whether hash based or path 
browser based) can
 
 In the above examples, any time the route changes, the `stateChanged` function 
will be called.
 
-The state of the router can likewise be changed directly by modifying the 
`router.routeState` and calling `router.setState()` `router.renderState()` is a 
similar method, but it will dispatch the `stateChanged` event as well and cause 
any attached beads to react to the state change.
+The state of the router can likewise be changed directly by modifying the 
`router.routeState` and calling `router.setState()` `router.renderState()` is a 
similar method, but it will dispatch the `stateChanged` event as well and cause 
any attached [beads](features/strands-and-beads) to react to the state change.
 
 ## Router Beads
 The full power of the Router becomes apparent when you use beads. Router can 
automatically sync the route state with the component's state. It can change 
which component is shown by creating and removing components. It can handle 
parameters, etc. Here are some examples:
diff --git a/features/styles-skins-themes.md b/features/styles-skins-themes.md
index 97e4847..fed1200 100644
--- a/features/styles-skins-themes.md
+++ b/features/styles-skins-themes.md
@@ -28,7 +28,7 @@ Customizing the look and feel of your application
 
 ## Styles
 
-You can plug different style classes into your Royale app that can manage 
different levels of styling features. Usually a Royale application will include 
a Style class at the Application bead level like this:
+You can plug different style classes into your Royale app that can manage 
different levels of styling features. Usually a Royale application will include 
a Style class at the Application [bead](features/strands-and-beads) level like 
this:
 
 ```mxml
 <js:Application xmlns:fx="http://ns.adobe.com/mxml/2009";
diff --git a/formatter.md b/formatter.md
index 4c77b84..2917f2d 100644
--- a/formatter.md
+++ b/formatter.md
@@ -26,7 +26,7 @@ Format your _.as_ and _.mxml_ source files
 
 ## User Guide
 
-Below are some pointers to help you get started with the [Apache 
Royale](https://royale.apache.org/) formatter in various environments.
+Below are some pointers to help you get started with the [Apache 
Royale](https://royale.apache.org/) formatter in various environments. This 
tool can format both [MXML](features/mxml) and [ActionScript 3.0 
(AS3)](features/as3).
 
 ### Command line
 
diff --git a/formatter/formatter-options.md b/formatter/formatter-options.md
index d8a36f1..f653820 100644
--- a/formatter/formatter-options.md
+++ b/formatter/formatter-options.md
@@ -24,7 +24,7 @@ permalink: /formatter/formatter-options
 
 List of all available formatter options
 
-The [**asformat**](formatter) tool has a number of useful configuration options
+The [**asformat**](formatter) tool included with [Apache 
Royale](https://royale.apache.org/) has a number of useful configuration options
 . The list below is also available by running `asformat -help advanced` in a 
terminal.
 
 - `-collapse-empty-blocks` -- Determines if empty blocks containing no 
statements will be collapsed to a single line, or if the closing curly brace 
should still appear on a new line. Default: `false`
diff --git a/get-started.md b/get-started.md
index 41522ee..563a46c 100644
--- a/get-started.md
+++ b/get-started.md
@@ -28,7 +28,7 @@ All you need to know to start developing with Apache Royale
 
 [Apache Royale](https://royale.apache.org/) is an open source project. You can 
get the [source code](http://royale.apache.org/source-code){:target='_blank'} 
and build Royale, or, if you are in a hurry, you can [click 
here](https://royale.apache.org/download){:target='_blank'} to find out how to 
download pre-compiled code and get going quickly.
 
-In Apache Royale you develop your applications using ActionScript 3 (AS3) and 
MXML languages. Your source code is build with the Royale compiler to generate 
the final Application that will run on the chosen platform.
+In Apache Royale you develop your applications using [ActionScript 3 
(AS3)](features/as3) and [MXML](features/mxml) languages. Your source code is 
build with the Royale compiler to generate the final Application that will run 
on the chosen platform.
 
 
 ## Getting Royale
diff --git a/get-started/development-tools.md b/get-started/development-tools.md
index 2601e43..6d090c2 100644
--- a/get-started/development-tools.md
+++ b/get-started/development-tools.md
@@ -32,8 +32,8 @@ IDEs that support Royale provide getting-started instructions 
to help you specif
 
 ### IDEs with Royale support
 
-- [Visual Studio Code with ActionScript and MXML 
Extensions](https://github.com/BowlerHatLLC/vscode-nextgenas/wiki/Install-the-ActionScript-and-MXML-extension-for-Visual-Studio-Code){:target='_blank'}
-- [Moonshine IDE](http://moonshine-ide.com){:target='_blank'}
+- [Visual Studio Code with ActionScript and MXML 
Extensions](https://github.com/BowlerHatLLC/vscode-as3mxml/wiki/Install-the-ActionScript-and-MXML-extension-for-Visual-Studio-Code){:target='_blank'}
+- [Moonshine IDE](https://moonshine-ide.com){:target='_blank'}
 
 ### IDES that supported Flex and work with Royale with some restrictions and 
limitations.
 
diff --git a/get-started/frameworks.md b/get-started/frameworks.md
index f1db85a..35a0520 100644
--- a/get-started/frameworks.md
+++ b/get-started/frameworks.md
@@ -42,7 +42,7 @@ Documentation for Crux will be available soon.
 
 ## Apache Royale Component Sets
 
-Apache Royale supports its own [component sets](component-sets) of controls, 
options for grouping controls, and other elements designed to help developers 
get the most of the technology.
+Apache Royale supports its own [component sets](component-sets) of [user 
interface](user-interface) controls, options for grouping and layouting out 
controls, and other elements designed to help developers get the most of the 
technology.
 
 - [Basic](component-sets/basic) is the most smallest, fastest and most PAYG 
set of components possible in Royale, and is used by other sets like Jewel as 
their base.
 
diff --git a/get-started/hello-world.md b/get-started/hello-world.md
index 3316a5b..379ef05 100644
--- a/get-started/hello-world.md
+++ b/get-started/hello-world.md
@@ -48,7 +48,7 @@ Projects/HelloWorld/src
 
 ## Create the source file
 
-In the `src` folder, create a file called `HelloWorld.mxml` and use your 
favorite text editor to give that file the following contents:
+In the `src` folder, create an [MXML](features/mxml) file called 
`HelloWorld.mxml` and use your favorite text editor to give that file the 
following contents:
 
 ```mxml
 <?xml version="1.0" encoding="utf-8"?>
diff --git a/get-started/royale-cli.md b/get-started/royale-cli.md
index 03a94d9..75bccd8 100644
--- a/get-started/royale-cli.md
+++ b/get-started/royale-cli.md
@@ -56,7 +56,7 @@ Navigate in the command window to the directory where you 
want to create the new
 royale new my-royale-app
 ```
 
-This creates a new directory structure using the name of the application, and 
creates a basic app with one main file: `my-royale-app/src/Main.mxml`.
+This creates a new directory structure using the name of the application, and 
creates a basic app with one main [MXML](features/mxml) file: 
`my-royale-app/src/Main.mxml`.
 
 To review the app structure so far, navigate into the new direcctory:
 
diff --git a/index.md b/index.md
index d77b932..27ecb11 100644
--- a/index.md
+++ b/index.md
@@ -27,7 +27,7 @@ Designed for the future. Code Once. Run Everywhere.
 {:align="center"}
 ![Apache Royale 
Logo](assets/images/apache-royale-main-logo-1000x1000.png){:height="33%" 
width="33%"}
 
-[Apache Royale](https://royale.apache.org/) is the new SDK, built on the solid 
foundation developed by the Flex universe, that lets you create applications in 
MXML and ActionScript that will run almost anywhere without heavy plugins like 
Flash or Adobe AIR.
+[Apache Royale](https://royale.apache.org/) is the new SDK, built on the solid 
foundation developed by the Flex universe, that lets you create applications in 
[MXML](features/mxml) and [ActionScript 3.0 (AS3)](features/as3) that will run 
almost anywhere without heavy plugins like Flash or Adobe AIR.
 
 With Royale, you can create a single code base that can be compiled to work 
like a native app on Windows or Apple systems, on Android phones, on tablets of 
all systems and sizes, in browsers, or on embedded JavaScript environments like 
Chromium Embedded Framework. 
 
diff --git a/libraries/compiled-code-libraries.md 
b/libraries/compiled-code-libraries.md
index 9fdb20f..01c3fdd 100644
--- a/libraries/compiled-code-libraries.md
+++ b/libraries/compiled-code-libraries.md
@@ -26,9 +26,9 @@ Instructions on creating your own SWC libraries
 
 ## Concepts
 
-On the most basic level, SWC libraries are just compiled ActionScript classes. 
You need to include the necessary classes and the code will be included in your 
compiled SWC.
+On the most basic level, SWC libraries are just compiled 
[ActionScript](features/as3) classes. You need to include the necessary classes 
and the code will be included in your compiled SWC.
 
-Libraries can also declare components that can be used in MXML files by 
referencing a namespace.
+Libraries can also declare components that can be used in 
[MXML](features/MXML) files by referencing a namespace.
 
 In this example, we're going to assume that you have both code and components 
to include.
 
@@ -81,7 +81,7 @@ package {
 Just referencing the classes like that is enough to have them included.
 
 ## The CSS file
-`defaults.css` is where you declare any HTML or Royale CSS that's needed for 
your library. This is where you declare default beads and the like. Make sure 
you declare your namespace that's used for the MXML declarations of you 
components.
+`defaults.css` is where you declare any HTML or Royale CSS that's needed for 
your library. This is where you declare default 
[beads](features/strands-and-beads) and the like. Make sure you declare your 
namespace that's used for the MXML declarations of you components.
 
 ```
 @namespace "library://ns.somesite.com/kapow";
@@ -101,7 +101,7 @@ The config file is a convenience file for loading compiler 
options. It's very he
 The notable difference between the two files:
 1. `compile-config.xml` has `playerglobal.swc` referenced in the 
`external-library-path`.
 2. `compile-config.xml` has `COMPILE::SWF` as `true` while 
`js-compile-config.xml` has `COMPILE::JS` as `true`.
-3. If you have a `lib/Foo.swc` JS typedef dependency that you want to include, 
you should add the following to the `js-compile-config.xml`:
+3. If you have a `lib/Foo.swc` JS [typedef (sometimes also called 
externs)](features/externs) dependency that you want to include, you should add 
the following to the `js-compile-config.xml`:
 
 ```
         <js-external-library-path append="true">
diff --git a/libraries/crux/dependency-injection.md 
b/libraries/crux/dependency-injection.md
index f80d613..28a5818 100644
--- a/libraries/crux/dependency-injection.md
+++ b/libraries/crux/dependency-injection.md
@@ -49,7 +49,7 @@ Due to restrictions imposed by runtimes, Crux cannot inject 
into `private`, `pro
 
 By default, injections in view components happen during the `ADDED_TO_STAGE` 
event. <!--This behavior can be modified by changing the Crux configuration.--> 
It is important to understand that this means that injections occur after the 
<!--CREATION_COMPLETE-->`initComplete` event. If you need to trigger logic 
during creation that depends on injections, use a `[PostConstruct]` method.
 
-> Note: `ADDED_TO_STAGE` is a SWF event. In __Javascript__ you need to add a 
bead to your Application beads called `JSStageEvents` to simulated stage events 
like `ADDED_TO_STAGE` or 'REMOVED_FROM_STAGE`
+> Note: `ADDED_TO_STAGE` is a SWF event. In __Javascript__ you need to add a 
[bead](features/strands-and-beads) to your Application beads called 
`JSStageEvents` to simulated stage events like `ADDED_TO_STAGE` or 
'REMOVED_FROM_STAGE`
 
 ## Inject by type {#inject-by-type}
 
diff --git a/libraries/library-basics.md b/libraries/library-basics.md
index ea1f364..982b187 100644
--- a/libraries/library-basics.md
+++ b/libraries/library-basics.md
@@ -32,7 +32,7 @@ Royale libraries are packaged in `swc` files. A `swc` file is 
a zipped archive w
 ## Types of libraries
 There are two basic library types:
 1. Compiled Code libraries
-2. Typedef libraries
+2. Typedef libraries (sometimes called Externs libraries)
 
 There is no obvious way to tell the difference. Both have a `.swc` extension, 
although typedef libraries do not have any `js` code included and will 
generally be smaller.
 
@@ -42,7 +42,7 @@ Compiled code libraries contain code that will end up in your 
compiled applicati
 Compiled code libraries are created using the `compc` compiler. See [detailed 
instructions on how to create one](libraries/compiled-code-libraries).
 
 ### Typedef libraries
-Typedef libraries define the types of different classes, but contain no code 
that would be added to an application. Typedef libraries hold core Web APIs and 
third party JavaScript libraries which could be included in applications as 
separate JavaScript files (such as jQuery). Typedef libraries are similar to 
Typescript `d.ts` files.
+Typedef libraries define the types of different classes, but contain no code 
that would be added to an application. [Typedef (sometimes called 
externs)](features/externs) libraries hold core Web APIs and third party 
JavaScript libraries which could be included in applications as separate 
JavaScript files (such as jQuery). Typedef libraries are similar to Typescript 
`d.ts` files.
 
 Typedef libraries are created using the `externc` compiler. (TODO add sample 
configs for doing this.)
 
diff --git a/linter.md b/linter.md
index 18d685d..8ea55c4 100644
--- a/linter.md
+++ b/linter.md
@@ -26,7 +26,7 @@ Discover common issues in your _.as_ and _.mxml_ source files
 
 ## User Guide
 
-Below are some pointers to help you get started with the [Apache 
Royale](https://royale.apache.org/) linter in various environments.
+Below are some pointers to help you get started with the [Apache 
Royale](https://royale.apache.org/) linter in various environments. This tool 
can analyze both [MXML](features/mxml) and [ActionScript 3.0 
(AS3)](features/as3).
 
 ### Command line
 
diff --git a/linter/linter-options.md b/linter/linter-options.md
index 584fb4d..66e9863 100644
--- a/linter/linter-options.md
+++ b/linter/linter-options.md
@@ -24,7 +24,7 @@ permalink: /linter/linter-options
 
 List of all available linter options
 
-The [**aslint**](linter) tool has a number of useful configuration options. 
The list below is also available by running `aslint -help advanced` in a 
terminal.
+The [**aslint**](linter) tool included with [Apache 
Royale](https://royale.apache.org/) has a number of useful configuration 
options. The list below is also available by running `aslint -help advanced` in 
a terminal.
 
 - `-class-name` -- Ensures that class names match the pattern 
`^[A-Z][a-zA-Z0-9]*$`. Default: `false`
 - `-constant-name` -- Ensures that constant names match the pattern 
`^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$`. Default: `false`
diff --git a/migrate-an-existing-app/migrate-from-js.md 
b/migrate-an-existing-app/migrate-from-js.md
index cb18621..c60a073 100644
--- a/migrate-an-existing-app/migrate-from-js.md
+++ b/migrate-an-existing-app/migrate-from-js.md
@@ -34,9 +34,9 @@ JS has some 'compilers' that try to catch problems before the 
app user crashes i
 
 Most of us are familiar with furniture, toys, and other comsumables that have 
"some assembly required". That is true of all software languages, but some 
provide better guidance than others. JS offers lots of options for writing your 
code and sticking it together, but unless you are very attentive or very 
experienced, you can end up with a package that has a mysterious glitch 
somewhere that is hard to track down and fix.
 
-Royale is also an assemble-it-yourself language. However, like the better 
furniture stores that provide not just the nails and screws but instructions 
with illustrations, Royale helps you develop in a way that minimizes errors. 
Semi-structured languages like ActionScript let you establish custom connectors 
so that the components you write can only go together in certain ways. 
Declarative languages like MXML provide diagrams to help you see the pieces 
that you are attaching and what you c [...]
+Royale is also an assemble-it-yourself language. However, like the better 
furniture stores that provide not just the nails and screws but instructions 
with illustrations, Royale helps you develop in a way that minimizes errors. 
Semi-structured languages like [ActionScript](features/as3) let you establish 
custom connectors so that the components you write can only go together in 
certain ways. Declarative languages like [MXML](features/mxml) provide diagrams 
to help you see the pieces that [...]
 
-Many in the JS world use higher-level languages like Dart and TypeScript to 
reduce the chances of error in the JS code they write. Royale provides similar 
guardrails; it also provdes the option to use a declarative language, MXML.
+Many in the JS world use higher-level languages like Dart and TypeScript to 
reduce the chances of error in the JS code they write. Royale provides similar 
guardrails; it also provides the option to use a declarative language, 
[MXML](features/mxml).
 
 If you are thinking of moving to an easier way of writing applications, 
compiling them into JavaScript and releasing them to the world on a wide range 
of platforms, Royale may be your answer.
 
diff --git a/testing/royaleunit/create-a-unit-test.md 
b/testing/royaleunit/create-a-unit-test.md
index 7cda9d6..bb8ac1d 100644
--- a/testing/royaleunit/create-a-unit-test.md
+++ b/testing/royaleunit/create-a-unit-test.md
@@ -69,7 +69,7 @@ If the value of the `result` variable is not equal to `5`, 
the test will fail.
 
 ## Run unit tests
 
-Create a simple Apache Royale application and name it *MyTests.mxml*:
+Create a simple Apache Royale application in an [MXML](features/mxml) file 
with the name *MyTests.mxml*:
 
 ```mxml
 <?xml version="1.0" encoding="utf-8"?>
diff --git a/tutorials.md b/tutorials.md
index 9f4d2c5..b742c3f 100644
--- a/tutorials.md
+++ b/tutorials.md
@@ -41,4 +41,4 @@ Here you can find links to tutorials and how-to blog articles 
that will help you
   * [Customization through the Royale 
API](https://royale.apache.org/customization-through-the-royale-api){:target='_blank'}
   * [Data 
binding](https://royale.apache.org/binding-the-text-property-of-a-jewel-textinput-to-update-a-text-label/){:target="_blank"}
   
-[Tour de Jewel](https://royale.apache.org/tourdejewel){:target='_blank'} is an 
ever-expanding set of examples of how to use the [Jewel component 
set](component-sets/jewel) to build a user interface that will deliver what you 
want and provide a great user experience.
+[Tour de Jewel](https://royale.apache.org/tourdejewel){:target='_blank'} is an 
ever-expanding set of examples of how to use the [Jewel component 
set](component-sets/jewel) to build a [user interface](user-interface) that 
will deliver what you want and provide a great user experience.
diff --git a/user-interface/components.md b/user-interface/components.md
index b0bdef7..bdc41e5 100644
--- a/user-interface/components.md
+++ b/user-interface/components.md
@@ -23,7 +23,7 @@ permalink: /user-interface/components
 
 Meet the UI building blocks.
 
-[Apache Royale](https://royale.apache.org/) provides a wide range of 
components to help you design a user interface that presents your material 
clearly and offers a pleasing user experience. As with Flex, these include:
+[Apache Royale](https://royale.apache.org/) provides a wide range of 
components to help you design a [user interface](user-interface) that presents 
your material clearly and offers a pleasing user experience. As with Flex, 
these include:
 
   * Layout aids (groups, cards, grids, forms)
   * Ways to display data (lists, text boxes, tables, charts, repeating 
components)
@@ -32,7 +32,7 @@ Meet the UI building blocks.
   * Usability features (alerts, snackbar pop-ups, localization features, 
dynamic displays depending on the user's metadata)
   * Rich content (images, videos, audio, transitions)
 
-Developers who have worked in Flex will quickly feel at home with Royale 
components, although they will need to pay attention to the ["Pay as you 
go"](features/payg) concept that is a Royale hallmark. Components do well the 
basic functions associated with their names, but to add features (for instance, 
you want to force the text the user enters to lower case), you need to add the 
appropriate bead to the strand of the component:
+Developers who have worked in Flex will quickly feel at home with Royale 
components, although they will need to pay attention to the ["Pay as you 
go"](features/payg) concept that is a Royale hallmark. Components do well the 
basic functions associated with their names, but to add features (for instance, 
you want to force the text the user enters to lower case), you need to add the 
appropriate [bead](features/strands-and-beads) to the strand of the component:
 
 ```as3 
 <j:TextInput text="Your entry will appear in LOWER case">
diff --git a/welcome/high-level-view.md b/welcome/high-level-view.md
index 438456c..8068a11 100644
--- a/welcome/high-level-view.md
+++ b/welcome/high-level-view.md
@@ -45,7 +45,7 @@ These features help you make fewer mistakes when writing 
code, and that saves ti
 
 Because both [ActionScript](features/as3) and JavaScript are based on the same 
language, ECMAScript, most code you write in AS translates well to JS. One 
significant difference is that AS uses the concepts of classes and objects to 
structure how your code functions, while pure JavaScript does not have those 
concepts. When you get ready to compile and run your application, the Royale 
compiler translates AS-specific code into JS code organized into 
pseudo-classes, which then run just fine  [...]
 
-That takes care of pretty much everything except the user interface. For that, 
Royale provides a set of UI containers and controls that do the work that the 
pure Flex containers and controls required the Flash engine to do.
+That takes care of pretty much everything except the [user 
interface](user-interface). For that, Royale provides a set of UI containers 
and controls that do the work that the pure Flex containers and controls 
required the Flash engine to do.
 
 ## Status
 
diff --git a/working-with-data/loading-external-data/httpservice.md 
b/working-with-data/loading-external-data/httpservice.md
index c28f1ef..03b4fa8 100644
--- a/working-with-data/loading-external-data/httpservice.md
+++ b/working-with-data/loading-external-data/httpservice.md
@@ -32,7 +32,7 @@ In Apache Royale we have two `HTTPService` implementations:
 
 * **MXRoyale**: Is an emulation of the implementation that Flex applications 
use. It is the best option if you're migrating from Flex since it supports the 
same API that the Flex framework uses.
 
-* **Network**: Is a newer bead implementation. This is still under 
development, so you may run into some issues that will need to be resolved.
+* **Network**: Is a newer [bead](features/strands-and-beads) implementation. 
This is still under development, so you may run into some issues that will need 
to be resolved.
 
 ## Examples
 
diff --git a/working-with-data/loading-external-data/remoteobject.md 
b/working-with-data/loading-external-data/remoteobject.md
index 524f6e8..798a63c 100644
--- a/working-with-data/loading-external-data/remoteobject.md
+++ b/working-with-data/loading-external-data/remoteobject.md
@@ -32,7 +32,7 @@ In Apache Royale we have two `RemoteObject` implementations:
 
 * **MXRoyale**: Is an emulation of the implementation that Flex applications 
use. It is the best option if you're migrating from Flex since it supports the 
same API that the Flex framework uses.
 
-* **Network**: Is a newer bead implementation. This is still under 
development, so you may run into some issues that will need to be resolved.
+* **Network**: Is a newer [bead](features/strands-and-beads) implementation. 
This is still under development, so you may run into some issues that will need 
to be resolved.
 
 > We recommend using `MXRoyale` instead of the `Network` version for now, 
 > since it is closer to the Flex implementation and is already in use in 
 > Apache Royale applications currently in production.
 

Reply via email to