1425 lines
42 KiB
JavaScript
1425 lines
42 KiB
JavaScript
var App = (() => {
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from2, except, desc) => {
|
|
if (from2 && typeof from2 === "object" || typeof from2 === "function") {
|
|
for (let key of __getOwnPropNames(from2))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// build/dev/javascript/markdown2/markdown2.mjs
|
|
var markdown2_exports = {};
|
|
__export(markdown2_exports, {
|
|
main: () => main,
|
|
testing: () => testing
|
|
});
|
|
|
|
// build/dev/javascript/prelude.mjs
|
|
var CustomType = class {
|
|
withFields(fields) {
|
|
let properties = Object.keys(this).map(
|
|
(label) => label in fields ? fields[label] : this[label]
|
|
);
|
|
return new this.constructor(...properties);
|
|
}
|
|
};
|
|
var List = class {
|
|
static fromArray(array3, tail) {
|
|
let t = tail || new Empty();
|
|
for (let i = array3.length - 1; i >= 0; --i) {
|
|
t = new NonEmpty(array3[i], t);
|
|
}
|
|
return t;
|
|
}
|
|
[Symbol.iterator]() {
|
|
return new ListIterator(this);
|
|
}
|
|
toArray() {
|
|
return [...this];
|
|
}
|
|
atLeastLength(desired) {
|
|
let current = this;
|
|
while (desired-- > 0 && current) current = current.tail;
|
|
return current !== void 0;
|
|
}
|
|
hasLength(desired) {
|
|
let current = this;
|
|
while (desired-- > 0 && current) current = current.tail;
|
|
return desired === -1 && current instanceof Empty;
|
|
}
|
|
countLength() {
|
|
let current = this;
|
|
let length2 = 0;
|
|
while (current) {
|
|
current = current.tail;
|
|
length2++;
|
|
}
|
|
return length2 - 1;
|
|
}
|
|
};
|
|
function prepend(element, tail) {
|
|
return new NonEmpty(element, tail);
|
|
}
|
|
function toList(elements, tail) {
|
|
return List.fromArray(elements, tail);
|
|
}
|
|
var ListIterator = class {
|
|
#current;
|
|
constructor(current) {
|
|
this.#current = current;
|
|
}
|
|
next() {
|
|
if (this.#current instanceof Empty) {
|
|
return { done: true };
|
|
} else {
|
|
let { head, tail } = this.#current;
|
|
this.#current = tail;
|
|
return { value: head, done: false };
|
|
}
|
|
}
|
|
};
|
|
var Empty = class extends List {
|
|
};
|
|
var List$Empty = () => new Empty();
|
|
var NonEmpty = class extends List {
|
|
constructor(head, tail) {
|
|
super();
|
|
this.head = head;
|
|
this.tail = tail;
|
|
}
|
|
};
|
|
var List$NonEmpty = (head, tail) => new NonEmpty(head, tail);
|
|
var List$isNonEmpty = (value) => value instanceof NonEmpty;
|
|
var List$NonEmpty$first = (value) => value.head;
|
|
var List$NonEmpty$rest = (value) => value.tail;
|
|
var BitArray = class {
|
|
/**
|
|
* The size in bits of this bit array's data.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
bitSize;
|
|
/**
|
|
* The size in bytes of this bit array's data. If this bit array doesn't store
|
|
* a whole number of bytes then this value is rounded up.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
byteSize;
|
|
/**
|
|
* The number of unused high bits in the first byte of this bit array's
|
|
* buffer prior to the start of its data. The value of any unused high bits is
|
|
* undefined.
|
|
*
|
|
* The bit offset will be in the range 0-7.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
bitOffset;
|
|
/**
|
|
* The raw bytes that hold this bit array's data.
|
|
*
|
|
* If `bitOffset` is not zero then there are unused high bits in the first
|
|
* byte of this buffer.
|
|
*
|
|
* If `bitOffset + bitSize` is not a multiple of 8 then there are unused low
|
|
* bits in the last byte of this buffer.
|
|
*
|
|
* @type {Uint8Array}
|
|
*/
|
|
rawBuffer;
|
|
/**
|
|
* Constructs a new bit array from a `Uint8Array`, an optional size in
|
|
* bits, and an optional bit offset.
|
|
*
|
|
* If no bit size is specified it is taken as `buffer.length * 8`, i.e. all
|
|
* bytes in the buffer make up the new bit array's data.
|
|
*
|
|
* If no bit offset is specified it defaults to zero, i.e. there are no unused
|
|
* high bits in the first byte of the buffer.
|
|
*
|
|
* @param {Uint8Array} buffer
|
|
* @param {number} [bitSize]
|
|
* @param {number} [bitOffset]
|
|
*/
|
|
constructor(buffer, bitSize, bitOffset) {
|
|
if (!(buffer instanceof Uint8Array)) {
|
|
throw globalThis.Error(
|
|
"BitArray can only be constructed from a Uint8Array"
|
|
);
|
|
}
|
|
this.bitSize = bitSize ?? buffer.length * 8;
|
|
this.byteSize = Math.trunc((this.bitSize + 7) / 8);
|
|
this.bitOffset = bitOffset ?? 0;
|
|
if (this.bitSize < 0) {
|
|
throw globalThis.Error(`BitArray bit size is invalid: ${this.bitSize}`);
|
|
}
|
|
if (this.bitOffset < 0 || this.bitOffset > 7) {
|
|
throw globalThis.Error(
|
|
`BitArray bit offset is invalid: ${this.bitOffset}`
|
|
);
|
|
}
|
|
if (buffer.length !== Math.trunc((this.bitOffset + this.bitSize + 7) / 8)) {
|
|
throw globalThis.Error("BitArray buffer length is invalid");
|
|
}
|
|
this.rawBuffer = buffer;
|
|
}
|
|
/**
|
|
* Returns a specific byte in this bit array. If the byte index is out of
|
|
* range then `undefined` is returned.
|
|
*
|
|
* When returning the final byte of a bit array with a bit size that's not a
|
|
* multiple of 8, the content of the unused low bits are undefined.
|
|
*
|
|
* @param {number} index
|
|
* @returns {number | undefined}
|
|
*/
|
|
byteAt(index3) {
|
|
if (index3 < 0 || index3 >= this.byteSize) {
|
|
return void 0;
|
|
}
|
|
return bitArrayByteAt(this.rawBuffer, this.bitOffset, index3);
|
|
}
|
|
equals(other) {
|
|
if (this.bitSize !== other.bitSize) {
|
|
return false;
|
|
}
|
|
const wholeByteCount = Math.trunc(this.bitSize / 8);
|
|
if (this.bitOffset === 0 && other.bitOffset === 0) {
|
|
for (let i = 0; i < wholeByteCount; i++) {
|
|
if (this.rawBuffer[i] !== other.rawBuffer[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
const trailingBitsCount = this.bitSize % 8;
|
|
if (trailingBitsCount) {
|
|
const unusedLowBitCount = 8 - trailingBitsCount;
|
|
if (this.rawBuffer[wholeByteCount] >> unusedLowBitCount !== other.rawBuffer[wholeByteCount] >> unusedLowBitCount) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
for (let i = 0; i < wholeByteCount; i++) {
|
|
const a = bitArrayByteAt(this.rawBuffer, this.bitOffset, i);
|
|
const b = bitArrayByteAt(other.rawBuffer, other.bitOffset, i);
|
|
if (a !== b) {
|
|
return false;
|
|
}
|
|
}
|
|
const trailingBitsCount = this.bitSize % 8;
|
|
if (trailingBitsCount) {
|
|
const a = bitArrayByteAt(
|
|
this.rawBuffer,
|
|
this.bitOffset,
|
|
wholeByteCount
|
|
);
|
|
const b = bitArrayByteAt(
|
|
other.rawBuffer,
|
|
other.bitOffset,
|
|
wholeByteCount
|
|
);
|
|
const unusedLowBitCount = 8 - trailingBitsCount;
|
|
if (a >> unusedLowBitCount !== b >> unusedLowBitCount) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Returns this bit array's internal buffer.
|
|
*
|
|
* @deprecated
|
|
*
|
|
* @returns {Uint8Array}
|
|
*/
|
|
get buffer() {
|
|
if (this.bitOffset !== 0 || this.bitSize % 8 !== 0) {
|
|
throw new globalThis.Error(
|
|
"BitArray.buffer does not support unaligned bit arrays"
|
|
);
|
|
}
|
|
return this.rawBuffer;
|
|
}
|
|
/**
|
|
* Returns the length in bytes of this bit array's internal buffer.
|
|
*
|
|
* @deprecated
|
|
*
|
|
* @returns {number}
|
|
*/
|
|
get length() {
|
|
if (this.bitOffset !== 0 || this.bitSize % 8 !== 0) {
|
|
throw new globalThis.Error(
|
|
"BitArray.length does not support unaligned bit arrays"
|
|
);
|
|
}
|
|
return this.rawBuffer.length;
|
|
}
|
|
};
|
|
function bitArrayByteAt(buffer, bitOffset, index3) {
|
|
if (bitOffset === 0) {
|
|
return buffer[index3] ?? 0;
|
|
} else {
|
|
const a = buffer[index3] << bitOffset & 255;
|
|
const b = buffer[index3 + 1] >> 8 - bitOffset;
|
|
return a | b;
|
|
}
|
|
}
|
|
var UtfCodepoint = class {
|
|
constructor(value) {
|
|
this.value = value;
|
|
}
|
|
};
|
|
var Result = class _Result extends CustomType {
|
|
static isResult(data2) {
|
|
return data2 instanceof _Result;
|
|
}
|
|
};
|
|
var Ok = class extends Result {
|
|
constructor(value) {
|
|
super();
|
|
this[0] = value;
|
|
}
|
|
isOk() {
|
|
return true;
|
|
}
|
|
};
|
|
var Result$Ok = (value) => new Ok(value);
|
|
var Error2 = class extends Result {
|
|
constructor(detail) {
|
|
super();
|
|
this[0] = detail;
|
|
}
|
|
isOk() {
|
|
return false;
|
|
}
|
|
};
|
|
var Result$Error = (detail) => new Error2(detail);
|
|
function isEqual(x, y) {
|
|
let values2 = [x, y];
|
|
while (values2.length) {
|
|
let a = values2.pop();
|
|
let b = values2.pop();
|
|
if (a === b) continue;
|
|
if (!isObject(a) || !isObject(b)) return false;
|
|
let unequal = !structurallyCompatibleObjects(a, b) || unequalDates(a, b) || unequalBuffers(a, b) || unequalArrays(a, b) || unequalMaps(a, b) || unequalSets(a, b) || unequalRegExps(a, b);
|
|
if (unequal) return false;
|
|
const proto = Object.getPrototypeOf(a);
|
|
if (proto !== null && typeof proto.equals === "function") {
|
|
try {
|
|
if (a.equals(b)) continue;
|
|
else return false;
|
|
} catch {
|
|
}
|
|
}
|
|
let [keys, get2] = getters(a);
|
|
const ka = keys(a);
|
|
const kb = keys(b);
|
|
if (ka.length !== kb.length) return false;
|
|
for (let k of ka) {
|
|
values2.push(get2(a, k), get2(b, k));
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getters(object3) {
|
|
if (object3 instanceof Map) {
|
|
return [(x) => x.keys(), (x, y) => x.get(y)];
|
|
} else {
|
|
let extra = object3 instanceof globalThis.Error ? ["message"] : [];
|
|
return [(x) => [...extra, ...Object.keys(x)], (x, y) => x[y]];
|
|
}
|
|
}
|
|
function unequalDates(a, b) {
|
|
return a instanceof Date && (a > b || a < b);
|
|
}
|
|
function unequalBuffers(a, b) {
|
|
return !(a instanceof BitArray) && a.buffer instanceof ArrayBuffer && a.BYTES_PER_ELEMENT && !(a.byteLength === b.byteLength && a.every((n, i) => n === b[i]));
|
|
}
|
|
function unequalArrays(a, b) {
|
|
return Array.isArray(a) && a.length !== b.length;
|
|
}
|
|
function unequalMaps(a, b) {
|
|
return a instanceof Map && a.size !== b.size;
|
|
}
|
|
function unequalSets(a, b) {
|
|
return a instanceof Set && (a.size != b.size || [...a].some((e) => !b.has(e)));
|
|
}
|
|
function unequalRegExps(a, b) {
|
|
return a instanceof RegExp && (a.source !== b.source || a.flags !== b.flags);
|
|
}
|
|
function isObject(a) {
|
|
return typeof a === "object" && a !== null;
|
|
}
|
|
function structurallyCompatibleObjects(a, b) {
|
|
if (typeof a !== "object" && typeof b !== "object" && (!a || !b))
|
|
return false;
|
|
let nonstructural = [Promise, WeakSet, WeakMap, Function];
|
|
if (nonstructural.some((c) => a instanceof c)) return false;
|
|
return a.constructor === b.constructor;
|
|
}
|
|
|
|
// build/dev/javascript/gleam_stdlib/dict.mjs
|
|
var referenceMap = /* @__PURE__ */ new WeakMap();
|
|
var tempDataView = /* @__PURE__ */ new DataView(
|
|
/* @__PURE__ */ new ArrayBuffer(8)
|
|
);
|
|
var referenceUID = 0;
|
|
function hashByReference(o) {
|
|
const known = referenceMap.get(o);
|
|
if (known !== void 0) {
|
|
return known;
|
|
}
|
|
const hash = referenceUID++;
|
|
if (referenceUID === 2147483647) {
|
|
referenceUID = 0;
|
|
}
|
|
referenceMap.set(o, hash);
|
|
return hash;
|
|
}
|
|
function hashMerge(a, b) {
|
|
return a ^ b + 2654435769 + (a << 6) + (a >> 2) | 0;
|
|
}
|
|
function hashString(s) {
|
|
let hash = 0;
|
|
const len = s.length;
|
|
for (let i = 0; i < len; i++) {
|
|
hash = Math.imul(31, hash) + s.charCodeAt(i) | 0;
|
|
}
|
|
return hash;
|
|
}
|
|
function hashNumber(n) {
|
|
tempDataView.setFloat64(0, n);
|
|
const i = tempDataView.getInt32(0);
|
|
const j = tempDataView.getInt32(4);
|
|
return Math.imul(73244475, i >> 16 ^ i) ^ j;
|
|
}
|
|
function hashBigInt(n) {
|
|
return hashString(n.toString());
|
|
}
|
|
function hashObject(o) {
|
|
const proto = Object.getPrototypeOf(o);
|
|
if (proto !== null && typeof proto.hashCode === "function") {
|
|
try {
|
|
const code = o.hashCode(o);
|
|
if (typeof code === "number") {
|
|
return code;
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
if (o instanceof Promise || o instanceof WeakSet || o instanceof WeakMap) {
|
|
return hashByReference(o);
|
|
}
|
|
if (o instanceof Date) {
|
|
return hashNumber(o.getTime());
|
|
}
|
|
let h = 0;
|
|
if (o instanceof ArrayBuffer) {
|
|
o = new Uint8Array(o);
|
|
}
|
|
if (Array.isArray(o) || o instanceof Uint8Array) {
|
|
for (let i = 0; i < o.length; i++) {
|
|
h = Math.imul(31, h) + getHash(o[i]) | 0;
|
|
}
|
|
} else if (o instanceof Set) {
|
|
o.forEach((v) => {
|
|
h = h + getHash(v) | 0;
|
|
});
|
|
} else if (o instanceof Map) {
|
|
o.forEach((v, k) => {
|
|
h = h + hashMerge(getHash(v), getHash(k)) | 0;
|
|
});
|
|
} else {
|
|
const keys = Object.keys(o);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const k = keys[i];
|
|
const v = o[k];
|
|
h = h + hashMerge(getHash(v), hashString(k)) | 0;
|
|
}
|
|
}
|
|
return h;
|
|
}
|
|
function getHash(u) {
|
|
if (u === null) return 1108378658;
|
|
if (u === void 0) return 1108378659;
|
|
if (u === true) return 1108378657;
|
|
if (u === false) return 1108378656;
|
|
switch (typeof u) {
|
|
case "number":
|
|
return hashNumber(u);
|
|
case "string":
|
|
return hashString(u);
|
|
case "bigint":
|
|
return hashBigInt(u);
|
|
case "object":
|
|
return hashObject(u);
|
|
case "symbol":
|
|
return hashByReference(u);
|
|
case "function":
|
|
return hashByReference(u);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
var Dict = class {
|
|
constructor(size2, root) {
|
|
this.size = size2;
|
|
this.root = root;
|
|
}
|
|
};
|
|
var bits = 5;
|
|
var mask = (1 << bits) - 1;
|
|
var noElementMarker = /* @__PURE__ */ Symbol();
|
|
var generationKey = /* @__PURE__ */ Symbol();
|
|
var emptyNode = /* @__PURE__ */ newNode(0);
|
|
var emptyDict = /* @__PURE__ */ new Dict(0, emptyNode);
|
|
var errorNil = /* @__PURE__ */ Result$Error(void 0);
|
|
function makeNode(generation, datamap, nodemap, data2) {
|
|
return {
|
|
// A node is a high-arity (32 in practice) hybrid tree node.
|
|
// Hybrid means that it stores data directly as well as pointers to child nodes.
|
|
//
|
|
// Each node contains 2 bitmaps:
|
|
// - The datamap has a bit set if that slot in the node contains direct data
|
|
// - The nodemap has a bit set if that slot in the node contains another node.
|
|
//
|
|
// Both are exclusive to on another, so datamap & nodemap == 0.
|
|
//
|
|
// Every key/hash value directly correlates to a specific bit by using a trie
|
|
// suffix (least significant bits first) encoding.
|
|
// For example, if the last 5 bits of the hash are 1101, the bit to check for
|
|
// that value is the 13th bit.
|
|
datamap,
|
|
nodemap,
|
|
// The slots itself are stored in a single contiguous array that contains
|
|
// both direct k/v-pairs and child nodes.
|
|
//
|
|
// The direct children come first, followed by the child nodes in _reverse order_:
|
|
//
|
|
// 7654321
|
|
// datamap: 1000100
|
|
// nodemap: 10011
|
|
// data: [key3, value3, key7, value7, child5, child2, child1]
|
|
// -------------------------> <---------------------
|
|
// datamap nodemap
|
|
//
|
|
// Every `1` bit in the datamap corresponds to a pair of [key, value] entries,
|
|
// and every `1` bit in the nodemap corresponds to a child node entry.
|
|
//
|
|
// Children are stored in reverse order to avoid having to store or calculate an
|
|
// "offset" value to skip over the direct children.
|
|
data: data2,
|
|
// The generation is used to track which nodes need to be copied during transient updates.
|
|
// Using a symbol here makes `isEqual` ignore this field.
|
|
[generationKey]: generation
|
|
};
|
|
}
|
|
function newNode(generation) {
|
|
return makeNode(generation, 0, 0, []);
|
|
}
|
|
function copyNode(node, generation) {
|
|
if (node[generationKey] === generation) {
|
|
return node;
|
|
}
|
|
const newData = node.data.slice(0);
|
|
return makeNode(generation, node.datamap, node.nodemap, newData);
|
|
}
|
|
function copyAndSet(node, generation, idx, val) {
|
|
if (node.data[idx] === val) {
|
|
return node;
|
|
}
|
|
node = copyNode(node, generation);
|
|
node.data[idx] = val;
|
|
return node;
|
|
}
|
|
function copyAndInsertPair(node, generation, bit, idx, key, val) {
|
|
const data2 = node.data;
|
|
const length2 = data2.length;
|
|
const newData = new Array(length2 + 2);
|
|
let readIndex = 0;
|
|
let writeIndex = 0;
|
|
while (readIndex < idx) newData[writeIndex++] = data2[readIndex++];
|
|
newData[writeIndex++] = key;
|
|
newData[writeIndex++] = val;
|
|
while (readIndex < length2) newData[writeIndex++] = data2[readIndex++];
|
|
return makeNode(generation, node.datamap | bit, node.nodemap, newData);
|
|
}
|
|
function make() {
|
|
return emptyDict;
|
|
}
|
|
function get(dict2, key) {
|
|
const result = lookup(dict2.root, key, getHash(key));
|
|
return result !== noElementMarker ? Result$Ok(result) : errorNil;
|
|
}
|
|
function lookup(node, key, hash) {
|
|
for (let shift = 0; shift < 32; shift += bits) {
|
|
const data2 = node.data;
|
|
const bit = hashbit(hash, shift);
|
|
if (node.nodemap & bit) {
|
|
node = data2[data2.length - 1 - index(node.nodemap, bit)];
|
|
} else if (node.datamap & bit) {
|
|
const dataidx = Math.imul(index(node.datamap, bit), 2);
|
|
return isEqual(key, data2[dataidx]) ? data2[dataidx + 1] : noElementMarker;
|
|
} else {
|
|
return noElementMarker;
|
|
}
|
|
}
|
|
const overflow = node.data;
|
|
for (let i = 0; i < overflow.length; i += 2) {
|
|
if (isEqual(key, overflow[i])) {
|
|
return overflow[i + 1];
|
|
}
|
|
}
|
|
return noElementMarker;
|
|
}
|
|
function toTransient(dict2) {
|
|
return {
|
|
generation: nextGeneration(dict2),
|
|
root: dict2.root,
|
|
size: dict2.size,
|
|
dict: dict2
|
|
};
|
|
}
|
|
function fromTransient(transient) {
|
|
if (transient.root === transient.dict.root) {
|
|
return transient.dict;
|
|
}
|
|
return new Dict(transient.size, transient.root);
|
|
}
|
|
function nextGeneration(dict2) {
|
|
const root = dict2.root;
|
|
if (root[generationKey] < Number.MAX_SAFE_INTEGER) {
|
|
return root[generationKey] + 1;
|
|
}
|
|
const queue = [root];
|
|
while (queue.length) {
|
|
const node = queue.pop();
|
|
node[generationKey] = 0;
|
|
const nodeStart = data.length - popcount(node.nodemap);
|
|
for (let i = nodeStart; i < node.data.length; ++i) {
|
|
queue.push(node.data[i]);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
function destructiveTransientInsert(key, value, transient) {
|
|
const hash = getHash(key);
|
|
transient.root = insertIntoNode(transient, transient.root, key, value, hash, 0);
|
|
return transient;
|
|
}
|
|
function insertIntoNode(transient, node, key, value, hash, shift) {
|
|
const data2 = node.data;
|
|
const generation = transient.generation;
|
|
if (shift > 32) {
|
|
for (let i = 0; i < data2.length; i += 2) {
|
|
if (isEqual(key, data2[i])) {
|
|
return copyAndSet(node, generation, i + 1, value);
|
|
}
|
|
}
|
|
transient.size += 1;
|
|
return copyAndInsertPair(node, generation, 0, data2.length, key, value);
|
|
}
|
|
const bit = hashbit(hash, shift);
|
|
if (node.nodemap & bit) {
|
|
const nodeidx2 = data2.length - 1 - index(node.nodemap, bit);
|
|
let child2 = data2[nodeidx2];
|
|
child2 = insertIntoNode(transient, child2, key, value, hash, shift + bits);
|
|
return copyAndSet(node, generation, nodeidx2, child2);
|
|
}
|
|
const dataidx = Math.imul(index(node.datamap, bit), 2);
|
|
if ((node.datamap & bit) === 0) {
|
|
transient.size += 1;
|
|
return copyAndInsertPair(node, generation, bit, dataidx, key, value);
|
|
}
|
|
if (isEqual(key, data2[dataidx])) {
|
|
return copyAndSet(node, generation, dataidx + 1, value);
|
|
}
|
|
const childShift = shift + bits;
|
|
let child = emptyNode;
|
|
child = insertIntoNode(transient, child, key, value, hash, childShift);
|
|
const key2 = data2[dataidx];
|
|
const value2 = data2[dataidx + 1];
|
|
const hash2 = getHash(key2);
|
|
child = insertIntoNode(transient, child, key2, value2, hash2, childShift);
|
|
transient.size -= 1;
|
|
const length2 = data2.length;
|
|
const nodeidx = length2 - 1 - index(node.nodemap, bit);
|
|
const newData = new Array(length2 - 1);
|
|
let readIndex = 0;
|
|
let writeIndex = 0;
|
|
while (readIndex < dataidx) newData[writeIndex++] = data2[readIndex++];
|
|
readIndex += 2;
|
|
while (readIndex <= nodeidx) newData[writeIndex++] = data2[readIndex++];
|
|
newData[writeIndex++] = child;
|
|
while (readIndex < length2) newData[writeIndex++] = data2[readIndex++];
|
|
return makeNode(generation, node.datamap ^ bit, node.nodemap | bit, newData);
|
|
}
|
|
function fold(dict2, state, fun) {
|
|
const queue = [dict2.root];
|
|
while (queue.length) {
|
|
const node = queue.pop();
|
|
const data2 = node.data;
|
|
const edgesStart = data2.length - popcount(node.nodemap);
|
|
for (let i = 0; i < edgesStart; i += 2) {
|
|
state = fun(state, data2[i], data2[i + 1]);
|
|
}
|
|
for (let i = edgesStart; i < data2.length; ++i) {
|
|
queue.push(data2[i]);
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
function popcount(n) {
|
|
n -= n >>> 1 & 1431655765;
|
|
n = (n & 858993459) + (n >>> 2 & 858993459);
|
|
return Math.imul(n + (n >>> 4) & 252645135, 16843009) >>> 24;
|
|
}
|
|
function index(bitmap, bit) {
|
|
return popcount(bitmap & bit - 1);
|
|
}
|
|
function hashbit(hash, shift) {
|
|
return 1 << (hash >>> shift & mask);
|
|
}
|
|
|
|
// build/dev/javascript/gleam_stdlib/gleam/dict.mjs
|
|
function from_list_loop(loop$transient, loop$list) {
|
|
while (true) {
|
|
let transient = loop$transient;
|
|
let list2 = loop$list;
|
|
if (list2 instanceof Empty) {
|
|
return fromTransient(transient);
|
|
} else {
|
|
let rest = list2.tail;
|
|
let key = list2.head[0];
|
|
let value = list2.head[1];
|
|
loop$transient = destructiveTransientInsert(key, value, transient);
|
|
loop$list = rest;
|
|
}
|
|
}
|
|
}
|
|
function from_list(list2) {
|
|
return from_list_loop(toTransient(make()), list2);
|
|
}
|
|
|
|
// build/dev/javascript/gleam_stdlib/gleam/list.mjs
|
|
function reverse_and_prepend(loop$prefix, loop$suffix) {
|
|
while (true) {
|
|
let prefix = loop$prefix;
|
|
let suffix = loop$suffix;
|
|
if (prefix instanceof Empty) {
|
|
return suffix;
|
|
} else {
|
|
let first$1 = prefix.head;
|
|
let rest$1 = prefix.tail;
|
|
loop$prefix = rest$1;
|
|
loop$suffix = prepend(first$1, suffix);
|
|
}
|
|
}
|
|
}
|
|
function reverse(list2) {
|
|
return reverse_and_prepend(list2, toList([]));
|
|
}
|
|
function filter_loop(loop$list, loop$fun, loop$acc) {
|
|
while (true) {
|
|
let list2 = loop$list;
|
|
let fun = loop$fun;
|
|
let acc = loop$acc;
|
|
if (list2 instanceof Empty) {
|
|
return reverse(acc);
|
|
} else {
|
|
let first$1 = list2.head;
|
|
let rest$1 = list2.tail;
|
|
let _block;
|
|
let $ = fun(first$1);
|
|
if ($) {
|
|
_block = prepend(first$1, acc);
|
|
} else {
|
|
_block = acc;
|
|
}
|
|
let new_acc = _block;
|
|
loop$list = rest$1;
|
|
loop$fun = fun;
|
|
loop$acc = new_acc;
|
|
}
|
|
}
|
|
}
|
|
function filter(list2, predicate) {
|
|
return filter_loop(list2, predicate, toList([]));
|
|
}
|
|
function map_loop(loop$list, loop$fun, loop$acc) {
|
|
while (true) {
|
|
let list2 = loop$list;
|
|
let fun = loop$fun;
|
|
let acc = loop$acc;
|
|
if (list2 instanceof Empty) {
|
|
return reverse(acc);
|
|
} else {
|
|
let first$1 = list2.head;
|
|
let rest$1 = list2.tail;
|
|
loop$list = rest$1;
|
|
loop$fun = fun;
|
|
loop$acc = prepend(fun(first$1), acc);
|
|
}
|
|
}
|
|
}
|
|
function map2(list2, fun) {
|
|
return map_loop(list2, fun, toList([]));
|
|
}
|
|
function flatten_loop(loop$lists, loop$acc) {
|
|
while (true) {
|
|
let lists = loop$lists;
|
|
let acc = loop$acc;
|
|
if (lists instanceof Empty) {
|
|
return reverse(acc);
|
|
} else {
|
|
let list2 = lists.head;
|
|
let further_lists = lists.tail;
|
|
loop$lists = further_lists;
|
|
loop$acc = reverse_and_prepend(list2, acc);
|
|
}
|
|
}
|
|
}
|
|
function flatten(lists) {
|
|
return flatten_loop(lists, toList([]));
|
|
}
|
|
function flat_map(list2, fun) {
|
|
return flatten(map2(list2, fun));
|
|
}
|
|
|
|
// build/dev/javascript/gleam_stdlib/gleam_stdlib.mjs
|
|
var Nil = void 0;
|
|
function identity(x) {
|
|
return x;
|
|
}
|
|
function parse_int(value) {
|
|
if (/^[-+]?(\d+)$/.test(value)) {
|
|
return Result$Ok(parseInt(value));
|
|
} else {
|
|
return Result$Error(Nil);
|
|
}
|
|
}
|
|
function string_replace(string3, target, substitute) {
|
|
return string3.replaceAll(target, substitute);
|
|
}
|
|
function graphemes(string3) {
|
|
const iterator = graphemes_iterator(string3);
|
|
if (iterator) {
|
|
return arrayToList(Array.from(iterator).map((item) => item.segment));
|
|
} else {
|
|
return arrayToList(string3.match(/./gsu));
|
|
}
|
|
}
|
|
var segmenter = void 0;
|
|
function graphemes_iterator(string3) {
|
|
if (globalThis.Intl && Intl.Segmenter) {
|
|
segmenter ||= new Intl.Segmenter();
|
|
return segmenter.segment(string3)[Symbol.iterator]();
|
|
}
|
|
}
|
|
function pop_grapheme(string3) {
|
|
let first;
|
|
const iterator = graphemes_iterator(string3);
|
|
if (iterator) {
|
|
first = iterator.next().value?.segment;
|
|
} else {
|
|
first = string3.match(/./su)?.[0];
|
|
}
|
|
if (first) {
|
|
return Result$Ok([first, string3.slice(first.length)]);
|
|
} else {
|
|
return Result$Error(Nil);
|
|
}
|
|
}
|
|
function split(xs, pattern) {
|
|
return arrayToList(xs.split(pattern));
|
|
}
|
|
function starts_with(haystack, needle) {
|
|
return haystack.startsWith(needle);
|
|
}
|
|
function split_once(haystack, needle) {
|
|
const index3 = haystack.indexOf(needle);
|
|
if (index3 >= 0) {
|
|
const before = haystack.slice(0, index3);
|
|
const after = haystack.slice(index3 + needle.length);
|
|
return Result$Ok([before, after]);
|
|
} else {
|
|
return Result$Error(Nil);
|
|
}
|
|
}
|
|
var unicode_whitespaces = [
|
|
" ",
|
|
// Space
|
|
" ",
|
|
// Horizontal tab
|
|
"\n",
|
|
// Line feed
|
|
"\v",
|
|
// Vertical tab
|
|
"\f",
|
|
// Form feed
|
|
"\r",
|
|
// Carriage return
|
|
"\x85",
|
|
// Next line
|
|
"\u2028",
|
|
// Line separator
|
|
"\u2029"
|
|
// Paragraph separator
|
|
].join("");
|
|
var trim_start_regex = /* @__PURE__ */ new RegExp(
|
|
`^[${unicode_whitespaces}]*`
|
|
);
|
|
var trim_end_regex = /* @__PURE__ */ new RegExp(`[${unicode_whitespaces}]*$`);
|
|
function trim_start(string3) {
|
|
return string3.replace(trim_start_regex, "");
|
|
}
|
|
function trim_end(string3) {
|
|
return string3.replace(trim_end_regex, "");
|
|
}
|
|
function print(string3) {
|
|
if (typeof process === "object" && process.stdout?.write) {
|
|
process.stdout.write(string3);
|
|
} else if (typeof Deno === "object") {
|
|
Deno.stdout.writeSync(new TextEncoder().encode(string3));
|
|
} else {
|
|
console.log(string3);
|
|
}
|
|
}
|
|
var MIN_I32 = -(2 ** 31);
|
|
var MAX_I32 = 2 ** 31 - 1;
|
|
var U32 = 2 ** 32;
|
|
var MAX_SAFE = Number.MAX_SAFE_INTEGER;
|
|
var MIN_SAFE = Number.MIN_SAFE_INTEGER;
|
|
function arrayToList(array3) {
|
|
let list2 = List$Empty();
|
|
let i = array3.length;
|
|
while (i--) {
|
|
list2 = List$NonEmpty(array3[i], list2);
|
|
}
|
|
return list2;
|
|
}
|
|
|
|
// build/dev/javascript/gleam_stdlib/gleam/string.mjs
|
|
function replace(string3, pattern, substitute) {
|
|
let _pipe = string3;
|
|
let _pipe$1 = identity(_pipe);
|
|
let _pipe$2 = string_replace(_pipe$1, pattern, substitute);
|
|
return identity(_pipe$2);
|
|
}
|
|
function split2(x, substring) {
|
|
if (substring === "") {
|
|
return graphemes(x);
|
|
} else {
|
|
let _pipe = x;
|
|
let _pipe$1 = identity(_pipe);
|
|
let _pipe$2 = split(_pipe$1, substring);
|
|
return map2(_pipe$2, identity);
|
|
}
|
|
}
|
|
function trim(string3) {
|
|
let _pipe = string3;
|
|
let _pipe$1 = trim_start(_pipe);
|
|
return trim_end(_pipe$1);
|
|
}
|
|
|
|
// build/dev/javascript/gleam_stdlib/gleam/result.mjs
|
|
function unwrap(result, default$) {
|
|
if (result instanceof Ok) {
|
|
let v = result[0];
|
|
return v;
|
|
} else {
|
|
return default$;
|
|
}
|
|
}
|
|
|
|
// build/dev/javascript/gleam_json/gleam_json_ffi.mjs
|
|
function json_to_string(json) {
|
|
return JSON.stringify(json);
|
|
}
|
|
function object(entries) {
|
|
return Object.fromEntries(entries);
|
|
}
|
|
function identity2(x) {
|
|
return x;
|
|
}
|
|
function array(list2) {
|
|
const array3 = [];
|
|
while (List$isNonEmpty(list2)) {
|
|
array3.push(List$NonEmpty$first(list2));
|
|
list2 = List$NonEmpty$rest(list2);
|
|
}
|
|
return array3;
|
|
}
|
|
|
|
// build/dev/javascript/gleam_json/gleam/json.mjs
|
|
function to_string2(json) {
|
|
return json_to_string(json);
|
|
}
|
|
function string2(input) {
|
|
return identity2(input);
|
|
}
|
|
function int2(input) {
|
|
return identity2(input);
|
|
}
|
|
function object2(entries) {
|
|
return object(entries);
|
|
}
|
|
function preprocessed_array(from2) {
|
|
return array(from2);
|
|
}
|
|
function array2(entries, inner_type) {
|
|
let _pipe = entries;
|
|
let _pipe$1 = map2(_pipe, inner_type);
|
|
return preprocessed_array(_pipe$1);
|
|
}
|
|
|
|
// build/dev/javascript/markdown2/mode.mjs
|
|
var Hirachy = class extends CustomType {
|
|
};
|
|
var Truth = class extends CustomType {
|
|
};
|
|
var Marking = class extends CustomType {
|
|
};
|
|
var Quote = class extends CustomType {
|
|
};
|
|
|
|
// build/dev/javascript/markdown2/definition.mjs
|
|
var Line = class extends CustomType {
|
|
constructor($0) {
|
|
super();
|
|
this[0] = $0;
|
|
}
|
|
};
|
|
var Text = class extends CustomType {
|
|
constructor($0) {
|
|
super();
|
|
this[0] = $0;
|
|
}
|
|
};
|
|
var Push = class extends CustomType {
|
|
constructor($0) {
|
|
super();
|
|
this[0] = $0;
|
|
}
|
|
};
|
|
var Pop = class extends CustomType {
|
|
constructor($0) {
|
|
super();
|
|
this[0] = $0;
|
|
}
|
|
};
|
|
var Hirachy2 = class extends CustomType {
|
|
constructor($0) {
|
|
super();
|
|
this[0] = $0;
|
|
}
|
|
};
|
|
var Truth2 = class extends CustomType {
|
|
constructor($0) {
|
|
super();
|
|
this[0] = $0;
|
|
}
|
|
};
|
|
var Marking2 = class extends CustomType {
|
|
constructor($0) {
|
|
super();
|
|
this[0] = $0;
|
|
}
|
|
};
|
|
var Quote2 = class extends CustomType {
|
|
constructor($0) {
|
|
super();
|
|
this[0] = $0;
|
|
}
|
|
};
|
|
|
|
// build/dev/javascript/markdown2/parser.mjs
|
|
function whatsthat(mod) {
|
|
let modes = from_list(
|
|
toList([
|
|
[
|
|
"!",
|
|
[
|
|
new Marking(),
|
|
(var0) => {
|
|
return new Marking2(var0);
|
|
}
|
|
]
|
|
],
|
|
[
|
|
"@",
|
|
[new Truth(), (var0) => {
|
|
return new Truth2(var0);
|
|
}]
|
|
],
|
|
[
|
|
">",
|
|
[new Quote(), (var0) => {
|
|
return new Quote2(var0);
|
|
}]
|
|
],
|
|
[
|
|
"#",
|
|
[
|
|
new Hirachy(),
|
|
(var0) => {
|
|
return new Hirachy2(var0);
|
|
}
|
|
]
|
|
]
|
|
])
|
|
);
|
|
let $ = pop_grapheme(mod);
|
|
if ($ instanceof Ok) {
|
|
let prefix = $[0][0];
|
|
let rest = $[0][1];
|
|
let $1 = get(modes, prefix);
|
|
if ($1 instanceof Ok) {
|
|
let m = $1[0][0];
|
|
let make_definition = $1[0][1];
|
|
if (rest === "-") {
|
|
return new Pop(m);
|
|
} else {
|
|
let _block;
|
|
let _pipe = parse_int(rest);
|
|
_block = unwrap(_pipe, 1);
|
|
let value = _block;
|
|
return new Push(make_definition(value));
|
|
}
|
|
} else {
|
|
return new Text(mod);
|
|
}
|
|
} else {
|
|
return new Text(mod);
|
|
}
|
|
}
|
|
function parse(modificators) {
|
|
let _pipe = modificators;
|
|
let _pipe$1 = replace(_pipe, "#", " |#");
|
|
let _pipe$2 = replace(_pipe$1, "@", " |@");
|
|
let _pipe$3 = replace(_pipe$2, "!", " |!");
|
|
let _pipe$4 = replace(_pipe$3, ">", " |>");
|
|
let _pipe$5 = split2(_pipe$4, " |");
|
|
let _pipe$6 = flat_map(
|
|
_pipe$5,
|
|
(block) => {
|
|
let $ = starts_with(block, "#") || starts_with(
|
|
block,
|
|
"@"
|
|
) || starts_with(block, "!") || starts_with(block, ">");
|
|
if ($) {
|
|
let $1 = split_once(block, " ");
|
|
if ($1 instanceof Ok) {
|
|
let tag = $1[0][0];
|
|
let rest = $1[0][1];
|
|
return toList([tag, rest]);
|
|
} else {
|
|
return toList([block]);
|
|
}
|
|
} else {
|
|
return toList([block]);
|
|
}
|
|
}
|
|
);
|
|
let _pipe$7 = map2(_pipe$6, trim);
|
|
return filter(_pipe$7, (x) => {
|
|
return x !== "";
|
|
});
|
|
}
|
|
function handler(line) {
|
|
let result = parse(line);
|
|
let result$1 = echo(
|
|
map2(result, whatsthat),
|
|
void 0,
|
|
"src/parser.gleam",
|
|
10
|
|
);
|
|
return new Line(result$1);
|
|
}
|
|
function echo(value, message, file, line) {
|
|
const grey = "\x1B[90m";
|
|
const reset_color = "\x1B[39m";
|
|
const file_line = `${file}:${line}`;
|
|
const inspector = new Echo$Inspector();
|
|
const string_value = inspector.inspect(value);
|
|
const string_message = message === void 0 ? "" : " " + message;
|
|
if (globalThis.process?.stderr?.write) {
|
|
const string3 = `${grey}${file_line}${reset_color}${string_message}
|
|
${string_value}
|
|
`;
|
|
globalThis.process.stderr.write(string3);
|
|
} else if (globalThis.Deno) {
|
|
const string3 = `${grey}${file_line}${reset_color}${string_message}
|
|
${string_value}
|
|
`;
|
|
globalThis.Deno.stderr.writeSync(new TextEncoder().encode(string3));
|
|
} else {
|
|
const string3 = `${file_line}${string_message}
|
|
${string_value}`;
|
|
globalThis.console.log(string3);
|
|
}
|
|
return value;
|
|
}
|
|
var Echo$Inspector = class {
|
|
#references = new globalThis.Set();
|
|
#isDict(value) {
|
|
try {
|
|
const empty_dict = make();
|
|
const dict_class = empty_dict.constructor;
|
|
return value instanceof dict_class;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
#float(float2) {
|
|
const string3 = float2.toString().replace("+", "");
|
|
if (string3.indexOf(".") >= 0) {
|
|
return string3;
|
|
} else {
|
|
const index3 = string3.indexOf("e");
|
|
if (index3 >= 0) {
|
|
return string3.slice(0, index3) + ".0" + string3.slice(index3);
|
|
} else {
|
|
return string3 + ".0";
|
|
}
|
|
}
|
|
}
|
|
inspect(v) {
|
|
const t = typeof v;
|
|
if (v === true) return "True";
|
|
if (v === false) return "False";
|
|
if (v === null) return "//js(null)";
|
|
if (v === void 0) return "Nil";
|
|
if (t === "string") return this.#string(v);
|
|
if (t === "bigint" || globalThis.Number.isInteger(v)) return v.toString();
|
|
if (t === "number") return this.#float(v);
|
|
if (v instanceof UtfCodepoint) return this.#utfCodepoint(v);
|
|
if (v instanceof BitArray) return this.#bit_array(v);
|
|
if (v instanceof globalThis.RegExp) return `//js(${v})`;
|
|
if (v instanceof globalThis.Date) return `//js(Date("${v.toISOString()}"))`;
|
|
if (v instanceof globalThis.Error) return `//js(${v.toString()})`;
|
|
if (v instanceof globalThis.Function) {
|
|
const args = [];
|
|
for (const i of globalThis.Array(v.length).keys())
|
|
args.push(globalThis.String.fromCharCode(i + 97));
|
|
return `//fn(${args.join(", ")}) { ... }`;
|
|
}
|
|
if (this.#references.size === this.#references.add(v).size) {
|
|
return "//js(circular reference)";
|
|
}
|
|
let printed;
|
|
if (globalThis.Array.isArray(v)) {
|
|
printed = `#(${v.map((v2) => this.inspect(v2)).join(", ")})`;
|
|
} else if (v instanceof List) {
|
|
printed = this.#list(v);
|
|
} else if (v instanceof CustomType) {
|
|
printed = this.#customType(v);
|
|
} else if (this.#isDict(v)) {
|
|
printed = this.#dict(v);
|
|
} else if (v instanceof Set) {
|
|
return `//js(Set(${[...v].map((v2) => this.inspect(v2)).join(", ")}))`;
|
|
} else {
|
|
printed = this.#object(v);
|
|
}
|
|
this.#references.delete(v);
|
|
return printed;
|
|
}
|
|
#object(v) {
|
|
const name = globalThis.Object.getPrototypeOf(v)?.constructor?.name || "Object";
|
|
const props = [];
|
|
for (const k of globalThis.Object.keys(v)) {
|
|
props.push(`${this.inspect(k)}: ${this.inspect(v[k])}`);
|
|
}
|
|
const body = props.length ? " " + props.join(", ") + " " : "";
|
|
const head = name === "Object" ? "" : name + " ";
|
|
return `//js(${head}{${body}})`;
|
|
}
|
|
#dict(map3) {
|
|
let body = "dict.from_list([";
|
|
let first = true;
|
|
let key_value_pairs = fold(map3, [], (pairs, key, value) => {
|
|
pairs.push([key, value]);
|
|
return pairs;
|
|
});
|
|
key_value_pairs.sort();
|
|
key_value_pairs.forEach(([key, value]) => {
|
|
if (!first) body = body + ", ";
|
|
body = body + "#(" + this.inspect(key) + ", " + this.inspect(value) + ")";
|
|
first = false;
|
|
});
|
|
return body + "])";
|
|
}
|
|
#customType(record) {
|
|
const props = globalThis.Object.keys(record).map((label) => {
|
|
const value = this.inspect(record[label]);
|
|
return isNaN(parseInt(label)) ? `${label}: ${value}` : value;
|
|
}).join(", ");
|
|
return props ? `${record.constructor.name}(${props})` : record.constructor.name;
|
|
}
|
|
#list(list2) {
|
|
if (list2 instanceof Empty) {
|
|
return "[]";
|
|
}
|
|
let char_out = 'charlist.from_string("';
|
|
let list_out = "[";
|
|
let current = list2;
|
|
while (current instanceof NonEmpty) {
|
|
let element = current.head;
|
|
current = current.tail;
|
|
if (list_out !== "[") {
|
|
list_out += ", ";
|
|
}
|
|
list_out += this.inspect(element);
|
|
if (char_out) {
|
|
if (globalThis.Number.isInteger(element) && element >= 32 && element <= 126) {
|
|
char_out += globalThis.String.fromCharCode(element);
|
|
} else {
|
|
char_out = null;
|
|
}
|
|
}
|
|
}
|
|
if (char_out) {
|
|
return char_out + '")';
|
|
} else {
|
|
return list_out + "]";
|
|
}
|
|
}
|
|
#string(str) {
|
|
let new_str = '"';
|
|
for (let i = 0; i < str.length; i++) {
|
|
const char = str[i];
|
|
switch (char) {
|
|
case "\n":
|
|
new_str += "\\n";
|
|
break;
|
|
case "\r":
|
|
new_str += "\\r";
|
|
break;
|
|
case " ":
|
|
new_str += "\\t";
|
|
break;
|
|
case "\f":
|
|
new_str += "\\f";
|
|
break;
|
|
case "\\":
|
|
new_str += "\\\\";
|
|
break;
|
|
case '"':
|
|
new_str += '\\"';
|
|
break;
|
|
default:
|
|
if (char < " " || char > "~" && char < "\xA0") {
|
|
new_str += "\\u{" + char.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0") + "}";
|
|
} else {
|
|
new_str += char;
|
|
}
|
|
}
|
|
}
|
|
new_str += '"';
|
|
return new_str;
|
|
}
|
|
#utfCodepoint(codepoint2) {
|
|
return `//utfcodepoint(${globalThis.String.fromCodePoint(codepoint2.value)})`;
|
|
}
|
|
#bit_array(bits2) {
|
|
if (bits2.bitSize === 0) {
|
|
return "<<>>";
|
|
}
|
|
let acc = "<<";
|
|
for (let i = 0; i < bits2.byteSize - 1; i++) {
|
|
acc += bits2.byteAt(i).toString();
|
|
acc += ", ";
|
|
}
|
|
if (bits2.byteSize * 8 === bits2.bitSize) {
|
|
acc += bits2.byteAt(bits2.byteSize - 1).toString();
|
|
} else {
|
|
const trailingBitsCount = bits2.bitSize % 8;
|
|
acc += bits2.byteAt(bits2.byteSize - 1) >> 8 - trailingBitsCount;
|
|
acc += `:size(${trailingBitsCount})`;
|
|
}
|
|
acc += ">>";
|
|
return acc;
|
|
}
|
|
};
|
|
|
|
// build/dev/javascript/markdown2/markdown2.mjs
|
|
function inline_to_json(inline) {
|
|
if (inline instanceof Text) {
|
|
let text = inline[0];
|
|
return object2(
|
|
toList([["type", string2("text")], ["value", string2(text)]])
|
|
);
|
|
} else if (inline instanceof Push) {
|
|
let feeling = inline[0];
|
|
if (feeling instanceof Hirachy2) {
|
|
let level = feeling[0];
|
|
return object2(
|
|
toList([["type", string2("hirachy")], ["value", int2(level)]])
|
|
);
|
|
} else if (feeling instanceof Truth2) {
|
|
let level = feeling[0];
|
|
return object2(
|
|
toList([["type", string2("truth")], ["value", int2(level)]])
|
|
);
|
|
} else if (feeling instanceof Marking2) {
|
|
let level = feeling[0];
|
|
return object2(
|
|
toList([["type", string2("marking")], ["value", int2(level)]])
|
|
);
|
|
} else {
|
|
let level = feeling[0];
|
|
return object2(
|
|
toList([["type", string2("quote")], ["value", int2(level)]])
|
|
);
|
|
}
|
|
} else {
|
|
let text = inline[0];
|
|
return object2(
|
|
toList([
|
|
["type", string2("pop")],
|
|
[
|
|
"value",
|
|
(() => {
|
|
if (text instanceof Hirachy) {
|
|
return string2("Hirachy");
|
|
} else if (text instanceof Truth) {
|
|
return string2("Truth");
|
|
} else if (text instanceof Marking) {
|
|
return string2("Marking");
|
|
} else {
|
|
return string2("Quote");
|
|
}
|
|
})()
|
|
]
|
|
])
|
|
);
|
|
}
|
|
}
|
|
function line_to_json(line) {
|
|
let inlines = line[0];
|
|
let _pipe = array2(inlines, inline_to_json);
|
|
return to_string2(_pipe);
|
|
}
|
|
function main() {
|
|
let input = "ljiosfgdjiosdfgj\n @2! A slightly important statement !1 I believe is wrong, !- quoted inside another quote.\n !3 A slightly important statement I believe is wrong, quoted inside another quote.\n #3!2@2 A slightly important statement I believe is wrong, quoted inside another quote.\n\n !2@3 important trusted but @- important !5 more important !- 2 important and !- normal";
|
|
print(line_to_json(handler(input)));
|
|
return void 0;
|
|
}
|
|
function testing(input) {
|
|
return line_to_json(handler(input));
|
|
}
|
|
return __toCommonJS(markdown2_exports);
|
|
})();
|