Obsidian Portal - Campaign websites for Dungeons and Dragons and other tabletop RPGs

Wraith-Shadow (Fumbral)

Author: neqis

Slug: mll_shadow

Type: GameCharacter

System: World of Darkness

DST Source Code

Note: This is the latest, unapproved DST code. Only the DST author can use an unapproved DST, and even then only they can see it. If it's a new DST, then it's invisible to everyone else. If modifying a previously approved DST, then everyone else uses the most recent approved version.

HTML Template

		<div class="mll_sheet mll_owod mll_wraith mll_shadow" data-version="1">
			<span class="dsf_mll_data_version readonly hidden"></span>
			<template class="item">
				<li><label class="tipped"><span class="dsf dsf_dyn_{base}_{i:02}_name"></span><span class="dsf dsf_dyn_{base}_{i:02}_notes notes tip"></span></label><span class="dsf dsf_dyn_{base}_{i:02}"></span></li>
			</template>

			<ul class="tabs">
				<li class="stats">Stats</li>
				<li class="bio">Bio</li>
				<li class="help">Help</li>
			</ul>

			<div class="page stats">
				<section class="basic">
					<h2>Shadow</h2>
					<span class="dsf dsf_avatar_image"></span>
					<dl>
						<dt><label>Psyche</label></dt>
						<dd><span class="dsf dsf_psyche"></span></dd>

						<dt class="editonly"><label>Psyche slug</label></dt>
						<dd class="editonly"><span class="dsf dsf_psyche_slug editonly"></span></dd>
						
						<dt><label>Archetype</label></dt>
						<dd><span class="dsf dsf_archetype"></span></dd>

						<dt>Shadowguide Player</dt>
						<dd><span class="dsf dsf_player readonly"></span></dd>

						<dt>Chronicle</dt>
						<dd><span class="dsf dsf_campaign readonly"></span></dd>
					</dl>
				</section>
				
				<section class="advantages">
					<h3>Advantages</h3>
					<section class="thorns">
						<h3>Thorns</h3>
						
						<template class="item">
							<li>
								<span class="tipped">
									<span class="dsf dsf_dyn_thorns_{i:02}"></span>
									<span class="dsf dsf_dyn_thorns_{i:02}_notes notes tip"></span>
								</span>
							</li>
						</template>
						
						<ul class="udf nopips">
						</ul>
					</section>

					<section class="darkPassions">
						<h3>Dark Passions</h3>
						<ul class="udf pips">
						</ul>
					</section>
				</section>

				<section class="attributes">
					<h3>Attributes</h3>
					<div>
						<ul class="udf pips">
						</ul>
					</div>
				</section>

				<section class="assets">
					<h3>Assets</h3>
					<section>
						<div>
							<h4><label>Angst</label></h4>
							<span class="angst dsf dsf_perm_angst perm pips" data-pips="10"></span>
							<span class="angst dsf dsf_curr_angst current pips" data-pips="10"></span>
						</div>

						<div>
							<h4>Psyche Willpower</h4>
							<span class="willpower dsf dsf_perm_willpower perm pips" data-pips="10"></span>
						</div>
					</section>

					<section>
						<div>
							<h4><label>Experience</label></h4>
							<span class="dsf dsf_experience"></span>
						</div>
					</section>
				</section>

			</div>
			
			<div class="page bio">
				<section>
					<h4>Shadowlife</h4>
					<div><span class="dsf dsf_bio readonly"></span></div>
				</section>
			</div>
			
			<div class="page help">
				<dl>
					<dt>Pips</dt>
					<dd><p>To clear pips, click the <span class="control clear"></span> box.</p></dd>

					<dt>Permanent & Current Traits</dt>
					<dd>
						<p>While "permanent" values for traits can only be changed when editing the sheet, some traits also have a current value, indicated with square pips. These can be changed without editing the sheet, but the changes are only available locally, and not in other browsers or on other devices. Clearing local storage (either manually or because of security settings) will discard these changes. Editing the sheet where the changes are accessible will incorporate the changed value into what's stored for the sheet, making the change accessible in other browsers & on other platforms.</p>

						<p>Permanent values set an upper bound for current values, but this is not enforced by the sheet. You can set the current value past the permanent value. The maximum is indicated by shading of the pips for the current value beyond the maximum.</p>
					</dd>

					<dt>Dynamic lists</dt>
					<dd>
						<p>Some sections allow you to add your own items; click <button class="control button add"></button> to add an item. <button class="control button del"></button> will delete an item. Items can be moved within a list by dragging them, or by clicking <span class="control button drag" title="drag"></span> and then clicking another item; the first item will then be inserted at the position of the clicked item. Tap the "esc" key to cancel moves; clicking the item to move will also effectively cancel the move (as it's already in that position).</p>

						<p>Lists are limited (somewhat arbitrarily) to a maximum of 99 items each.</p>
					</dd>

					<dt>Undo & Redo</dt>
					<dd>
						<p>A history is kept of some edits, so they can be undone & redone. The undo and redo key commands are "<kbd>control</kbd>-<kbd>z</kbd>" and "<kbd>shift</kbd>-<kbd>control</kbd>-<kbd>Z</kbd>" (or "<kbd>control</kbd>-<kbd>y</kbd>"), respectively. On a Mac, "<kbd>⌘</kbd><kbd>z</kbd>" and "<kbd>⌘</kbd><kbd>y</kbd>" will also work, but "<kbd>⌘</kbd><kbd>⇧</kbd><kbd>Z</kbd>" cannot (the browser won't passed it to the sheet script).</p>

						<p>This feature is brittle; use with caution.</p>
					</dd>
				</dl>
			</div>
			<div>Sheet by <span class="dsf dsf_dst_author"></span></div>
		</div>

CSS

/*****
 * Inspired in part by:
 * + nWoD RELOADED!, by Jp12x
 * + Old World of Darkness Generic, by Monstah
 *	 + Changeling the Dreaming CS, by Takissis
 *****/

/** material.css */
/**
 * Layout and behavioral styling for function.
 */

/** site & browser style overrides */

.mll_sheet ul {
	list-style-type: none;
}

.mll_sheet ul,
.mll_sheet li {
	padding: 0;
	margin: 0;
}

.mll_sheet label,
.mll_sheet li label {
	display: inline-block;
	cursor: default;
}

/** general */

.mll_sheet template,
.mll_sheet .compatibility,
.mll_sheet .hidden {
	display: none;
}

.mll_sheet .dsf form {
	display: inline-block;
}

.mll_sheet .tip .dsf form,
.mll_sheet .tip.dsf form {
	width: 100%;
}


/** Tabs */

.mll_sheet .tabs li {
	position: relative;
	display: inline-block;
	cursor: pointer;
}

.mll_sheet .tabs .selected {
	z-index: 5;
}



/** Alerts */
.mll_sheet .alerts {
	position: fixed;
	bottom: 0;
	left: 0;
	right: 0;
}

.mll_sheet .alert {
	display: block;
	box-sizing: border-box;
	opacity: 1;
	transition: opacity 3s ease-in-out;
}

.mll_sheet .alert .close::before {
	cursor: pointer;
	content: "⊗";
}

/** highlighting */
.mll_sheet .highlight {
	position: relative;
}

.mll_sheet .highlight::after {
	content: "";
	position: absolute;
	top: 0;
	right: 0;
	bottom: -2px;
	left: 0;
}

/** Effects */

.mll_sheet .immediate,
.mll_sheet .highlight.immediate::after {
	transition: none !important;
}

.mll_sheet .highlight::after,
.mll_sheet .fade-out:not(.highlight) {
	opacity: 1;
	transition: opacity 2s ease-in-out;
}

.mll_sheet .highlight.faded-out::after,
.mll_sheet .faded-out:not(.highlight) {
	opacity: 0;
}

.mll_sheet .wipe {
	box-sizing: border-box ! important;
	transition-property: margin, padding, height;
	transition-duration: 0.5s;
	transition-timing-function: ease-in-out;
}

.mll_sheet .wiped {
	box-sizing: border-box ! important;
	height: 0 ! important;
	margin: 0 ! important;
	padding: 0 ! important;
}

/** sheet */

/** general sections */

/** specific sections */
.mll_sheet .attributes .pips {
	vertical-align: top;
}
.mll_sheet .attributes .pips > span {
	vertical-align: top;
}


.mll_sheet .page > section > .dsf_bio.editing {
	width: 100%;
}

/** UDFs */
.mll_sheet .controls {
	display: none;
}

.mll_sheet .controls > button,
.mll_sheet .controls > span,
.mll_sheet .help .button,
.mll_sheet .help button {
	display: inline-block;
	cursor: default;
}


.mll_sheet .controls > button,
.mll_sheet .controls > span {
	cursor: pointer;
}

.editable .mll_sheet .controls {
	display: unset;
}

/** Tooltips */

.mll_sheet .tipped {
	position: relative;
}

.mll_sheet .tipped:hover {
	z-index: 1;
}

.mll_sheet .tip {
	display: none;
	position: absolute;
	top: 99%;
	left: 1rem;
	z-index: 1;
}


.mll_sheet .tipped:hover .tip:not(:empty),
.mll_sheet .tipped:hover+.tip:not(:empty),
.mll_sheet .tipped .tip:not(:empty):hover,
.mll_sheet .tipped+.tip:not(:empty):hover,
.editable .mll_sheet .tipped:hover .tip,
.editable .mll_sheet .tipped:hover+.tip,
.editable .mll_sheet .tipped .tip:hover,
.editable .mll_sheet .tipped+.tip:hover {
	display: block;
}

/** Playing */
.mll_sheet .dsf:empty.readonly:not(.hidden)::before {
	/* clear "Click to Edit" placeholder */
	content: " ";
	display: inline-block;
	height: 1em;
}

/** Editing */

.mll_sheet .editonly {
	display: none;
}

.editable .mll_sheet .editonly {
	display: unset;
}

.editable .mll_sheet .dsf:empty:not(.readonly)::before,
.editable .mll_sheet .dsf:empty.custedit::before {
	content: "Click to edit";
}

.mll_sheet input.checkbox.dsf::before,
.mll_sheet input[type="checkbox"].dsf::before {
	content: ""	 !important /* edit marker selector above is more specific (has more classes), so overrides this ruleset without the !important */;
}

/** Pips */

.mll_sheet .pips {
	width: min-content;
}

.mll_sheet .dsf.pips.perm {
	display: block;
}

/*.editable .mll_sheet .pips::before,*/
.mll_sheet .pips > span {
	display: inline-block;
	border-radius: 1em; /* as long as it's > 50% of height */
	width: 13px;
	height: 13px;
}

.editable .mll_sheet .pips > span,
.mll_sheet .pips.current > span {
	position: relative;
	cursor: pointer;
}

.unowned .mll_sheet .pips.current > span {
	cursor: default;
}

.editable .mll_sheet .help .pips > span,
.mll_sheet .help .pips.current > span {
	cursor: unset;
	line-height: 1.1;
}

.mll_sheet .pips.demi > span,
.mll_sheet .demi .pips > span {
	width: 7px;
}

.mll_sheet .pips.demi > span:nth-child(2n),
.mll_sheet .demi .pips > span:nth-child(2n) {
	border-top-right-radius: 0;
	border-bottom-right-radius: 0;
	border-right: 0;
	margin-right: 0;
}

.mll_sheet .pips.demi > span:nth-child(2n+1),
.mll_sheet .demi .pips > span:nth-child(2n+1) {
	border-top-left-radius: 0;
	border-bottom-left-radius: 0;
	/* overrides border for clear box */
	/*border-left: 0;*/
	margin-left: 0;
}


/*.editable .mll_sheet .pips::before,*/
.mll_sheet .pips > span:first-child,
.mll_sheet .demi .pips > span:first-child,
.mll_sheet .help .clear {
	display: none;

	/*vertical-align: top;*/
	border-radius: 0;
	position: relative;
	width: 13px;
	height: 13px;
}


.mll_sheet .pips.perm > span:first-child {
	/* to align permanent & temp pips */
	display: inline-block;
	visibility: hidden;
}

.editable .mll_sheet .perm .pips > span:first-child {
	visibility: visible;
}


/* clear box */
.mll_sheet .pips > span:first-child::before,
.mll_sheet .help .control.clear::before {
	content: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA0AAAANCAQAAADY4iz3AAAAMUlEQVQY032OsQ0AAAjC+P/pujlBHUxMIyUhffjVQIOsgxXBEq9SDrAPLApzYHKsFQcIRxjoZIqTXQAAAABJRU5ErkJggg=="); /* 13px */
	line-height: 13px;
	position: absolute;
}

.editable .mll_sheet .pips > span:first-child,
.mll_sheet .pips.current > span:first-child,
.mll_sheet .help .control.clear {
	display: inline-block;
	visibility: visible;
}

.mll_sheet .help .control.clear {
	vertical-align: baseline;
}

/** theme.css */
/**
 * Purely for show.
 */


/** site & browser style overrides */

.mll_sheet,
.mll_sheet ul,
.mll_sheet ol,
.mll_sheet dl {
	line-height: 1.1;
	margin-bottom: 0;
}

.mll_sheet dt {
	font-weight: normal;
}

.mll_sheet dd {
	padding: 0;
	margin: 0;
}

.mll_sheet table,
.mll_sheet table thead,
.mll_sheet table tfoot {
	background-color: unset;
}

.mll_sheet table tr.even,
.mll_sheet table tr.alt,
.mll_sheet table tr:nth-of-type(2n) {
	background-color: #9995;
}

.mll_sheet li label {
	min-width: 6em;
}

.mll_sheet label {
	color: black;
	font-size: 1em;
}

.mll_sheet .page > section > section {
	background-color: unset;
}

.mll_sheet section > h2:first-child,
.mll_sheet section > h3:first-child {
	margin-top: 0;
	margin-bottom: 0.5em;
}


/** general */

.mll_sheet h4 {
	margin-bottom: 0.5em;
}

.mll_sheet label + span {
	margin-left: 0.5em;
}

.mll_sheet .notes ul,
.mll_sheet .notes ul li {
	list-style-type: initial;
	list-style-position: outside;
}

.mll_sheet .notes ul,
.mll_sheet .notes ol {
	padding-left: 1.1em;
}
.mll_sheet .notes li {
}


/** Tabs */
.mll_sheet .tabs {
	border-bottom: 1px solid black;
	text-align: right;
}

.mll_sheet .tabs li {
	border: 1px solid black;
	border-bottom: 0px;
	border-radius: 3px 3px 0 0;
	padding: 0.25em 0.75em;
	margin: 0 -0.25em;

	color: #444;
	background-color: #AAA;
}

.mll_sheet .tabs li:hover:not(.selected) {
	background-color: #CCC;
}

.mll_sheet .tabs li:last-child {
	margin-right: 0;
}

.mll_sheet .tabs .selected {
	background-color: white;
	color: black;

	border-bottom: 1px solid white;
	margin-bottom: -1px;
	/*
	position: relative;
	bottom: -1px;
   */
	padding-top: 0.5em;
}

/** Alert */
.mll_sheet .alert {
	margin: 1em;
	border: 1px solid white;
	border-radius: 3px;
	padding: 0.25em;
	background-color: #AAA;
	color: white;

	min-width: 15em;
	max-width: 50%;
}

.mll_sheet .alert .close::before {
	font-size: 1.25rem;
}

.mll_sheet .alert .close:first-child::before {
	margin-right: 1em;
}
.mll_sheet .alert .close:last-child::before {
	margin-left: 1em;
}

/** */
.mll_sheet .highlight::after {
	box-shadow: 0px 0px 5px #800;
	border-radius: 3px;
}

/** Effects */

/** sheet */

.mll_sheet .page.stats > section {
	display: grid;
	grid-template-columns: 1fr 1fr 1fr;
}

@media screen and (max-width:900px) {
	.mll_sheet .page.stats > section.assets {
		grid-template-columns: 1fr 1fr;
	}
}

.mll_sheet .page.bio > .associates .udf label.type {
	min-width: 4em;
	background-color: #DDD;
	padding: 0.1em;
}

.mll_sheet .page.stats > section.advantages,
.mll_sheet .page.bio > section.associates,
.mll_shadow .page.stats > section {
	grid-template-columns: 1fr 1fr;
}

.mll_shadow .page.stats > .attributes {
	display: block;
}




.mll_sheet .page.stats > section.basic {
	display: block;
	position: relative;
	overflow: auto;
}

/** general sections */
.mll_sheet .page > section {
	clear: both;
	overflow: visible;
	padding: 0;
}

.mll_sheet .page > section::after {
	content: "";
	clear: both;
	display: block;
}

.mll_sheet .page > section:nth-of-type(2n+1) {
	background: radial-gradient(circle at 105% 95%, black 0%, #888 10%, white 100%);
}

.mll_sheet .page > section:nth-of-type(2n) {
	background: radial-gradient(circle at -5% 95%, black 0%, #888 10%, white 100%);
}

.character-show .main-content .mll_sheet section {
	margin-top: 1em;
	/* solid line all the way to left side */
	/*border-top: 2px solid black;*/
}

.mll_sheet section > section {
	display: inline-block;
	border-top: 0;
	margin-top: 0;
	background-color: transparent;
}

.mll_sheet .page > section > h2,
.mll_sheet .page > section > h3 {
	grid-column: 1 / -1;
	grid-row: 1;

	position: relative;
	

	padding-left: 1em;
	padding-top: 0.25em;
	/* hollow on left side */
	border-top: 2px solid black;
	border-left: 3px double black;
	border-bottom: 3px solid transparent;
}

.mll_sheet .equipment {
	grid-column: 1 / -1;
}




.mll_sheet h4:first-child {
	margin-top: 0px;
}




.mll_sheet .page > section > section,
.mll_sheet .page > section > div {
	display: inline-block;
	vertical-align: top;
	/* width: 45%; */
	padding: 0.5em 0.25em;
	/* leave space for clear-box*/
	/*
	padding-left: 16px;
   */
}




.mll_sheet section > section > div {
	display: block;
}

.mll_sheet dt {
	float: left;
	clear: left;
	min-width: 5em;
	margin-right: 0.5em;
	margin-bottom: 0;
	/*margin-right: 1em;*/
}

.mll_sheet .help dt {
	float: none;
	margin-left: 1em;
	font-size: 1.2em;
}

.mll_sheet dt label {
	display: inline-block;
	margin-bottom: 0;
}


/** specific sections */

.mll_sheet .basic {
	text-align: right;
}

.mll_sheet .basic > * {
	text-align: left;
}

.mll_sheet .basic h2 {
	/*float: left;*/
}

/* `.page` is needed for specificity */
.mll_sheet .page .basic > div {
	min-width: 20em;
	width: auto;
}

.mll_sheet .basic dl {
	margin-top: 0;
	clear: left;
}

.mll_sheet .basic dt {
	margin: 0 0.5em 0 0;
	background-color: #DDD;
	padding: 0.2em;
}
.mll_sheet .basic dt::after {
	content: ":";
}
.mll_sheet .basic dd {
	padding: 0.2em;
	min-height: 1em;
	/*outline: 1px solid grey;*/
}
.mll_sheet .basic dd > :first-child {
	border-bottom: 1px solid #AAA;
}
.mll_sheet.mll_shadow .basic dd > :first-child {
	border-bottom: 0;
}

.mll_sheet .attributes dt {
	line-height: 1;
}

.mll_sheet .physical dt {
	min-width: 6em;
}

.mll_sheet .social dt {
	min-width: 7em;
}

.mll_sheet .mental dt {
	min-width: 6em;
}






.mll_sheet .advantages .backgrounds .tipped .hint::before {
	content: "(";
}

.mll_sheet .advantages .backgrounds .tipped .hint::after {
	content: ")";
}

.mll_sheet .equipment table {
	width: auto;
}

.mll_sheet .equipment td {
	padding: 0.25em;
}


.mll_sheet .associates dt {
	float: none;
}

.mll_sheet .associates dd,
.mll_sheet .associates div.notes {
	margin: 0.15em 1em 0.35em;
}

.mll_sheet .associates .item {
	padding: 0.25em 0;
}

.mll_sheet .page.bio .biodata,
.mll_sheet .page.bio .biography .stats {
	float: right;
	margin: 1em;
	border: 1px solid black;
	background-color: #AAA8;
	width: 30%;
}

.mll_sheet .page.bio .biodata dt,
.mll_sheet .page.bio .biography .stats dt {
	margin-right: 1em;
}

/** Fields */
.mll_sheet .dsf blockquote,
.mll_sheet .dsf blockquote p {
	color: #600;
}

.mll_sheet .dsf.specialty {
	font-size: 0.75em;
}




.mll_sheet .page > section > .dsf_bio {
	padding: 1em;
	display: block;
}

.mll_sheet .dsf_bio textarea {
	display: block;
	width: 95%;
	min-height: 20em;
}

.mll_sheet .dsf_avatar_image {
	float: left;
	margin: 1em 2em;
	max-width: 30%;
	position: relative;
}

.mll_sheet .page.bio .dsf_avatar_image {
	max-width: 60%;
}

.mll_sheet .dsf_avatar_image img {
	float: left;
	max-width: 100%;
	box-shadow: -3px -3px 15px -5px #260000;
}

.mll_sheet .dsf_avatar_image::after {
	content: "";
	z-index: 1;
	position: absolute;
	top: 0;
	bottom: 0;
	left: 0;
	right: 0;
	box-shadow: 3px 3px 30px black inset;
}


.mll_sheet.mll_shadow .dsf_avatar_image {
	float: right;
	margin-top: -2em;
}

.mll_sheet.mll_shadow .dsf_avatar_image img,
.mll_sheet .mll_shadow .dsf_avatar_image img {
	box-shadow: 3px -3px 15px -5px #260000;
}

.mll_sheet.mll_shadow .dsf_avatar_image::after,
.mll_sheet .mll_shadow .dsf_avatar_image::after {
	box-shadow: -3px 3px 30px black inset;
}

.mll_sheet h3.dsf_tagline {
	text-align: center;
}


/** UDFs */
.mll_sheet span.controls {
	margin-left: 0.5em;
	vertical-align: middle;
}

.mll_sheet td span.controls {
	margin-left: 0;
}

.mll_sheet .pips + .controls {
	margin-left: 0;
}

.mll_sheet .dsf form button {
	margin-bottom: 0;
}

.mll_sheet .controls > button,
.mll_sheet .controls > span,
.mll_sheet .help .button,
.mll_sheet .help button {
	background: white;
	color: black;
	font-size: 0.75em;
	text-align: center;
	vertical-align: middle;

	line-height: initial;

	height: 1.5em;
	width: 1.5em;
	padding: 0;
	border: 1px solid black;
	border-radius: 3px;
	margin: 0 1px;
}

.mll_sheet .swapping {
	outline: 1px solid #800;
}
.mll_sheet .swapping .drag {
	background-color: #DDD;
}


.mll_shadow .attributes .udf {
	display: grid;
	grid-template-columns: 1fr 1fr 1fr;
}
.mll_shadow .attributes .udf li {
	padding: 0.1em 0.5em;
	border-right: 1px solid black;
}
.mll_shadow .attributes .udf li:last-child,
.mll_shadow .attributes .udf li:nth-child(3n) {
	border-right: 0;
}

/** Tooltips */

/*.mll_sheet .tipped:has(> .tip:not(:empty))::after,*/
.mll_sheet .tipped.mark::after {
	content: "…";
	font-size: 0.5em;
	border: 1px solid black;
	border-radius: 50%;
	padding: 0 0.1em;
	opacity: 0.35;
	position: absolute;
	top: -30%;
}

.mll_sheet .tip {
	white-space: nowrap;
	background-color: #CCCD;
	border: 1px solid #222;
	padding: 0.5em;
}

.mll_sheet .page h4.tipped .tip {
	font-size: 80%;
}

.mll_sheet :not(h4).tipped:not(.notip) {
	box-shadow: 0px 0px 4px -1px inset #4008;
}
.mll_sheet .tipped:not(.notip):hover {
	box-shadow: 0 0 4px #100C inset;
}

.mll_sheet .tipped::after {
	font-size: 60%;
	vertical-align: top;
}

.mll_sheet h4.tipped::after {
	content: " ⓘ";
}

/* TODO: find a way to keep tipped marker while highlighting */
.mll_sheet h4.tipped.highlight::after,
.mll_sheet h4.tipped.notip::after {
	content: "";
}




/** Playing */

/** Editing */

.editable .mll_sheet .abilities label {
	font-size: 80%;
}

.editable .mll_sheet .abilities .pips {
	margin-left: 0;
}

.editable .mll_sheet .dsf.custedit textarea {
	min-height: 5em;
	/* width: 90%; */
}

.editable .mll_sheet .dsf.custedit.tip textarea {
	width: 95%;
}

.editable .mll_sheet .dsf.notes.custedit.editing {
	min-width: 20em;
}




.mll_sheet .dsf:content("Click to edit") {
	text-decoration: 1px dotted underline;
}

.mll_sheet .dsf:empty:not(.readonly)::before,
.mll_sheet .dsf:empty.custedit::before,
.editable .mll_sheet .dsf:not(.readonly):not(select),
.editable .mll_sheet .dsf.custedit {
	text-decoration: 1px dotted underline;
}

.editable .mll_sheet select.dsf {
	text-decoration: none;
}


.mll_sheet .specialty input {
	min-width: 5em ! important;
}
.mll_sheet .dsf .jeditable_input {
	margin-bottom: 0;
	height: auto !important;
}

.mll_sheet option.section {
	text-indent: 0;
}

.mll_sheet option.subsection {
	text-indent: 2em;
}


/** Pips */

.mll_sheet .pips {
	/*display: inline-block;*/
	white-space: nowrap;
	vertical-align: middle;
	/* space for 0-pip */
	/*padding-left: 4px;*/
	margin-left: 2px;
}

.mll_sheet .help .pips {
	white-space: normal;
	vertical-align: top;
	margin-left: 0;
}

/*.editable .mll_sheet .pips::before,*/
.mll_sheet .pips > span {
	margin: 2px;
	border: 1px solid black;
	vertical-align: middle;
	background: white;
}

.mll_sheet .help .pips.current > span {
	border-style: solid;
}


/*.editable .mll_sheet .pips::before,*/
.mll_sheet .pips > span:first-child,
.mll_sheet .demi .pips > span:first-child,
.mll_sheet .help .clear {
	border-width: 1px;
	border-style: dotted;
}


/* clear box */

/* filled pip */
.mll_sheet .pips > span.X {
	background-color: black;
}

/* blocked pip */
.mll_sheet .pips > span.D {
	background-color: #CCC;
}

.mll_sheet .pips > span.X.D {
	background-color: #449;
}

.mll_sheet .pips.current.health > span:not(:first-child)::before,
.mll_sheet .pips.health > span.B::before,
.mll_sheet .pips.health > span.L::before,
.mll_sheet .pips.health > span.A::before {
	font-size: 0.75em;
	position: relative;
	vertical-align: top;
}

.mll_sheet .pips.health > span.B::before,
.mll_sheet .pips.current.health > span:not(.X):not(.L):not(.A):not(:first-child)::before,
.mll_sheet .help .pips > span:first-child::before {
	content: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA0AAAANCAQAAADY4iz3AAAAEUlEQVQY02NgIBn8H5UgGgAAf0MK9sDfEOAAAAAASUVORK5CYII="); /* short, 12px */
}

.mll_sheet .pips.health > span.L::before {
	content: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA0AAAANCAQAAADY4iz3AAAALklEQVQY042QyQ0AMAjDvP/S7gJgmmcOIwEpy7PKFsXA4xZwBdbCQlk3/PrGqAdO1hTs8Xx4NQAAAABJRU5ErkJggg=="); /* short, 13px */
}

.mll_sheet .pips.health > span.A::before {
	content: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA0AAAANCAQAAADY4iz3AAAAfklEQVQY02NgIBIsYRBBF+JgsEKS4mUwQ0ixM6xn8IRK8TJsZTBH1sfOsJHBAyilwLCBwRDT0E0MNxh2MuggC3YxfGd4z/Cc4RnDfySIBJgZ5gB17WLQRTeOlWEx2C5FoLEodrExrGTwgrqQj2EbgylCihPFX3wMFkSFBlYAADIRHZJs6rnyAAAAAElFTkSuQmCC"); /* 8-pt, 13px */
}

/*  */
.mll_sheet .pips.current > span {
	border-radius: initial;
}

/** UDFS */
.mll_sheet .controls .add::before,
.mll_sheet .help .control.add::before {
	content: "+";
}

.mll_sheet .controls .del::before,
.mll_sheet .help .control.del::before {
	content: "–";
}

.mll_sheet .controls .drag::before,
.mll_sheet .help .control.drag::before {
	content: "⇅";
}

Javascript

(function ($) {
	var dbg = 1,
		$slug = $('.dst_slug'),
		slug = $slug.text(),
		globals = {},
		editMarker = 'Click to edit',
		containerId,
		pippedKinds = ['attributes', 'abilities', 'advantages', 'arcanoi'];



		let module = {
		modules: {},
		dependencies: {},
		handlers: {},
		_current: {},
		_done: {},
		_active: [],
		base: {
			init($context, slug) {
				this.$context = $context;
				this.slug = slug;
			},
			preLoad(opts, $context) {
				this.$context = $context;
				this.slug = opts.slug;
			},
			postLoad() {},
			change() {},
			preSave() {},
			tryTransact(fn, all=false) {
				if (modules.undo) {
					modules.undo.transact(fn, all);
				} else {
					return fn();
				}
			},
		},
		all(func, ...args) {
			if (this._current.func) {
				this._active.push({current: this._current, done: this._done});
			}
			let done = {},
				now = Object.keys(this.modules),
				later = [],
				errs = {};
			this._done[func] = done;
			this._current = { func };
			try {
			while (now.length) {
				for (let name of now) {
					try {
						if (this.delay(name, func, done)) {
							later.push(name);
						} else {
							done[name] = true;
							this._current.module = name;
							this.modules[name][func](...args);
							delete this._current.module;
						}
					} catch (err) {
						if (err.delay) {
							later.push(name);
							delete done[name];
						} else if (err.missing) {
							err.message = `Missing dependencies for ${name}.${func}: ${err.missing}.`;
							console.log(err.message);
							throw err;
						} else {
							console.log(`Error running ${name}.${func}: ${err.message}`);
							errs[name] = err;
						}
					}
				}
				if (now.length > later.length) {
					now = later;
					later = [];
				} else {
					let message = `Cyclic dependency with ${func}; have to skip ${now}.`;
					console.error(message);
					throw {
						message,
						skipped: now,
					};
				}
			}
			} finally {
				if (this._active.length) {
					const {current, done} = this._active.pop();
					this._current = current;
					this._done = done;
				} else {
					this._current = {};
				}
			}
			this.fire(func, args);
			switch (Object.keys(errs).length) {
			case 0:
				break;
			case 1:
				throw Object.values(errs)[0];
			default:
				throw errs;
			}
		},
		delay(dependent, event, done) {
			let dependencies = this.dependencies[event] || {};
			if (dependent in dependencies) {
				return dependencies[dependent].some(m => ! (m in done));
			}
			return false;
		},
		fire(func, args=[]) {
			let errs = {},
				previous;
			if (this._current.func) {
				previous = this._current.func;
			}
			this._current = { func };
			if (func in this.handlers) {
				for (let id in this.handlers[func]) {
					try {
						this.handlers[func][id](...args);
					} catch (err) {
						errs[id] = err;
					}
				}
			}
			if (previous) {
				this._current = {func: previous};
			} else {
				this._current = {};
			}
			switch (Object.keys(errs).length) {
			case 0:
				break;
			case 1:
				throw Object.values(errs)[0];
			default:
				throw errs;
			}
		},
		loaded(module) {
			return module in this.modules;
		},
		on(event, handler, id) {
			if (is_string(handler)) {
				[handler, id] = [id, handler];
			}
			if (! id) {
				id = handler.toString();
			}
			if (! (event in this.handlers)) {
				this.handlers[event] = {};
			}
			this.handlers[event][id] = handler;
			return id;
		},
		off(event, id) {
			if (event in this.handlers) {
				delete this.handlers[event][id];
			}
		},
		register(name, mod) {
			this.modules[name] = mod;
			mod.__name = name;
			mixIn(mod, this.base);
		},
		registerDependency(dependent, event, principles) {
			if (! (event in this.dependencies)) {
				this.dependencies[event] = {};
			}
			this.dependencies[event][dependent] = principles;
		},
		tarryFor(...names) {
			let missing = names.filter(name => ! (name in this.modules));
			if (missing.length) {
				console.info(`Ignoring missing requirements for ${this._current.module}.${this._current.func}: ${missing}.`);
			}
			if (names.some(name => name in this.modules && ! (name in this._done[this._current.func]))) {
				throw {delay: true, 'for': names};
			}
		},
		waitFor(...names) {
			let missing = names.filter(name => ! (name in this.modules));
			if (missing.length) {
				throw {missing, message: `Missing dependencies: ${missing}`};
			}
			if (names.some(name => ! (name in this._done[this._current.func]))) {
				throw {delay: true, 'for': names};
			}
		},
	};
	module.loaded = module.loaded.bind(module);
	const {breakString, halveString} = (function () {
		function breaker(string, sep, matcher, opts={include:1}) {
			let i = matcher(string, sep),
				parts = [string];
			if (i) {
				parts[0] = string.substring(0, i.index);
				parts.push(...i.match.slice(opts.include).filter(x => x));
				parts.push(string.substring(i.index + i.length));
				parts.groups = i.match.groups;
			}
			return parts;
		}
		function matchRegex(string, sep) {
			let match = string.match(sep);
			if (match) {
				return {
					index: match.index,
					length: match[0].length,
					match,
				};
			}
		}
		function matchString(string, sep) {
			let index = string.indexOf(sep);
			if (index > -1) {
				return {index, length: sep.length, match:[sep]};
			}
		}
		function chooseMatcher(sep) {
			if (sep instanceof RegExp) {
				return matchRegex;
			} else {
				return matchString;
			}
		}
		function breakString(string, sep, opts={}) {
			let {limit, include=1} = opts,
				nParts = 1; 
			if ('number' === typeof(opts)) {
				limit = opts;
			} else if ('boolean' === typeof(opts)) {
				include = opts;
			}
			if ('boolean' === typeof(include)) {
				include = include ? (sep instanceof RegExp) : Infinity;
			}
			let all = (is_undefined(limit)),
				parts = [string],
				halves, matcher;
			matcher = chooseMatcher(sep);
			parts.groups = [];
			while (all || (nParts < limit)) {
				halves = breaker(parts[parts.length-1], sep, matcher, {include});
				if (halves.groups) {
					parts.groups[nParts-1] = halves.groups;
				}
				++nParts; 
				if (halves.length < 2) {
					break;
				}
				parts.splice(-1, 1, ...halves);
			}
			return parts;
		}
		globals.breakString = breakString;
		function halveString(string, sep, opts={include:1}) {
			let matcher = chooseMatcher(sep);
			opts.include || (opts.include = 1);
			return breaker(string, sep, matcher, opts);
		}
		globals.halveString = halveString;
		return {breakString, halveString};
	})();
	function applyAllFunctions(funcs, args) {
		return funcs.map(f => f(...args)).filter(r => ! is_undefined(r));
	}
	function applyForAll(obj, keys, func, args=[], {related=false}={}) {
		let results = [],
			exceptions = Object.defineProperties(
				{}, {
					length: {
						value: 0,
						writable: true,
					},
					results: {
						value: results,
					},
				});
		for (let key of keys) {
			if (is_function(obj[key][func])) {
				try {
					results[key] = obj[key][func](...args);
					results.push(results[key]);
				} catch (err) {
					if (related) {
						err.for = key;
						err.results = results;
						throw err;
					}
					results.push(undefined);
					exceptions[key] = err;
					++exceptions.length;
				}
			}
		}
		if (exceptions.length) {
			if (1 == exceptions.length) {
				throw Object.values(exceptions)[0];
			}
			throw exceptions;
		}
		return results;
	}
	function callAllFunctions(funcs, ...args) {
		return funcs.map(f => f(...args)).filter(r => ! is_undefined(r));
	}
	function callForAll(obj, keys, func, ...args) {
		return applyForAll(obj, keys, func, args);
	}
	function memoize(f) {
		var results = {};
		function _memoized(name, ...args) {
			if (! (name in results)) {
				results[name] = f.call(this, name, ...args);
			}
			return results[name];
		}
		_memoized.original = f;
		f.results = results;
		return _memoized;
	}
	function bindAll(obj, self) {
		bindSome(obj, Object.keys(obj || {}), self);
	}
	function bindSome(obj, methods, self) {
		self || (self = obj);
		for (let method of methods) {
			if (is_function(obj[method])) {
				obj[method] = obj[method].bind(self);
			}
		}
	}
	function copy(thing) {
		if (Array.isArray(thing)) {
			return [...thing]; 
		} else if (is_object(thing)) {
			return {...thing}; 
		}
		return thing;
	}
	globals.copy = copy;
	function copyAll(things) {
		return things.map(copy);
	}
	globals.copyAll = copyAll;
	function derefProperties(obj) {
		for (let [name, value] of Object.entries(obj || {})) {
			while (value in obj) {
				value = obj[name] = obj[value];
			}
		}
		return obj;
	}
	function fillObject(keys, value, target = {}) {
		if (! (keys instanceof Array || Array.isArray(keys))) {
			keys = Object.keys(keys);
		}
		for (let key of keys) {
			target[key] = value;
		}
		return target;
	}
	function filterObject(obj, pred) {
		const filtered = {};
		for (const [key, value] of Object.entries(obj)) {
			if (pred(value, key)) {
				filtered[key] = value;
			}
		}
		return filtered;
	}
	globals.filterObject = filterObject;
	function flipObject(obj) {
		const result = {};
		for (const [key, val] of Object.entries(obj)) {
			if (Array.isArray(val)) {
				for (let v of val) {
					mergeVal(result, v, key);
				}
			} else {
				mergeVal(result, val, key);
			}
		}
		return result;
	}
	function mapObject(obj, fn) {
		const result = {};
		for (let [key, value] of Object.entries(obj)) {
			let mapped = fn(value, key);
			if (is_object(mapped)) {
			} else if (Array.isArray(mapped)) {
				[key, value] = mapped;
				mapped = {[key]: value};
			} else {
				mapped = {[key]: mapped};
			}
			Object.assign(result, mapped);
		}
		return result;
	}
	function mergeObjects(dest, ...srcs) {
		for (let src of srcs) {
			for (let [k, v] of Object.entries(src)) {
				if (! (k in dest && dest[k])) {
					dest[k] = v;
				}
			}
		}
		return dest;
	}
	function mergeVal(obj, key, val) {
		if (key in obj) {
			if (Array.isArray(obj[key])) {
				obj[key].push(val);
			} else {
				obj[key] = [obj[key], val];
			}
		} else {
			obj[key] = val;
		}
	}
	function mixIn(dest, ...srcs) {
		for (let src of srcs) {
			for (let [k, v] of Object.entries(src)) {
				if (! (k in dest)) {
					dest[k] = v;
				}
			}
		}
		return dest;
	}
	function pickObject(obj, keys) {
		return Object.fromEntries(keys.map(k => [k, obj[k]]));
	}
	function zipObject(keys, values) {
		let result = {};
		for (let i = 0; i < keys.length; ++i) {
			result[keys[i]] = values[i];
		}
		return result;
	}
	function animationFrame() {
		return new Promise(resolve => {
			let reqId = requestAnimationFrame((...args) => {
				resolve(...args);
			});
		});
	}
	globals.animationFrame = animationFrame;
	function animationPost() {
		return new Promise(resolve => {
			requestAnimationFrame(() => {
				setTimeout(resolve, 0);
			});
		});
	}
	globals.animationPost = animationPost;
	function wait(time) {
		return new Promise(resolve => {
			setTimeout(resolve, time);
		});
	}
	globals.wait = wait;
	function waitOn(elt, name, selector, data) {
		let $elt = $(elt);
		return new Promise(resolve => {
			$elt.one(name, selector, data, resolve);
		});
	}
	globals.waitOn = waitOn;
	function is_flag(elt, value) {
		return elt.type == 'checkbox'
			|| /\bcheckbox\b/.test(elt.className)
			|| 'boolean' === typeof(value);
	}
	function is_function(value) {
		return 'function' === typeof(value);
	}
	function is_hex_rational(value) {
		return /^\s*(?:0x[\da-f]+|\d+)\s*\/\s*(?:0x[\da-f]+|\d+)\s*$/i.test(value);
	}
	function is_int(value) {
		return (value % 1) === 0;
	}
	function is_iterable(value) {
		return 'object' === typeof(value)
			&& 'function' === typeof(value.next);
	}
	function is_kind(kind, elt) {
		let $elt = $(elt);
		if (is_string(kind)) {
			return $elt.closest(`.${kind}`).length;
		} else {
			return kind.find(kind => $elt.closest(`.${kind}`).length);
		}
	}
	function is_numeric(value) {
		return 'number' === typeof(value)
			|| /^ *[-+]? *\d+(?:\.\d+)? *$/.test(value);
	}
	function is_object(value) {
		return 'object' === typeof(value)
			&& ! (value instanceof String)
			&& ! (Array.isArray(value));
	}
	function is_real(value) {
		return ! Number.isNaN(value) && is_numeric(value);
	}
	function is_rational(value) {
		return /^\s*\d+\s*\/\s*\d+\s*$/.test(value);
	}
	function is_string(value) {
		return 'string' === typeof(value)
			|| value instanceof String;
	}
	function is_undefined(value) {
		return 'undefined' === typeof(value);
	}
	function to_boolean(value) {
		if (is_object(value)) {
			return ! $.isEmptyObject(value);
		}
		if (Array.isArray(value)) {
			return !! value.length;
		}
		const literals = {
			'false': false,
			'off': false,
			'NaN': false,
			'0': false,
			'no': false,
		};
		if (value in literals) {
			return literals[value];
		}
		value = +value;
		return !!value || Number.isNaN(value);
	}
	function addPippedKinds(...kinds) {
		pippedKinds.push(...kinds);
	}
	function setPippedKinds(kinds) {
		pippedKinds = kinds;
	}
	function commonAncestor(a, b) {
		let range = new Range();
		range.setStart(a, 0);
		range.setEnd(b, 0);
		if (range.collapsed) {
			range.setStart(b, 0);
			range.setEnd(a, 0);
		}
		return range.commonAncestorContainer;
	}
	function decodeEntities(source) {
		let elt = document.createElement("TEXTAREA");
		elt.innerHTML = source;
		return elt.childNodes.length ? (elt.childNodes[0] || {}).nodeValue : "";
	}
	function nodeIndex(node) {
		return Array.prototype.indexOf.call(node.parentNode.children, node);
	}
	function retagElement(elt, tag) {
		const to = document.createElement(tag);
		for (let attr of elt.attributes) {
			to.setAttribute(attr.name, attr.value);
		}
		to.append(...elt.childNodes);
		elt.replaceWith(to);
		return to;
	}
	function stripBreaks(source) {
		return source.replace(/<(p)[^>]*\/?>/g, '').replace(/<(\/p|br)[^>]*\/?>\n+/g, "\n");
	}
	function stripHtml(source) {
		var doc = new DOMParser().parseFromString(source, "text/html");
		return doc.documentElement.textContent;
	}
	$.fn.closestHaving = function(sel, pred) {
		if (is_string(pred)) {
			let psel = pred;
			pred = (i, node) => node.querySelector(psel);
		}
		let $nodes = this,
			$candidates = {};
		for (;
			 $nodes.length && ! $candidates.length;
			 $nodes = $nodes.parent().closest(sel))
		{
			$candidates = $nodes.filter(pred);
		};
		return this.pushStack($candidates);
	};
	$.fn.waitOn = async function (name) {
		await waitOn(this, name);
	};
	if ($.event.fixHooks) {
		const toCopy = ['dataTransfer'];
		function copyEventProps(name, toCopy) {
			if ($.event.fixHooks[name]) {
				if ($.event.fixHooks[name].props) {
					let props = new Set($.event.fixHooks[name].props);
					for (let prop of toCopy) {
						props.add(prop);
					}
					$.event.fixHooks[name].props = [...props.values()];
				} else {
					$.event.fixHooks[name].props = toCopy;
				}
			} else {
				$.event.fixHooks[name] = {
    				props: toCopy,
				};
			}
		}
		copyEventProps('dragstart', toCopy);
		copyEventProps('dragenter', toCopy);
		copyEventProps('dragend', toCopy);
	}
	{ 
		const disabledHooks = {};
		$.disableHooks = function (category, name) {
			const hooks = category + 'Hooks'
			if ($[hooks] && $[hooks][name]) {
				disabledHooks[category] || (disabledHooks[category] = {});
				disabledHooks[category][name] = $[hooks][name];
				delete $[hooks][name];
			}
		}
		$.enableHooks = function(category, name) {
			const hooks = category + 'Hooks'
			if ($[hooks] && disabledHooks[category] && disabledHooks[category][name]) {
				$[hooks][name] = disabledHooks[category][name];
			}
		}
	}
	$.fn.closer = function(...sels) {
		let $nodes = this,
			matches = [];
		for (; $nodes.length && ! matches.length; $nodes = $nodes.parent()) {
			matches = sels.filter(sel => $nodes.filter(sel).length);
		};
		if (matches && matches.length < 2) {
			return matches[0];
		}
		return matches;
	};
	$.fn.findClosest = function (...sels) {
	};
	$.fn.hasEveryClass = function (...classes) {
		return classes.every(cls => this.hasClass(cls));
	};
	$.fn.hasSomeClass = function (...classes) {
		return classes.some(cls => this.hasClass(cls));
	};
	$.fn.redelegate = function(event, original, replacement) {
		for (let elt of this) {
			let handlers = ($._data(elt, 'events') || {})[event] || [];
			for (let handler of handlers) {
				if (original == handler.selector) {
					handler.selector = replacement;
				}
			}
		}
		return this;
	};
	if (! ('even' in $.fn)) {
		$.fn.even = function() {
			return this.pushStack( jQuery.grep( this, function( _elem, i ) {
				return ( i + 1 ) % 2;
			} ) );
		};
		$.fn.odd = function() {
			return this.pushStack( jQuery.grep( this, function( _elem, i ) {
				return i % 2;
			} ) );
		};
	}
	if (! (Symbol.iterator in $.fn)) {
		$.fn[Symbol.iterator] = function* () {
			for (let i = 0; i < this.length; ++i) {
				yield this[i];
			};
		};
	}
	if (! ('findLastIndex' in Array.prototype)) {
		Object.defineProperty(
			Array.prototype, 'findLastIndex', {
				value: function (fn, that) {
					if (that) {
						fn = fn.bind(that);
					}
					let i = this.length - 1;
					for (; i >= 0; --i) {
						if (fn(this[i], i, this)) {
							return i;
						}
					}
					return i;
				},
			});
	}
	if (! ('map' in Object.prototype)) {
		Object.defineProperties(Object.prototype, {
			map: {
				value: function (fn) {
					let result = Object.create(this);
					for (let p in this) {
						result[p] = fn(this[p]);
					}
					return result;
				},
			},
			mapKeys: {
				value: function (fn) {
					let result = Object.create(this);
					for (let p in this) {
						result[fn(p)] = this[p];
					}
					return result;
				},
			},
			mapEntries: {
				value: function (fn) {
					let result = Object.create(this),
						key, value;
					for (let p in this) {
						[key, value] = fn(p, this[p]);
						result[key] = value;
					}
					return result;
				}
			},
		});
	}
	if (! ('capitalize' in String.prototype)) {
		String.prototype.capitalize = function() {
			return this.charAt(0).toUpperCase() + this.substr(1).toLowerCase();
		};
		String.prototype.titleCase = function() {
			return this.replace(
					/\b(\w)(\w*)/g,
				function (_, a, b) {
					return a.toUpperCase() + b.toLowerCase();
				});
		};
		String.prototype.dromedaryCase = function ({spaces=true}={}) {
			let pattern;
			if (spaces) {
				pattern = /[-_ ]+([a-z])/ig; 
			} else {
				pattern = /[-_]+([a-z])/ig;
			}
			return this.replace(
					pattern,
				function (_, a) {
					return a.toUpperCase();
				}
			);
		};
		String.prototype.ucfirst = function() {
			return this.charAt(0).toUpperCase() + this.substr(1);
		};
		String.prototype.ucwords = function() {
			return this.replace(/\b\w/g, function (m) {return m.toUpperCase();});
		};
	}
	if (! ('cmp' in String.prototype)) {
		if ('localeCompare' in String.prototype) {
			String.prototype.cmp = function(b) {
				return this.localeCompare(b);
			};
		} else {
			String.prototype.cmp = function(b) {
				return (a < b)
					? -1
					: +(a > b);
			};
		}
	}
	if (! ('matchAll' in String.prototype)) {
		Object.defineProperty(
			String.prototype, 'matchAll', {
				value: function* (regex) {
					let match;
					while ((match = regex.exec(this))) {
						yield match;
					}
				},
			});
	}
	if (! ('splice' in String.prototype)) {
		String.prototype.splice = function(start, deleteCount, items='') {
			if (is_string(deleteCount)) {
				items = deleteCount;
				deleteCount = null;
			}
			deleteCount || (deleteCount = this.length);
			return this.slice(0, start) + items + this.slice(start + deleteCount);
		};
	}
	if (! ('bits' in Math)) {
		Math.bits = function (x) {
			return 1 + Math.floor(Math.log2(x));
		}
	}
	if (! ('digits' in Math)) {
		Math.digits = function (x) {
			return 1 + Math.floor(Math.log10(x));
		}
	}
	let version = globals.version = {
		_byver: {},
		_inorder: [],
		_resort: true,
		versionKey: 'mll_data_version',
		init($context) {
			this.$context = $context;
		},
		dataVersion({version, data}={}) {
			data || (data = dynamic_sheet_attrs);
			if (version) {
				this._version = version;
				data[this.versionKey] = version;
				if (this.$context) {
					this.$context.find(`.dsf_${this.versionKey}`).text(version);
				}
				return;
			}
			if (! ('_version' in this)) {
				this._version = +data[this.versionKey] || 0;
			}
			return this._version;
		},
		dstVersion() {
			if (this.$context) {
				return +this.$context.find('.mll_sheet')[0].dataset.version || 0;
			}
		},
		register(version, updater) {
			version = +(version.toString().match(/\d+(?:\.\d+)?/) || [version])[0];
			if (! (version in this._byver)) {
				let updaters = [];
				this._byver[version] = updaters;
				Object.defineProperty(
					updaters, 'version',
					{
						value: version,
						writeable: false,
						enumerable: false,
					});
				this._inorder.push(updaters);
				this._resort = true;
			}
			this._byver[version].push(updater);
		},
		registerModule(module) {
			for (let [version, updater] of Object.entries(module.updaters || {})) {
				let {name} = updater;
				updater = updater.bind(module);
				updater.name = name;
				this.register(version, updater);
			}
		},
		update(data) {
			data || (data = dynamic_sheet_attrs);
			let dataVersion = this.dataVersion({data}),
				newVersion = 0;
			if (this._resort) {
				this._inorder.sort((a, b) => a.version - b.version);
			}
			let dstVersion = this.dstVersion() || Infinity,
				toapply = this._inorder.filter(
					up => up.version > dataVersion
						&& up.version <= dstVersion
				);
			for (let updaters of toapply) {
				for (let updater of updaters) {
					try {
						updater(data);
					} catch (err) {
						console.log(`Error running updater ${updater.name} for ${updaters.version}: ${err.message}`, err);
					}
				}
				newVersion = updaters.version;
			}
			this.dataVersion({data, version: newVersion});
		},
    }
	let klass = globals.klass = {
		reVar: /{(?<name>[^:}]+)(?::(?<fmt>[^}]*))?}/,
		apply(fromTpl, toTpl, vals) {
			let env = this.extract(fromTpl, vals);
			return this.eval(toTpl, env);
		},
		eval(name, env, unbrace=false) {
			return name.replace(
				this.reVars,
				function (match, key, fmt) {
					if (key in env) {
						let value = env[key];
						if (fmt) {
							value = klass.format(value, fmt);
						}
						return value;
					}
					if (unbrace) {
						return key;
					} else {
						return match;
					}
				}
			)
		},
		evalAll(names, env, unbrace=false) {
			let results = new names.constructor();
			for (let [k, name] of Object.entries(names)) {
				results[k] = this.eval(name, env, unbrace);
			}
			return results;
		},
		*entries(obj, include) {
			let tpl = include;
			if (is_string(include)) {
				include = name => klass.matches(name, tpl);
			} else if (tpl instanceof RegExp) {
				include = name => tpl.test(name);
			}
			for (let name in obj) {
				if (include(name)) {
					yield [name, obj[name]];
				}
			}
		},
		extract(tpl, name) {
			let match = this.matches(tpl, name);
			if (match) {
				return match.groups;
			}
		},
		filter(obj, pred) {
			let filtered = {};
			for (let [name, value] of this.entries(obj, pred)) {
				filtered[name] = value;
			}
			return filtered;
		},
		format(value, fmt) {
			let width = +fmt,
				padChar = ' ';
			if (/^[^1-9]/.test(fmt)) {
				padChar = fmt[0];
			}
			return value.toString().padStart(width, padChar);
		},
		hasVars(name) {
			return this.reVar.test(name);
		},
		matches(tpl, name) {
			return name.match(this.tplToRe(tpl));
		},
		matchesAny(tpls, name) {
			return tpls.find(tpl => this.matches(tpl, name));
		},
		name(tpl, className) {
			let matches = this.matches(tpl, className);
			if (matches) {
				return matches[0];
			}
		},
		param(elt, param) {
			let matches = elt.className.match(new RegExp(`\\b${param}_(?<value>\\S+)`));
			if (matches) {
				return matches.groups.value
			}
		},
		prefix: memoize(function (name) {
			let matches = name.match(/^[^{]+/);
			if (matches) {
				return matches[0];
			}
			return name;
		}),
		tplToRe(tpl, allowEmpty) {
			let quant = allowEmpty ? '*' : '+';
			return new RegExp('\\b' + tpl.replace(this.reVars, `(?<$1>[^ _]${quant}?)`) + '\\b');
		},
		vars: memoize(function (name) {
			let vars = [...name.matchAll(this.reVars)] || [];
			return vars.map(m => m.groups.name);
		}),
		_varify(name, suffix) {
			let base, tpl;
			if (klass.hasVars(name)) {
				tpl = name;
				base = klass.prefix(name).replace(/_+$/, '');
			} else {
				base = name;
				tpl = name + suffix.replace(/^_*/, '_');
			}
			return {base, tpl};
		},
	};
	klass.reVars = new RegExp(klass.reVar, 'g');
	let nameGen = {
		count(tpl) {
			return this.last(tpl).i;
		},
		last(tpl) {
			let base, i=1, name, last;
			({base, tpl} = klass._varify(tpl, '_{i:02}'));
			if (tpl in this._next) {
				i = this._next[tpl];
			}
			while (true) {
				name = klass.eval(tpl, {i});
				if (this.exists(name)) {
					last = name;
					++i;
				} else {
					name = last;
					break;
				}
			}
			this._next[tpl] = i;
			--i;
			return {name, i};
		},
		next(tpl, start=1) {
			return start + this.count(tpl);
		},
		nextName(...tpls) {
			let i, opts = {start:1},
				names = {};
			if (is_object(tpls[0])) {
				opts = {...opts, ...(tpls[1] || {})};
				tpls = tpls[0];
				const first = Object.values(tpls)[0];
				i = this.next(first, opts.start);
				names = klass.evalAll(tpls, {i});
			} else {
				if (Array.isArray(tpls[0])) {
					opts = {...opts, ...(tpls[1] || {})};
					tpls = tpls[0];
				} else if (is_object(tpls[tpls.length - 1])) {
					opts = {...opts, ...tpls.pop()};
				}
				i = this.next(tpls[0], opts.start);
				if (tpls.length > 1) {
					names = tpls.map(tpl => klass.eval(tpl, {i}));
				} else {
					names = new String(klass.eval(tpls[0], {i}));
				}
			}
			if (is_object(names)) {
				Object.defineProperty(names, 'i', {
					enumerable:false,
					value: i,
				});
			} else {
				names.i = i;
			}
			return names;
		},
	};
	const transitions = globals.transitions = {
		classes: {
			start: 'fade fade-in fade-out wipe wipe-in wipe-out',
			finished: 'faded faded-in faded-out wiped-in wiped-out',
			fade: 'fade fade-in fade-out faded faded-in faded-out',
			wipe: 'wipe wipe-in wipe-out wiped wiped-in wiped-out',
		},
		states: {
			fade: {start: 'fade-out', finished: 'faded-out'},
			wipe: {start: 'wipe', finished: 'wiped'},
		},
		after($elt, duration) {
			return new Promise((resolve, reject) => {
				$elt.data('timer.transition', setTimeout(
					() => {
						$elt.removeData('timer.transition');
						$elt.removeData('reject');
						resolve();
					},
					duration * 1000));
				$elt.data('reject', reject);
			});
		},
		async animate($elt, transition, {css, reset=false}={}) {
			const {start, finished} = this.states[transition];
			await this.reset($elt, transition, reset);
			this.prepare($elt);
			$elt.addClass(start);
			if (css) {
				await animationFrame();
				$elt.css(css);
				await animationFrame();
			} else {
				await animationPost();
			}
			$elt.addClass(finished);
			await $elt.waitOn('transitionend');
			$elt.removeClass(start);
			return;
		},
		cancel($elt, transition) {
			const classes = this.classes[transition],
				  reject = $elt.data('reject') || (() => {});
			clearTimeout($elt.data('timer.transition'));
			reject();
			$elt.addClass('immediate')
				.off('transitionend')
				.removeClass(classes);
		},
		cancelFade($elt) {
			this.cancel($elt, 'fade');
		},
		cancelWipe($elt) {
			this.cancel($elt, 'wipe');
		},
		clear($elt, classes) {
			$elt.removeClass(classes);
		},
		clearFade($elt) {
			this.clear($elt, this.classes.fade);
		},
		clearWipe($elt) {
			this.clear($elt, this.classes.wipe);
		},
		async fade($elt, opts) {
			return await this.animate($elt, 'fade', opts);
		},
		fadeAfter($elt, duration) {
			$elt.data('timer.transition', setTimeout(
				() => this.fade($elt),
				duration * 1000));
		},
		is($elt, transition) {
			return $elt.hasClass(this.states[transition].start);
		},
		prepare($elt) {
			$elt.css({transition: ''})
				.removeClass('immediate');
		},
		async reset($elt, transition, reset) {
			if (reset && this.is($elt, transition)) {
				this.cancel($elt, transition);
				await animationPost();
			}
		},
		async wipe($elt, opts) {
			return await this.animate(
				$elt, 'wipe',
				{ ...opts, css: {height: $elt.css('height')} }
			);
		},
	};
	const alerts = globals.alerts = {
		current: {},
		defaultDuration: 5,
		ids: {},
		init($context) {
			this.$context = $context;
			this.$alerts = $('<div class="alerts"></div>');
			this.$context.find('.mll_sheet').append(this.$alerts);
			this.clicker = this.clickedClose.bind(this);
			this.$alert = $('<div class="alert"><span class="close"></span><span class="text"></span>');
			this.$alerts.on('click', '.alert .close', this.clicker);
		},
		alert(msg, opts={}) {
			opts.id || (opts.id = this.id(msg));
			let $alert,
				{id, duration} = opts;
			if (this.current[id]) {
				$alert = this.current[id];
				duration = this.revive($alert);
			} else {
				({$alert, duration} = this.create(msg, opts));
			}
			if (! opts.sticky) {
				duration || (duration = this.duration(msg) || this.defaultDuration);
				transitions.after($alert, duration)
					.then(async () => this.fadeAlert($alert), () => {});
			}
			return $alert;
		},
		cancelFade($alert) {
			transitions.cancelFade($alert);
			transitions.cancelWipe($alert);
		},
		clickedClose(evt) {
			return this.closeAlert($(evt.target).closest('.alert'));
		},
		closeAlert($alert) {
			let id = $alert.data('id');
			delete this.current[id];
			$alert.remove();
		},
		create(msg, opts={}) {
			opts.id || (opts.id = this.id(msg));
			opts.duration || (opts.duration = this.duration(msg));
			opts.$alert = this.$alert.clone();
			opts.$alert.addClass(opts.classes);
			opts.$alert.attr('id', opts.id);
			this.textFor(opts.$alert, msg);
			opts.$alert.data('id', opts.id);
			opts.$alert.data('duration', opts.duration);
			this.current[opts.id] = opts.$alert;
			this.$alerts.append(opts.$alert);
			return opts;
		},
		duration(msg) {
			return (msg.length / 50);
		},
		async fadeAlert($alert) {
			await transitions.fade($alert);
			await transitions.wipe($alert, {prepare: false});
			this.closeAlert($alert);
		},
		id: memoize((msg) => msg.replace(/\W+/g, '').toLowerCase()),
		info(msg, opts={}) {
			if (opts.classes) {
				opts.classes += ' info';
			} else {
				opts.classes = 'info';
			}
			return this.alert(msg, opts);
		},
		revive($alert) {
			this.cancelFade($alert);
			return $alert.data('duration') || this.duration($alert.text() || this.defaultDuration);
		},
		textFor($alert, text) {
			return $alert.children('.text').text(text);
		},
	};
	let dsf = globals.dsf = {
		preLoad({containerId, slug, isEditable}, $context) {
			this.$context = $context;
			this.sheetId = containerId;
			this.slug = slug;
			this.isEditable = isEditable;
		},
		postLoad(opts, $context) {
			this.each(function (elt, $elt, name, value) {
				if (editMarker == elt.textContent) {
					elt.textContent = '';
				} else {
					this._saveValue({elt, value: elt.textContent});
				}
			}, this);
			this.$context.find('.dsf.specialty').each(function (i, elt) {
				elt.title = 'Specialty';
			});
		},
		change({fieldName, fieldValue, $field, field, oldValue}) {
			if (! ('value' in field.dataset)) {
				field.dataset.value = oldValue || '';
			}
			field.dataset.oldValue = oldValue || '';
			this.value(fieldName, fieldValue);
			delete field.dataset.oldValue;
		},
		addPrefix(name) {
			return name.replace(/^(?:dsf_)?/, 'dsf_');
		},
		clean() {
			$("#dst_select").data("sheetValueChanged", false);
		},
		clear(eltDsf) {
			delete eltDsf.dataset.value;
			let $eltDsf = $(eltDsf);
			$eltDsf.removeData('value');
			if (! $eltDsf.hasClass('pips')) {
				$eltDsf.empty();
			}
		},
		count(tpl) {
			return this.last(tpl).i;
		},
		dirty() {
			$("#dst_select").data("sheetValueChanged", true);
		},
		dsf(name) {
			let {elt} = this.resolve(name);
			return elt;
		},
		$dsf(name) {
			if (name) {
				name = this.addPrefix(name);
				return this.$context.find(`.${name}`);
			}
			return $();
		},
		$dsfs(context, {excludeCompatibility=false}={}) {
			let $dsfs = $(context).find('.dsf');
			if (excludeCompatibility) {
				$dsfs = $dsfs.not(dsf => $(dsf).closest('.compatibility').length);
			}
			return $dsfs;
		},
		each(fn, self) {
			if (self) {
				fn = fn.bind(self);
			}
			this.$dsfs(this.$context).each((i, elt) => {
				let $elt = $(elt),
					name = this.name(elt),
					value = this.value(elt);
				if (name) {
					fn(elt, $elt, name, value);
				} else {
					console.warn(`No name for dsf ${elt.className}`, elt);
				}
			});
		},
		editable(node) {
			this.$dsfs($(node))
				.not('.readonly')
				.each((i, elt) => {
					let name = this.stripPrefix(this.name(elt));
					aisleten.characters.bindField(name, this.sheetId, this.slug);
				});
		},
		entries(tpl) {
			tpl = this.addPrefix(tpl);
			let pre = klass.prefix(tpl);
			return this.$context.find(`.dsf[class*=" ${pre}"]`)
				.toArray()
				.filter(elt => klass.matches(tpl, elt.className))
				.map(elt => [this.name(elt), this.value(elt)]);
		},
		exists(name) {
			try {
				return this.$dsf(name).length;
			} catch (err) {
				console.error(err);
				return false;
			}
		},
		extract(context) {
			const data = {};
			for (let field of this.$dsfs(context)) {
				data[this.name(field)] = this.value(field);
			}
			return data;
		},
		isVolatile(node) {
			return /(?:\b|_)curr_|\bcurrent\b|\bvolatile\b/.test(node.className);
		},
		last(tpl) {
			let entries = this.entries(tpl),
				i =  entries.length,
				last = entries[entries.length - 1],
				name = last && last[0];
			return {name, i};
		},
		linked: {
			base(name) {
				if (this.isExtra(name)) {
					return name.replace(/(^|_)extra_/, '$1');
				}
			},
			bases(name) {
				let bases = [], base;
				if (this.isExtra(name)) {
					if ((base = this.perm(name))) {
						bases.push(base);
					}
					if ((base = this.curr(name))) {
						bases.push(base);
					}
				}
			},
			curr(name) {
				if (this.is_ep(name)) {
					return name.replace(/(^|_)(extra|perm)_/, '$1curr_');
				}
			},
			$curr(name) {
				({name} = this.resolve(name));
				return dsf.$dsf(this.curr(name));
			},
			extra(name) {
				if (this.isBase(name)) {
					return name.replace(/(^|_)(perm|curr)_/, '$1extra_');
				}
			},
			$extra(name) {
				({name} = this.resolve(name));
				return dsf.$dsf(this.extra(name));
			},
			perm(name) {
				if (this.is_ec(name)) {
					return name.replace(/(^|_)(extra|curr)_/, '$1perm_');
				}
			},
			$perm(name) {
				({name} = this.resolve(name));
				return dsf.$dsf(this.perm(name));
			},
			is(name) {
				return /(^|_)(extra|perm|curr)_/.test(name);
			},
			isBase(name) {
				return /(^|_)(perm|curr)_/.test(name);
			},
			isCurr(name) {
				return /(^|_)curr_/.test(name);
			},
			is_ec(name) {
				return /(^|_)(extra|curr)_/.test(name);
			},
			is_ep(name) {
				return /(^|_)(extra|perm)_/.test(name);
			},
			isExtra(name) {
				return /(^|_)extra_/.test(name);
			},
			isPerm(name) {
				return /(^|_)perm_/.test(name);
			},
		},
		rename(oldName, newName, {overwrite=false}={}) {
			let $old = this.$dsf(oldName),
				$new = this.$dsf(newName);
			if ($old.length) {
				if ($new.length) {
					if (overwrite) {
						this._value($new, this.value($old));
						$old.remove();
					} else {
						return false;
					}
				} else {
					$old.removeClass(this.addPrefix(oldName)).addClass(this.addPrefix(newName));
				}
				return true;
			}
			return false;
		},
		$section(elt) {
			let $elt;
			if (is_string(elt)) {
				$elt = this.$context.find(elt);
				if (! $elt.length) {
					$elt = this.$dsf(elt);
				}
			} else if (elt instanceof $) {
				$elt = elt;
			} else {
				$elt = $(elt);
			}
			return $section = $elt.parent().closest('div[class], section[class]');
		},
		section(elt) {
			let $section = this.$section(elt);
			if ($section[0]) {
				return $section[0];
			}
		},
		sectionName(elt) {
			let sectionElt = this.section(elt);
			if (sectionElt) {
				return sectionElt.className.split(/\s+/)[0];
			}
		},
		sku(name) {
			return this.sheetId + '.' + name;
		},
		stripPrefix(name) {
			return name.replace(/^dsf_/, '');
		},
		name(elt) {
			if (elt instanceof $) {
				elt = elt[0];
			}
			return klass.param(elt, 'dsf');
		},
		removeValue(field) {
			let {elt, name} = this.resolve(field);
			name = this.sku(this.stripPrefix(name));
			localStorage.removeItem(name);
		},
		resolve(field) {
			let name, elt, $elt, type;
			if (is_string(field)) {
				name = this.stripPrefix(field);
				$elt = this.$dsf(name);
				elt = $elt[0];
			} else {
				if (field instanceof $) {
					$elt = field;
					elt = $elt[0];
				} else {
					elt = field;
					$elt = $(field);
				}
				name = this.name(elt);
			}
			type = this.typify($elt);
			return {name, elt, $elt, type};
		},
		type(elt) {
			let {$elt, type} = this.resolve(elt);
			return type;
		},
		typify($elt) {
			if (! $elt[0]) {
				return;
			}
			if (   $elt.hasClass('checkbox')
				|| $elt.find('> input[type="checkbox"]').length)
			{
				return 'checkbox';
			}
			if (   'TEXTAREA' == $elt[0].tagName
				|| $elt.hasClass('notes') || $elt.hasClass('text'))
			{
				return 'text';
			}
			if ('SELECT' == $elt[0].tagName) {
				return 'select';
			}
			return 'default';
		},
		_dsf: {
			getters: {
				checkbox($elt) {
					return $elt.find('input').prop('checked');
				},
				select($elt) {
					return $elt.val();
				},
				text($elt) {
					return $elt.html();
				},
				default($elt) {
					if ('value' in $elt[0].dataset) {
						return $elt[0].dataset.value;
					}
					let value = $elt.data('value');
					if (! is_undefined(value)) {
						return value;
					}
					return $elt.text();
				},
			},
			setters: {
				checkbox($elt, value) {
					$.disableHooks('prop', 'checked');
					$elt.find('input').prop('checked', to_boolean(value));
					$.enableHooks('prop', 'checked');
				},
				select($elt, values) {
					if (values.match(',')) {
						values = values.split(/\s*,\s*/);
					}
					return $elt.val(values);
				},
				text($elt, value) {
					$elt.html(value);
				},
				default($elt, value) {
					$elt.text(value);
				},
			},
		},
		_recordUndo(change, setValue) {
			if (modules.undo) {
				if (! ('oldValue' in change)) {
					if ('oldValue' in change.elt.dataset) {
						change.oldValue = change.elt.dataset.oldValue;
					} else {
						change.oldValue = this.value(change.elt);
					}
				}
				change.name || (change.name = this.name(change.elt));
				change.$elt || (change.$elt = $(change.elt));
				setValue = setValue.bind(this);
				modules.undo.record(
					() => {
						modules.undo.highlight(change.elt, change.$elt);
						setValue({...change, value: change.oldValue});
					},
					() => {
						modules.undo.highlight(change.elt, change.$elt);
						setValue(change);
					},
				);
			}
		},
		_setValue({elt, $elt, type, value}) {
			this._dsf.setters[type]($elt, value);
			this._saveValue({elt, $elt, value});
			this._storeValue({elt, name:this.name(elt), value});
		},
		_saveValue({elt, $elt, value}) {
			elt.dataset.value = value;
			($elt || $(elt)).data('value', value);
		},
		_storeValue({elt, name, value}) {
			if (this.isVolatile(elt)) {
				name = this.sku(this.stripPrefix(name || this.name(elt)));
				if (this.isEditable) {
					localStorage.removeItem(name);
				} else {
					localStorage[name] = value;
				}
			}
		},
		storeValue(field, value) {
			let {elt, name} = this.resolve(field);
			this._storeValue({elt, name, value});
		},
		_value(field, value) {
			let {elt, $elt, type} = this.resolve(field);
			if (! elt) {
				return '';
			}
			this._setValue({elt, $elt, type, value});
		},
		value(field, value) {
			let {elt, $elt, type} = this.resolve(field);
			if (! elt) {
				return '';
			}
			if (! is_undefined(value)) {
				this._recordUndo({elt, $elt, type, value}, this._setValue);
				this._setValue({elt, $elt, type, value});
				return value;
			}
			let getter = this._dsf.getters[type] || this._dsf.getters.default;
			return getter($elt);
		},
		override(name, value) {
			name = this.stripPrefix(name);
			let key = this.sku(name);
			if (key in localStorage) {
				value = localStorage[key];
				this.value(name, value);
			}
			return value;
		},
		update(eltField, value, name) {
			name || (name = this.name(eltField));
			function saveValue(kwargs) {
				this._saveValue(kwargs);
				this._storeValue(kwargs)
			}
			let change = {
				elt: eltField, $elt: $(eltField),
				name, value,
				oldValue: eltField.dataset.value,
			};
			if (change.value !== change.oldValue) {
				this._recordUndo(change, saveValue);
				saveValue.call(this, change);
			}
		},
	};
	bindSome(dsf, ['exists']);
	mixIn(dsf, nameGen);
	function resettableGenerator(generator, reset) {
		reset || (reset = () => {});
		function Resettable(...args) {
			let items;
			this.args = args;
			this.init();
		}
		Resettable.prototype = {
			base: generator,
			init() {
				this.generator = generator.apply(this, this.args);
			},
			reset() {
				if (! reset.call(this)) { 
					this.init();
				}
			},
			next(value) {
				return this.generator.next(value);
			},
			[Symbol.iterator]() {
				return this;
			},
		};
		return function (...args) {
			return new Resettable(...args);
		};
	}
	globals.resettableGenerator = resettableGenerator;
	const authorize = globals.authorize = {
		init($context, slug, isEditable) {
			this.$context = $context;
			this.set_owner();
			this.set_ownership();
			Object.defineProperties(this, {
				isEditable: {
					configurable: false,
					writeable: false,
					enumerable: true,
					value: isEditable,
				},
			});
		},
		set_owner() {
			if (! this.owner) {
				const owner = (dynamic_sheet_attrs.player || '').replace(/<[^>]*>/g, '');
				if (owner) {
					Object.defineProperty(authorize, 'owner', {
						configurable: false,
						writeable: false,
						enumerable: true,
						value: owner,
					});
				} else {
					return;
				}
			}
			this.set_owner = () => {};
		},
		set_ownership() {
			if (this.can_edit()) {
				this.$context.addClass('owned');
			} else {
				this.$context.addClass('unowned');
			}
		},
	};
	Object.defineProperties(authorize, {
		user: {
			configurable: false,
			writeable: false,
			enumerable: true,
			value: $('head meta#current-user-login').attr('content'),
		},
		is_owner: {
			configurable: false,
			writeable: false,
			enumerable: false,
			value: function() {
				return this.owner && this.user === this.owner;
			}
		},
		can_edit: {
			configurable: false,
			writeable: false,
			enumerable: false,
			value: function() {
				return this.isEditable || this.is_owner();
			}
		}
	});
	$(function() {
		authorize.set_owner();
	});
	let resolver = {
		resolve(thing) {
			let resolved = {};
			if (is_string(thing)) {
				resolved.$elt = $(thing);
				resolved.elt = resolved.$elt[0];
				resolved.selector = thing;
			} else if (thing instanceof $) {
				resolved.$elt = thing;
				resolved.elt = thing[0];
				if (thing.selector) {
					resolved.selector = thing.selector;
				}
			} else {
				resolved.elt = thing;
				resolved.$elt = $(thing);
			}
			if (is_function(this.name)) {
				resolved.name = this.name(resolved.$elt);
			} else {
				resolved.name = dsf.name(resolved.elt);
			}
			return resolved;
		},
	};
	let dsa = globals.dsa = {
		_next: {},
		get data() {
			return window.dynamic_sheet_attrs;
		},
		add(names, values, base) {
			names = this.nextName(names);
			let key; 
			for (key in names) {
				if (key in values) {
					this.data[names[key]] = values[key];
				}
			}
			return {
				base: base
					|| ((names.value || names[key]).match(/^dyn_(?<base>[^_]+)/) || [])[1],
				i: names.i,
			};
		},
		compact(tpls, stop={gap:5}) {
			let tpl = Object.values(tpls)[0],
				names, name,
				i, j, loop,
				fields;
			fields || (fields = this);
			if (is_numeric(stop)) {
				stop = {index: stop};
			}
			if (stop.index) {
				loop = {
					exists: true,
					continue(i) {
						return this.exists || i <= stop.index;
					},
					missing(i) {
						this.exists = false;
					},
					present(i) {
						this.exists = true;
					},
				};
			} else if (stop.gap) {
				loop = {
					continue(i) {
						return (i - this.i) <= stop.gap;
					},
					missing(i) {},
					present(i) {
						this.i = i;
					},
				};
			}
			i = 0; j = -1;
			do { 
				++i; ++j;
				name = klass.eval(tpl, {i});
			} while (fields.exists(name));
			loop.present(j);
			loop.missing(i);
			do {
				name = klass.eval(tpl, {i: ++i});
				if (fields.exists(name)) {
					fields.renumber(tpls, i, ++j);
					loop.present(i);
				} else {
					loop.missing(i);
				}
			} while (loop.continue(i));
			return j;
		},
		count(tpl) {
			return this.last(tpl).i;
		},
		entries(tpl, envs, opts={}) {
			if (envs) {
				return  this.entriesByBounds(tpl, envs, opts);
			} else {
				return  this.entriesByScan(tpl, opts);
			}
		},
		*entriesByBounds(tpl, envs, {continuous=false}={}) {
			let data = this.data,
				vars = klass.vars(tpl);
			for (let env of envs) {
				let name = klass.eval(tpl, env);
				if (dsa.exists(name, data)) {
					yield [name, data[name], env];
				} else if (continuous && Object.values(env).every(x => x)) {
					let n = 1;
					for (let i = vars.length - 1; i >= 0; --i) {
						if (env[vars[i]] > 1) {
							envs.next(n);
							break;
						}
						++n;
					}
				}
			}
		},
		*entriesByScan(tpl, opts={}) {
			let data = this.data;
			yield* Object.entries(data).filter(([name, value]) => klass.matches(tpl, name));
		},
		exists(name, data) {
			return name in (data || this.data);
		},
		getAll(names, values) {
			let entries;
			if (Array.isArray(names)) {
				entries = names.entries();
				values || (values = new Array(names.length));
			} else if (is_object(names)) {
				entries = Object.entries(names);
				values || (values = {});
			} else {
				throw new TypeError(`dsa.getAll: Invalid argument type: ${typeof(names)}. Arguments must both be either arrays or simple objects.`);
			}
			for (const [i, name] of entries) {
				values[i] || (values[i] = dsa.data[name] || '');
			}
			return values;
		},
		rename(oldName, newName, {overwrite=false}={}) {
			if (   this.exists(oldName)
				&& (   overwrite
					|| ! this.exists(newName))
			) {
				this.data[newName] = this.data[oldName];
				delete this.data[oldName];
			}
		},
		renumber(tpls, oldNum, newNum, options={}) {
			for (let tpl of Object.values(tpls)) {
				this.rename(
					klass.eval(tpl, {i:oldNum}),
					klass.eval(tpl, {i:newNum}),
					options);
			}
		},
	};
	bindSome(dsa, ['exists']);
	mixIn(dsa, nameGen);
	let path = globals.path = {
		_sep: '_',
		reSeparator: /_/,
		get separator() {
			return this._sep;
		},
		set separator(value) {
			this._sep = value;
			this.reSeparator = new RegExp(`${value}(\d+)${value}`);
		},
		join(...parts) {
			return parts.join(this.separator);
		},
		split(name) {
			return dsf.stripPrefix(name).split(this.reSeparator);
		},
	};
	let pips = globals.pips = {
		reDemi: /(?<left>(?<lmask>0x)?[\dA-F]+) *\/ *(?<right>(?<rmask>0x)?[\dA-F]+)/i,
		marker: 'X',
		blocked: 'D',
		init($context) {
			this.$context = $context;
			this.clicker = this.clicked.bind(this);
			this.clickerInLimit = this.clickedInLimit.bind(this);
		},
		postLoad(opts, $context) {
			module.waitFor('dsf');
			dsf.each(function (elt, $elt, name, value) {
				value = dsf.override(name, value)
				if (   ! is_flag(elt, value)
					&& this.is(elt, value)
				) {
					$elt.text('');
					this.pippify($elt, {name, value});
				}
			}, this);
			if (authorize.can_edit()) {
				this.$context.on('click', '.pips.current > span', this.clicker);
			}
			for (const fn of this.postLoad.queue) {
				fn();
			}
			this.postLoad.queue = [];
			this.postLoad.done = true;
		},
		preSave() {
			dsf.each(function (elt, $elt, name, value) {
				if (pips.is(elt, value)) {
					pips.unpippify($elt, {name, value});
				}
			});
		},
		change(opts) {
			module.waitFor('dsf');
			if (dsf.linked.isExtra(opts.fieldName)) {
				let base = dsf.linked.base(opts.fieldName),
					$base = $(`.dsf.pips.${base}`);
				for (let elt of $base) {
					this.reassemble($(elt));
				};
			}
		},
		demi: {
			clicked() {},
			is() { return false; },
			pippify() {},
			rating() { return 0; },
			_refresh() {},
			refresh() {},
			start() {},
			value() { return },
			zero() { return '0'; },
		},
		addKinds: addPippedKinds,
		addPips($elt, delta) {
			for (let i = 0; i < delta; ++i) {
				$elt.append($(`<span></span>`));
			}
		},
		adjust($elt, delta, blocker) {
			modules.undo && modules.undo.record(
				() => this.adjust($elt, -delta, blocker),
				() => this.adjust($elt, delta, blocker),
			);
			if (delta > 0) {
				this.addPips($elt, delta);
				let name = dsf.name($elt);
				if (dsf.linked.isCurr(name)) {
					this.block($elt, dsf.value(dsf.linked.perm(name)), blocker);
				}
				this.refresh($elt);
			} else if (delta < 0) {
				this.delPips($elt, delta);
			}
			const $kids = $elt.children(),
				  length = $kids.length - 1;
			$elt.trigger('adjust.pips', {length, delta});
		},
		assemble($elt) {
			let nPips = this.count($elt[0]);
			if (this.demi.is($elt)) {
				nPips *= 2;
			}
			for (let i = 0; i <= nPips; ++i) {
				$elt.append($(`<span></span>`));
			}
			$elt.children().first().attr('title', 'click to clear pips');
		},
		block($elt, value, blocker) {
			blocker || (blocker = this.blocked);
			value = +value;
			const $pips = $elt.find('span');
			$pips.slice(1, value+1).removeClass(blocker);
			$pips.slice(value+1).addClass(blocker);
		},
		blockCurr(name, nPip, {$elt, rating, oldValue}={}) {
			const matches = name.match(/perm_(?<curr>.*)/);
			if (matches) {
				if ($elt) {
					oldValue || (oldValue = rating || dsf.value($elt));
					modules.undo && modules.undo.record(
						() => this.block(dsf.$dsf(`curr_${curr}`), oldValue),
						() => this.block(dsf.$dsf(`curr_${curr}`), nPip),
					);
				}
				const curr = matches.groups.curr;
				this.block(dsf.$dsf(`curr_${curr}`), nPip);
			}
		},
		clear(elt) {
			let $elt;
			if (elt instanceof $) {
				$elt = elt;
				elt = elt[0];
			} else {
				$elt = $(elt);
			}
			if ($elt.hasClass('pips')) {
				this.mark($elt, 0);
				if (this.demi.is($elt)) {
					this.demi.value($elt, this.demi.zero());
				} else {
					this.value($elt, 0);
				}
			} else {
				$elt.find('.pips').each((i, elt) => pips.clear(elt));
			}
		},
		clicked(evt) {
			if (this.demi.is(evt.target)) {
				this.demi.clicked(evt);
			} else {
				this.tryTransact(() => this.fill(evt.target));
			}
		},
		clickedInLimit(evt) {
			const name = dsf.name(evt.target.parentNode),
				maxPips = dsf.lookup(`perm_${name}`, 10),
				nPip = Math.min(this.countPips(evt.target), maxPips);
			this.tryTransact(() => this.setPips(evt.target, nPip));
		},
		count(elt, dflt) {
			const nPips = +elt.dataset.pips || +dflt || 5,
				  name = dsf.name(elt),
				  extra = dsf.linked.extra(name);
			let nExtra = 0;
			if (extra) {
				nExtra = + dsf.value(extra);
			}
			return nPips + nExtra;
		},
		countPips: nodeIndex,
		delPips($elt, delta) {
			const $kids = $elt.children();
			let length = $kids.length - 1;
			delta = Math.max(-Math.abs(delta), -length);
			length += delta;
			$kids.slice(length + 1).remove();
			return length;
		},
		fill(elt) {
			const nPip = this.countPips(elt);
			this.setPips(elt, nPip);
		},
		has(elt) {
			let $elt = $(elt),
				closer = $elt.closer('.pips', '.nopips');
			return closer == '.pips'
				|| $elt.find('.pips').length
				|| (! closer && is_kind(pippedKinds, elt));
		},
		is(field, value) {
			let {$elt, elt} = this.resolve(field),
				closer = $elt.closer('.pips', '.nopips');
			return closer != '.nopips'
				&& ! $elt.parent('label').length
				&& ! $elt.hasSomeClass('hidden', 'specialty', 'notes')
				&& ! /_(name|description|specialty|size)\b/.test($elt[0].className)
				&& (   closer == '.pips'
					|| (   is_kind(pippedKinds, elt)
						&& ! is_flag(elt, value)))
			;
		},
		isMarked(elt) {
			let $elt = $(elt);
			return $elt.hasClass(this.marker);
		},
		isMarkedAt(pipped, i) {
			let {$elt} = this.resolve(pipped);
			return this.isMarked($elt.children().eq(i+1));
		},
		mark($elt, value, marker) {
			marker || (marker = this.marker);
			value = +value;
			let $pips = $elt.find('span'),
				oldValue = this.rating($elt);
			function mark(value) {
				if (! $pips.last()[0].parentElement) {
					$pips = $elt.find('span');
				}
				$pips.slice(1, value+1).addClass(marker);
				$pips.slice(value+1).removeClass(marker);
				return $elt;
			}
			if ($pips.length) {
				mark(value);
				modules.undo && modules.undo.record(
					() => mark(oldValue),
					() => mark(value)
				);
			}
		},
		markRe: memoize(function (marker='X') {
			return new RegExp(`\\b${marker}\\b`);
		}),
		pippify($elt, {name, value}={}) {
			if ($elt instanceof $) {
				if ($elt.length > 1) {
					return $elt.each((i, elt) => this.pippify(elt));
				}
			} else {
				$elt = $($elt);
			}
			name || (name = dsf.name($elt[0]));
			if (is_undefined(value)) {
				value = dsf.value($elt) || '0';
			}
			$elt.addClass('pips readonly');
			if (this.demi.is($elt)) {
				this.demi.pippify($elt, {name, value});
				return;
			}
			var pips;
			if (value) {
				[value, pips] = value.toString().split('/', 2);
				value = +value;
				if (+pips) {
					$elt[0].dataset.pips = +pips;
				}
				dsf.update($elt[0], value, name);
			}
			this.assemble($elt);
			this.mark($elt, value);
			if (name) {
				this.ready(() => this.blockCurr(name, value));
			}
		},
		rating($elt, marker) {
			if (this.demi.is($elt)) {
				return this.demi.rating($elt);
			}
			marker || (marker = this.marker);
			return $elt.find(`.${marker}`).length;
		},
		ready(fn) {
			if (this.postLoad.done) {
				fn.bind(this)();
			} else {
				this.postLoad.queue.push(fn.bind(this));
			}
		},
		reassemble($elt) {
			let nPips = this.count($elt[0]),
				nKids = $elt.children().length,
				delta;
			if (this.demi.is($elt)) {
				nPips *= 2;
			}
			delta = nPips - nKids + 1; 
			this.adjust($elt, delta);
		},
		_refresh($elt) {
			if (this.demi.is($elt)) {
				this.demi._refresh($elt);
			} else {
				this._mark($elt, this.value($elt));
			}
		},
		refresh($elt) {
			if (this.demi.is($elt)) {
				this.demi.refresh($elt);
			} else {
				this.mark($elt, this.value($elt));
			}
		},
		setKinds: setPippedKinds,
		setPips(eltPip, nPip) {
			let eltField = eltPip.parentNode,
				$field = $(eltField),
				name = dsf.name(eltField),
				value = nPip,
				oldValue = dsf.value($field) ||this.rating($field),
				parts;
			if (   eltField.dataset.value
				&& (parts = eltField.dataset.value.match(/( *\/ *(?:0x[\dA-F]+|\d+))$/i)))
			{
				value = nPip + parts[1];
			}
			dsf.update(eltField, value, name);
			this.mark($field, nPip);
			this.blockCurr(name, nPip, {$elt:$field, oldValue });
		},
		start() {
			this.$context.find('input.dsf').prop('disabled', false);
			this.$context.find('.mll_sheet')
				.on('click', '.pips:not(.current) > span', this.clicker);
			this.demi.start();
		},
		stop() {
			this.$context.find('.mll_sheet')
				.off('click', '.pips:not(.current) > span', this.clicker);
			this.$context.find('input.dsf').prop('disabled', true);
		},
		toggle(eltPip, marker) {
			marker || (marker = this.marker);
			let $eltPip = $(eltPip);
			if ($eltPip.hasClass(marker)) {
				$eltPip.removeClass(marker);
				this.tryTransact(
					() => $eltPip.addClass(marker),
					() => $eltPip.removeClass(marker),
				);
			} else {
				$eltPip.addClass(marker);
				this.tryTransact(
					() => $eltPip.removeClass(marker),
					() => $eltPip.addClass(marker),
				);
			}
		},
		unpippify($elt, {value=0, marker}={}) {
			marker || (marker = this.marker);
			value || (value = dsf.value($elt) || $elt.find('.' + marker).length);
			$elt.empty();
			$elt.text(value);
		},
		value(elt, val) {
			if (elt instanceof $) {
				elt = elt[0];
			}
			if (this.demi.is(elt)) {
				return this.demi.value(elt, val);
			}
			if (val) {
				this.setPips(elt.children[0], val);
			}
			return +dsf.value(elt) || 0;
		},
	};
	pips.postLoad.queue = [];
	bindSome(pips, ['is']);
	mixIn(pips, resolver);
	let range = globals.range = {
		_ends: ['to', 'thru', 'through', 'upthru', 'upthrough', 'downthru', 'downthrough', 'upto', 'downto'],
		_parameterize(params, to, step) {
			const conds = {
				to: {
					up: {
						continue(i) { return i < this.to; },
						stop(i) { return i >= this.to; },
					},
					down: {
						continue(i) { return i > this.to; },
						stop(i) { return i <= this.to; },
					},
				},
				through: {
					up: {
						continue(i) { return i <= this.to; },
						stop(i) { return i > this.to; },
					},
					down: {
						continue(i) { return i >= this.to; },
						stop(i) { return i < this.to; },
					},
				}
			};
			let cond = conds.to;
			if (is_numeric(params)) {
				if (arguments.length == 1) {
					return {
						from: 0,
						to: params,
						step: 1,
						stop: cond.up.stop,
						'continue': cond.up.continue,
					}
				} else {
					params = {
						from: params,
						to: to,
						step: step,
					};
				}
			}
			if ('continue' in params) {
				return params;
			}
			for (let pre of ['', 'up', 'down']) {
				if (`${pre}thru` in params) {
					params[`${pre}through`] || (params[`${pre}through`] = params[`${pre}thru`]);
				}
			}
			if ('start' in params) {
				params.from || (params.from = params.start || 0);
			} else {
				params.from || (params.from = 0);
			}
			if (is_undefined(params.to)) { 
				if ('through' in params) {
					params.to = params.through;
					cond = conds.through;
				} else if ('upthrough' in params) {
					params.to = params.upthrough;
					cond = conds.through;
					params.step = Math.abs(params.step) || 1;
				} else if ('downthrough' in params) {
					params.to = params.downthrough;
					cond = conds.through;
					params.step = -Math.abs(params.step) || -1;
				} else if ('upto' in params) {
					params.to = params.upto;
					params.step = Math.abs(params.step) || 1;
				} else if ('downto' in params) {
					params.to = params.downto;
					params.step = -Math.abs(params.step) || -1;
				} else {
					params.to = params.from;
					params.from = 0;
				}
			}
			if (! params.step) {
				params.step = params.from <= params.to ? 1 : -1;
			}
			if (params.step > 0) {
				if (params.from > params.to) {
					[params.from, params.to] = [params.to, params.from];
				}
				Object.assign(params, cond.up);
			} else {
				if (params.from < params.to) {
					[params.from, params.to] = [params.to, params.from];
				}
				Object.assign(params, cond.down);
			}
			return params;
		},
		async *asyncConcat(...seqs) {
			let result;
			for (let seq of seqs) {
				result = yield* seq;
				if (result > 0) {
					return result - 1;
				}
			}
		},
		concat: function*(...seqs) {
			let result;
			for (let seq of seqs) {
				result = yield* seq;
				if (result > 0) {
					return result - 1;
				}
			}
		},
		entry: resettableGenerator(function*(key, vals, obj = {}) {
			let result;
			if (is_iterable(vals)) {
				('reset' in vals) && vals.reset();
			} else {
				vals = range.over(vals);
			}
			for (let val of vals) {
				obj[key] = val;
				result = yield {...obj};
				if (result > 0) { 
					yield `break ${result}`;
					return result - 1;
				}
			}
		}, function() {
			('reset' in this.args[1]) && this.args[1].reset();
		}),
		entries(entries) {
			for (let i in entries) {
				if (! is_iterable(entries[i][1])) {
					entries[i][1] = range.over(entries[i][1]);
				}
			}
			function *_recurse(obj={}, i=0) {
				let entry, result;
				if (i < entries.length) {
					entry = entries[i];
					for (let val of range.entry(entry[0], entry[1], obj)) {
						result = yield* _recurse(val, i+1);
						if (result > 0) { 
							return result - 1;
						}
					}
				} else {
					result = yield {...obj};
					if (result > 0) {
						yield `break ${result}`;
						return result;
					}
				}
				return 0;
			}
			const _resettable = resettableGenerator(
				_recurse,
				function () {
					for (let entry of entries) {
						'reset' in entry && entry.reset();
					}
				}
			);
			return _resettable();
		},
		filter: resettableGenerator(function*(iter, fn) {
			let result;
			for (let x of iter) {
				if (fn(x)) {
					result = yield x;
					if (result > 0) {
						yield `break ${result}`;
						return result - 1;
					}
				}
			}
		}, function () {
			('reset' in this.args[0]) && this.args[0].reset();
		}),
		forVar(v, {lower=1, step, upper={}}={}) {
			let xs;
			if (v in upper) {
				xs = range.over(lower, upper[v], step);
			} else switch (v) {
			case 'i':
				xs = range.over(lower, 100, step);
				break;
			case 'j':
				xs = range.over(lower, 4, step);
				break;
			default:
				xs = range.over(lower, 10, step);
				break;
			}
			return xs;
		},
		forVars(vars, opts={}) {
			let ranges = {};
			for (let v of vars) {
				ranges[v] = this.forVar(v, opts);
			}
			return range.keyed(ranges);
		},
		*halves(string, sep) {
			if (sep instanceof RegExp) {
				yield* range.halvesByRe(string, sep);
			} else {
				yield* range.halvesByStr(string, sep);
			}
		},
		*halvesByRe(string, reSep) {
			let tail = halveString(string, reSep, {include:0}),
				halves = [tail[0], tail[tail.length - 1]],
				result;
			while (tail.length > 1 && halves[1]) {
				result = yield halves.slice(0, 2);
				if (result > 0) {
					yield `break ${result}`;
					return result - 1;
				}
				halves[0] += tail[1];
				tail = halveString(halves[1], reSep, {include:0});
				halves[0] += tail[0];
				halves[1] = tail[tail.length - 1];
			}
		},
		*halvesByStr(string, sep) {
			sep = sep.toString();
			let halves = halveString(string, sep),
				tail,
				result;
			while (halves.length > 1 && halves[1]) {
				result = yield halves.slice(0, 2);
				if (result > 0) {
					yield `break ${result}`;
					return result - 1;
				}
				tail = halveString(halves[1], sep);
				halves[0] += sep + tail[0];
				halves[1] = tail[1];
			}
		},
		hasEnd(params) {
			return this._ends.some(end => end in params);
		},
		keyed: resettableGenerator(function*(obj) {
			return yield* range.entries(Object.entries(obj));
		}, function () {
			for (let iter of this.args[0]) {
				('reset' in iter && iter.reset());
			}
		}),
		keyOver: resettableGenerator(function*(key, params, vals = {}) {
			params = range._parameterize(params);
			let result;
			for (let i = params.from; params.continue(i); i += params.step) {
				vals[key] = i;
				result = yield vals;
				if (result > 0) {
					yield `break ${result}`;
					return result - 1;
				}
			}
		}),
		keysOver: resettableGenerator(function*(keys, params) {
			params = range._parameterize(params);
			let key, vals, result;
			switch (keys.length) {
			case 0:
				break;
			case 1:
				yield* this.keyOver(keys[0], params);
				break;
			default:
				key = keys[0];
				keys = keys.slice(1);
				for (let val of this.keysOver(keys, params)) {
					result = yield* this.keyOver(key, params, val);
					if (result > 0) {
						return result - 1;
					}
				}
				break;
			}
		}),
		map: resettableGenerator(function*(iter, fn) {
			let result;
			for (let x of iter) {
				result = yield fn(x);
				if (result > 0) {
					yield `break ${result}`;
					return result - 1;
				}
			}
		}, function () {
			'reset' in this.args[0] && this.args[0].reset();
		}),
		over: function (params, to, step) {
			if (Array.isArray(params)) {
				if (   0 < params.length && params.length < 4
					&& params.every(x => 'number' === typeof(x)))
				{
					[params, to, step] = params;
				} else {
					return params;
				}
			}
			params = range._parameterize(params, to, step);
			let i = params.from;
			return {
				next(value) {
					if (value > 0) {
						return {value: value - 1, done: true};
					}
					if (params.stop(i)) {
						return {value: undefined, done: true};
					} else { 
						let next = { value: i, done: false };
						i += params.step;
						return next;
					}
				},
				reset() {
					i = params.from;
				},
				[Symbol.iterator]() { return this; },
			};
		},
		overAll(paramses) {
			paramses = paramses.map(param => range._parameterize(param));
			function* _recurse(front=[], end=0) {
				let result;
				if (end < paramses.length) {
					let params = paramses[end];
					for (let i = params.from; params.continue(i); i += params.step) {
						front[end] = i;
						result = yield* _recurse(front, end+1);
						if (result > 0) {
							return result - 1;
						}
					}
				} else {
					result = yield front.slice();
					if (result > 0) {
						yield `break ${result}`;
						return result;
					}
				}
			}
			const _resettable = resettableGenerator(_recurse);
			return _resettable();
		},
	};
	let reorder = globals.reorder = {
		active: [],
		itemClass: 'item',
		itemSel: '.item',
		postLoad(opts, $context) {
			if (! opts.isEditable) {
				return;
			}
			this.$context = $context;
			this.starter = this.started.bind(this);
			this.dragger = this.dragged.bind(this);
			this.stopper = this.stopped.bind(this);
			this.swapStarter = this.swapStarted.bind(this);
			this.swapCanceller = this.swapCancelled.bind(this);
			this.swapEnder = this.swapEnded.bind(this);
			this.keyChecker = this.keyCheck.bind(this);
			let $udf = this.$context.find('.udf');
			$udf.find('li').prop('draggable', true).addClass(this.itemClass);
			$udf.find('tr').prop('draggable', true).addClass(this.itemClass);
			$udf.on('dragstart', this.itemSel, this.starter);
			$udf.on('dragover', evt => evt.preventDefault());
			$udf.on('dragenter', this.itemSel, this.dragger);
			$udf.on('dragend', this.stopper);
			$udf.on('click', '.drag', this.swapStarter);
		},
		dragged(evt) {
			let draggable = $(evt.delegateTarget).data('payload'),
				target = reorder.target(evt.target);
			evt.dataTransfer || (evt.dataTransfer = {});
			evt.dataTransfer.dropEffect = evt.dataTransfer.effectAllowed;
			reorder.insertBefore(draggable, target);
		},
		id(elt) {
			return elt
				&& (   elt.id
				    || $(elt).find('.dsf').filter((i, elt) => /_name$/.test(elt.className)).text());
		},
		insertBefore(elt, other) {
			if (elt != other && elt.parentNode == other.parentNode) {
				let parent = other.parentNode,
					iElt = nodeIndex(elt),
					iOther = nodeIndex(other);
				if (iElt < iOther) {
					other = other.nextSibling;
				}
				parent.insertBefore(elt, other);
			}
		},
		keyCheck(evt) {
			switch (evt.keyCode) {
			case 27:
				this.swapCanceller();
				break;
			}
		},
		makeDraggable(elt) {
			let $elt;
			if (elt instanceof $) {
				$elt = elt;
				elt = elt[0];
			} else {
				$elt = $(elt);
			}
			elt.draggable = true;
			$elt.addClass(this.itemClass);
		},
		started(evt) {
			(evt.dataTransfer || {}).effectAllowed = "move";
			let elt = reorder.target(evt.target);
			elt.style.opacity = 0.5;
			$(evt.delegateTarget).data('payload', elt);
		},
		stopped(evt) {
			let elt = reorder.target(evt.target);
			elt.style.opacity = null;
			$(evt.delegateTarget).removeData('payload');
			udf.renumberList(evt.delegateTarget);
		},
		swapCancelled(evt) {
			if (evt) {
				this.swapOff(evt);
			} else {
				for (let delegateTarget of this.active) {
					this.swapOff({delegateTarget, stopPropagation: () => {}}, {keepActive: false});
				}
				this.active = [];
			}
		},
		swapEnded(evt) {
			let other = reorder.target(evt.target),
				elt = $(evt.delegateTarget).data('payload');
			reorder.insertBefore(elt, other);
			this.swapOff(evt);
			udf.renumberList(evt.delegateTarget);
		},
		swapOff(evt, {keepActive=true}={}) {
			evt.stopPropagation();
			if (keepActive) {
				this.active = this.active.filter(elt => elt !== evt.delegateTarget);
			}
			let elt = $(evt.delegateTarget).data('payload');
			$(elt).removeClass('swapping');
			$(evt.delegateTarget).removeData('payload');
			$(evt.delegateTarget).removeClass('busy');
			$(evt.delegateTarget).on('click', '.drag', this.swapStarter);
			$(evt.delegateTarget).off('click', this.itemSel, this.swapEnder);
			$(document).off('click', this.swapCanceller);
			$(document).off('keydown', this.keyChecker);
		},
		swapStarted(evt) {
			evt.stopPropagation();
			if ($(evt.delegateTarget).data('payload')) {
				return;
			}
			this.active.push(evt.delegateTarget);
			let elt = reorder.target(evt.target);
			$(evt.delegateTarget).data('payload', elt);
			$(elt).addClass('swapping');
			$(evt.delegateTarget).addClass('busy');
			$(evt.delegateTarget).off('click', '.drag', this.swapStarter);
			$(evt.delegateTarget).on('click', this.itemSel, this.swapEnder);
			$(document).on('click', this.swapCanceller);
			$(document).on('keydown', this.keyChecker);
		},
		target(elt) {
			return $(elt).closest(this.itemSel)[0];
		},
	};
	function ShorthandDict(mapping={}) {
		this.shorthand = {};
		this.full = {};
		let shortdict = new Proxy(this, {
			apply(target, thisArg, args) {
			},
			defineProperty(target, key, descriptor) {
				Object.defineProperty(this, key, descriptor);
				return true;
			},
			deleteProperty(target, key) {
				let entry = this.resolve(key);
				if (entry) {
					let short = this.shorthand(key);
					if (short && short in target.shorthand) {
						target.shorthand[short] = target.shorthand[short].filter(item => item != entry.key);
						if (! target.shorthand[short].length) {
							delete target.shorthand[short];
						}
					}
					delete target.full[entry.key];
				}
			},
			entry(full, key, target) {
				let match = this.matches(full, key);
				if (match) {
					return {
						key: full,
						value: this.value({
							value: target.full[full],
							match, full, key,
						})
					};
				}
			},
			_direct: {shorthand:1, full:1},
			'get': function(target, key, receiver) {
				if (key in this._direct) {
					return target[key];
				}
				let entry = this.resolve(target, key);
				if (entry) {
					return entry.value;
				}
			},
			getPrototypeOf(target) {
				return ShorthandDict.prototype;
			},
			getOwnPropertyDescriptor(target, key) {
				let entry = this.resolve(target, key);
				return Object.getOwnPropertyDescriptor(target.full, key);
			},
			has(target, key) {
				let entry = this.resolve(target, key);
				return ! is_undefined(entry);
			},
			matches(full, key) {
				return klass.matches(full, key);
			},
			ownKeys(target) {
				return Object.keys(target.full);
			},
			resolve(target, key) {
				if (key in target.full) {
					return {key, value: target.full[key]};
				}
				let short = this.shorthand(key),
					entry;
				if (   short in target.shorthand
					&& (entry = this.search(target.shorthand[short], key, target)))
				{
					return entry;
				}
				if (   short in target.full
					&& (entry = this.entry(short, key, target)))
				{
					return entry;
				}
				return this.search(Object.keys(target.full), key, target);
			},
			search(candidates, key, target) {
				let entry;
				for (let full of candidates) {
					if ((entry = this.entry(full, key, target))) {
						return entry;
					}
				}
			},
			_overwriteable: {entry:1, matches:1, shorthand:1, value:1},
			'set': function(target, key, value) {
				if (key in this._overwriteable && is_function(value)) {
					this[key] = value.bind(target);
					return true;
				}
				let short = this.shorthand(key);
				if (short) {
					if (short in target.shorthand) {
						target.shorthand[short].push(key);
					} else {
						target.shorthand[short] = [key];
					}
				}
				target.full[key] = value;
				return true;
			},
			setPrototypeOf(target, prototype) {
				target.constructor.prototype = prototype;
				return true;
			},
			shorthand(key) {
				return klass.prefix(key);
			},
			value({value, match, full, key}) {
				return value;
			},
		});
		for (let [key, value] of Object.entries(mapping)) {
			shortdict[key] = value;
		}
		return shortdict;
	}
	globals.ShorthandDict = ShorthandDict;
	const words = globals.words = {
		_pluralize: {
			'arcanum': 'arcanoi',
			'obolus': 'oboli',
			'money': 'money',
			'equipment': 'equipment',
		},
		_typos: {
			'corups': 'corpus',
			'corup': 'corpus',
			'memorium': 'memoriam',
			'permenant': 'permanent',
		},
		_singles: {
			'corpus': 'corpus',
			'pathos': 'pathos',
			'status': 'status',
			'obolus': 'obolus',
		},
		_standards: {
			'artefact': 'artifact',
			'artefacts': 'artifacts',
			'bg': 'background',
			'xp': 'experience',
		},
		_plurals: {},
		_singulize: {},
		correct(word) {
			let lower = word.toLowerCase();
			if ( modules.aliases && modules.aliases.typos && modules.aliases.typos[lower]) {
				return modules.aliases.typos[lower];
			}
			return this.lookup(word, this._typos);
		},
		is_plural(word) {
			return (word in this._plurals)
				|| (! (word in this._singles) && /s$/.test(word));
		},
		lookup(word, thesaurus) {
			return thesaurus[word.toLowerCase()] || word;
		},
		pluralize(word) {
			if (this.is_plural(word)) {
				return word;
			}
			return this._pluralize[word]
				|| word.replace(/s?$/, 's').replace(/ys\b/, 'ies');
		},
		singulize(word) {
			word = this.correct(word);
			if (word.toLowerCase() in this._singles) {
				return word;
			}
			return  word.replace(/ies\b/, 'y').replace(/s\b/, '');
		},
		standardize(word) {
			return this.lookup(
				this.correct(word),
				this._standards);
		},
	};
	for (let [single, plural] of Object.entries(words._pluralize)) {
		words._plurals[plural] = plural;
		words._singles[single] = single;
		words._singulize[plural] = single;
	}
	for (let [name, fn] of Object.entries(words)) {
		if (is_function(fn) && fn.length < 2) {
			words[name] = memoize(fn.bind(words));
		}
	}
	const udf = globals.udf = {
		itemNumberWidth: 2,
		maxCount: 100,
		udfSel: '.udf',
		get $udfs() {
			if (! this._$udfs && this.$context) {
				this._$udfs = this.$context.find(this.udfSel);
			}
			return this._$udfs;
		},
		preLoad({slug}, $context) {
			module.tarryFor('compatibility', 'edition');
			this.slug = slug;
			this._createControls();
			this._subscribeListeners();
			for (let template of $('template')) {
				for (let dsf of template.content.querySelectorAll('.dsf')) {
					if (! ('value' in dsf.dataset)) {
						dsf.dataset.value = dsf.textContent;
					}
				}
			}
			this.createItems();
		},
		postLoad() {
			module.on('postLoad', () => this.loaded = true, 'udf.postLoad');
		},
		preSave() {
			this.reCountAll();
		},
		updaters: {
			'1': function (data) {
				let parts;
				for (let name in data) {
					parts = this.parseOld(name);
					if (parts) {
						this.renameField(data, name, parts);
					}
				}
			},
		},
		parseOld(name) {
			const parts = name.match(/^(?:dsf_)?(?<base>(?:thorn|dark_passion|attribute)s?)(?:_(?<sub>\w+))?_(?<i>\d+)$/);
			return (parts || {}).groups;
		},
		renameField(data, name, {base, sub, i}) {
			const rename = {
				'label': 'name',
				'value': '',
			};
			base = words.pluralize(base.dromedaryCase());
			let updated = `dyn_${base}_${i}`;
			if (rename[sub]) {
				sub = rename[sub];
			}
			if (sub) {
				updated += '_' + sub;
			}
			dsa.rename(name, updated, {data});
		},
		_appendItem(eltList, item) {
			$(eltList).append(item);
			$(eltList).trigger('add.mll.udf', [item]);
		},
		_createControls() {
			this.$listControls = $('<div class="controls"><button class="add" title="add"></button></div>');
			this.$itemControls = $('<span class="controls"><span class="del" title="delete"></span><span class="drag" title="click or drag to move"></span></span>');
		},
		_createSizeDsf(udf, {base, $udf}={}) {
			this.$size(udf, {base, $udf});
		},
		_createSizeDsfs() {
			for (let elt of this.$udfs) {
				this._createSizeDsf(elt);
			};
		},
		_subscribeListeners() {
			$(document).on('click', '.udf + .controls button', (evt) => {
				evt.preventDefault();
				return false;
			});
			$(document).on('click', '.udf + .controls .add', (evt) => {
				evt.preventDefault();
				this.add(this.udfFor(evt.target));
				return false;
			});
			$(document).on('click', '.udf + * .controls .add', (evt) => {
				evt.preventDefault();
				this.add(this.udfFor(evt.target));
				return false;
			});
			$(document).on('click', '.udf .del', (evt) => {
				evt.preventDefault();
				if (! $(evt.target).closest(this.udfSel).hasClass('busy')) {
					let $item = $(evt.target).closest('.udf > *');
					switch ($item) {
					case 'dd':
						this.del($item.prev('dt'));
						break;
					case 'dt':
						this.del($item.next('dd'));
						break;
					}
					this.del($item);
				}
				return false;
			});
		},
		add(eltList) {
			modules.undo && modules.undo.begin();
			let eltItem, $dsfs, $toPip;
			eltItem = this.newItem(eltList);
			this._appendItem(eltList, eltItem);
			if (   (pips.has(eltItem))
				&& ($dsfs = $(eltItem).find('span.dsf')).length >= 2)
			{
				$toPip = $dsfs.filter('.pips');
				if (! $toPip.length) {
					$toPip = $dsfs.last();
				}
				pips.pippify($toPip);
			}
			reorder.makeDraggable(eltItem);
			dsf.editable(eltItem);
			if (modules.undo) {
				let $eltItem = $(eltItem),
					$prevItem = $eltItem.prev().last(),
					$parent = $(eltList);
				modules.undo.record(
					() => {
						$prevItem = $eltItem.prev().last();
						$eltItem.remove();
						return $parent;
					},
					() => {
						if ($prevItem.parent().length) {
							$prevItem.after($eltItem);
						} else {
							$parent.append($eltItem);
						}
						return $eltItem;
					}
				);
				modules.undo.commit();
			}
		},
		addDsa(names, values, base) {
			let result = dsa.add(...arguments);
			if (result.base) {
				this.updateSize(result.base, result.i);
			}
		},
		addItemControls(eltItem, $placeholder) {
			let $controls = this.$itemControls.clone();
			$placeholder || ($placeholder = $(eltItem).find('.controls'));
			if ($placeholder.length) {
				$placeholder.replaceWith($controls);
			} else switch (eltItem.tagName) {
			case 'TR':
				$(eltItem).append(
					$('<td></td>')
						.append($controls)
				);
				break;
			default:
				$(eltItem).append($controls);
				break;
			}
		},
		addListControls(eltList, $placeholder) {
			let $controls = this.$listControls.clone();
			$placeholder || ($placeholder = $(eltList).find('+ .controls'));
			if ($placeholder.length) {
				$placeholder.replaceWith($controls);
			} else switch (eltList.tagName) {
			case 'TBODY':
				$(eltList).after(
					$('<tfoot></tfoot>')
						.append(
							$('<tr></tr>')
								.append($('<td></td>')
										.append($controls)))
				);
				break;
			default:
				$(eltList).after($controls);
				break;
			}
		},
		base(eltList) {
			return klass.param(eltList, 'list')
				|| eltList.dataset.base
				|| eltList.dataset.name
				|| dsf.sectionName(eltList)
			;
		},
		bases(section) {
			const $udfs = section ? this.$udf(section) : this.$udfs;
			return $udfs.toArray().map(this.base.bind(this));
			if (section) {
				this.$udf(section).toArray().map(this.base.bind(this));
			} else {
				return this.$udfs
					.parent()
					.closest('[class]')
					.toArray()
					.map(elt => elt.className.replace(/ .*/, ''));
			}
		},
		baseToRe: memoize(function (base) {
			return new RegExp(`^(?:dsf_)?dyn_${base}(?:_|$)`);
		}),
		compact(base, tpls, stop={gap:5}) {
			let sizeName = this.sizeName(base);
			if (! tpls) {
				tpls = this.keyedFieldsFor(base);
				if (! tpls.length) {
					tpls = {
						name: `dyn_${base}_{i:02}_name`,
						value: `dyn_${base}_{i:02}`,
					};
				}
			}
			if (dsa.exists(sizeName) && is_numeric(dsa.data[sizeName])) {
				stop = dsa.data[sizeName]
			}
			let size = dsa.compact(tpls, stop);
			if (dsa.exists(sizeName) && is_numeric(size)) {
				dsa.data[sizeName] = size;
			}
			return size;
		},
		countUdfItems(data) {
			data || (data = dsa.data);
			let counts = {},
				uncounted = {},
				scan = false;
			for (let udf of this.$udfs) {
				let base = this.base(udf),
					name = this.sizeName(base);
				if (dsa.exists(name, data) && is_real(data[name])) {
					counts[base] = data[name];
				} else {
					delete data[name];
					uncounted[base] = base;
					scan = true;
				}
			};
			if (scan) {
				console.info('Scanning data to determine size of UDFs without a stored size field:', Object.values(uncounted));
				for (let base in uncounted) {
					let tpl = `dyn_${base}_{i:02}`,
						name, i;
					for (i = 1; i < this.maxCount; ++i) {
						name = klass.eval(tpl, {i});
						if (! (   dsa.exists(name, data)
							   || dsa.exists(name + '_name', data)))
						{
							break;
						}
					}
					if ((counts[base] = i-1)) {
						delete uncounted[base];
					}
				}
			}
			if (Object.keys(uncounted).length) {
				for (let name of Object.keys(data)) {
					let {base, i} = this.destructureName(name) || {};
					if (base && i) { 
						if (base in counts) {
							counts[base] = Math.max(counts[base], +i);
						} else {
							counts[base] = +i;
						}
					}
				}
			}
			return counts;
		},
		createItemsFor(eltList, nItems, {base}) {
			base || (base = this.base(eltList));
			let $eltList = $(eltList),
				$scion = this.newItem(eltList, {base}),
				$clone;
			this._createSizeDsf(eltList, {base, $udf: $eltList});
			for (let i = 1; i <= nItems; ++i) {
				$clone = $scion.clone();
				this.renumberItem($clone, i);
				this._appendItem($eltList, $clone);
			}
		},
		createItems() {
			let udfCounts = this.countUdfItems();
			for (let udf of this.$udfs) {
				let base = this.base(udf);
				this.createItemsFor(udf, udfCounts[base], {base});
			}
		},
		del(item) {
			let { $elt: $item, elt } = this.resolve(item),
				$parent = $item.parent(),
				iItem = nodeIndex(elt),
				$itemPrev = $item.prev().last(),
				itemNext = $item.next()[0];
			item = elt;
			this.id({item, $item});
			$item.remove();
			$parent.trigger('del.mll.udf', [item]);
			modules.undo && modules.undo.record(
				() => {
					if (itemNext && itemNext.parentElement) {
						$item.insertBefore(itemNext);
					} else if ($itemPrev.parent().length) {
						$itemPrev.after($item);
					} else {
						$parent.append($item);
					}
					return $item;
				},
				() => {
					$item.remove();
					return $parent;
				}
			);
			if (itemNext) {
				this.renumberItems(itemNext);
			}
		},
		destructureName: memoize(function (name) {
			let parts = this.splitName(name);
			if (parts.length) {
				return {base: parts[0], i: parts[1], key: parts[2]};
			}
		}),
		each(fn, self) {
			if (self) {
				fn = fn.bind(self);
			}
			this.$udfs.each(function (i, elt) {
				fn.bind(this)(elt, i);
			});
		},
		eachEntry(items, fn) {
			function entry(item) {
				return fn(this.entry(item));
			}
			this.eachItem(items, entry.bind(this));
		},
		eachItem(items, fn) {
			let {$elt} = this.resolve(items);
			$elt.children().each(fn);
		},
		entry(item) {
			let data = dsf.extract(item);
			return Object.entries(data).reduce((accum, property) => {
				const name = property[0],
					  value = property[1],
					  {base, i, key} = this.parseName(name);
				accum.names[key] = name;
				accum.values[key] = value;
				accum.base = base;
				accum.i = i;
				return accum;
			}, {names:{}, values:{}});
		},
		*entries(list) {
			yield* this.mapItems(list, this.entry.bind(this));
		},
		exists(name, $context) {
			if (name) {
				return ($context || this.$context).find(`.${name} .udf`).length;
			}
		},
		extract(item) {
			return this.extractFrom(dsf.extract(item));
		},
		extractAll(list) {
			let items = {};
			for (let item of this.items(list)) {
				items[item.name] = this.extract(item);
			}
			return items;
		},
		extractFrom(data) {
			return Object.entries(data).reduce((accum, property) => {
				const name = property[0],
					  value = property[1],
					  {base, i, key} = this.parseName(name);
				accum.names[key] = name;
				accum.values[key] = value;
				accum[`${key}_field`] = name;
				accum[key] = value;
				accum.base = base;
				accum.i = i;
				return accum;
			}, {names:{}, values:{}});
		},
		*extracts(list) {
			yield* this.mapItems(list, this.extract.bind(this));
		},
		fieldInfo() {
			let fieldInfo = new ShorthandDict({
				shorthand: this.shorthand,
				matches(full, key) {
					return klass.matchesAny(this.full[full], key);
				},
				value({full, match}) {
					return {base: full, field: match};
				},
			});
			for (let udf of this.$udfs) {
				let base = this.base(udf),
					$udf = $(udf),
					parts, short;
				fieldInfo[base] = this.fieldsFor(udf, {base});
			};
			this.fieldInfo = function () {
				return fieldInfo;
			};
			return fieldInfo;
		},
		fieldsFor(eltList, {base, tpl, $tpl}={}) {
			let resolved = this.resolve(eltList);
			eltList = resolved.elt;
			base || (base = resolved.base);
			if (base in this.fieldsFor) { 
				return this.fieldsFor[base];
			}
			$tpl || ($tpl = tpl ? $(tpl) : this.$templateItem(eltList));
			let env = {base, name: base},
				$dsfs = dsf.$dsfs($tpl),
				names = $dsfs.toArray().map(elt => klass.eval(dsf.name(elt), env).replace(/\d+$/, '{i:02}'));
			this.fieldsFor[base] = names;
			return names;
		},
		id({item, $item}) {
			if (! item.id) {
				let $udf = ($item || $(item)).closest('.udf'),
					udf = $udf[0],
					iItem;
				if (is_undefined($udf.data('id-counter'))) {
					$udf.data('id-counter', 0);
					iItem = 0;
				} else {
					iItem = $udf.data('id-counter');
				}
				item.id = this.base(udf) + '_Item_' + iItem;
				$udf.data('id-counter', iItem + 1);
			}
			return item.id;
		},
		indexOf(name, tpl) {
			let parts;
			if (tpl && (vars = klass.extract(tpl, name)) && 'i' in vars) {
				return +vars.i;
			} else if ((parts = name.match(/\d+$/))) {
				return +parts[0];
			}
		},
		isName(name) {
			return /^(dsf_)?dyn_/.test(name);
		},
		isTemplate(name) {
			return /^(dsf_)?dyn_.*\{.*\}/.test(name);
		},
		*items(udf) {
			let {$elt} = this.resolve(udf);
			yield* $elt.children();
		},
		itemNumber(eltItem) {
			return nodeIndex(eltItem) + 1;
		},
		key(name, dflt='value') {
			let {key} = this.parseName(name, dflt);
			return key;
		},
		keyedFieldsFor(eltList, kwargs={}) {
			let fields = this.fieldsFor(eltList, kwargs).map(dsf.stripPrefix),
				tpls = {},
				nTpls = 0;
			for (let field of fields) {
				let key = this.key(field);
				tpls[key] = field;
				++nTpls;
			}
			Object.defineProperty(tpls, 'length', {
				enumerable:false,
				value: nTpls,
			});
			Object.defineProperty(tpls, 'size', {
				enumerable:false,
				value: nTpls,
			});
			return tpls;
		},
		*mapItems(list, f) {
			for (let item of this.items(list)) {
				yield f(item);
			}
		},
		newItem(eltList, env={}) {
			let $tpl = this.$template(eltList),
				iItem = eltList.children.length + 1,
				$eltItem;
			if ($tpl.length) {
				env.base || (env.base = this.base(eltList));
				env.name || (env.name = env.base);
				env.i || (env.i = iItem);
				$eltItem = $tpl.clone(true);
				this.setNameList($eltItem, env.base);
				this.renameItem($eltItem, env);
			} else {
				$eltItem = $(eltList.children[0].cloneNode(true));
				this.resetItem($eltItem, iItem);
			}
			return $eltItem;
		},
		parseName(name, dflt='value') {
			let parts = this.destructureName(name);
			parts && (parts.key || (parts.key = dflt));
			return parts;
		},
		reCount(eltList) {
			let n = eltList.children.length;
			this.$size(eltList).text(n);
		},
		reCountAll() {
			this.each(function (eltList) {
				this.reCount(eltList);
			}, this);
		},
		renameItem(eltItem, env) {
			for (let node of dsf.$dsfs(eltItem)) {
				node.className = klass.eval(node.className, env);
			};
		},
		renumberItem(eltItem, i, {width, addl, volatile}={}) {
			if (! i) {
				let iLast = eltItem.length - 1;
				if ('length' in eltItem && iLast in $tpl) {
					i = this.itemNumber(eltItem[iLast]) / eltItem.length;
				} else {
					i = this.itemNumber(eltItem);
				}
			}
			for (let elt of dsf.$dsfs(eltItem)) {
				let vars = (klass.vars(elt.className) || []).filter(v => 1 == v.length);
				if (vars.length) {
					elt.className = klass.eval(elt.className, {[vars[0]]: i});
				} else {
					elt.className = elt.className.replace(
						/\b(dsf_[^ \d]*[^_ \d])(?:_\d+)?/,
						'$1_' + this.zeroPad(i, width)
					);
				}
				if (volatile) {
					dsf.removeValue(elt);
				}
			};
			addl && addl(eltItem);
		},
		renumberItems(eltItem, options={}) {
			let iItem = this.itemNumber(eltItem);
			for (; eltItem; eltItem = eltItem.nextSibling) {
				this.renumberItem(eltItem, iItem++, {...options, volatile:true});
			}
		},
		renumberList(eltList, options={}) {
			let eltItem;
			for (let i = 0; i < eltList.children.length; ++i) {
				this.renumberItem(eltList.children[i], i + 1, {...options, volatile:true});
			}
		},
		resetItem(eltItem, iItem) {
			let $eltItem = $(eltItem);
			$eltItem.find('.dsf').each((i, elt) => dsf.clear(elt));
			pips.clear($eltItem);
			this.renumberItem(eltItem, iItem);
		},
		resolve(list) {
			let base, elt, $elt;
			if (is_string(list)) {
				base = list;
				$elt = this.$udf(base);
				elt = $elt[0];
			} else {
				if (list instanceof $) {
					$elt = list;
					elt = list[0];
				} else {
					elt = list;
					$elt = $(list);
				}
				base = this.base(elt);
			}
			return {base, elt, $elt};
		},
		scan(section) {
			if (this.loaded) {
				return this.scanDsfs(section);
			} else {
				return this.scanDsa(section);
			}
		},
		*scanDsfs(section) {
			for (let list of this.$udf(section)) {
				for (let data of this.extracts(list)) {
					yield data;
				}
			}
		},
		*scanDsa(section) {
			const bases = this.bases(section),
				  tpls = [
					  'dyn_{base}_{i:02}',
					  'dyn_{base}_{i:02}_specialty'
				  ];
			for (let [field, value, env] of
				 dsa.entries('dyn_{base}_{i:02}_name',
							 range.keyed({
								 base: bases,
								 i:[1, this.maxCount]
							 }), {continuous:true})
				)
			{
				const names = [field, ...klass.evalAll(tpls, env)],
					  values = dsa.getAll(names),
					  data = this.extractFrom(zipObject(names, values));
				yield data;
			}
		},
		setNameList($eltItem, base) {
			const namesList = `MLL_${base}_names`;
			if ($(`#${namesList}`).length) {
				$eltItem.find('.dsf.name').attr('list', namesList);
			}
		},
		shorthand: memoize(function (name) {
			let parts = name.match(/^(?:dsf_)?(?:dyn_)?([^_]+)_/);
			if (parts) {
				return parts[1];
			}
		}),
		size(list) {
			let {base, elt, $elt} = this.resolve(list),
				size = this.sizeName(base);
			return dsf.value(size) || dsa.data[size];
		},
		$size(eltList, {base, $udf}={}) {
			base || (base = this.base(eltList));
			$udf || ($udf = $(eltList));
			let $size = this.sizeField(eltList, {base, $udf});
			if (! $size.length) {
				$size = $(`<span class="dsf ${$size.name} readonly hidden nopips"></span>`);
				switch (eltList.tagName) {
				case 'TR':
					$udf.closest('table').before($size);
					break;
				default:
					$udf.before($size);
					break;
				}
			}
			return $size;
		},
		sizeField(eltList, {base, $udf}) {
			base || (base = this.base(eltList));
			$udf || ($udf = $(eltList));
			let name = `dsf_${base}_size`,
				$size = $udf.parent().find(`.${name}`);
			$size.name = name;
			return $size;
		},
		sizeName(base) {
			return base + '_size';
		},
		splitName: memoize(function (name) {
			if (this.isName(name)) {
				return path.split(this.stripPrefix(name));
			}
			return [];
		}),
		start() {
			for (let doc of this.$context.find('template.item')) {
				let item = doc.content.firstElementChild;
				this.addItemControls(item);
			};
			for (let eltList of this.$udfs) {
				let $list = $(eltList),
					$controls = $list.find('+ .controls');
				if ($controls.length && $controls[0].childElementCount) {
					$controls.show();
				} else {
					this.addListControls(eltList, $controls);
				}
			};
			for (let eltItem of this.$context.find('.udf > *')) {
				let $controls = $(eltItem).find('.controls');
				if ($controls.length && $controls[0].childElementCount) {
					$controls.show();
				} else {
					this.addItemControls(eltItem, $controls);
				}
			};
		},
		stop() {
		},
		stripPrefix(name) {
			return name.replace(/^(dsf_)?dyn_/, '');
		},
		template(eltList) {
			let $eltList;
			if (is_string(eltList)) {
				$eltList = this.$udf(eltList);
			} else {
				$eltList = $(eltList);
			}
			let tpl = $eltList.parent()
				.closestHaving('[class]', ':scope > template')
				.children('template')[0];
			if (tpl && 'content' in tpl) {
				tpl = tpl.content;
			}
			return tpl;
		},
		$template(eltList) {
			return $((this.template(eltList) || {}).children);
		},
		$templateItem(eltList) {
			let $tpl = this.$template(eltList);
			if ($tpl.length) {
				return $tpl;
			}
			return $(eltList.children[0]);
		},
		$udf(base) {
			if (base instanceof HTMLElement) {
				base = $(base);
			}
			if (base instanceof $) {
				return base.find(this.udfSel);
			}
			return this.$context.find(`.page .${base} .udf`);
		},
		udfField: memoize(function (name, fieldInfo) {
			return fieldInfo[name];
		}),
		udfFor(elt) {
			while (elt && ! (elt.previousElementSibling && /\budf\b/.test(elt.previousElementSibling.className))) {
				elt = elt.parentNode;
			}
			return elt && elt.previousElementSibling;
		},
		updateSize(base, size) {
			let sizeName = this.sizeName(base);
			if (sizeName in dsa.data) {
				dsa.data[sizeName] = Math.max(dsa.data[sizeName], size);
			}
		},
		zeroPad(i, width) {
			return i.toString().padStart(width || this.itemNumberWidth, '0')
		},
	};
	bindSome(udf, ['exists']);
	let tabs = globals.tabs = {
		preLoad(opts, $context) {
			this.$context = $context;
			this.$tabGroups = this.$context.find('.tabs');
			this.$tabGroups.children().on('click', this.clicked.bind(this));
			this.$tabGroups.each(function (i, elt) {
				let $elt = $(elt),
					name = tabs.savedTab($elt) || tabs.name(elt.children[0]);
				tabs.select($elt, name);
			});
		},
		groupName($tabGroup) {
			return this.name($tabGroup.parent()[0]);
		},
		is(elt) {
			return /\btabs\b/.test(elt.parentNode.className);
		},
		name(elt) {
			return elt.className.replace(/ .*/, '');
		},
		$pages(tab) {
			return $(tab).closestHaving('*', ':scope > .page').children('.page');
		},
		resolve($tabGroup, tab) {
			let $tab, name;
			if (is_string(tab)) {
				name = tab;
				$tab = this.$tab($tabGroup, tab);
			} else {
				$tab = $(tab);
				name = this.name($tab[0]);
			}
			return {$tab, name};
		},
		savedTab($tabGroup) {
			let groupName = this.groupName($tabGroup),
				hash = window.location.hash.replace(/^#/, '');
			if (hash && $tabGroup.find(`> .${hash}`).length) {
				return hash;
			} else if ('tabs' in localStorage && groupName in localStorage.tabs) {
				return localStorage.tabs[groupName];
			}
		},
		select($tabGroup, tab) {
			let {$tab, name} = this.resolve($tabGroup, tab);
			if (name !== $tabGroup.data('current')) {
				this.$tabs($tabGroup).removeClass('selected');
				this.$pages($tabGroup).hide();
				$tabGroup.data('current', name);
				$tab.addClass('selected');
				$tabGroup.parent().find(`.page.${name}`).show();
			}
		},
		tab(name) {
			return this.$context.find(`.tabs > .${name}`);
		},
		$tab($tabGroup, name) {
			return $tabGroup.children(`.${name}`);
		},
		$tabGroup(tab) {
			return $(tab).closest('.tabs');
		},
		$tabs($tabGroup) {
			return $tabGroup.children();
		},
		clicked(evt) {
			if (this.is(evt.target)) {
				let name = this.name(evt.target),
					$tabGroup = this.$tabGroup(evt.target);
				this.select($tabGroup, name);
			}
		},
	};
	var op = globals.op = {
		get app() {
			return aisleten.characters;
		},
		trigger(name, ...args) {
			if (args.length == 1 && Array.isArray(args[0])) {
				args = args[0];
			}
			name = name.replace(/^data/i, '');
			this.app.dstCallback(`${this.slug}_data${name.ucfirst()}`, ...args);
		}
	};
	const editor = globals.editor = {
		_$editors: {},
		custClass: 'custedit',
		_$inputs: {
			input($dsf) {
				return $(`<input />`);
			},
			list($dsf) {
				let name = editor.listFor($dsf);
				return $(`<input list="${name}" />`);
			},
			text($dsf) {
				return $('<textarea></textarea>');
			},
		},
		_inputUpdaters: {
			input($input, {$dsf, name, type}) {
			},
			list($input, {$dsf, name, type}) {
				let list = editor.listFor($dsf);
				$input.attr('list', list);
			},
			text($input, {$dsf, name, type}) {
			},
		},
		init($context, slug) {
			this.$context = $context;
			this.slug = slug;
		},
		preLoad(opts) {
			this.opts = {...opts};
		},
		postLoad({isEditable}) {
			if (isEditable) {
				this.keyChecker = this.keyCheck.bind(this);
				this.clicker = this.clicked.bind(this);
				this.submitter = this.submitted.bind(this);
				this.blurrer = this.blurred.bind(this);
				$('.udf').on('add.mll.udf', (evt, ...args) => this.setup(...args));
				this.setup(this.$context);
			}
		},
		blurred(evt) {
			this.save(evt.target);
		},
		clicked(evt) {
			const $dsf = $(evt.target).closest('.dsf'),
				  name = dsf.name($dsf); 
			let $editor;
			console.debug(`editor.clicked ${name}`);
			if (! $dsf.hasClass('editing')) {
				$editor = this.start($dsf);
			} else {
				evt.stopPropagation();
				$editor = $dsf.data('$editor') || this.$active;
			}
			if ($editor) {
				$editor.data('$input').trigger('focus');
			}
		},
		editCancelled(evt) {
			modules.undo && (modules.undo.freeze = true);
			try {
				let $dsf = this.resolve(evt);
				this.stop($dsf);
				this.restore($dsf);
			} finally {
				modules.undo && (modules.undo.freeze = false);
			}
		},
		keyCheck(evt) {
			switch (evt.keyCode) {
			case 27:
				this.editCancelled(evt);
				break;
			}
		},
		submitted(evt) {
			evt.preventDefault();
			$(evt.target).find('.value').trigger('blur');
			return false;
		},
		addBreaks(value) {
			return value.replace(/(^|[^>])(?:<br\/?>)*\n(?!\s*<)/gm, '$1<br/>\n');
		},
		delBreaks(value) {
			return value.replace(/(?:<br\/?>)*\n/g, '\n');
		},
		$editor($dsf) {
			let name = dsf.name($dsf),
				type = this.type($dsf);
			if (! type) {
				return;
			}
			if (! (type in this._$editors)) {
				let $form = $('<form></form>'),
					$input = this._$inputs[type]($dsf);
				$input.addClass('value');
				$form.append($input);
				$form.data('$input', $input);
				$form.value = function (val) {
					this.data('$input').val(val); 
				};
				$input.on('keydown', this.keyChecker);
				$input.on('blur', this.blurrer);
				$form.on('submit', this.submitter);
				this._$editors[type] = $form;
			} else {
				let $form = this._$editors[type],
					$input = this.$input($form);
				this._inputUpdaters[type]($input, {$dsf, name, type});
			}
			return this._$editors[type];
		},
		$input($elt) {
			let $editor;
			if (! $elt) {
				return;
			}
			if ('FORM' == $elt[0].tagName) {
				$editor = $elt;
			} else {
				$editor = $elt.data('$editor') || this.$editor($elt);
			}
			return $editor.data('$input')
				|| $editor.find('input, textarea, select');
		},
		listFor($dsf) {
			if ($dsf instanceof $) {
				return $dsf.attr('list');
			} else {
				return $dsf.getAttribute('list');
			}
		},
		resolve(dsf) {
			if ('target' in dsf) {
				dsf = dsf.target;
			}
			if (! (dsf instanceof $)) {
				dsf = $(dsf);
			}
			return dsf.closest('.dsf')
		},
		restore($dsf) {
			let value = $dsf.data('old-value'),
				$input = this.$input($dsf);
			$input.val(value);
			this.store($dsf, value);
		},
		save($dsf) {
			$dsf = this.resolve($dsf);
			if (! $dsf.hasClass('editing')) {
				return;
			}
			console.debug(`editor.save ${dsf.name($dsf)}`);
			this.stop($dsf);
			let $editor = $dsf.data('$editor'),
				val = $editor.find('.value').val(),
				oldVal = dsf.value($dsf);
			let noChange = val === oldVal;
			if (noChange) {
				modules.undo && (modules.undo.freeze = true);
			}
			try {
				this.store($dsf, val);
			} finally {
				if (noChange) {
					modules.undo && (modules.undo.freeze = false);
				}
			}
			this.opts.fieldName = dsf.name($dsf);
			this.opts.fieldValue = val;
			this.opts.oldValue = oldVal;
		},
		setup($context) {
			if (! ($context instanceof $)) {
				$context = $($context);
			}
			$context.find('.dsf[list], .dsf.notes')
				.addClass('readonly ' + this.custClass)
				.on('click', this.clicker);
		},
		start($dsf) {
			$dsf = this.resolve($dsf);
			let val = this.delBreaks($dsf.html()),
				$editor = this.$editor($dsf),
				$input = this.$input($dsf);
			console.debug(`editor.start ${dsf.name($dsf)}`);
			if (! $editor) {
				console.debug(`editor: skipping; no editor for ${dsf.name($dsf)}`);
				return;
			}
			if (val == editMarker) {
				val = '';
			}
			$dsf.addClass('editing');
			$input.val(val); 
			$dsf.data('old-value', val);
			$dsf.text('');
			$dsf.append($editor);
			$dsf.data('$editor', $editor);
			this.$active = $editor;
			return $editor;
		},
		stop($dsf) {
			console.debug(`editor.stop ${dsf.name($dsf)}`);
			$dsf = this.resolve($dsf);
			let $editor = $dsf.data('$editor');
			$dsf.removeClass('editing');
			$editor.detach();
		},
		store($dsf, value) {
			console.debug(`editor.store ${dsf.name($dsf)} <- ${value}`);
			if (! /<p\b/.test(value)) {
				value = this.addBreaks(value);
			}
			dsf.value($dsf, value);
			$dsf.removeData('old-value');
		},
		type($dsf) {
			if ($dsf.attr('list')) {
				return 'list';
			}
			if ($dsf.hasClass('notes') || $dsf.hasClass('text')) {
				return 'text';
			}
			return 'input';
		},
	};
	let notes = globals.notes = {
		postLoad({isEditable}) {
			this.$context = $context;
			if (! isEditable) {
				$context.find(':not(.help) .tipped > .tip:empty').parent().addClass('notip').removeClass('tipped');
			}
		},
	};
	let shadow = globals.shadow = {
		postLoad(opts, $context) {
			let psyche_slug = dsf.value('psyche_slug');
			if (psyche_slug) {
				dsf.$dsf('psyche').wrap(`<a href="/characters/${psyche_slug}"></a>`);
			}
		}
	};
	const undo = globals.undo = {
		freeze: false,
		_history: [],
		_future: [],
		_transactions: [],
		get history() {
			if (this.freeze) {
				return [];
			}
			return this._history;
		},
		set history(value) {
			if (this.freeze) {
				return;
			}
			this._history = value;
		},
		get future() {
			if (this.freeze) {
				return [];
			}
			return this._future;
		},
		set future(value) {
			if (this.freeze) {
				return;
			}
			this._future = value;
		},
		get transactions() {
			if (this.freeze) {
				return [];
			}
			return this._transactions;
		},
		set transactions(value) {
			if (this.freeze) {
				return;
			}
			this._future = value;
		},
		get undos() {
			return this.history;
		},
		set undos(value) {
			this.history = value;
		},
		get redos() {
			return this.future;
		},
		set redos(value) {
			this.future = value;
		},
		init($context, slug, isEditable) {
			this.freeze = true;
			this.$context = $context;
			this.keyPresser = this.keyPressed.bind(this);
			if (isEditable) {
				$(window).on('keydown', this.keyPresser);
			}
		},
		postLoad() {
			this.freeze = false;
		},
		preSave() {
			this.freeze = true;
		},
		get isMac() {
			return /^Mac/.test(navigator.platform);
		},
		get transactioning() {
			return this.transactions.length;
		},
		apply(operation, changes, revert) {
			if (this.transactioning) {
				console.error(`undo.{$operation}: Some module did not finish combining changes for undoing, and ${caller.name} did not handle it; doing so now. However, this may leave undo/redo and the sheet in an inconsistent state. Please save now and then re-edit.`);
				this.commitAll();
			}
			let result;
			if (changes.length) {
				let change = changes.pop();
				try {
					this.freeze = true;
					result = change[operation]();
					this.freeze = false;
					revert.push(change);
					if (result) {
						this.highlight(result);
					}
				} catch (err) {
					console.error(`Error during ${operation}:`, err);
					alert(`Error during ${operation}: ${err}. Please save now & reopen for further edits. Redoes redoes may leave sheet with inconsistent data; redo at your own risk.`);
				} finally {
					this.freeze = false;
				}
			} else {
				alerts.info(`No more ${operation}s.`);
			}
			if (this.history.length) {
				dsf.dirty();
			} else {
				dsf.clean();
			}
			return result;
		},
		begin() {
			if (this.freeze) { 
				return;
			}
			return this.transactions.push({undos:[], redos:[]});
		},
		cancel() {
			if (this.freeze) { 
				return;
			}
			return this.transactions.pop();
		},
		cancelAll() {
			if (this.freeze) { 
				return;
			}
			this.transactions = [];
		},
		clear() {
			this.history = [];
			this.future = [];
		},
		cmdKey(evt) {
			if (evt.metaKey || evt.ctrlKey ) {
				return evt.key;
			}
			return;
		},
		commit() {
			if (this.freeze) { 
				return;
			}
			let changes = this.transactions.pop();
			if (changes) {
				if (changes.undos.length > 1) {
					let undos = () => callAllFunctions(changes.undos),
						redos = () => callAllFunctions(changes.redos);
					undos.undos = changes.undos;
					redos.redos = changes.redos;
					this.record(
						undos, 
						redos, 
					);
				} else {
					this.record(changes.undos[0], changes.redos[0]);
				}
			}
		},
		commitAll() {
			if (this.freeze) { 
				return;
			}
			let changes = this.transactions.shift();
			if (changes) {
				for (let change of this.transactions) {
					changes.undo.push(...change.undo);
					changes.redo.push(...change.redo);
				}
				this.transactions = [changes];
				this.commit();
			}
		},
		async highlight(elt, $elt) {
			if (Array.isArray(elt)) {
				elt.map(e => this.highlight(e));
				return;
			}
			let requested = true;
			if (elt instanceof $) {
				$elt = elt;
				elt = $elt[0];
			}
			$elt || ($elt = $(elt));
			while ('none' == $elt.css('display')) {
				elt = elt.parentNode;
				$elt = $(elt);
				requested = false;
			}
			if (! (requested || $elt.closest('.dsf').length || $elt.hasClass('tipped'))) {
				return;
			}
			if (elt.scrollIntoView) {
				elt.scrollIntoView({behavior: 'smooth', block: 'nearest'});
				$elt.addClass('highlight');
				await transitions.fade($elt, {reset: true});
				$elt.removeClass('highlight');
				transitions.clearFade($elt);
			}
		},
		keyPressed(evt) {
			switch (this.cmdKey(evt)) {
			case 'z':
				this.undo();
				evt.preventDefault();
				break;
			case 'Z':
			case 'y':
				this.redo();
				evt.preventDefault();
				break;
			}
		},
		record(undo, redo) {
			if (this.freeze) { 
				return;
			}
			let transaction = this.transaction();
			if (transaction) {
				transaction.undos.push(undo);
				transaction.redos.push(redo);
			} else {
				this.history.push({undo, redo});
				this.future = [];
				dsf.dirty();
			}
		},
		redo() {
			if (this.transactioning) {
				console.warn(`undo.${operation}: Some module did not finish combining changes for undoing; doing so now. This invalidates all redoes.`);
				alert(`Cannot redo, as . Attempting to clean up, which discards future redoes.`);
				this.commitAll();
			} else {
				this.apply('redo', this.future, this.history);
			}
		},
		transact(fn, all=false) {
			let result;
			this.begin();
			try {
				result = fn();
			} finally {
				if (all) {
					this.commitAll();
				} else {
					this.commit();
				}
			}
			return result;
		},
		transaction() {
			return this.transactions[this.transactions.length-1];
		},
		undo() {
			if (this.transactioning) {
				console.warn(`undo.${operation}: Some module did not finish combining changes for undoing; doing so now (these changes will be the ones undone).`);
				this.commitAll();
			}
			this.apply('undo', this.history, this.future);
		},
	};

	const requires = {
    "abilities": {
        "klass": "klass",
        "ResettableGenerator": "ResettableGenerator",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "path": "path",
        "pips": "pips",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf"
    },
    "alerts": {
        "transitions": "transitions"
    },
    "aliases": {
        "klass": "klass",
        "ResettableGenerator": "ResettableGenerator",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "path": "path",
        "pips": "pips",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf",
        "abilities": "abilities",
        "compatibility": "compatibility",
        "aliases": "aliases"
    },
    "associates": [],
    "authorize": [],
    "compatibility": {
        "klass": "klass",
        "ResettableGenerator": "ResettableGenerator",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "path": "path",
        "pips": "pips",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf",
        "abilities": "abilities",
        "compatibility": "compatibility",
        "aliases": "aliases"
    },
    "deluxe": {
        "klass": "klass",
        "nameGen": "nameGen",
        "transitions": "transitions",
        "alerts": "alerts",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "pips": "pips",
        "op": "op",
        "ResettableGenerator": "ResettableGenerator",
        "path": "path",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf",
        "abilities": "abilities",
        "edition": "edition",
        "editor": "editor",
        "health": "health",
        "notes": "notes",
        "tabs": "tabs",
        "undo": "undo"
    },
    "demipips": {
        "klass": "klass",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "pips": "pips"
    },
    "dsa": {
        "klass": "klass",
        "nameGen": "nameGen"
    },
    "dsf": {
        "klass": "klass",
        "nameGen": "nameGen"
    },
    "edition": {
        "klass": "klass",
        "ResettableGenerator": "ResettableGenerator",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "path": "path",
        "pips": "pips",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf",
        "abilities": "abilities"
    },
    "editor": {
        "klass": "klass",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "op": "op"
    },
    "funcs": [],
    "health": {
        "klass": "klass",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "pips": "pips"
    },
    "klass": [],
    "module": [],
    "nameGen": {
        "klass": "klass"
    },
    "notes": [],
    "op": [],
    "path": {
        "klass": "klass",
        "nameGen": "nameGen",
        "dsf": "dsf"
    },
    "pips": {
        "klass": "klass",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver"
    },
    "range": {
        "ResettableGenerator": "ResettableGenerator"
    },
    "reorder": {
        "ResettableGenerator": "ResettableGenerator",
        "klass": "klass",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "path": "path",
        "pips": "pips",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf"
    },
    "ResettableGenerator": [],
    "resolver": {
        "klass": "klass",
        "nameGen": "nameGen",
        "dsf": "dsf"
    },
    "shadow": {
        "klass": "klass",
        "ResettableGenerator": "ResettableGenerator",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "path": "path",
        "pips": "pips",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf",
        "tabs": "tabs"
    },
    "ShorthandDict": {
        "klass": "klass"
    },
    "tabs": [],
    "transitions": [],
    "udf": {
        "klass": "klass",
        "ResettableGenerator": "ResettableGenerator",
        "nameGen": "nameGen",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "path": "path",
        "pips": "pips",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf"
    },
    "undo": {
        "klass": "klass",
        "nameGen": "nameGen",
        "transitions": "transitions",
        "alerts": "alerts",
        "dsf": "dsf"
    },
    "version": {
        "module": "module"
    },
    "words": [],
    "wraith": {
        "klass": "klass",
        "nameGen": "nameGen",
        "transitions": "transitions",
        "alerts": "alerts",
        "dsf": "dsf",
        "authorize": "authorize",
        "module": "module",
        "resolver": "resolver",
        "dsa": "dsa",
        "pips": "pips",
        "op": "op",
        "ResettableGenerator": "ResettableGenerator",
        "path": "path",
        "range": "range",
        "reorder": "reorder",
        "ShorthandDict": "ShorthandDict",
        "words": "words",
        "udf": "udf",
        "abilities": "abilities",
        "edition": "edition",
        "editor": "editor",
        "health": "health",
        "notes": "notes",
        "tabs": "tabs",
        "undo": "undo",
        "associates": "associates",
        "deluxe": "deluxe"
    }
};


	const modules = {"klass":"klass","nameGen":"nameGen","transitions":"transitions","alerts":"alerts","dsf":"dsf","ResettableGenerator":"ResettableGenerator","authorize":"authorize","resolver":"resolver","dsa":"dsa","path":"path","pips":"pips","range":"range","reorder":"reorder","ShorthandDict":"ShorthandDict","words":"words","udf":"udf","tabs":"tabs","op":"op","editor":"editor","notes":"notes","shadow":"shadow","undo":"undo"};

	for (let name in modules) {
		if (name in globals && 'object' == typeof(globals[name])) {
			modules[name] = globals[name];
			module.register(name, globals[name]);
			if ('updaters' in globals[name]) {
				version.registerModule(globals[name]);
			}
		}
	}

	/*** */
	const advantages = {
		arcanoi: fillObject([
			'argos', 'castigate', 'embody', 'fascinate', 'fatalism', 'flux',
			'inhabit', 'intimation', 'keening', 'lifeweb', 'mnemosynis', 'moliate',
			'outrage', 'pandemonium', 'phantasm', 'puppetry', 'serendipity', 'usury'
		], 1),
		backgrounds: fillObject([
			'ally', 'artifact', 'contact', 'eidolon', 'haunt', 'legacy',
			'mentor', 'memoriam', 'notoriety', 'relic', 'status',
		], 1),
	};

	if ('compatibility' in modules) {
		compatibility.aliases = aliases;
		compatibility.advantages = advantages;
		compatibility.defaults = {
			perm_health: 10,
			perm_willpower: 5,
			curr_willpower: 'perm_willpower',
		};
	}

	function edit() {
		pips.start();
		udf.start();
	}

	function noedit() {
		pips.stop();
		udf.stop();
		$('.editable').removeClass('.editable');
	}

	$.extend(globals, {edit, noedit});

	// disable example buttons
	$('.help button').on('click', function (evt) {
		evt.preventDefault();
		evt.stopPropagation();
		return false;
	});

	/*** DS API */
	let listeners = {};

	let $context;
	listeners.PreLoad = function dataPreLoad(opts) {
		let sel = `#${opts.containerId}`;
		$context = $(sel);
		$context.selector = sel;
		$context.containerId = opts.containerId;
		// for debugging
		mll_sheet.$context = $context;

		// init, so updaters have $context
		module.all('init', $context, slug, opts.isEditable);
		// update before preLoad
		version.update();
		module.all('preLoad', opts, $context);
	};

	listeners.PostLoad = function dataPostLoad(opts) {
		module.all('postLoad', opts, $context);

		if (opts.isEditable) {
			edit();
		} else {
			noedit();
		}
	};

	listeners.Change = function dataChange(opts) {
		if (listeners.Change.active) {
			return;
		}
		listeners.Change.active = true;

		opts.$field = dsf.$dsf(opts.fieldName);
		opts.field = opts.$field[0];
		if (! ('oldValue' in opts)) {
			// should return old value (as field.dataset.value should take precedence)
			opts.oldValue = dsf.value(opts.$field);
		}
		module.base.tryTransact(() => {
				module.all('change', opts, $context);
			});

		listeners.Change.active = false;
	};

	listeners.PreSave = function dataPreSave(opts) {
		module.all('preSave', opts, $context);
	};

	/* ${slug}_dataPreLoad, at least, must be present before the dynamic sheet framework loads DSFs, so might as well do them all. */
	function registerListeners() {
		for (let evt in listeners) {
			window[`${slug}_data${evt}`] = listeners[evt];
		}
	}

	if (slug) {
		registerListeners();
	} else {
		$(function () {
			if (! slug) {
				$slug = $('.dst_slug');
				slug = $slug.text();
				registerListeners();
			}
		});
	}

	// for debugging
	window.mll_sheet = $.extend(window.mll_sheet /*??*/|| {}, globals);
	window.mll_sheet.module = module;
	if (dbg) {
		$.extend(window, globals);
	}
})(jQuery);

Back

Wraith-Shadow (Fumbral)

Create Your Campaign

Just One More Step

Just A Little More Info

Use a Social Account