extwee 2.0.5 → 2.2.0

package/build/extwee.web.min.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! https://mths.be/he v1.2.0 by @mathias | MIT license */

package/docs/README.md

@@ -0,0 +1,167 @@
+# Extwee
+
+[![codecov](https://codecov.io/gh/videlais/extwee/branch/master/graph/badge.svg)](https://codecov.io/gh/videlais/extwee)
+
+[![npm version](https://badge.fury.io/js/extwee.svg)](https://badge.fury.io/js/extwee)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+[![NPM Badge](https://nodei.co/npm/extwee.png?downloads=true)](https://www.npmjs.com/package/extwee)
+
+## Story Compilation
+
+The process of *story compilation* converts human-readable content, what is generally called a *story*, into a playable format such as HyperText Markup Language (HTML) able to be read by another application such as a web browser. The result is then presented as links or other visual, interactive elements to a player or reader, depending on the work created.
+
+The term *compilation* is used because different parts of code are put together in a specific arrangement to enable later play. As part of Twine-compatible HTML, this means combining story format JavaScript code with story HTML data.
+
+Extwee is **not** an authoring tool. It cannot be used to create story content. This data must be created using other tools or processes. Extwee can then *compile* the story with story format code to produce something playable.
+
+Playable formats are the following and require external story formats[^1] to enable play:
+
+- Twine 2 HTML
+- Twine 1 HTML
+
+More human-readable formats include:
+
+- Twee 3[^2]
+- Twine 2 JSON[^3]
+
+From 2009 to 2015, Twine 1 supported a now [historical format named TWS](https://github.com/iftechfoundation/twine-specs/blob/master/twine-1-twsoutput.md). This was a binary format used for archival purposes. Extwee can read this format but does not support creating it because no other tools, including current versions of Twine, accept it as valid input.
+
+Twine 2 supports exporting a collection of stories (known as a *library*) in the [Twine 2 Archive HTML format](https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-archive-spec.md). Extwee can also read and write this format, creating either a collection of stories from the data or writing a collection of internal objects to a file.
+
+[^1]: Extwee does not include or publish story formats. These can be found in the [Story Format Archive (SFA)](https://github.com/videlais/story-formats-archive).
+
+[^2]: Twee exists in three versions. The first existed between 2006 to 2009 and was part of Twine 1. The move to Twine 2 in 2009 dropped support and the story compilation tools [Twee2](https://dan-q.github.io/twee2/) and [Tweego](https://www.motoslave.net/tweego/) adopted their own extensions and modifications. Beginning in 2017, work was done to unite the different projects. This resulted in [Twee 3](https://github.com/iftechfoundation/twine-specs/blob/master/twee-3-specification.md) in March 2021.
+
+[^3]: In October 2023, JavaScript Object Notation (JSON) was added as a supported community format for story compilation tools. Extwee is the first tool to support this format.
+
+## Format Support
+
+Extwee is a story compilation tool supporting multiple historical and current Twine-compatible formats.
+
+<table>
+    <tr>
+        <td>Format</td>
+        <td>Input</td>
+        <td>Output</td>
+    </tr>
+    <tr>
+        <td><a href='https://github.com/iftechfoundation/twine-specs/blob/master/twine-1-htmloutput-doc.md'>Twine 1 HTML (2006 - 2015)</a> </td>
+        <td>Yes</td>
+        <td>Partial support. Twine 1 HTML can be produced, but the StorySettings optional passage introduced in Twine 1.4.0 requires external libraries like jQuery not included with Extwee.</td>
+    </tr>
+    <tr>
+        <td><a href="https://github.com/iftechfoundation/twine-specs/blob/master/twine-1-twsoutput.md">Twine 1 TWS (2009 - 2015)</a></td>
+        <td>Yes</td>
+        <td>Extwee does not support TWS (Python pickle) output because no current version of Twine or other story compilation tool produces this historical format.</td>
+    </tr>
+    <tr>
+        <td><a href="https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-htmloutput-spec.md">Twine 2 HTML (2015 - Present)</a></td>
+        <td>Yes</td>
+        <td>Yes</td>
+    </tr>
+    <tr>
+        <td><a href="https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-archive-spec.md">Twine 2 Archive HTML (2015 - Present)</a></td>
+        <td>Yes</td>
+        <td>Yes</td>
+    </tr>
+    <tr>
+        <td><a href="https://github.com/iftechfoundation/twine-specs/blob/master/twee-3-specification.md">Twee 3 (2021 - Present)</a></td>
+        <td>Yes</td>
+        <td>Yes</td>
+    </tr>
+    <tr>
+        <td><a href="https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-jsonoutput-doc.md">Twine 2 JSON (2023 - Present)</a></td>
+        <td>Yes</td>
+        <td>Yes</td>
+    </tr>
+</table>
+
+**Note:** Round-trip translations can present problems because of required fields and properties per format. Some metadata may be added or removed based on the specification being followed.
+
+## Node and Web API
+
+The following objects and methods are available in Node.js or browser contexts.
+
+**Note:** When used in a browser context, all objects and methods are part of the `window.Extwee` global.
+
+### Objects
+
+An object must be created using either the `new` keyword in JavaScript or as the result of parsing data.
+
+- `StoryFormat`
+- `Passage`
+- `Story`
+
+Story and Passage objects can generate multiple output formats: `toTwee()`, `toTwine1HTML()`, `toTwine2HTML()`, and `toJSON()`. Stories cannot be played in a browser without the corresponding compiler combining it with story format data.
+
+### Parsers
+
+Translates output formats such as HTML, Twee, JSON, or JSONP into objects.
+
+**Note:** Twine 1 story formats exist across multiple files (`header.html` and optional `code.js`). They cannot be parsed into a `StoryFormat` object.
+
+- `parseTwee()`
+- `parseJSON()`
+- `parseStoryFormat()`
+- `parseTwine1HTML()`
+- `parseTwine2HTML()`
+- `parseTwine2ArchiveHTML()`
+
+### Compilers
+
+Compiles story, story formats, or other data into an archive or playable format.
+
+- `compileTwine2HTML()`
+- `compileTwine1HTML()`
+- `compileTwine2ArchiveHTML()`
+
+**Note:** In order to create playable Twine 1 HTML, an `engine.js` file must be supplied.
+
+## Documentation
+
+Extwee has documentation on individual source files hosted on GitHub Pages.
+
+## Command-Line Usage
+
+Extwee supports a command-line interface for four general scenarios:
+
+### Compiling Twee 3 + Twine 2 Story Format into Twine 2 HTML
+
+Compile Twee 3 + StoryFormat into Twine 2 HTML:
+
+`extwee -c -i <tweeFile> -s <storyFormat> -o <Twine2HTML>`
+
+### De-compiling Twine 2 HTML into Twee 3
+
+De-compile Twine 2 HTML into Twee 3:
+
+`extwee -d -i <twine2HTML> -o <outputTwee>`
+
+### Compiling Twee 3 into Twine 1 HTML
+
+Enabling Twine 1 mode requires using the `-t1` or `--twine1` flag.
+
+`extwee -t1 -c -i <tweeFile> -o <Twine1HTML> -engine <engineJS> -name <storyFormatName> -codejs <CodeJS> -header <header>`
+
+### De-compiling Twine 1 HTML into Twee 3
+
+Enabling Twine 1 mode requires using the `-t1` or `--twine1` flag.
+
+`extwee -t1 -d -i <twine1HTML> -o <outputTwee>`
+
+## Roadmap
+
+Each major version has its own GitHub project:
+
+- [Road to Extwee 2.2.0](https://github.com/users/videlais/projects/2)
+- [Road to Extwee 2.4.0](https://github.com/users/videlais/projects/4)
+
+## Tree Shaking Support
+
+For [advanced tree shaking](https://developer.mozilla.org/en-US/docs/Glossary/Tree_shaking) patterns, most formats are broke into `compile.js` and `parse.js` files exporting associated `compile()` and `parse()` functions. When using the API, it is possible to only import a single function or object to produce smaller and potentially faster code in projects dependent on Extwee functionality.
+
+## License
+
+Distributed under the MIT License. See `LICENSE.txt` for more information.

package/docs/_sidebar.md

@@ -0,0 +1,19 @@
+- Installation and General Usage
+  - [Binaries (stand alone)](/install/binaries.md)
+  - [Using NPX (as part of workflow)](/install/npx.md)
+  - [Using NPM (via API)](/install/npm.md)
+- Objects
+  - [Passage](/objects/passage.md)
+  - [Story](/objects/story.md)
+  - [Story Format](/objects/storyformat.md)
+- Formats
+  - [Twee 3](/formats/twee.md)
+  - [Twine 2 HTML](/formats/twine2HTML.md)
+  - [Twine 2 JSON](/formats/json.md)
+  - [Twine 2 Archive HTML](/formats/twine2ArchiveHTML.md)
+  - [Twine 1 HTML](/formats/twine1HTML.md)
+  - [Twine 1 TWS](/formats/tws.md)
+  
+- Examples
+  - [Dynamically Generating Passages](/examples/dynamicPassages.md)
+  - [Converting Twine 2 JSON into Twee 3](/examples/jsonToTwee.md)

package/docs/examples/dynamicPassages.md

@@ -0,0 +1,28 @@
+# Dynamically Generating Passages
+
+Through using the API, it is possible to dynamically create passages and then export this story into Twee (or JSON) using only the **Story** and **Passage** objects.
+
+Both **Story** and **Passage** objects can be created through the `new` keyword in JavaScript. After creating a **Story**, the use of the method `addPassage(Passage)` can be used to add new passages.
+
+In the following example, the use of a `for()` loop is used to generate 20 passages and a starting passage is set. Finally, the **Story** data is converted into Twee and written to an output file.
+
+```javascript
+// Import only Story and Passage.
+import { Story, Passage } from 'extwee';
+// Import only writeFileSync() for writing to files.
+import { writeFileSync } from 'node:fs';
+
+// Create the story.
+const example = new Story( 'Example' );
+
+// Generate 20 passages and add them to the story.
+for(let i = 0; i < 20; i++;) {
+    example.addPassage( new Passage( `Passage ${i}`, 'Some Text') );
+}
+
+// Set a starting passage.
+example.start = 'Passage 1';
+
+// Create a Twee file.
+writeFileSync( 'example.twee', example.toTwee() );
+```

package/docs/examples/jsonToTwee.md

@@ -0,0 +1,23 @@
+# Converting Twine 2 JSON to Twee 3
+
+Conversion from Twine 2 JSON to Twee 3 requires multiple steps:
+
+1. Read the JSON file.
+2. Use `parseJSON()` to convert JSON into a **Story** object.
+3. Using `Story.toTwee()`, convert the **Story** object into Twee 3.
+
+```javascript
+// Import only Story and parseJSON().
+import { Story, parseJSON } from 'extwee';
+// Import only readFileSync() and writeFileSync() for reading and writing to files.
+import { readFileSync, writeFileSync } from 'node:fs';
+
+// Read in the JSON file
+const inputFile = readFileSync( 'example.json', 'utf-8' );
+
+// Convert from Twine 2 JSON to Story.
+const s = parseJSON(inputFile);
+
+// Write Twee output
+writeFileSync( 'output.twee', s.toTwee() );
+```

package/docs/examples/twsToTwee.md

@@ -0,0 +1,25 @@
+# TWS To Twee
+
+Converting from TWS to Twee 3 is similar to many other conversion processes:
+
+1. Read the binary file.
+2. Convert the binary files into a Buffer.
+3. Parse the Buffer into a Story.
+4. Convert Story data into Twee.
+
+```javascript
+// Import only readFileSynce() and writeFileSync().
+import { readFileSync, writeFileSync } from 'node:fs';
+// Only import Story and parseTWS().
+import { Story, parseTWS } from 'extwee';
+
+// Read the file contents using binary encoding.
+const contents = readFileSync( 'Example1.tws', 'binary' );
+// Convert from binary into Buffer.
+const b = Buffer.from( contents, 'binary' );
+// convert TWS into Story.
+const s = parseTWS( b );
+
+// Write Twee to output file.
+writeFileSync( 'example.twee', s.toTwee() );
+```

package/docs/formats/json.md

@@ -0,0 +1,17 @@
+# JSON
+
+The [Twine 2 JSON specification](https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-jsonoutput-doc.md) defines a format for storing a Twine 2 compatible story and passage data in JavaScript Objection Notation (JSON).
+
+Extwee can perform two actions.
+
+## Parse
+
+When using the `parseJSON()` function (or `JSON/parse.js` export), incoming Twine 2 JSON will be converted into a [**Story**](/objects/story.md) object.
+
+## Output
+
+Every **Story** object can create a JSON representation of its data using the `Story.toJSON()` method.
+
+## Format Caution
+
+As of December 2023, no current story compilation (other than Extwee) or version of Twine supports input or output of the Twine 2 JSON format.

package/docs/formats/twee.md

@@ -0,0 +1,13 @@
+# Twee
+
+The [Twee 3 specification](https://github.com/iftechfoundation/twine-specs/blob/master/twee-3-specification.md) defines a human-readable format for storing a Twine 2 compatible story and passage data.
+
+Extwee can perform two actions with Twee.
+
+## Parse
+
+When using the `parseTwee()` function (or `Twee/parse.js` export), incoming Twee will be converted into a [**Story**](/objects/story.md) object.
+
+## Output
+
+Every **Story** object can create a Twee representation of its data using the `Story.toTwee()` method.

package/docs/formats/twine1HTML.md

@@ -0,0 +1,13 @@
+# Twine 1 HTML
+
+The [Twine 1 HTML Output specification](https://github.com/iftechfoundation/twine-specs/blob/master/twine-1-htmloutput-doc.md) defines the elements and attributes for encoding Twine 1 story and passage data.
+
+Extwee can perform two actions with Twine 1 HTML.
+
+## Parsing
+
+When using the `parseTwine1HTML()` function (or `Twine1HTML/parse.js` export), incoming Twine 1 HTML will be converted into a [**Story**](/objects/story.md) object.
+
+## Compilation
+
+When using the `compileTwine1HTML()` function (or `Twine2HTML/compile.js` export), [**Story**](/objects/story.md) objects can be compiled into Twine 1 HTML output with additional content from `engine.js`, `header.html`, and `code.js` files.

package/docs/formats/twine2ArchiveHTML.md

@@ -0,0 +1,13 @@
+# Twine 2 Archive HTML
+
+The [Twine 2 Archive HTML specification](https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-archive-spec.md) defines a collection of Twine 2 stories stored in HTML.
+
+Extwee can perform two actions with Twine 2 archive HTML.
+
+## Parsing
+
+When using the `parseTwine2ArchiveHTML()` function (or `Twine2ArchiveHTML/parse.js` export), incoming Twine 2 Archive HTML will be converted into an array of [**Story**](/objects/story.md) objects.
+
+## Compilation
+
+When using the `compileTwine2ArchiveHTML()` function (or `Twine2ArchiveHTML/compile.js` export), an array of **Story** objects can be converted into Twine 2 Archive HTML.

package/docs/formats/twine2HTML.md

@@ -0,0 +1,13 @@
+# Twine 2 HTML
+
+The [Twine 2 HTML Output specification](https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-htmloutput-spec.md) defines the elements and attributes for encoding Twine 2 story and passage data.
+
+Extwee can perform two actions with Twine 2 HTML.
+
+## Parsing
+
+When using the `parseTwine2HTML()` function (or `Twine2HTML/parse.js` export), incoming Twine 2 HTML will be converted into a [**Story**](/objects/story.md) object.
+
+## Compilation
+
+When using the `compileTwine2HTML()` function (or `Twine2HTML/compile.js` export), [**Story**](/objects/story.md) and [**StoryFormat**](/objects/storyformat.md) objects can be compiled into Twine 2 HTML output.

package/docs/formats/tws.md

@@ -0,0 +1,9 @@
+# TWS
+
+The [Twine 1 TWS documentation](https://github.com/iftechfoundation/twine-specs/blob/master/twine-1-twsoutput.md) details the Python pickle format used in Twine 1.
+
+Extwee can only parse TWS files.
+
+## Parsing
+
+When using the `parseTWS()` function (or `TWS/parse.js` export), incoming TWS will be converted into a [**Story**](/objects/story.md) object.

package/docs/index.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Document</title>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+  <meta name="description" content="Description">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0">
+  <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/docsify/themes/buble.css" />
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    window.$docsify = {
+      name: 'Extwee Documentation',
+      repo: 'https://github.com/videlais/extwee',
+      loadSidebar: true
+    }
+  </script>
+  <!-- Docsify v4 -->
+  <script src="//cdn.jsdelivr.net/npm/docsify@4"></script>
+  <script src="https://cdn.jsdelivr.net/npm/docsify-themeable@0/dist/js/docsify-themeable.min.js"></script>
+  <script src="//cdn.jsdelivr.net/npm/docsify-copy-code/dist/docsify-copy-code.min.js"></script>
+  <script src="//cdn.jsdelivr.net/npm/prismjs@1/components/prism-javascript.min.js"></script>
+</body>
+</html>

package/docs/install/binaries.md

@@ -0,0 +1,9 @@
+# Binaries
+
+Either by downloading the `extwee` (or `extwee.exe`) files from the [Releases listing](https://github.com/videlais/extwee/releases) or from the `build` folder, Extwee can be used as a stand-alone command-line program. (Currently, only builds for MacOS and Windows are included.)
+
+## CLI Example
+
+```bash
+extwee.exe -c -i <tweeFile> -s <storyFormat> -o <Twine2HTML>
+```

package/docs/install/npm.md

@@ -0,0 +1,20 @@
+# NPM
+
+While general compilation and de-compilation is possible using the CLI, more advanced usage patterns can be enabled through the API.
+
+By installing `extwee`, developers can directly access its objects, parsers, and compilation functionality.
+
+## Example
+
+```javascript
+import { Story, Passage } from 'extwee';
+
+// Create the story.
+const example = new Story( 'Example' );
+// Add a new passage.
+example.addPassage(new Passage( 'Test', 'Some Text') );
+
+// Confirm size change.
+// (Should produce 1).
+console.log ( example.size() );
+```

package/docs/install/npx.md

@@ -0,0 +1,9 @@
+# NPX
+
+Extwee can be used via NPX (node package execution) without being added to a local project. When used this way, precede all uses with "npx".
+
+## NPX Example
+
+```bash
+npx extwee -c -i <tweeFile> -s <storyFormat> -o <Twine2HTML>
+```

package/docs/objects/passage.md

@@ -0,0 +1,47 @@
+# Passage
+
+The smallest unit in Twine is a *passage*.
+
+## Properties
+
+When using the Extwee API, a **Passage** object holds four properties:
+
+- name ( string ) Name of the passage.
+- text ( string ) Content of the passage.
+- tags ( array(string) ) Array of tags associated with the passage.
+- Metadata ( object ) Key-value pairs associated with the passage.
+
+### Property Example
+
+```javascript
+import { Passage } from 'extwee';
+
+// Create a single passage.
+const example = new Passage('Example', 'Some text');
+
+// Output current passage text.
+console.log( example.text );
+```
+
+## Methods
+
+Each passage is capable of producing multiple formats of its internal data:
+
+- `toTwee()`: Converts passage data into Twee 3.
+- `toJSON()`: Converts passage data into Twine 2 JSON.
+- `toTwine2HTML()`: Converts passage data into Twine 2 HTML.
+- `toTwine1HTML()`: Converts passage data into Twine 1 HTML.
+
+### Method Example
+
+```javascript
+import { Passage } from 'extwee';
+
+// Create a single passage.
+const example = new Passage('Example', 'Some text');
+
+// Convert to Twee 3.
+console.log( example.toTwee() );
+```
+
+**Note:** While each passage can create different representations of its data, each conversion is considered partial without the corresponding story metadata or story format to create the playable form.

package/docs/objects/story.md

@@ -0,0 +1,70 @@
+# Story
+
+A *story* is a collection of [passages](/guide/passage.md) with its own metadata.
+
+## Properties
+
+Depending on the incoming format or creation method, many possible properties can be populated.
+
+- name ( string ) Name of the story.
+- start ( string ) Starting passage for Twine 2 HTML or Twee 3.
+- IFID ( string ) When converting to multiple formats, a new IFID will be generated if it does not exist.
+- format ( string ) Name of the story format for Twine 2 HTML.
+- formatVersion ( string ) Semantic version of the named story format for Twine 2 HTML or Twee 3.
+- zoom ( float ) Zoom level for Twine 2 HTML or Twee 3.
+- passages ( array(Passage) ) **[Read-only]** Collection of internal passages.
+- creator ( string ) Name of story creation tool. (Defaults to "Extwee").
+- creatorVersion ( string ) Semantic version of named creation tool.
+- metadata ( object ) Key-value pairs of metadata values.
+- tagColors ( object ) Key-value pairs of tags and their named colors.
+
+## Creation Example
+
+```javascript
+import { Story } from 'extwee';
+
+// Create a story.
+const example = new Story('Example');
+
+// Show story name
+console.log ( example.name );
+```
+
+**Note:** All properties have protections. Attempting to assign the wrong type will result in an error.
+
+## Passage Methods
+
+As collections of passages, each **Story** has multiple methods for accessing and mutating its data:
+
+- `addPassage(Passage)`: Adds a new passage to the collection. (In Twine, passage names must be unique. Extwee will produce a console warning and ignore any repeating names.)
+- `removePassageByName(string)`: Looks for an removes a passage based on its name. If the passage does not exist, nothing happens.
+- `getPassagesByTags(string)`: Returns an array of any passages containing a particular tag value.
+- `getPassageByName(string)`: Returns either `null`` or the named passage.
+- `size()`: Returns the number of passages in the collection.
+- `forEachPassage(callback)`: Allows for iterating over the passage collection.
+
+## Passage Creation Example
+
+```javascript
+import { Story, Passage } from 'extwee';
+
+// Create the story.
+const example = new Story( 'Example' );
+// Add a new passage.
+example.addPassage(new Passage( 'Test', 'Some Text') );
+
+// Confirm size change.
+// (Should produce 1).
+console.log ( example.size() );
+```
+
+**Note:** It is not possible to directly access and act on the *passages* property. All actions must take place through available methods.
+
+Like passages, each **Story** can generate multiple formats based on its data:
+
+- `toTwee()`: Convert the story, its properties, and all its passages into Twee 3.
+- `toJSON()`: Converts the story, its properties, and all its passages into Twine 2 JSON.
+- `toTwine1HTML()`: Converts the story, its properties, and all its passages into Twine 1 HTML.
+- `toTwine2HTML()`: Converts the story, its properties, and all its passages into Twine 2 HTML.
+
+**Note:** While stories can create different representations of its data, most conversions are considered partial without the corresponding story format to create the playable form.

package/docs/objects/storyformat.md

@@ -0,0 +1,27 @@
+# Story Format
+
+For a story to be playable in Twine, it must be combined with a *story format*.
+
+In Twine 1, story formats can exist across multiple files:
+
+- `engine.js`: "engine" as included from Twine 1.
+- `header.html`: HTML "header" the Twine 1 HTML will be added into to create published file.
+- `code.js`: While technically optional, most story formats include extra code found in a `code.js` file.
+
+In Twine 2, story formats are single files generally named `format.js`. These are [JSONP files](https://en.wikipedia.org/wiki/JSONP) with JSON data of the story format included within a function call payload.
+
+## Properties
+
+When working with Twine 2 story formats, the associated `parse()` function call be used to create a **StoryFormat** object with the following properties:
+
+- name ( string ) Name of the story format.
+- version ( string ) Semantic version.
+- author ( string ) Author of the story format.
+- description ( string ) Summary of the story format.
+- image ( string ) URL of an image (ideally SVG) acting as its icon in Twine.
+- url ( string ) URL of the directory containing the `format.js` file.
+- license ( string ) License acronym and sometimes version.
+- proofing ( boolean ) (defaults to false). True if the story format is a "proofing" format.
+- source ( string ) Full HTML output of the story format including the two placeholders {{STORY_NAME}} and {{STORY_DATA}}. (The placeholders are not themselves required.)
+
+**Note:** Generally, even when using the Extwee API, it is rare to work with story formats beyond parsing them as part of Twine 1 or Twine 2 HTML compilation.

package/index.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Document</title>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+  <meta name="description" content="Description">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0">
+  <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/docsify@4/lib/themes/vue.css">
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    window.$docsify = {
+      name: '',
+      repo: ''
+    }
+  </script>
+  <!-- Docsify v4 -->
+  <script src="//cdn.jsdelivr.net/npm/docsify@4"></script>
+</body>
+</html>