### Redux Reducer and Store Initialization in JavaScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-default-parameters/output.html

This snippet illustrates how to define individual Redux reducers (`visibleTodoFilter` and `todos`) and then combine them using `combineReducers`. Finally, it shows how to create a Redux store with the combined reducer, setting up a basic state management system for a todo application.

```javascript
function visibleTodoFilter(state = 'watch', action) {
  switch (action.type) {
    case 'CHANGE_VISIBLE_FILTER':
      return action.filter;
    default:
      return state;
  }
}

function todos(state, action) {
  switch (action.type) {
    case 'ADD_TODO':
      return [...state, { text: action.text, completed: false }];
    case 'COMPLETE_TODO':
      return [
        ...state.slice(0, action.index),
        Object.assign({}, state[action.index], { completed: true }),
        ...state.slice(action.index + 1)
      ];
    default:
      return state;
  }
}

import { combineReducers, createStore } from 'redux';

let reducer = combineReducers({ visibleTodoFilter, todos });
let store = createStore(reducer);
```

--------------------------------

### Install refractor package

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Instructions for installing the refractor library using npm for Node.js, Deno via esm.sh, and directly in browsers using esm.sh.

```Shell
npm install refractor
```

```JavaScript
import {refractor} from 'https://esm.sh/refractor@5'
```

```HTML
<script type="module">
  import {refractor} from 'https://esm.sh/refractor@5?bundle'
</script>
```

--------------------------------

### JavaScript Regular Expression Syntax Examples

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-regex/input.txt

Illustrates various forms of regular expression definitions in JavaScript, including simple patterns, patterns with escaped forward slashes and newlines, patterns with flags (global and multiline), and examples of regex interpolation within expressions.

```JavaScript
x = /\/
x = /\n/
x = /ab\/ ab/
x = f /6 * 2/ - 3
x = f /foo * 2/gm
x = if true then /\n/ else /[.,]+/
x = ///^key-#{key}-\d+///
```

--------------------------------

### Basic HTML Heading Element

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/markdown-code/output.html

A simple HTML heading element demonstrating basic HTML structure and content representation.

```html
<h1>a</h1>
```

--------------------------------

### Define Simple Functions in CoffeeScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-function/input.txt

Demonstrates basic function declaration syntax in CoffeeScript for returning null, true, and squaring a number. These are common utility functions.

```CoffeeScript
returnNull = -> null
returnTrue = () -> true
square = (x) -> x * x
```

--------------------------------

### Basic JSX Element Syntax and Usage

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-jsx/input.txt

Illustrates fundamental JSX element creation, including self-closing tags, nested elements with children, and elements with attributes. It also shows a simple JavaScript variable declaration in context.

```JavaScript
var jsx = <node/>;
var jsx = <node><child/></node>;
var jsx = <node>...<child>...</child></node>;
var jsx = <div><br /></div>;
var x = 5;
return (<node attr="value"></node>);
```

--------------------------------

### Programming Language Regular Expression Literals

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-regex/output.html

Demonstrates different ways to define and use regular expression literals. Examples include escaping forward slashes, using newline characters, applying global and multiline flags, and integrating regexes into arithmetic or conditional expressions. The last example shows a pattern that might involve interpolation, common in languages like Ruby, but presented here in a general context.

```JavaScript
x = /\/
x = /\n/
x = /ab\/ ab/
x = f /6 * 2/ - 3
x = f /foo * 2/gm
x = if true then /\n/ else /[.,]+/
x = ///^key-#{key}-\d+///
```

--------------------------------

### Basic refractor usage for syntax highlighting

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Demonstrates how to import refractor and use its `highlight` method to process a JavaScript string, returning a HAST (Hypertext Abstract Syntax Tree) representation. The example also shows the structure of the yielded HAST object.

```JavaScript
import {refractor} from 'refractor'

const tree = refractor.highlight('"use strict";', 'js')

console.log(tree)
```

```JavaScript
{
  type: 'root',
  children: [
    {
      type: 'element',
      tagName: 'span',
      properties: {className: ['token', 'string']},
      children: [{type: 'text', value: '"use strict"'}]
    },
    {
      type: 'element',
      tagName: 'span',
      properties: {className: ['token', 'punctuation']},
      children: [{type: 'text', value: ';'}]
    }
  ]
}
```

--------------------------------

### Python String Literal Syntax Demonstration

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-strings/output.html

This snippet showcases a variety of string literal forms available in Python, including single-quoted, double-quoted, byte strings, raw strings, and raw strings with multiple hash delimiters. It also includes examples of common escape sequences and invalid unicode escapes for testing purposes.

```Python
'a';
'\n';
'\x1A';
'\u12AS';
'\U1234ASDF';
b'a';
"hello";
b"hello";
r"hello";
r###"world"###;
r##" "##\# "# "##;
```

--------------------------------

### Basic CSS Universal Selector Rule

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/markdown-code/output.html

A basic CSS rule setting the color property for all elements using the universal selector, demonstrating fundamental CSS styling.

```css
* { color: red; }
```

--------------------------------

### Basic JSX Element Syntax

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-jsx/output.html

Illustrates different forms of JSX element declarations in JavaScript, covering self-closing tags, elements with children, and elements with attributes. It also shows a simple variable assignment and a return statement containing JSX.

```JavaScript
var jsx = <node/>; var jsx = <node><child/></node>; var jsx = <node>...<child>...</child></node>; var jsx = <div><br /></div>; var x = 5; return (<node attr="value"></node>);
```

--------------------------------

### POST /task API Request Example

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/http-default/output.html

This snippet demonstrates a sample HTTP POST request to the `/task` endpoint, including standard headers and a JSON request body. It illustrates how to send data to the server and specify content type and length for a typical API interaction.

```APIDOC
POST /task?id=1 HTTP/1.1
Host: example.org
Content-Type: application/json; charset=utf-8
Content-Length: 19

{"status": "ok", "extended": true}
```

--------------------------------

### Basic HTML Heading Element

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/markdown-code/input.txt

This snippet demonstrates a fundamental HTML structure, specifically a level 1 heading tag. It's a common element used for defining main titles on a webpage.

```html
<h1>a</h1>
```

--------------------------------

### Basic CSS Universal Selector Styling

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/markdown-code/input.txt

This CSS snippet illustrates the use of the universal selector (*) to apply a style to all elements on a page. In this case, it sets the text color of every element to red.

```css
* { color: red; }
```

--------------------------------

### Rust Numeric Literals Syntax

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-numbers/input.txt

Illustrates the syntax for various integer and floating-point literals in Rust. This includes standard decimal numbers, hexadecimal (0x), binary (0b), and octal (0o) representations, along with examples of type suffixes such as `usize`, `u8`, `i32`, `u16`, `f32`, and `f64` to explicitly define the literal's type.

```Rust
123;
123usize;
123_usize;
0xff00;
0xff_u8;
0b1111111110010000;
0b1111_1111_1001_0000_i32;
0o764317;
0o764317_u16;
123.0;
0.1;
0.1f32;
12E+99_f64;
```

--------------------------------

### Tail Log File in Bash

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/bash-no-numbers/output.html

Demonstrates how to use the `tail` command in a bash shell to display the last 10 lines of a specified log file. This is a common operation for monitoring real-time logs and is often used in shell scripting.

```bash
tail \-10 access.log
```

--------------------------------

### Map String Characters to ASCII Codes in CoffeeScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-function/input.txt

Shows how to process a string by splitting it into words and then mapping each word to the ASCII character code of its first character. This uses array `map` for transformation.

```CoffeeScript
str.split(" ").map((m) -> m.charCodeAt(0))
```

--------------------------------

### HTTP POST Request with JSON Payload and Response

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/http-default/input.txt

This snippet illustrates a standard HTTP POST request to the '/task' endpoint, including common headers like 'Host', 'Content-Type', and 'Content-Length'. It also shows a sample JSON request body and a corresponding JSON response. This pattern is typical for RESTful API interactions.

```APIDOC
POST /task?id=1 HTTP/1.1
Host: example.org
Content-Type: application/json; charset=utf-8
Content-Length: 19

{"status": "ok", "extended": true}
```

--------------------------------

### JavaScript Division and Regular Expression Literal Parsing

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-division/output.html

These examples demonstrate various syntaxes involving the division operator (/) and regular expression literals in JavaScript. They highlight potential ambiguities or specific parsing rules when a forward slash could be interpreted as either a division operator or the start/end of a regex literal, especially when followed by flags or other operators. This is crucial for syntax highlighting and parsing tools.

```JavaScript
x = 6/foo/i
```

```JavaScript
x = 6 /foo
```

```JavaScript
x = 6 / foo
```

```JavaScript
x = 6 /foo * 2/gm
```

```JavaScript
x = f /foo
```

```JavaScript
x = f / foo / gm
```

```JavaScript
x = f /foo * 2/6
```

--------------------------------

### Node.js Basic Variable Declaration

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-shebang/output.html

This snippet demonstrates a basic variable declaration in Node.js. It initializes a variable 'a' with the integer value 1. This is a fundamental operation in JavaScript for storing data.

```JavaScript
#!/usr/bin/env node var a = 1;
```

--------------------------------

### Redux Reducers and Store Setup in JavaScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-default-parameters/input.txt

This snippet defines two Redux reducers, `visibleTodoFilter` and `todos`, which manage different parts of an application's state. It then demonstrates how to combine these reducers using `combineReducers` and create a Redux store with `createStore`. This pattern is fundamental for managing application state in Redux applications.

```JavaScript
function visibleTodoFilter(state = 'watch', action) {
  switch (action.type) {
  case 'CHANGE_VISIBLE_FILTER':
    return action.filter;
  default:
    return state;
  }
}

function todos(state, action) {
  switch (action.type) {
  case 'ADD_TODO':
    return [...state, {
      text: action.text,
      completed: false
    }];
  case 'COMPLETE_TODO':
    return [
      ...state.slice(0, action.index),
      Object.assign({}, state[action.index], {
        completed: true
      }),
      ...state.slice(action.index + 1)
    ]
  default:
    return state;
  }
}

import { combineReducers, createStore } from 'redux';
let reducer = combineReducers({ visibleTodoFilter, todos });
let store = createStore(reducer);
```

--------------------------------

### Groovy Class Definition and Property Access

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/groovy-fixture/input.txt

This snippet defines a simple Groovy class `AGroovyBean` with a `color` property. It then demonstrates object instantiation and two common ways to access and modify properties in Groovy: using explicit `setColor`/`getColor` methods (which are automatically generated by Groovy) and using Groovy's direct property access syntax, which is syntactic sugar for the underlying getter/setter calls.

```Groovy
class AGroovyBean {
  String color
}

def myGroovyBean = new AGroovyBean()

myGroovyBean.setColor('baby blue')
assert myGroovyBean.getColor() == 'baby blue'

myGroovyBean.color = 'pewter'
assert myGroovyBean.color == 'pewter'
```

--------------------------------

### Lisp: Handling Spaces and Newlines in Expressions

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/haskell-nested-comments/lisp-mec/input.txt

This Lisp-like snippet illustrates how spaces and newlines might be interpreted within a multi-line expression or literal. It demonstrates a syntax pattern that a parser or syntax highlighter would need to correctly process, showing a literal block containing 'spaces and newlines' followed by a variable 'x'.

```Lisp
(|spaces and
newlines| x)
```

--------------------------------

### Define Protocol and Class in Swift

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/swift-functions/output.html

This Swift code snippet illustrates the definition of a protocol named `Protocol` with two function signatures (`f1()` and `f2()`), and a class named `MyClass` containing a method `f()` that returns a boolean value.

```Swift
protocol Protocol { func f1() func f2() } class MyClass { func f() { return true } }
```

--------------------------------

### Rust Variable Declarations

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-variables/output.html

Demonstrates fundamental variable declaration syntax in Rust. This includes declaring an immutable variable (`let`), a mutable variable (`let mut`), and an unused variable (prefixed with `_`) to suppress compiler warnings.

```Rust
let foo; let mut bar; let _foo_bar;
```

--------------------------------

### CSS `not()` Pseudo-Class Selectors

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/css-pseudo-selector/input.txt

Demonstrates the use of the CSS `:not()` pseudo-class to select elements that do not match a specified selector. It shows both single and chained `:not()` selectors for targeting list items based on their class attributes.

```css
li:not(.red){}
li:not(.red):not(.green){}
```

--------------------------------

### Basic JSX Element Syntax

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/jsx/output.html

This snippet illustrates various forms of JSX elements, including self-closing tags, elements with single or multiple children, elements with spread attributes, and elements with explicit attributes. It covers common patterns found in React or similar JSX-based frameworks.

```JavaScript
var jsx = <node/>;
var jsx = <node><child/></node>;
var jsx = <node>...<child>...</child></node>;
var jsx = <div><br /></div>;
var x = 5;
return (<node attr="value"></node>);
```

--------------------------------

### Declaring and Using JSX Elements

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/jsx/input.txt

This snippet showcases different forms of JSX element declarations, ranging from simple self-closing tags to elements with nested children and attributes. It also includes a basic variable assignment and a return statement demonstrating JSX usage within a function context.

```JavaScript
var jsx = <node/>;
var jsx = <node><child/></node>;
var jsx = <node>...<child>...</child></node>;
var jsx = <div><br /></div>;
var x = 5;
return (<node attr="value"></node>);
```

--------------------------------

### Refractor Language Aliasing (`refractor.alias`)

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Registers new aliases for already registered programming languages within Refractor. This allows highlighting content using alternative names for a language. The example shows how to add multiple aliases for 'markdown' and then use one of them for highlighting.

```APIDOC
refractor.alias(name[, alias])

Signatures:
  - alias(name, alias | list)
  - alias(aliases)

Parameters:
  - language (`string`): programming language name
  - alias (`string`): new alias for the programming language
  - list (`Array<string>`): list of aliases
  - aliases (`Record<language, alias | list>`): map of `language`s to `alias`es or `list`s

Example:
import markdown from 'refractor/markdown'
import {refractor} from 'refractor/core'

refractor.register(markdown)

// refractor.highlight('*Emphasis*', 'mdown')
// ^ would throw: Error: Unknown language: `mdown` is not registered

refractor.alias({markdown: ['mdown', 'mkdn', 'mdwn', 'ron']})
refractor.highlight('*Emphasis*', 'mdown')
// ^ Works!
```

--------------------------------

### Read and Parse JSON File Asynchronously in CoffeeScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-function/input.txt

Demonstrates how to read a local JSON file ('package.json') asynchronously using Node.js's `fs.readFile` in CoffeeScript. It includes error handling, parsing the content, and accessing a specific property ('version').

```CoffeeScript
fs.readFile("package.json", "utf-8", (err, content) ->
  data = JSON.parse(content)

  data.version
)
```

--------------------------------

### Define a Function that Throws an Error in CoffeeScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-function/input.txt

Illustrates how to define a CoffeeScript function that immediately throws a new Error object. This pattern is often used for unimplemented methods or to signal an invalid state.

```CoffeeScript
npmWishlist.sha256 = (str) ->
    throw new Error()
```

--------------------------------

### Groovy List Unique Elements Assertion

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/groovy-fixture/input.txt

This snippet demonstrates how to use Groovy's `first()` and `unique()` methods on a list of lists to assert that duplicate elements are removed from the first inner list, resulting in a list of unique elements.

```Groovy
assert [[1,2,3,3,3,3,4]].first().unique() == [1,2,3]
```

--------------------------------

### View Last Lines of a Log File in Bash

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/bash-no-numbers/input.txt

This snippet demonstrates how to view the last 10 lines of a specified log file using the `tail` command in a Bash shell. It's commonly used for monitoring recent activity in server logs or other frequently updated files.

```bash
tail -10 access.log
```

--------------------------------

### Rust Variable Declaration Syntax

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-variables/input.txt

This code snippet demonstrates fundamental variable declaration syntax in Rust. It shows how to declare an immutable variable using `let`, a mutable variable using `let mut`, and an unused variable by prefixing its name with an underscore (`_`).

```Rust
let foo;
let mut bar;
let _foo_bar;
```

--------------------------------

### Groovy Class Definition, Property Access, and List Operations

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/groovy-fixture/output.html

This snippet illustrates how to define a simple Groovy class, instantiate an object, and interact with its properties using both traditional getter/setter methods and Groovy's direct property access. It also shows an example of list manipulation using `first()` and `unique()` methods, along with Groovy's `assert` keyword for testing conditions.

```Groovy
@BaseScript MyBaseClass baseScript @DelegatesTo(EmailSpec) assert [[1,2,3,3,3,3,4]].first().unique() == [1,2,3] class AGroovyBean { String color } def myGroovyBean = new AGroovyBean() myGroovyBean.setColor('baby blue') assert myGroovyBean.getColor() == 'baby blue' myGroovyBean.color = 'pewter' assert myGroovyBean.color == 'pewter'
```

--------------------------------

### Lisp: Using Quoted Literals

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/haskell-nested-comments/lisp-mec/input.txt

This Lisp-like snippet demonstrates the use of a single-quoted literal. In Lisp, a single quote typically prevents evaluation and treats the following expression as data rather than code, which is a fundamental concept for symbolic programming and metaprogramming.

```Lisp
(x '|quoted|)
```

--------------------------------

### CSS :not() Pseudo-class Examples

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/css-pseudo-selector/output.html

These CSS snippets illustrate how to use the `:not()` pseudo-class to select elements that do not possess a specified class. The first rule targets list items without the 'red' class, while the second targets list items without both 'red' and 'green' classes.

```css
li:not(.red){}
li:not(.red):not(.green){}
```

--------------------------------

### Define CSS Styles for Class

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/xml-sublanguages/input.txt

This snippet defines a basic CSS rule for the class `foo`, setting its color property to red. It demonstrates how to embed styling directly within an HTML document using a `<style>` tag, which is useful for page-specific styles or quick prototyping.

```css
.foo {
  color: red;
}
```

--------------------------------

### Groovy String Interpolation

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/groovy-string-interpolation/input.txt

This Groovy code snippet shows how to use GString (interpolated string) to embed the result of an arithmetic expression directly into a string. The `def` keyword declares a variable, and the `${}` syntax evaluates the expression `2 + 3` at runtime, inserting its result into the string.

```Groovy
def sum = "The sum of 2 and 3 equals ${2 + 3}"
```

--------------------------------

### Rust Numeric Literal Examples

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-numbers/output.html

This snippet illustrates different ways to define integer and floating-point numeric literals in Rust. It covers decimal, hexadecimal (0x), binary (0b), and octal (0o) bases for integers, as well as explicit type suffixes (e.g., `usize`, `u8`, `i32`, `f32`, `f64`) and digit separators (`_`) for improved readability.

```Rust
123; 123usize; 123_usize; 0xff00; 0xff_u8; 0b1111111110010000; 0b1111_1111_1001_0000_i32; 0o764317; 0o764317_u16; 123.0; 0.1; 0.1f32; 12E+99_f64;
```

--------------------------------

### React Dismissible Alert Component with Bootstrap-Styled

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/jsx-advanced/input.txt

This React class component (`AlertDismissExample`) demonstrates how to create a dismissible alert using the `Alert` component from `bootstrap-styled`. It manages the alert's visibility through its internal state and provides an `onDismiss` handler to hide the alert. A button is included to potentially reset the alert's visibility (though the `resetCloseAlert` method is not defined in this snippet).

```JavaScript
import React from 'react';

import {
  Alert,
  Button,
} from 'bootstrap-styled';

export default class AlertDismissExample extends React.Component {

  state = {
    visible: true,
  };

  onDismiss = () => {
    this.setState({ visible: false });
  };

  render() {
    return (
      <div>
        <Alert color="info" isOpen={this.state.visible} toggle={this.onDismiss}>
          I am an alert and I can be dismissed!
        </Alert>
        <Button className="btn btn-primary" onClick={this.resetCloseAlert}>Reset alert</Button>
      <div>
    )
  }
}
```

--------------------------------

### Refractor Supported Languages and Inclusion Methods

Source: https://github.com/wooorm/refractor/blob/main/readme.md

This API documentation outlines the languages supported by the `refractor` library for syntax highlighting, detailing how different sets of syntaxes can be included. It explains the distinction between `refractor/core`, `refractor`, and `refractor/all` imports, and lists all available languages with their aliases.

```APIDOC
Refractor Language Inclusion:

refractor/core:
  - No syntaxes included by default.
  - Allows manual addition of languages.

refractor:
  - Includes 'checked' syntaxes by default.
  - Operates as a singleton: once a language is registered, it's globally available.

refractor/all:
  - Provides access to all 'unchecked' syntaxes in addition to 'checked' ones.

Supported Languages (with aliases):

Checked Syntaxes (included with `refractor`):
- arduino (alias: ino)
- bash (aliases: sh, shell)
- basic
- c
- clike
- cpp
- csharp (aliases: cs, dotnet)
- css
- diff
- go
- ini
- java
- javascript (alias: js)
- json (alias: webmanifest)
- kotlin (aliases: kt, kts)
- less
- lua
- makefile
- markdown (alias: md)
- markup (aliases: atom, html, mathml, rss, ssml, svg, xml)
- markup-templating
- objectivec (alias: objc)
- perl
- php
- python (alias: py)
- r
- regex
- ruby (alias: rb)
- rust
- sass
- scss
- sql
- swift
- typescript (alias: ts)
- vbnet
- yaml (alias: yml)

Unchecked Syntaxes (available via `refractor/all` or manual import):
- abap
- abnf
- actionscript
- ada
- agda
- al
- antlr4 (alias: g4)
- apacheconf
- apex
- apl
- applescript
- aql
- arff
- armasm (alias: arm-asm)
- arturo (alias: art)
- asciidoc (alias: adoc)
...
```

--------------------------------

### Highlighting Markdown with Refractor

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Demonstrates how to register a language (markdown) with Refractor and then use it to highlight a string. The output shows the HAST (Hypertext Abstract Syntax Tree) structure generated by Refractor.

```js
import markdown from 'refractor/markdown'
import {refractor} from 'refractor/core'

refractor.register(markdown)

console.log(refractor.highlight('*Emphasis*', 'markdown'))
```

```js
{
  type: 'root',
  children: [
    {type: 'element', tagName: 'span', properties: [Object], children: [Array]}
  ]
}
```

--------------------------------

### refractor API Reference

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Detailed API documentation for the `refractor` object, including methods for highlighting code and registering new syntaxes. The `highlight` method processes code into a HAST tree, while `register` allows adding custom or external language grammars.

```APIDOC
refractor.highlight(value, language)
  Highlight `value` (code) as `language` (programming language).

  Parameters:
    value (string) — code to highlight
    language (string or Grammar) — programming language name, alias, or grammar

  Returns:
    Node representing highlighted code (Root)

  Example:
    import css from 'refractor/css'
    import {refractor} from 'refractor/core'

    refractor.register(css)
    console.log(refractor.highlight('em { color: red }', 'css'))

    Yields:
    {
      type: 'root',
      children: [
        {type: 'element', tagName: 'span', properties: [Object], children: [Array]},
        {type: 'text', value: ' '},
        // …
        {type: 'text', value: ' red '},
        {type: 'element', tagName: 'span', properties: [Object], children: [Array]}
      ]
    }

refractor.register(syntax)
  Register a syntax.

  Parameters:
    syntax (Function) — language function custom made for refractor, as in, the files in `refractor/*`
```

--------------------------------

### Initialize Code Highlighting in JavaScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-keywords/input.txt

This JavaScript function, `$initHighlight`, attempts to initialize syntax highlighting for a given code block. It checks for a 'no-highlight' class to bypass processing, includes a try-catch block for error handling, and iterates through a 'classes' array with a conditional check. The function returns different values based on conditions, including a regex pattern.

```javascript
function $initHighlight(block, cls) {
  try {
    if (cls.search(/\bno\-highlight\b/) != -1)
      return process(block, true, 0x0F) +
             ' class=""';
  } catch (e) {
    /* handle exception */
  }
  for (var i = 0 / 2; i < classes.length; i++) {
    if (checkCondition(classes[i]) === undefined)
      return /\d+[\s/]/g;
  }
}
```

--------------------------------

### JavaScript Module Imports (Default, Named, Aliased)

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-modules/output.html

Illustrates how to import modules in JavaScript, including importing a default export, specific named exports, and aliasing a named import during the import process for local renaming.

```JavaScript
import _, { each, something as otherthing } from 'underscore';
```

--------------------------------

### JavaScript Syntax Highlight Initialization Function

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-keywords/output.html

This JavaScript function, `$initHighlight`, is designed to initialize syntax highlighting for a given code block. It first checks if the block's class string contains a 'no-highlight' class, in which case it bypasses further processing. If not, it iterates through a global `classes` array, applying a `checkCondition` to each element. The function includes basic error handling for its initial class check.

```javascript
function $initHighlight(block, cls) { try { if (cls.search(/\bno\-highlight\b/) != -1) return process(block, true, 0x0F) + ' class=""'; } catch (e) { /* handle exception */ } for (var i = 0 / 2; i < classes.length; i++) { if (checkCondition(classes[i]) === undefined) return /\d+[\s/]/g; } }
```

--------------------------------

### Node.js Shebang and Variable Declaration

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-shebang/input.txt

This snippet demonstrates a basic Node.js script structure, including the shebang line for execution and a simple variable declaration using the 'var' keyword.

```JavaScript
#!/usr/bin/env node

var a = 1;
```

--------------------------------

### Serializing Refractor HAST Output to HTML

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Illustrates how to take the HAST tree generated by Refractor's `highlight` function and convert it into an HTML string using the `hast-util-to-html` library. This allows for rendering highlighted code as standard HTML.

```js
import {toHtml} from 'hast-util-to-html'
import {refractor} from 'refractor'

const tree = refractor.highlight('"use strict";', 'js')

console.log(toHtml(tree))
```

```html
<span class="token string">"use strict"</span><span class="token punctuation">;</span>
```

--------------------------------

### JavaScript ES Module Import Syntax

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-modules/input.txt

This snippet illustrates how to import different types of exports from a JavaScript module. It demonstrates importing a default export, specific named exports, and a named export with an alias, which are essential for consuming functionalities from other modules.

```JavaScript
import _, { each, something as otherthing } from 'underscore';
```

--------------------------------

### Importing Prism Dark CSS Theme

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Demonstrates how to import the Prism Dark CSS theme from esm.sh for use with refractor in a browser environment, providing styling for syntax-highlighted code. This approach is necessary because refractor itself does not inject CSS.

```html
<link rel="stylesheet" href="https://esm.sh/prismjs@1.30.0/themes/prism-dark.css">
```

--------------------------------

### JavaScript Module Exports (Default, Named, Aliased)

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-modules/output.html

Demonstrates different ways to export functions and values from a JavaScript module, including a default export, named function exports, and an aliased named export for backward compatibility or clarity.

```JavaScript
export default function (obj) {};
export function each(obj, iterator, context) {};
export { each as forEach };
export function something() {};
```

--------------------------------

### Define Basic CoffeeScript Functions

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-function/output.html

Illustrates simple function definitions in CoffeeScript, including functions that return null, true, or perform a basic mathematical operation like squaring a number.

```CoffeeScript
returnNull = -> null
returnTrue = () -> true
square = (x) -> x * x
```

--------------------------------

### Python String, Byte, and Raw Literals

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-strings/input.txt

This snippet illustrates the syntax for standard strings (single and double quotes), byte strings (prefixed with 'b'), and raw strings (prefixed with 'r'), showcasing escape sequences and multi-line raw string delimiters.

```Python
'a';
'\n';
'\x1A';
'\u12AS';
'\U1234ASDF';
b'a';

"hello";
b"hello";

r"hello";
r###"world"###;
r##" "### "# "##;
```

--------------------------------

### JavaScript ES Module Export Syntax

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-modules/input.txt

This snippet showcases various ways to export entities from a JavaScript module. It includes a default export, named function exports, and an aliased named export, demonstrating common patterns for exposing module functionalities.

```JavaScript
export default function (obj) {};
export function each(obj, iterator, context) {};
export { each as forEach };
export function something() {};
```

--------------------------------

### Define a Swift Protocol

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/swift-functions/input.txt

This snippet defines a Swift protocol named 'Protocol' that declares two required methods, 'f1()' and 'f2()'. Protocols specify a blueprint of methods, properties, and other requirements that can be adopted by classes, structs, or enums, ensuring conformance to a specific interface.

```Swift
protocol Protocol {
  func f1()
  func f2()
}
```

--------------------------------

### Read File and Parse JSON in CoffeeScript (Node.js)

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-function/output.html

Shows how to asynchronously read a file (e.g., `package.json`) using Node.js `fs.readFile`, parse its content as JSON, and access properties like the version.

```CoffeeScript
fs.readFile("package.json", "utf-8", (err, content) -> data = JSON.parse(content) data.version )
```

--------------------------------

### CoffeeScript Error Throwing and String Character Mapping

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-function/output.html

Demonstrates how to throw a new error in CoffeeScript and a common pattern for mapping characters of a string to their ASCII codes using `split` and `charCodeAt`.

```CoffeeScript
npmWishlist.sha256 = (str) -> throw new Error()
str.split(" ").map((m) -> m.charCodeAt(0))
```

--------------------------------

### Converting Refractor HAST to React Nodes

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Shows how to transform the HAST tree produced by Refractor into React (or Preact) nodes using `hast-util-to-jsx-runtime`, enabling direct rendering of highlighted code within a React application.

```js
import {toJsxRuntime} from 'hast-util-to-jsx-runtime'
import {Fragment, jsxs, jsx} from 'react/jsx-runtime'
import {refractor} from 'refractor'

const tree = refractor.highlight('"use strict";', 'js')
const reactNode = toJsxRuntime(tree, {Fragment, jsxs, jsx})

console.log(react)
```

```js
{
  '$$typeof': Symbol(react.element),
  type: 'div',
  key: 'h-1',
  ref: null,
  props: { children: [ [Object], [Object] ] },
  _owner: null,
  _store: {}
}
```

--------------------------------

### Define Basic CSS Style Rule

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/xml-sublanguages/output.html

This snippet defines a simple CSS rule for the class `.foo`, setting its text color to red. It illustrates how CSS can be embedded directly within an HTML document using the `<style>` tag.

```CSS
.foo { color: red; }
```

--------------------------------

### Refractor List Registered Languages (`refractor.listLanguages`)

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Retrieves a list of all language names and aliases currently registered with Refractor. This is useful for dynamically determining available highlighting options.

```APIDOC
refractor.listLanguages()

Returns:
  - `Array<string>`: An array of registered language names and aliases.

Example:
import markdown from 'refractor/markdown'
import {refractor} from 'refractor/core'

console.log(refractor.listLanguages()) //=> []

refractor.register(markdown)

console.log(refractor.listLanguages())

Yields:
[
  'markup', // Note that `markup` (a lot of xml based languages) is a dep of markdown.
  'html',
  // …
  'markdown',
  'md'
]
```

--------------------------------

### Declare and Initialize Floating-Point and Complex Variables

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/go-numbers/output.html

This snippet demonstrates the declaration and initialization of a floating-point variable and a complex number variable. The `:=` operator is used for short variable declarations, allowing type inference. The `f` suffix explicitly denotes a float literal, and `i` denotes the imaginary part of a complex number.

```Go-like
float_var := 1.0e10f
complex_var := 1.2e5+2.3i
```

--------------------------------

### Define a Swift Class with a Method

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/swift-functions/input.txt

This snippet defines a basic Swift class named 'MyClass' which includes a single method 'f()' that returns a boolean value. Classes are fundamental building blocks in object-oriented programming, serving as blueprints for creating objects with defined properties and behaviors.

```Swift
class MyClass {
  func f() {
    return true
  }
}
```

--------------------------------

### Declare and Assign Floating-Point and Complex Variables

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/go-numbers/input.txt

This snippet demonstrates the declaration and assignment of a floating-point variable and a complex number variable. The `:=` operator is characteristic of languages like Go for short variable declarations, while the `f` suffix for float literals is common in C/C++ and the `i` suffix for complex literals is found in Fortran or similar numerical languages.

```Go
float_var := 1.0e10f
complex_var := 1.2e5+2.3i
```

--------------------------------

### Defining Infix Operators with Precedence and Associativity

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/haskell-infix/input.txt

This snippet demonstrates how to declare infix operators with specified precedence and associativity using `infix`, `infixl` (left-associative), and `infixr` (right-associative) keywords. This syntax is typically found in language definition files or parser generators, where it influences how expressions involving these operators are parsed and evaluated. The number indicates precedence, and the keyword defines associativity.

```Language Definition
infix 3 `foo`
infixl 6 `bar`
infixr 9 `baz`
```

--------------------------------

### Define Car Class with Inheritance and Symbol

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-class/output.html

This JavaScript code defines a `Car` class that extends a `Vehicle` class. It demonstrates constructor usage, calling the parent constructor with `super()`, and using a `Symbol` to create a private-like property for `cost`, which is a common pattern for encapsulation before private class fields were standardized.

```JavaScript
class Car extends Vehicle { constructor(speed, cost) { super(speed); var c = Symbol('cost'); this[c] = cost; this.intro = `This is a car runs at ${speed}.`; } }
```

--------------------------------

### Rust Nested Block Comment Syntax

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-comments/input.txt

This snippet demonstrates how Rust allows block comments (`/* ... */`) to be nested. This feature is useful for commenting out large blocks of code that may already contain comments without needing to remove existing comments.

```Rust
/* rust has
/* nested /* block */ */
*/ comments
```

--------------------------------

### PHP Array Iteration and Modification by Reference

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/php/input.txt

This PHP snippet demonstrates iterating over an array by reference using the `foreach` loop. By prefixing the loop variable (`$value`) with an ampersand (`&`), any modifications to `$value` directly affect the original array element. It also highlights the importance of unsetting the reference after the loop to prevent unintended side effects with the last element.

```php
<?php
$arr = array(1, 2, 3, 4);
foreach ($arr as &$value) {
    $value = $value * 2;
}
// $arr is now array(2, 4, 6, 8)
unset($value); // break the reference with the last element
?>
```

--------------------------------

### Rust Function Definition: `sqr`

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-traits/input.txt

Defines a simple Rust function `sqr` that takes an `i32` integer `i` and returns its square. This demonstrates basic function syntax and integer arithmetic in Rust.

```Rust
fn sqr(i: i32) { i * i }
```

--------------------------------

### Define JavaScript Car Class with Symbol for Private Property

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/js-class/input.txt

This JavaScript code defines a `Car` class that extends a `Vehicle` class. It demonstrates the use of `Symbol` to create a pseudo-private property (`cost`) and utilizes template literals for string interpolation in the `intro` property. The constructor initializes inherited properties via `super()` and sets up the car's specific attributes.

```javascript
class Car extends Vehicle {
  constructor(speed, cost) {
    super(speed);

    var c = Symbol('cost');
    this[c] = cost;

    this.intro = `This is a car runs at
      ${speed}.`;
  }
}
```

--------------------------------

### Define Rust Function and Traits

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-traits/output.html

This snippet illustrates the syntax for defining a simple function that squares an integer and two different types of traits in Rust. It covers a basic function signature and body, along with trait declarations that include inheritance from another trait (`Copy`) and generic `where` clauses for type constraints (`Sized`, `Iterator<Item=Event>`).

```Rust
fn sqr(i: i32) { i * i }
trait Minimum : Copy {}
pub trait Builder where Self: Sized + Iterator<Item=Event> {}
```

--------------------------------

### Create a Dismissable Alert Component in React

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/jsx-advanced/output.html

This React class component demonstrates how to create a dismissable alert using `bootstrap-styled`'s `Alert` component. It manages the alert's visibility through its internal state (`visible`) and provides an `onDismiss` handler to hide the alert. A 'Reset alert' button is included to make the alert visible again, showcasing state manipulation.

```javascript
import React from 'react';
import { Alert, Button } from 'bootstrap-styled';

export default class AlertDismissExample extends React.Component {
  state = {
    visible: true,
  };

  onDismiss = () => {
    this.setState({ visible: false });
  };

  resetCloseAlert = () => {
    this.setState({ visible: true });
  };

  render() {
    return (
      <div>
        <Alert color="info" isOpen={this.state.visible} toggle={this.onDismiss}>
          I am an alert and I can be dismissed!
        </Alert>
        <Button className="btn btn-primary" onClick={this.resetCloseAlert}>Reset alert</Button>
      </div>
    );
  }
}
```

--------------------------------

### Parsing Division and Regular Expression-like Literals in JavaScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/coffeescript-division/input.txt

These snippets showcase different scenarios where the '/' character is used in JavaScript expressions. They demonstrate how the parser might interpret '/' as a division operator or as the delimiter for a regular expression literal, depending on the surrounding tokens and context, such as the presence of flags (e.g., 'i', 'gm') or other operators.

```JavaScript
x = 6/foo/i
x = 6 /foo
x = 6 / foo
x = 6 /foo * 2/gm
x = f /foo
x = f / foo / gm
x = f /foo * 2/6
```

--------------------------------

### Refractor Language Registration Check (`refractor.registered`)

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Checks whether a given language name or alias is currently registered with Refractor. It returns a boolean indicating the registration status.

```APIDOC
refractor.registered(aliasOrlanguage)

Parameters:
  - aliasOrlanguage (`string`): programming language name or alias

Example:
import markdown from 'refractor/markdown'
import {refractor} from 'refractor/core'

console.log(refractor.registered('markdown')) //=> false

refractor.register(markdown)

console.log(refractor.registered('markdown')) //=> true
```

--------------------------------

### PHP: Modifying Array Elements by Reference

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/php/output.html

This PHP snippet illustrates how to modify array elements directly within a `foreach` loop by passing the loop variable by reference. It initializes an array, then iterates through it, doubling each element's value. The `unset($value)` call after the loop is important to break the reference, preventing potential side effects with the last element.

```php
$arr = array(1, 2, 3, 4);
foreach ($arr as &$value) {
  $value = $value * 2;
}
// $arr is now array(2, 4, 6, 8)
unset($value); // break the reference with the last element
```

--------------------------------

### Define Variable with String Interpolation in JavaScript

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/groovy-string-interpolation/output.html

This snippet defines a variable named 'sum' and assigns it a string value. The string utilizes template literals (backticks) to embed a JavaScript expression, which calculates the sum of 2 and 3 directly within the string content. The `def` keyword and escaped equals sign `\=` suggest a non-standard or domain-specific language context, possibly for demonstration within a syntax highlighting library.

```JavaScript
def sum \= "The sum of 2 and 3 equals ${2 + 3}"
```

--------------------------------

### Rust Trait Definition: `Minimum`

Source: https://github.com/wooorm/refractor/blob/main/test/fixtures/rust-traits/input.txt

Defines a Rust trait named `Minimum` that requires any implementing type to also implement the `Copy` trait. This illustrates basic trait definition and trait inheritance in Rust.

```Rust
trait Minimum : Copy {}
```

--------------------------------

### Refractor Syntax Function Type Definition

Source: https://github.com/wooorm/refractor/blob/main/readme.md

Defines the TypeScript type for a Refractor syntax function, which is used to register new languages. It includes properties for aliases and a display name.

```ts
export type Syntax = ((prism: Refractor) => undefined | void) & {
  aliases?: Array<string> | undefined
  displayName: string
}
```