HTML-BASED CUSTOM ENTITY REFERENCES are unfortunately not supported in text/html (and XML support is spotty), despite their convenience in authoring, especially for non-technical authors or those who wish to share and utilize documents stored on the local file system without a server to execute substitutions.

All of the following client-side approaches are possible, though they may be technically discouraged for universal access since some people might not enable JavaScript or CSS (and XML support is currently inconsistent as far as entities, particularly with regard to external entities).

The example files detail the usage, but to summarize, the following means of defining entities are possible:

1. Via XML entities
   1. Advantages:
      1. Does not require script file
      2. Behavior defined in a standard
      3. Easy to write definitions and references
      4. Allows for nested entities
   2. Disadvantages:
      1. Browser support varies with single-point-of-failure for externally defined entities not found in the internal subset and no fallbacks despite the XML specification's recommendations.
      2. Requires less-used XML syntax and application/xhtml+xml or application/xml content-type
2. Via XML (namespaced) elements harvested for definitions by XSL or XSL variables
   1. Advantages:
      1. Pretty good browser support
      2. Not difficult to write definitions and references
      3. Allows for nested entities?
   2. Disadvantages:
      1. Not the official way to define replacement text (but will work)
      2. Requires less-used XML syntax and application/xhtml+xml or application/xml content-type
      3. Requires additional download of XSL template to perform replacements
   3. Disadvantages:
3. Via use of the CSS content property
   1. Advantages:
      1. Does not require script file
      2. Allows external file usage
   2. Disadvantages:
      1. Browser support varies
      2. Somewhat cumbersome to write
      3. Does not allow numeric definitions as allowed by the JavaScript code (though the latter are really redundant anyways since HTML supports numeric character references)).
      4. Does not allow arbitrary HTML substitution--only text
      5. Requires CSS to be enabled
      6. Does not support nested definitions
4. Via JavaScript (with optional HTML definitions):
   1. Approaches:
      1. Via definition of properties on a "JSEntityMap" global JavaScript object defined before the entities.js file is included
      2. Via HTML meta elements with name set to "entity" and "content" attribute set to "{entity name}={entity name}"; script also allows retrieval of meta elements defined in an iframe in the body of the document so that this approach will also allow external file definitions; note that this meta extension has been proposed at http://wiki.whatwg.org/wiki/MetaExtensions thereby making them "legal HTML5 meta names" per the wiki.
      3. (One could also simply define entities such as var copy = '\u00a9'; and then execute that, but that has the disadvantage of adding globals.)
   2. Advantages:
      1. Should work well in all well-used browsers
      2. Easy to write definitions and references
      3. Allows external file usage
   3. Disadvantages:
      1. Requires JavaScript enabled by user (though at least fallbacks can be used if desired)
      2. Requires inclusion and execution of external JavaScript file, waiting for content-load (and iframe load, if iframe definitions are used).
      3. Library does not currently support nested definitions or arbitrary HTML (though easy to add)

The following means exist for creating entity references using the above approaches:

1. Via XML entities:
   1. Entity references
2. Via XML elements
   1. Can use elements with or without content and let XSL handle substitutions as desired; preferable to use namespace
3. Via use of the CSS content property
   1. Empty HTML elements
      1. Custom elements for simple and descriptive but non-standard references (e.g., or <entity ent=>)--also requires special JavaScript handling in older IE browsers
      2. HTML4 tags (e.g., div or span)
      3. HTML5-standard "data" tag with "data-ent" attribute
4. Via HTML (in conjunction with JavaScript library and definitions):
   1. Empty HTML elements (or elements with fallback content for page load)
      1. Custom elements for simple and descriptive but non-standard references (e.g., or <entity ent=>)
      2. HTML4 tags (e.g., div or span) with "data-ent" attribute
      3. HTML5-standard "data" tag with "data-ent" attribute
   2. Script tags (<script>e('{entity name}')</script>)

Tested in IE10 with document mode set to IE7-IE10. Tested in Firefox 23.0