From 3dce58c00e73b2575bc7bbb0f52fb52a3bde684e Mon Sep 17 00:00:00 2001 From: burningtree Date: Sun, 12 Feb 2023 00:08:18 +0000 Subject: [PATCH] deploy: 6c8d980101363fa93e84839e24a092fbfb3d5f77 --- ...yout-2e854d4e.css => _layout-594d971c.css} | 155 +- .../chunks/{0-29f0da6c.js => 0-ef72d454.js} | 4 +- .../chunks/{1-1cedc3a7.js => 1-1568ac60.js} | 2 +- .../chunks/{2-cb606a98.js => 2-9f7ee5b3.js} | 2 +- _app/immutable/chunks/_layout-1187a9e2.js | 2782 ++++++ _app/immutable/chunks/_layout-f7327cba.js | 38 - .../{index-dc145a1c.js => index-a17c58e1.js} | 174 +- ...ons-57b7ce3e.js => singletons-34f1d235.js} | 2 +- ...e-63d63419.js => error.svelte-999441bb.js} | 4 +- ...ea2e7f73.js => _layout.svelte-3137396c.js} | 83 +- .../components/pages/_page.svelte-9806a2aa.js | 8623 +++++++++++++++++ .../components/pages/_page.svelte-d2237dc8.js | 468 - .../modules/pages/_layout.js-7c44c194.js | 4 + .../modules/pages/_layout.js-8202dbd8.js | 4 - .../{start-f0507d42.js => start-8808e009.js} | 10 +- _app/version.json | 2 +- index.html | 127 +- 17 files changed, 11878 insertions(+), 606 deletions(-) rename _app/immutable/assets/{_layout-2e854d4e.css => _layout-594d971c.css} (86%) rename _app/immutable/chunks/{0-29f0da6c.js => 0-ef72d454.js} (64%) rename _app/immutable/chunks/{1-1cedc3a7.js => 1-1568ac60.js} (87%) rename _app/immutable/chunks/{2-cb606a98.js => 2-9f7ee5b3.js} (83%) create mode 100644 _app/immutable/chunks/_layout-1187a9e2.js delete mode 100644 _app/immutable/chunks/_layout-f7327cba.js rename _app/immutable/chunks/{index-dc145a1c.js => index-a17c58e1.js} (79%) rename _app/immutable/chunks/{singletons-57b7ce3e.js => singletons-34f1d235.js} (98%) rename _app/immutable/components/{error.svelte-63d63419.js => error.svelte-999441bb.js} (95%) rename _app/immutable/components/pages/{_layout.svelte-ea2e7f73.js => _layout.svelte-3137396c.js} (90%) create mode 100644 _app/immutable/components/pages/_page.svelte-9806a2aa.js delete mode 100644 _app/immutable/components/pages/_page.svelte-d2237dc8.js create mode 100644 _app/immutable/modules/pages/_layout.js-7c44c194.js delete mode 100644 _app/immutable/modules/pages/_layout.js-8202dbd8.js rename _app/immutable/{start-f0507d42.js => start-8808e009.js} (98%) diff --git a/_app/immutable/assets/_layout-2e854d4e.css b/_app/immutable/assets/_layout-594d971c.css similarity index 86% rename from _app/immutable/assets/_layout-2e854d4e.css rename to _app/immutable/assets/_layout-594d971c.css index 53ffa5e..5d91422 100644 --- a/_app/immutable/assets/_layout-2e854d4e.css +++ b/_app/immutable/assets/_layout-594d971c.css @@ -485,11 +485,11 @@ body{ font-family: Ubuntu Mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; } -footer a{ +footer a, .markdown a{ text-decoration-line: underline; } -footer a:hover{ +footer a:hover, .markdown a:hover{ text-decoration-line: none; } @@ -538,11 +538,54 @@ footer a:hover{ .section-header{ margin-bottom: 4rem; + padding-top: 2.5rem; font-size: 3rem; line-height: 1; font-weight: 700; } +.text-mild{ + color: rgb(255 255 255 / 0.7); +} + +table.table-custom{ + font-size: 1rem; + line-height: 1.5rem; +} + +.table-custom td, .table-custom th{ + padding-left: 1rem; + padding-right: 1rem; + padding-top: 1rem; + padding-bottom: 1rem; + vertical-align: top; +} + +.table-custom th{ + color: rgb(255 255 255 / 0.7); +} + +.table-custom tbody tr:hover td{ + --tw-bg-opacity: 1; + background-color: rgb(255 255 255 / var(--tw-bg-opacity)); + --tw-text-opacity: 1; + color: rgb(0 0 0 / var(--tw-text-opacity)); +} + +.table-custom tbody tr:hover td .description{ + --tw-text-opacity: 1; + color: rgb(0 0 0 / var(--tw-text-opacity)); +} + +.table-custom td{ + border-width: 1px; + border-bottom-width: 0px; + border-left-width: 0px; + border-right-width: 0px; + --tw-border-opacity: 1; + border-color: rgb(75 85 99 / var(--tw-border-opacity)); +} + .fixed{ position: fixed; } @@ -556,22 +599,42 @@ footer a:hover{ margin-right: auto; } +.mb-36{ + margin-bottom: 9rem; +} + .mb-4{ margin-bottom: 1rem; } -.mb-48{ - margin-bottom: 12rem; +.mb-6{ + margin-bottom: 1.5rem; } .mb-8{ margin-bottom: 2rem; } +.mr-1{ + margin-right: 0.25rem; +} + +.mt-10{ + margin-top: 2.5rem; +} + +.mt-2{ + margin-top: 0.5rem; +} + .mt-4{ margin-top: 1rem; } +.mt-6{ + margin-top: 1.5rem; +} + .mt-8{ margin-top: 2rem; } @@ -584,6 +647,10 @@ footer a:hover{ display: flex; } +.table{ + display: table; +} + .grid{ display: grid; } @@ -620,6 +687,10 @@ footer a:hover{ width: 12rem; } +.w-5{ + width: 1.25rem; +} + .w-full{ width: 100%; } @@ -628,10 +699,18 @@ footer a:hover{ flex-grow: 1; } +.table-auto{ + table-layout: auto; +} + .cursor-pointer{ cursor: pointer; } +.list-disc{ + list-style-type: disc; +} + .grid-cols-2{ grid-template-columns: repeat(2, minmax(0, 1fr)); } @@ -656,10 +735,6 @@ footer a:hover{ gap: 1.5rem; } -.border{ - border-width: 1px; -} - .bg-\[\#0d1117\]{ --tw-bg-opacity: 1; background-color: rgb(13 17 23 / var(--tw-bg-opacity)); @@ -670,6 +745,16 @@ footer a:hover{ background-color: rgb(0 0 0 / var(--tw-bg-opacity)); } +.bg-white{ + --tw-bg-opacity: 1; + background-color: rgb(255 255 255 / var(--tw-bg-opacity)); +} + +.px-10{ + padding-left: 2.5rem; + padding-right: 2.5rem; +} + .px-3{ padding-left: 0.75rem; padding-right: 0.75rem; @@ -680,11 +765,26 @@ footer a:hover{ padding-right: 1rem; } +.px-5{ + padding-left: 1.25rem; + padding-right: 1.25rem; +} + +.px-6{ + padding-left: 1.5rem; + padding-right: 1.5rem; +} + .py-10{ padding-top: 2.5rem; padding-bottom: 2.5rem; } +.py-2{ + padding-top: 0.5rem; + padding-bottom: 0.5rem; +} + .py-32{ padding-top: 8rem; padding-bottom: 8rem; @@ -707,6 +807,10 @@ footer a:hover{ padding-bottom: 5rem; } +.pb-32{ + padding-bottom: 8rem; +} + .pt-20{ padding-top: 5rem; } @@ -715,6 +819,10 @@ footer a:hover{ padding-top: 1.5rem; } +.text-left{ + text-align: left; +} + .text-center{ text-align: center; } @@ -728,6 +836,11 @@ footer a:hover{ line-height: 2rem; } +.text-3xl{ + font-size: 1.875rem; + line-height: 2.25rem; +} + .text-5xl{ font-size: 3rem; line-height: 1; @@ -738,6 +851,11 @@ footer a:hover{ line-height: 1; } +.text-base{ + font-size: 1rem; + line-height: 1.5rem; +} + .text-lg{ font-size: 1.125rem; line-height: 1.75rem; @@ -756,19 +874,28 @@ footer a:hover{ text-transform: uppercase; } +.text-black{ + --tw-text-opacity: 1; + color: rgb(0 0 0 / var(--tw-text-opacity)); +} + .text-white{ --tw-text-opacity: 1; color: rgb(255 255 255 / var(--tw-text-opacity)); } -.text-white\/50{ - color: rgb(255 255 255 / 0.5); -} - .underline{ text-decoration-line: underline; } +.no-underline{ + text-decoration-line: none; +} + +.hover\:border-0:hover{ + border-width: 0px; +} + .hover\:bg-white:hover{ --tw-bg-opacity: 1; background-color: rgb(255 255 255 / var(--tw-bg-opacity)); @@ -779,6 +906,10 @@ footer a:hover{ color: rgb(0 0 0 / var(--tw-text-opacity)); } +.hover\:underline:hover{ + text-decoration-line: underline; +} + .hover\:no-underline:hover{ text-decoration-line: none; } diff --git a/_app/immutable/chunks/0-29f0da6c.js b/_app/immutable/chunks/0-ef72d454.js similarity index 64% rename from _app/immutable/chunks/0-29f0da6c.js rename to _app/immutable/chunks/0-ef72d454.js index 773b603..f92766a 100644 --- a/_app/immutable/chunks/0-29f0da6c.js +++ b/_app/immutable/chunks/0-ef72d454.js @@ -1,5 +1,5 @@ -import { _ } from "./_layout-f7327cba.js"; -import { default as default2 } from "../components/pages/_layout.svelte-ea2e7f73.js"; +import { _ } from "./_layout-1187a9e2.js"; +import { default as default2 } from "../components/pages/_layout.svelte-3137396c.js"; export { default2 as component, _ as universal diff --git a/_app/immutable/chunks/1-1cedc3a7.js b/_app/immutable/chunks/1-1568ac60.js similarity index 87% rename from _app/immutable/chunks/1-1cedc3a7.js rename to _app/immutable/chunks/1-1568ac60.js index 4abb42d..1486240 100644 --- a/_app/immutable/chunks/1-1cedc3a7.js +++ b/_app/immutable/chunks/1-1568ac60.js @@ -1,4 +1,4 @@ -import { default as default2 } from "../components/error.svelte-63d63419.js"; +import { default as default2 } from "../components/error.svelte-999441bb.js"; export { default2 as component }; diff --git a/_app/immutable/chunks/2-cb606a98.js b/_app/immutable/chunks/2-9f7ee5b3.js similarity index 83% rename from _app/immutable/chunks/2-cb606a98.js rename to _app/immutable/chunks/2-9f7ee5b3.js index 0058a20..23b46ab 100644 --- a/_app/immutable/chunks/2-cb606a98.js +++ b/_app/immutable/chunks/2-9f7ee5b3.js @@ -1,4 +1,4 @@ -import { default as default2 } from "../components/pages/_page.svelte-d2237dc8.js"; +import { default as default2 } from "../components/pages/_page.svelte-9806a2aa.js"; export { default2 as component }; diff --git a/_app/immutable/chunks/_layout-1187a9e2.js b/_app/immutable/chunks/_layout-1187a9e2.js new file mode 100644 index 0000000..62f4c0c --- /dev/null +++ b/_app/immutable/chunks/_layout-1187a9e2.js @@ -0,0 +1,2782 @@ +/*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */ +function isNothing(subject) { + return typeof subject === "undefined" || subject === null; +} +function isObject(subject) { + return typeof subject === "object" && subject !== null; +} +function toArray(sequence) { + if (Array.isArray(sequence)) + return sequence; + else if (isNothing(sequence)) + return []; + return [sequence]; +} +function extend(target, source) { + var index, length, key, sourceKeys; + if (source) { + sourceKeys = Object.keys(source); + for (index = 0, length = sourceKeys.length; index < length; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; + } + } + return target; +} +function repeat(string, count) { + var result = "", cycle; + for (cycle = 0; cycle < count; cycle += 1) { + result += string; + } + return result; +} +function isNegativeZero(number) { + return number === 0 && Number.NEGATIVE_INFINITY === 1 / number; +} +var isNothing_1 = isNothing; +var isObject_1 = isObject; +var toArray_1 = toArray; +var repeat_1 = repeat; +var isNegativeZero_1 = isNegativeZero; +var extend_1 = extend; +var common = { + isNothing: isNothing_1, + isObject: isObject_1, + toArray: toArray_1, + repeat: repeat_1, + isNegativeZero: isNegativeZero_1, + extend: extend_1 +}; +function formatError(exception2, compact) { + var where = "", message = exception2.reason || "(unknown reason)"; + if (!exception2.mark) + return message; + if (exception2.mark.name) { + where += 'in "' + exception2.mark.name + '" '; + } + where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")"; + if (!compact && exception2.mark.snippet) { + where += "\n\n" + exception2.mark.snippet; + } + return message + " " + where; +} +function YAMLException$1(reason, mark) { + Error.call(this); + this.name = "YAMLException"; + this.reason = reason; + this.mark = mark; + this.message = formatError(this, false); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } else { + this.stack = new Error().stack || ""; + } +} +YAMLException$1.prototype = Object.create(Error.prototype); +YAMLException$1.prototype.constructor = YAMLException$1; +YAMLException$1.prototype.toString = function toString(compact) { + return this.name + ": " + formatError(this, compact); +}; +var exception = YAMLException$1; +function getLine(buffer, lineStart, lineEnd, position, maxLineLength) { + var head = ""; + var tail = ""; + var maxHalfLength = Math.floor(maxLineLength / 2) - 1; + if (position - lineStart > maxHalfLength) { + head = " ... "; + lineStart = position - maxHalfLength + head.length; + } + if (lineEnd - position > maxHalfLength) { + tail = " ..."; + lineEnd = position + maxHalfLength - tail.length; + } + return { + str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail, + pos: position - lineStart + head.length + // relative position + }; +} +function padStart(string, max) { + return common.repeat(" ", max - string.length) + string; +} +function makeSnippet(mark, options) { + options = Object.create(options || null); + if (!mark.buffer) + return null; + if (!options.maxLength) + options.maxLength = 79; + if (typeof options.indent !== "number") + options.indent = 1; + if (typeof options.linesBefore !== "number") + options.linesBefore = 3; + if (typeof options.linesAfter !== "number") + options.linesAfter = 2; + var re = /\r?\n|\r|\0/g; + var lineStarts = [0]; + var lineEnds = []; + var match; + var foundLineNo = -1; + while (match = re.exec(mark.buffer)) { + lineEnds.push(match.index); + lineStarts.push(match.index + match[0].length); + if (mark.position <= match.index && foundLineNo < 0) { + foundLineNo = lineStarts.length - 2; + } + } + if (foundLineNo < 0) + foundLineNo = lineStarts.length - 1; + var result = "", i, line; + var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length; + var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3); + for (i = 1; i <= options.linesBefore; i++) { + if (foundLineNo - i < 0) + break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo - i], + lineEnds[foundLineNo - i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), + maxLineLength + ); + result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result; + } + line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength); + result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n"; + result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n"; + for (i = 1; i <= options.linesAfter; i++) { + if (foundLineNo + i >= lineEnds.length) + break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo + i], + lineEnds[foundLineNo + i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), + maxLineLength + ); + result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n"; + } + return result.replace(/\n$/, ""); +} +var snippet = makeSnippet; +var TYPE_CONSTRUCTOR_OPTIONS = [ + "kind", + "multi", + "resolve", + "construct", + "instanceOf", + "predicate", + "represent", + "representName", + "defaultStyle", + "styleAliases" +]; +var YAML_NODE_KINDS = [ + "scalar", + "sequence", + "mapping" +]; +function compileStyleAliases(map2) { + var result = {}; + if (map2 !== null) { + Object.keys(map2).forEach(function(style) { + map2[style].forEach(function(alias) { + result[String(alias)] = style; + }); + }); + } + return result; +} +function Type$1(tag, options) { + options = options || {}; + Object.keys(options).forEach(function(name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); + } + }); + this.options = options; + this.tag = tag; + this.kind = options["kind"] || null; + this.resolve = options["resolve"] || function() { + return true; + }; + this.construct = options["construct"] || function(data) { + return data; + }; + this.instanceOf = options["instanceOf"] || null; + this.predicate = options["predicate"] || null; + this.represent = options["represent"] || null; + this.representName = options["representName"] || null; + this.defaultStyle = options["defaultStyle"] || null; + this.multi = options["multi"] || false; + this.styleAliases = compileStyleAliases(options["styleAliases"] || null); + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } +} +var type = Type$1; +function compileList(schema2, name) { + var result = []; + schema2[name].forEach(function(currentType) { + var newIndex = result.length; + result.forEach(function(previousType, previousIndex) { + if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) { + newIndex = previousIndex; + } + }); + result[newIndex] = currentType; + }); + return result; +} +function compileMap() { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {}, + multi: { + scalar: [], + sequence: [], + mapping: [], + fallback: [] + } + }, index, length; + function collectType(type2) { + if (type2.multi) { + result.multi[type2.kind].push(type2); + result.multi["fallback"].push(type2); + } else { + result[type2.kind][type2.tag] = result["fallback"][type2.tag] = type2; + } + } + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; +} +function Schema$1(definition) { + return this.extend(definition); +} +Schema$1.prototype.extend = function extend2(definition) { + var implicit = []; + var explicit = []; + if (definition instanceof type) { + explicit.push(definition); + } else if (Array.isArray(definition)) { + explicit = explicit.concat(definition); + } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) { + if (definition.implicit) + implicit = implicit.concat(definition.implicit); + if (definition.explicit) + explicit = explicit.concat(definition.explicit); + } else { + throw new exception("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })"); + } + implicit.forEach(function(type$1) { + if (!(type$1 instanceof type)) { + throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object."); + } + if (type$1.loadKind && type$1.loadKind !== "scalar") { + throw new exception("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported."); + } + if (type$1.multi) { + throw new exception("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit."); + } + }); + explicit.forEach(function(type$1) { + if (!(type$1 instanceof type)) { + throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object."); + } + }); + var result = Object.create(Schema$1.prototype); + result.implicit = (this.implicit || []).concat(implicit); + result.explicit = (this.explicit || []).concat(explicit); + result.compiledImplicit = compileList(result, "implicit"); + result.compiledExplicit = compileList(result, "explicit"); + result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit); + return result; +}; +var schema = Schema$1; +var str = new type("tag:yaml.org,2002:str", { + kind: "scalar", + construct: function(data) { + return data !== null ? data : ""; + } +}); +var seq = new type("tag:yaml.org,2002:seq", { + kind: "sequence", + construct: function(data) { + return data !== null ? data : []; + } +}); +var map = new type("tag:yaml.org,2002:map", { + kind: "mapping", + construct: function(data) { + return data !== null ? data : {}; + } +}); +var failsafe = new schema({ + explicit: [ + str, + seq, + map + ] +}); +function resolveYamlNull(data) { + if (data === null) + return true; + var max = data.length; + return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL"); +} +function constructYamlNull() { + return null; +} +function isNull(object) { + return object === null; +} +var _null = new type("tag:yaml.org,2002:null", { + kind: "scalar", + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function() { + return "~"; + }, + lowercase: function() { + return "null"; + }, + uppercase: function() { + return "NULL"; + }, + camelcase: function() { + return "Null"; + }, + empty: function() { + return ""; + } + }, + defaultStyle: "lowercase" +}); +function resolveYamlBoolean(data) { + if (data === null) + return false; + var max = data.length; + return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE"); +} +function constructYamlBoolean(data) { + return data === "true" || data === "True" || data === "TRUE"; +} +function isBoolean(object) { + return Object.prototype.toString.call(object) === "[object Boolean]"; +} +var bool = new type("tag:yaml.org,2002:bool", { + kind: "scalar", + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function(object) { + return object ? "true" : "false"; + }, + uppercase: function(object) { + return object ? "TRUE" : "FALSE"; + }, + camelcase: function(object) { + return object ? "True" : "False"; + } + }, + defaultStyle: "lowercase" +}); +function isHexCode(c) { + return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102; +} +function isOctCode(c) { + return 48 <= c && c <= 55; +} +function isDecCode(c) { + return 48 <= c && c <= 57; +} +function resolveYamlInteger(data) { + if (data === null) + return false; + var max = data.length, index = 0, hasDigits = false, ch; + if (!max) + return false; + ch = data[index]; + if (ch === "-" || ch === "+") { + ch = data[++index]; + } + if (ch === "0") { + if (index + 1 === max) + return true; + ch = data[++index]; + if (ch === "b") { + index++; + for (; index < max; index++) { + ch = data[index]; + if (ch === "_") + continue; + if (ch !== "0" && ch !== "1") + return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + if (ch === "x") { + index++; + for (; index < max; index++) { + ch = data[index]; + if (ch === "_") + continue; + if (!isHexCode(data.charCodeAt(index))) + return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + if (ch === "o") { + index++; + for (; index < max; index++) { + ch = data[index]; + if (ch === "_") + continue; + if (!isOctCode(data.charCodeAt(index))) + return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + } + if (ch === "_") + return false; + for (; index < max; index++) { + ch = data[index]; + if (ch === "_") + continue; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + if (!hasDigits || ch === "_") + return false; + return true; +} +function constructYamlInteger(data) { + var value = data, sign = 1, ch; + if (value.indexOf("_") !== -1) { + value = value.replace(/_/g, ""); + } + ch = value[0]; + if (ch === "-" || ch === "+") { + if (ch === "-") + sign = -1; + value = value.slice(1); + ch = value[0]; + } + if (value === "0") + return 0; + if (ch === "0") { + if (value[1] === "b") + return sign * parseInt(value.slice(2), 2); + if (value[1] === "x") + return sign * parseInt(value.slice(2), 16); + if (value[1] === "o") + return sign * parseInt(value.slice(2), 8); + } + return sign * parseInt(value, 10); +} +function isInteger(object) { + return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object)); +} +var int = new type("tag:yaml.org,2002:int", { + kind: "scalar", + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function(obj) { + return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1); + }, + octal: function(obj) { + return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1); + }, + decimal: function(obj) { + return obj.toString(10); + }, + /* eslint-disable max-len */ + hexadecimal: function(obj) { + return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1); + } + }, + defaultStyle: "decimal", + styleAliases: { + binary: [2, "bin"], + octal: [8, "oct"], + decimal: [10, "dec"], + hexadecimal: [16, "hex"] + } +}); +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + "^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$" +); +function resolveYamlFloat(data) { + if (data === null) + return false; + if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === "_") { + return false; + } + return true; +} +function constructYamlFloat(data) { + var value, sign; + value = data.replace(/_/g, "").toLowerCase(); + sign = value[0] === "-" ? -1 : 1; + if ("+-".indexOf(value[0]) >= 0) { + value = value.slice(1); + } + if (value === ".inf") { + return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + } else if (value === ".nan") { + return NaN; + } + return sign * parseFloat(value, 10); +} +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; +function representYamlFloat(object, style) { + var res; + if (isNaN(object)) { + switch (style) { + case "lowercase": + return ".nan"; + case "uppercase": + return ".NAN"; + case "camelcase": + return ".NaN"; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case "lowercase": + return ".inf"; + case "uppercase": + return ".INF"; + case "camelcase": + return ".Inf"; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case "lowercase": + return "-.inf"; + case "uppercase": + return "-.INF"; + case "camelcase": + return "-.Inf"; + } + } else if (common.isNegativeZero(object)) { + return "-0.0"; + } + res = object.toString(10); + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res; +} +function isFloat(object) { + return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object)); +} +var float = new type("tag:yaml.org,2002:float", { + kind: "scalar", + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: "lowercase" +}); +var json = failsafe.extend({ + implicit: [ + _null, + bool, + int, + float + ] +}); +var core = json; +var YAML_DATE_REGEXP = new RegExp( + "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$" +); +var YAML_TIMESTAMP_REGEXP = new RegExp( + "^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$" +); +function resolveYamlTimestamp(data) { + if (data === null) + return false; + if (YAML_DATE_REGEXP.exec(data) !== null) + return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) + return true; + return false; +} +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date; + match = YAML_DATE_REGEXP.exec(data); + if (match === null) + match = YAML_TIMESTAMP_REGEXP.exec(data); + if (match === null) + throw new Error("Date resolve error"); + year = +match[1]; + month = +match[2] - 1; + day = +match[3]; + if (!match[4]) { + return new Date(Date.UTC(year, month, day)); + } + hour = +match[4]; + minute = +match[5]; + second = +match[6]; + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { + fraction += "0"; + } + fraction = +fraction; + } + if (match[9]) { + tz_hour = +match[10]; + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 6e4; + if (match[9] === "-") + delta = -delta; + } + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + if (delta) + date.setTime(date.getTime() - delta); + return date; +} +function representYamlTimestamp(object) { + return object.toISOString(); +} +var timestamp = new type("tag:yaml.org,2002:timestamp", { + kind: "scalar", + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp +}); +function resolveYamlMerge(data) { + return data === "<<" || data === null; +} +var merge = new type("tag:yaml.org,2002:merge", { + kind: "scalar", + resolve: resolveYamlMerge +}); +var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r"; +function resolveYamlBinary(data) { + if (data === null) + return false; + var code, idx, bitlen = 0, max = data.length, map2 = BASE64_MAP; + for (idx = 0; idx < max; idx++) { + code = map2.indexOf(data.charAt(idx)); + if (code > 64) + continue; + if (code < 0) + return false; + bitlen += 6; + } + return bitlen % 8 === 0; +} +function constructYamlBinary(data) { + var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map2 = BASE64_MAP, bits = 0, result = []; + for (idx = 0; idx < max; idx++) { + if (idx % 4 === 0 && idx) { + result.push(bits >> 16 & 255); + result.push(bits >> 8 & 255); + result.push(bits & 255); + } + bits = bits << 6 | map2.indexOf(input.charAt(idx)); + } + tailbits = max % 4 * 6; + if (tailbits === 0) { + result.push(bits >> 16 & 255); + result.push(bits >> 8 & 255); + result.push(bits & 255); + } else if (tailbits === 18) { + result.push(bits >> 10 & 255); + result.push(bits >> 2 & 255); + } else if (tailbits === 12) { + result.push(bits >> 4 & 255); + } + return new Uint8Array(result); +} +function representYamlBinary(object) { + var result = "", bits = 0, idx, tail, max = object.length, map2 = BASE64_MAP; + for (idx = 0; idx < max; idx++) { + if (idx % 3 === 0 && idx) { + result += map2[bits >> 18 & 63]; + result += map2[bits >> 12 & 63]; + result += map2[bits >> 6 & 63]; + result += map2[bits & 63]; + } + bits = (bits << 8) + object[idx]; + } + tail = max % 3; + if (tail === 0) { + result += map2[bits >> 18 & 63]; + result += map2[bits >> 12 & 63]; + result += map2[bits >> 6 & 63]; + result += map2[bits & 63]; + } else if (tail === 2) { + result += map2[bits >> 10 & 63]; + result += map2[bits >> 4 & 63]; + result += map2[bits << 2 & 63]; + result += map2[64]; + } else if (tail === 1) { + result += map2[bits >> 2 & 63]; + result += map2[bits << 4 & 63]; + result += map2[64]; + result += map2[64]; + } + return result; +} +function isBinary(obj) { + return Object.prototype.toString.call(obj) === "[object Uint8Array]"; +} +var binary = new type("tag:yaml.org,2002:binary", { + kind: "scalar", + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary +}); +var _hasOwnProperty$3 = Object.prototype.hasOwnProperty; +var _toString$2 = Object.prototype.toString; +function resolveYamlOmap(data) { + if (data === null) + return true; + var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data; + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + pairHasKey = false; + if (_toString$2.call(pair) !== "[object Object]") + return false; + for (pairKey in pair) { + if (_hasOwnProperty$3.call(pair, pairKey)) { + if (!pairHasKey) + pairHasKey = true; + else + return false; + } + } + if (!pairHasKey) + return false; + if (objectKeys.indexOf(pairKey) === -1) + objectKeys.push(pairKey); + else + return false; + } + return true; +} +function constructYamlOmap(data) { + return data !== null ? data : []; +} +var omap = new type("tag:yaml.org,2002:omap", { + kind: "sequence", + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); +var _toString$1 = Object.prototype.toString; +function resolveYamlPairs(data) { + if (data === null) + return true; + var index, length, pair, keys, result, object = data; + result = new Array(object.length); + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + if (_toString$1.call(pair) !== "[object Object]") + return false; + keys = Object.keys(pair); + if (keys.length !== 1) + return false; + result[index] = [keys[0], pair[keys[0]]]; + } + return true; +} +function constructYamlPairs(data) { + if (data === null) + return []; + var index, length, pair, keys, result, object = data; + result = new Array(object.length); + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + keys = Object.keys(pair); + result[index] = [keys[0], pair[keys[0]]]; + } + return result; +} +var pairs = new type("tag:yaml.org,2002:pairs", { + kind: "sequence", + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); +var _hasOwnProperty$2 = Object.prototype.hasOwnProperty; +function resolveYamlSet(data) { + if (data === null) + return true; + var key, object = data; + for (key in object) { + if (_hasOwnProperty$2.call(object, key)) { + if (object[key] !== null) + return false; + } + } + return true; +} +function constructYamlSet(data) { + return data !== null ? data : {}; +} +var set = new type("tag:yaml.org,2002:set", { + kind: "mapping", + resolve: resolveYamlSet, + construct: constructYamlSet +}); +var _default = core.extend({ + implicit: [ + timestamp, + merge + ], + explicit: [ + binary, + omap, + pairs, + set + ] +}); +var _hasOwnProperty$1 = Object.prototype.hasOwnProperty; +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; +function _class(obj) { + return Object.prototype.toString.call(obj); +} +function is_EOL(c) { + return c === 10 || c === 13; +} +function is_WHITE_SPACE(c) { + return c === 9 || c === 32; +} +function is_WS_OR_EOL(c) { + return c === 9 || c === 32 || c === 10 || c === 13; +} +function is_FLOW_INDICATOR(c) { + return c === 44 || c === 91 || c === 93 || c === 123 || c === 125; +} +function fromHexCode(c) { + var lc; + if (48 <= c && c <= 57) { + return c - 48; + } + lc = c | 32; + if (97 <= lc && lc <= 102) { + return lc - 97 + 10; + } + return -1; +} +function escapedHexLen(c) { + if (c === 120) { + return 2; + } + if (c === 117) { + return 4; + } + if (c === 85) { + return 8; + } + return 0; +} +function fromDecimalCode(c) { + if (48 <= c && c <= 57) { + return c - 48; + } + return -1; +} +function simpleEscapeSequence(c) { + return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? " " : c === 9 ? " " : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "…" : c === 95 ? " " : c === 76 ? "\u2028" : c === 80 ? "\u2029" : ""; +} +function charFromCodepoint(c) { + if (c <= 65535) { + return String.fromCharCode(c); + } + return String.fromCharCode( + (c - 65536 >> 10) + 55296, + (c - 65536 & 1023) + 56320 + ); +} +var simpleEscapeCheck = new Array(256); +var simpleEscapeMap = new Array(256); +for (var i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} +function State$1(input, options) { + this.input = input; + this.filename = options["filename"] || null; + this.schema = options["schema"] || _default; + this.onWarning = options["onWarning"] || null; + this.legacy = options["legacy"] || false; + this.json = options["json"] || false; + this.listener = options["listener"] || null; + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + this.firstTabInLine = -1; + this.documents = []; +} +function generateError(state, message) { + var mark = { + name: state.filename, + buffer: state.input.slice(0, -1), + // omit trailing \0 + position: state.position, + line: state.line, + column: state.position - state.lineStart + }; + mark.snippet = snippet(mark); + return new exception(message, mark); +} +function throwError(state, message) { + throw generateError(state, message); +} +function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } +} +var directiveHandlers = { + YAML: function handleYamlDirective(state, name, args) { + var match, major, minor; + if (state.version !== null) { + throwError(state, "duplication of %YAML directive"); + } + if (args.length !== 1) { + throwError(state, "YAML directive accepts exactly one argument"); + } + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + if (match === null) { + throwError(state, "ill-formed argument of the YAML directive"); + } + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); + if (major !== 1) { + throwError(state, "unacceptable YAML version of the document"); + } + state.version = args[0]; + state.checkLineBreaks = minor < 2; + if (minor !== 1 && minor !== 2) { + throwWarning(state, "unsupported YAML version of the document"); + } + }, + TAG: function handleTagDirective(state, name, args) { + var handle, prefix; + if (args.length !== 2) { + throwError(state, "TAG directive accepts exactly two arguments"); + } + handle = args[0]; + prefix = args[1]; + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state, "ill-formed tag handle (first argument) of the TAG directive"); + } + if (_hasOwnProperty$1.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, "ill-formed tag prefix (second argument) of the TAG directive"); + } + try { + prefix = decodeURIComponent(prefix); + } catch (err) { + throwError(state, "tag prefix is malformed: " + prefix); + } + state.tagMap[handle] = prefix; + } +}; +function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; + if (start < end) { + _result = state.input.slice(start, end); + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 9 || 32 <= _character && _character <= 1114111)) { + throwError(state, "expected valid JSON character"); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state, "the stream contains non-printable characters"); + } + state.result += _result; + } +} +function mergeMappings(state, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; + if (!common.isObject(source)) { + throwError(state, "cannot merge mappings; the provided source object is unacceptable"); + } + sourceKeys = Object.keys(source); + for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { + key = sourceKeys[index]; + if (!_hasOwnProperty$1.call(destination, key)) { + destination[key] = source[key]; + overridableKeys[key] = true; + } + } +} +function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) { + var index, quantity; + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); + for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { + if (Array.isArray(keyNode[index])) { + throwError(state, "nested arrays are not supported inside keys"); + } + if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") { + keyNode[index] = "[object Object]"; + } + } + } + if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") { + keyNode = "[object Object]"; + } + keyNode = String(keyNode); + if (_result === null) { + _result = {}; + } + if (keyTag === "tag:yaml.org,2002:merge") { + if (Array.isArray(valueNode)) { + for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { + mergeMappings(state, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state, _result, valueNode, overridableKeys); + } + } else { + if (!state.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) { + state.line = startLine || state.line; + state.lineStart = startLineStart || state.lineStart; + state.position = startPos || state.position; + throwError(state, "duplicated mapping key"); + } + if (keyNode === "__proto__") { + Object.defineProperty(_result, keyNode, { + configurable: true, + enumerable: true, + writable: true, + value: valueNode + }); + } else { + _result[keyNode] = valueNode; + } + delete overridableKeys[keyNode]; + } + return _result; +} +function readLineBreak(state) { + var ch; + ch = state.input.charCodeAt(state.position); + if (ch === 10) { + state.position++; + } else if (ch === 13) { + state.position++; + if (state.input.charCodeAt(state.position) === 10) { + state.position++; + } + } else { + throwError(state, "a line break is expected"); + } + state.line += 1; + state.lineStart = state.position; + state.firstTabInLine = -1; +} +function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + if (ch === 9 && state.firstTabInLine === -1) { + state.firstTabInLine = state.position; + } + ch = state.input.charCodeAt(++state.position); + } + if (allowComments && ch === 35) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 10 && ch !== 13 && ch !== 0); + } + if (is_EOL(ch)) { + readLineBreak(state); + ch = state.input.charCodeAt(state.position); + lineBreaks++; + state.lineIndent = 0; + while (ch === 32) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + } else { + break; + } + } + if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { + throwWarning(state, "deficient indentation"); + } + return lineBreaks; +} +function testDocumentSeparator(state) { + var _position = state.position, ch; + ch = state.input.charCodeAt(_position); + if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) { + _position += 3; + ch = state.input.charCodeAt(_position); + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + return false; +} +function writeFoldedLines(state, count) { + if (count === 1) { + state.result += " "; + } else if (count > 1) { + state.result += common.repeat("\n", count - 1); + } +} +function readPlainScalar(state, nodeIndent, withinFlowCollection) { + var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch; + ch = state.input.charCodeAt(state.position); + if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) { + return false; + } + if (ch === 63 || ch === 45) { + following = state.input.charCodeAt(state.position + 1); + if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + state.kind = "scalar"; + state.result = ""; + captureStart = captureEnd = state.position; + hasPendingContent = false; + while (ch !== 0) { + if (ch === 58) { + following = state.input.charCodeAt(state.position + 1); + if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + } else if (ch === 35) { + preceding = state.input.charCodeAt(state.position - 1); + if (is_WS_OR_EOL(preceding)) { + break; + } + } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + } else if (is_EOL(ch)) { + _line = state.line; + _lineStart = state.lineStart; + _lineIndent = state.lineIndent; + skipSeparationSpace(state, false, -1); + if (state.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state.input.charCodeAt(state.position); + continue; + } else { + state.position = captureEnd; + state.line = _line; + state.lineStart = _lineStart; + state.lineIndent = _lineIndent; + break; + } + } + if (hasPendingContent) { + captureSegment(state, captureStart, captureEnd, false); + writeFoldedLines(state, state.line - _line); + captureStart = captureEnd = state.position; + hasPendingContent = false; + } + if (!is_WHITE_SPACE(ch)) { + captureEnd = state.position + 1; + } + ch = state.input.charCodeAt(++state.position); + } + captureSegment(state, captureStart, captureEnd, false); + if (state.result) { + return true; + } + state.kind = _kind; + state.result = _result; + return false; +} +function readSingleQuotedScalar(state, nodeIndent) { + var ch, captureStart, captureEnd; + ch = state.input.charCodeAt(state.position); + if (ch !== 39) { + return false; + } + state.kind = "scalar"; + state.result = ""; + state.position++; + captureStart = captureEnd = state.position; + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 39) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + if (ch === 39) { + captureStart = state.position; + state.position++; + captureEnd = state.position; + } else { + return true; + } + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, "unexpected end of the document within a single quoted scalar"); + } else { + state.position++; + captureEnd = state.position; + } + } + throwError(state, "unexpected end of the stream within a single quoted scalar"); +} +function readDoubleQuotedScalar(state, nodeIndent) { + var captureStart, captureEnd, hexLength, hexResult, tmp, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 34) { + return false; + } + state.kind = "scalar"; + state.result = ""; + state.position++; + captureStart = captureEnd = state.position; + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 34) { + captureSegment(state, captureStart, state.position, true); + state.position++; + return true; + } else if (ch === 92) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + if (is_EOL(ch)) { + skipSeparationSpace(state, false, nodeIndent); + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state.result += simpleEscapeMap[ch]; + state.position++; + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + for (; hexLength > 0; hexLength--) { + ch = state.input.charCodeAt(++state.position); + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + } else { + throwError(state, "expected hexadecimal character"); + } + } + state.result += charFromCodepoint(hexResult); + state.position++; + } else { + throwError(state, "unknown escape sequence"); + } + captureStart = captureEnd = state.position; + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, "unexpected end of the document within a double quoted scalar"); + } else { + state.position++; + captureEnd = state.position; + } + } + throwError(state, "unexpected end of the stream within a double quoted scalar"); +} +function readFlowCollection(state, nodeIndent) { + var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch; + ch = state.input.charCodeAt(state.position); + if (ch === 91) { + terminator = 93; + isMapping = false; + _result = []; + } else if (ch === 123) { + terminator = 125; + isMapping = true; + _result = {}; + } else { + return false; + } + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + ch = state.input.charCodeAt(++state.position); + while (ch !== 0) { + skipSeparationSpace(state, true, nodeIndent); + ch = state.input.charCodeAt(state.position); + if (ch === terminator) { + state.position++; + state.tag = _tag; + state.anchor = _anchor; + state.kind = isMapping ? "mapping" : "sequence"; + state.result = _result; + return true; + } else if (!readNext) { + throwError(state, "missed comma between flow collection entries"); + } else if (ch === 44) { + throwError(state, "expected the node content, but found ','"); + } + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + if (ch === 63) { + following = state.input.charCodeAt(state.position + 1); + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } + _line = state.line; + _lineStart = state.lineStart; + _pos = state.position; + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state.tag; + keyNode = state.result; + skipSeparationSpace(state, true, nodeIndent); + ch = state.input.charCodeAt(state.position); + if ((isExplicitPair || state.line === _line) && ch === 58) { + isPair = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos); + } else if (isPair) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)); + } else { + _result.push(keyNode); + } + skipSeparationSpace(state, true, nodeIndent); + ch = state.input.charCodeAt(state.position); + if (ch === 44) { + readNext = true; + ch = state.input.charCodeAt(++state.position); + } else { + readNext = false; + } + } + throwError(state, "unexpected end of the stream within a flow collection"); +} +function readBlockScalar(state, nodeIndent) { + var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch; + ch = state.input.charCodeAt(state.position); + if (ch === 124) { + folding = false; + } else if (ch === 62) { + folding = true; + } else { + return false; + } + state.kind = "scalar"; + state.result = ""; + while (ch !== 0) { + ch = state.input.charCodeAt(++state.position); + if (ch === 43 || ch === 45) { + if (CHOMPING_CLIP === chomping) { + chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state, "repeat of a chomping mode identifier"); + } + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one"); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state, "repeat of an indentation width identifier"); + } + } else { + break; + } + } + if (is_WHITE_SPACE(ch)) { + do { + ch = state.input.charCodeAt(++state.position); + } while (is_WHITE_SPACE(ch)); + if (ch === 35) { + do { + ch = state.input.charCodeAt(++state.position); + } while (!is_EOL(ch) && ch !== 0); + } + } + while (ch !== 0) { + readLineBreak(state); + state.lineIndent = 0; + ch = state.input.charCodeAt(state.position); + while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + if (!detectedIndent && state.lineIndent > textIndent) { + textIndent = state.lineIndent; + } + if (is_EOL(ch)) { + emptyLines++; + continue; + } + if (state.lineIndent < textIndent) { + if (chomping === CHOMPING_KEEP) { + state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { + state.result += "\n"; + } + } + break; + } + if (folding) { + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat("\n", emptyLines + 1); + } else if (emptyLines === 0) { + if (didReadContent) { + state.result += " "; + } + } else { + state.result += common.repeat("\n", emptyLines); + } + } else { + state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; + while (!is_EOL(ch) && ch !== 0) { + ch = state.input.charCodeAt(++state.position); + } + captureSegment(state, captureStart, state.position, false); + } + return true; +} +function readBlockSequence(state, nodeIndent) { + var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch; + if (state.firstTabInLine !== -1) + return false; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + if (state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, "tab characters must not be used in indentation"); + } + if (ch !== 45) { + break; + } + following = state.input.charCodeAt(state.position + 1); + if (!is_WS_OR_EOL(following)) { + break; + } + detected = true; + state.position++; + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) { + throwError(state, "bad indentation of a sequence entry"); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = "sequence"; + state.result = _result; + return true; + } + return false; +} +function readBlockMapping(state, nodeIndent, flowIndent) { + var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch; + if (state.firstTabInLine !== -1) + return false; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + ch = state.input.charCodeAt(state.position); + while (ch !== 0) { + if (!atExplicitKey && state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, "tab characters must not be used in indentation"); + } + following = state.input.charCodeAt(state.position + 1); + _line = state.line; + if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) { + if (ch === 63) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = true; + allowCompact = true; + } else if (atExplicitKey) { + atExplicitKey = false; + allowCompact = true; + } else { + throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line"); + } + state.position += 1; + ch = following; + } else { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + break; + } + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (ch === 58) { + ch = state.input.charCodeAt(++state.position); + if (!is_WS_OR_EOL(ch)) { + throwError(state, "a whitespace character is expected after the key-value separator within a block mapping"); + } + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; + } else if (detected) { + throwError(state, "can not read an implicit mapping pair; a colon is missed"); + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; + } + } else if (detected) { + throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key"); + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; + } + } + if (state.line === _line || state.lineIndent > nodeIndent) { + if (atExplicitKey) { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + } + if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } + if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) { + throwError(state, "bad indentation of a mapping entry"); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + } + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = "mapping"; + state.result = _result; + } + return detected; +} +function readTagProperty(state) { + var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 33) + return false; + if (state.tag !== null) { + throwError(state, "duplication of a tag property"); + } + ch = state.input.charCodeAt(++state.position); + if (ch === 60) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); + } else if (ch === 33) { + isNamed = true; + tagHandle = "!!"; + ch = state.input.charCodeAt(++state.position); + } else { + tagHandle = "!"; + } + _position = state.position; + if (isVerbatim) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0 && ch !== 62); + if (state.position < state.length) { + tagName = state.input.slice(_position, state.position); + ch = state.input.charCodeAt(++state.position); + } else { + throwError(state, "unexpected end of the stream within a verbatim tag"); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + if (ch === 33) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, "named tag handle cannot contain such characters"); + } + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, "tag suffix cannot contain exclamation marks"); + } + } + ch = state.input.charCodeAt(++state.position); + } + tagName = state.input.slice(_position, state.position); + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, "tag suffix cannot contain flow indicator characters"); + } + } + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, "tag name cannot contain such characters: " + tagName); + } + try { + tagName = decodeURIComponent(tagName); + } catch (err) { + throwError(state, "tag name is malformed: " + tagName); + } + if (isVerbatim) { + state.tag = tagName; + } else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; + } else if (tagHandle === "!") { + state.tag = "!" + tagName; + } else if (tagHandle === "!!") { + state.tag = "tag:yaml.org,2002:" + tagName; + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } + return true; +} +function readAnchorProperty(state) { + var _position, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 38) + return false; + if (state.anchor !== null) { + throwError(state, "duplication of an anchor property"); + } + ch = state.input.charCodeAt(++state.position); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (state.position === _position) { + throwError(state, "name of an anchor node must contain at least one character"); + } + state.anchor = state.input.slice(_position, state.position); + return true; +} +function readAlias(state) { + var _position, alias, ch; + ch = state.input.charCodeAt(state.position); + if (ch !== 42) + return false; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (state.position === _position) { + throwError(state, "name of an alias node must contain at least one character"); + } + alias = state.input.slice(_position, state.position); + if (!_hasOwnProperty$1.call(state.anchorMap, alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; +} +function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type2, flowIndent, blockIndent; + if (state.listener !== null) { + state.listener("open", state); + } + state.tag = null; + state.anchor = null; + state.kind = null; + state.result = null; + allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext; + if (allowToSeek) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + blockIndent = state.position - state.lineStart; + if (indentStatus === 1) { + if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; + } else if (readAlias(state)) { + hasContent = true; + if (state.tag !== null || state.anchor !== null) { + throwError(state, "alias node should not have any properties"); + } + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + if (state.tag === null) { + state.tag = "?"; + } + } + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else if (indentStatus === 0) { + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } + if (state.tag === null) { + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } else if (state.tag === "?") { + if (state.result !== null && state.kind !== "scalar") { + throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"'); + } + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type2 = state.implicitTypes[typeIndex]; + if (type2.resolve(state.result)) { + state.result = type2.construct(state.result); + state.tag = type2.tag; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + break; + } + } + } else if (state.tag !== "!") { + if (_hasOwnProperty$1.call(state.typeMap[state.kind || "fallback"], state.tag)) { + type2 = state.typeMap[state.kind || "fallback"][state.tag]; + } else { + type2 = null; + typeList = state.typeMap.multi[state.kind || "fallback"]; + for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) { + if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) { + type2 = typeList[typeIndex]; + break; + } + } + } + if (!type2) { + throwError(state, "unknown tag !<" + state.tag + ">"); + } + if (state.result !== null && type2.kind !== state.kind) { + throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type2.kind + '", not "' + state.kind + '"'); + } + if (!type2.resolve(state.result, state.tag)) { + throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag"); + } else { + state.result = type2.construct(state.result, state.tag); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } + if (state.listener !== null) { + state.listener("close", state); + } + return state.tag !== null || state.anchor !== null || hasContent; +} +function readDocument(state) { + var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch; + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = /* @__PURE__ */ Object.create(null); + state.anchorMap = /* @__PURE__ */ Object.create(null); + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + if (state.lineIndent > 0 || ch !== 37) { + break; + } + hasDirectives = true; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; + if (directiveName.length < 1) { + throwError(state, "directive name must not be less than one character in length"); + } + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + if (ch === 35) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0 && !is_EOL(ch)); + break; + } + if (is_EOL(ch)) + break; + _position = state.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + directiveArgs.push(state.input.slice(_position, state.position)); + } + if (ch !== 0) + readLineBreak(state); + if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); + } else { + throwWarning(state, 'unknown document directive "' + directiveName + '"'); + } + } + skipSeparationSpace(state, true, -1); + if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } else if (hasDirectives) { + throwError(state, "directives end mark is expected"); + } + composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); + if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, "non-ASCII line breaks are interpreted as content"); + } + state.documents.push(state.result); + if (state.position === state.lineStart && testDocumentSeparator(state)) { + if (state.input.charCodeAt(state.position) === 46) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } + return; + } + if (state.position < state.length - 1) { + throwError(state, "end of the stream or a document separator is expected"); + } else { + return; + } +} +function loadDocuments(input, options) { + input = String(input); + options = options || {}; + if (input.length !== 0) { + if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) { + input += "\n"; + } + if (input.charCodeAt(0) === 65279) { + input = input.slice(1); + } + } + var state = new State$1(input, options); + var nullpos = input.indexOf("\0"); + if (nullpos !== -1) { + state.position = nullpos; + throwError(state, "null byte is not allowed in input"); + } + state.input += "\0"; + while (state.input.charCodeAt(state.position) === 32) { + state.lineIndent += 1; + state.position += 1; + } + while (state.position < state.length - 1) { + readDocument(state); + } + return state.documents; +} +function loadAll$1(input, iterator, options) { + if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") { + options = iterator; + iterator = null; + } + var documents = loadDocuments(input, options); + if (typeof iterator !== "function") { + return documents; + } + for (var index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } +} +function load$1(input, options) { + var documents = loadDocuments(input, options); + if (documents.length === 0) { + return void 0; + } else if (documents.length === 1) { + return documents[0]; + } + throw new exception("expected a single document in the stream, but found more"); +} +var loadAll_1 = loadAll$1; +var load_1 = load$1; +var loader = { + loadAll: loadAll_1, + load: load_1 +}; +var _toString = Object.prototype.toString; +var _hasOwnProperty = Object.prototype.hasOwnProperty; +var CHAR_BOM = 65279; +var CHAR_TAB = 9; +var CHAR_LINE_FEED = 10; +var CHAR_CARRIAGE_RETURN = 13; +var CHAR_SPACE = 32; +var CHAR_EXCLAMATION = 33; +var CHAR_DOUBLE_QUOTE = 34; +var CHAR_SHARP = 35; +var CHAR_PERCENT = 37; +var CHAR_AMPERSAND = 38; +var CHAR_SINGLE_QUOTE = 39; +var CHAR_ASTERISK = 42; +var CHAR_COMMA = 44; +var CHAR_MINUS = 45; +var CHAR_COLON = 58; +var CHAR_EQUALS = 61; +var CHAR_GREATER_THAN = 62; +var CHAR_QUESTION = 63; +var CHAR_COMMERCIAL_AT = 64; +var CHAR_LEFT_SQUARE_BRACKET = 91; +var CHAR_RIGHT_SQUARE_BRACKET = 93; +var CHAR_GRAVE_ACCENT = 96; +var CHAR_LEFT_CURLY_BRACKET = 123; +var CHAR_VERTICAL_LINE = 124; +var CHAR_RIGHT_CURLY_BRACKET = 125; +var ESCAPE_SEQUENCES = {}; +ESCAPE_SEQUENCES[0] = "\\0"; +ESCAPE_SEQUENCES[7] = "\\a"; +ESCAPE_SEQUENCES[8] = "\\b"; +ESCAPE_SEQUENCES[9] = "\\t"; +ESCAPE_SEQUENCES[10] = "\\n"; +ESCAPE_SEQUENCES[11] = "\\v"; +ESCAPE_SEQUENCES[12] = "\\f"; +ESCAPE_SEQUENCES[13] = "\\r"; +ESCAPE_SEQUENCES[27] = "\\e"; +ESCAPE_SEQUENCES[34] = '\\"'; +ESCAPE_SEQUENCES[92] = "\\\\"; +ESCAPE_SEQUENCES[133] = "\\N"; +ESCAPE_SEQUENCES[160] = "\\_"; +ESCAPE_SEQUENCES[8232] = "\\L"; +ESCAPE_SEQUENCES[8233] = "\\P"; +var DEPRECATED_BOOLEANS_SYNTAX = [ + "y", + "Y", + "yes", + "Yes", + "YES", + "on", + "On", + "ON", + "n", + "N", + "no", + "No", + "NO", + "off", + "Off", + "OFF" +]; +var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/; +function compileStyleMap(schema2, map2) { + var result, keys, index, length, tag, style, type2; + if (map2 === null) + return {}; + result = {}; + keys = Object.keys(map2); + for (index = 0, length = keys.length; index < length; index += 1) { + tag = keys[index]; + style = String(map2[tag]); + if (tag.slice(0, 2) === "!!") { + tag = "tag:yaml.org,2002:" + tag.slice(2); + } + type2 = schema2.compiledTypeMap["fallback"][tag]; + if (type2 && _hasOwnProperty.call(type2.styleAliases, style)) { + style = type2.styleAliases[style]; + } + result[tag] = style; + } + return result; +} +function encodeHex(character) { + var string, handle, length; + string = character.toString(16).toUpperCase(); + if (character <= 255) { + handle = "x"; + length = 2; + } else if (character <= 65535) { + handle = "u"; + length = 4; + } else if (character <= 4294967295) { + handle = "U"; + length = 8; + } else { + throw new exception("code point within a string may not be greater than 0xFFFFFFFF"); + } + return "\\" + handle + common.repeat("0", length - string.length) + string; +} +var QUOTING_TYPE_SINGLE = 1, QUOTING_TYPE_DOUBLE = 2; +function State(options) { + this.schema = options["schema"] || _default; + this.indent = Math.max(1, options["indent"] || 2); + this.noArrayIndent = options["noArrayIndent"] || false; + this.skipInvalid = options["skipInvalid"] || false; + this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"]; + this.styleMap = compileStyleMap(this.schema, options["styles"] || null); + this.sortKeys = options["sortKeys"] || false; + this.lineWidth = options["lineWidth"] || 80; + this.noRefs = options["noRefs"] || false; + this.noCompatMode = options["noCompatMode"] || false; + this.condenseFlow = options["condenseFlow"] || false; + this.quotingType = options["quotingType"] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE; + this.forceQuotes = options["forceQuotes"] || false; + this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null; + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + this.tag = null; + this.result = ""; + this.duplicates = []; + this.usedDuplicates = null; +} +function indentString(string, spaces) { + var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string.length; + while (position < length) { + next = string.indexOf("\n", position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + if (line.length && line !== "\n") + result += ind; + result += line; + } + return result; +} +function generateNextLine(state, level) { + return "\n" + common.repeat(" ", state.indent * level); +} +function testImplicitResolving(state, str2) { + var index, length, type2; + for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { + type2 = state.implicitTypes[index]; + if (type2.resolve(str2)) { + return true; + } + } + return false; +} +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; +} +function isPrintable(c) { + return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== CHAR_BOM || 65536 <= c && c <= 1114111; +} +function isNsCharOrWhitespace(c) { + return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED; +} +function isPlainSafe(c, prev, inblock) { + var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c); + var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c); + return ( + // ns-plain-safe + (inblock ? ( + // c = flow-in + cIsNsCharOrWhitespace + ) : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar + ); +} +function isPlainSafeFirst(c) { + return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT; +} +function isPlainSafeLast(c) { + return !isWhitespace(c) && c !== CHAR_COLON; +} +function codePointAt(string, pos) { + var first = string.charCodeAt(pos), second; + if (first >= 55296 && first <= 56319 && pos + 1 < string.length) { + second = string.charCodeAt(pos + 1); + if (second >= 56320 && second <= 57343) { + return (first - 55296) * 1024 + second - 56320 + 65536; + } + } + return first; +} +function needIndentIndicator(string) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string); +} +var STYLE_PLAIN = 1, STYLE_SINGLE = 2, STYLE_LITERAL = 3, STYLE_FOLDED = 4, STYLE_DOUBLE = 5; +function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) { + var i; + var char = 0; + var prevChar = null; + var hasLineBreak = false; + var hasFoldableLine = false; + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; + var plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1)); + if (singleLineOnly || forceQuotes) { + for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + char = codePointAt(string, i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + } else { + for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + char = codePointAt(string, i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented. + i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " "; + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " "); + } + if (!hasLineBreak && !hasFoldableLine) { + if (plain && !forceQuotes && !testAmbiguousType(string)) { + return STYLE_PLAIN; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; + } + if (indentPerLevel > 9 && needIndentIndicator(string)) { + return STYLE_DOUBLE; + } + if (!forceQuotes) { + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; +} +function writeScalar(state, string, level, iskey, inblock) { + state.dump = function() { + if (string.length === 0) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''"; + } + if (!state.noCompatMode) { + if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string + '"' : "'" + string + "'"; + } + } + var indent = state.indent * Math.max(1, level); + var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); + var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel; + function testAmbiguity(string2) { + return testImplicitResolving(state, string2); + } + switch (chooseScalarStyle( + string, + singleLineOnly, + state.indent, + lineWidth, + testAmbiguity, + state.quotingType, + state.forceQuotes && !iskey, + inblock + )) { + case STYLE_PLAIN: + return string; + case STYLE_SINGLE: + return "'" + string.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: + return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string) + '"'; + default: + throw new exception("impossible error: invalid scalar style"); + } + }(); +} +function blockHeader(string, indentPerLevel) { + var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ""; + var clip = string[string.length - 1] === "\n"; + var keep = clip && (string[string.length - 2] === "\n" || string === "\n"); + var chomp = keep ? "+" : clip ? "" : "-"; + return indentIndicator + chomp + "\n"; +} +function dropEndingNewline(string) { + return string[string.length - 1] === "\n" ? string.slice(0, -1) : string; +} +function foldString(string, width) { + var lineRe = /(\n+)([^\n]*)/g; + var result = function() { + var nextLF = string.indexOf("\n"); + nextLF = nextLF !== -1 ? nextLF : string.length; + lineRe.lastIndex = nextLF; + return foldLine(string.slice(0, nextLF), width); + }(); + var prevMoreIndented = string[0] === "\n" || string[0] === " "; + var moreIndented; + var match; + while (match = lineRe.exec(string)) { + var prefix = match[1], line = match[2]; + moreIndented = line[0] === " "; + result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width); + prevMoreIndented = moreIndented; + } + return result; +} +function foldLine(line, width) { + if (line === "" || line[0] === " ") + return line; + var breakRe = / [^ ]/g; + var match; + var start = 0, end, curr = 0, next = 0; + var result = ""; + while (match = breakRe.exec(line)) { + next = match.index; + if (next - start > width) { + end = curr > start ? curr : next; + result += "\n" + line.slice(start, end); + start = end + 1; + } + curr = next; + } + result += "\n"; + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + "\n" + line.slice(curr + 1); + } else { + result += line.slice(start); + } + return result.slice(1); +} +function escapeString(string) { + var result = ""; + var char = 0; + var escapeSeq; + for (var i = 0; i < string.length; char >= 65536 ? i += 2 : i++) { + char = codePointAt(string, i); + escapeSeq = ESCAPE_SEQUENCES[char]; + if (!escapeSeq && isPrintable(char)) { + result += string[i]; + if (char >= 65536) + result += string[i + 1]; + } else { + result += escapeSeq || encodeHex(char); + } + } + return result; +} +function writeFlowSequence(state, level, object) { + var _result = "", _tag = state.tag, index, length, value; + for (index = 0, length = object.length; index < length; index += 1) { + value = object[index]; + if (state.replacer) { + value = state.replacer.call(object, String(index), value); + } + if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) { + if (_result !== "") + _result += "," + (!state.condenseFlow ? " " : ""); + _result += state.dump; + } + } + state.tag = _tag; + state.dump = "[" + _result + "]"; +} +function writeBlockSequence(state, level, object, compact) { + var _result = "", _tag = state.tag, index, length, value; + for (index = 0, length = object.length; index < length; index += 1) { + value = object[index]; + if (state.replacer) { + value = state.replacer.call(object, String(index), value); + } + if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) { + if (!compact || _result !== "") { + _result += generateNextLine(state, level); + } + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += "-"; + } else { + _result += "- "; + } + _result += state.dump; + } + } + state.tag = _tag; + state.dump = _result || "[]"; +} +function writeFlowMapping(state, level, object) { + var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, pairBuffer; + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ""; + if (_result !== "") + pairBuffer += ", "; + if (state.condenseFlow) + pairBuffer += '"'; + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); + } + if (!writeNode(state, level, objectKey, false, false)) { + continue; + } + if (state.dump.length > 1024) + pairBuffer += "? "; + pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " "); + if (!writeNode(state, level, objectValue, false, false)) { + continue; + } + pairBuffer += state.dump; + _result += pairBuffer; + } + state.tag = _tag; + state.dump = "{" + _result + "}"; +} +function writeBlockMapping(state, level, object, compact) { + var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer; + if (state.sortKeys === true) { + objectKeyList.sort(); + } else if (typeof state.sortKeys === "function") { + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + throw new exception("sortKeys must be a boolean or a function"); + } + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ""; + if (!compact || _result !== "") { + pairBuffer += generateNextLine(state, level); + } + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); + } + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; + } + explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024; + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += "?"; + } else { + pairBuffer += "? "; + } + } + pairBuffer += state.dump; + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; + } + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ":"; + } else { + pairBuffer += ": "; + } + pairBuffer += state.dump; + _result += pairBuffer; + } + state.tag = _tag; + state.dump = _result || "{}"; +} +function detectType(state, object, explicit) { + var _result, typeList, index, length, type2, style; + typeList = explicit ? state.explicitTypes : state.implicitTypes; + for (index = 0, length = typeList.length; index < length; index += 1) { + type2 = typeList[index]; + if ((type2.instanceOf || type2.predicate) && (!type2.instanceOf || typeof object === "object" && object instanceof type2.instanceOf) && (!type2.predicate || type2.predicate(object))) { + if (explicit) { + if (type2.multi && type2.representName) { + state.tag = type2.representName(object); + } else { + state.tag = type2.tag; + } + } else { + state.tag = "?"; + } + if (type2.represent) { + style = state.styleMap[type2.tag] || type2.defaultStyle; + if (_toString.call(type2.represent) === "[object Function]") { + _result = type2.represent(object, style); + } else if (_hasOwnProperty.call(type2.represent, style)) { + _result = type2.represent[style](object, style); + } else { + throw new exception("!<" + type2.tag + '> tag resolver accepts not "' + style + '" style'); + } + state.dump = _result; + } + return true; + } + } + return false; +} +function writeNode(state, level, object, block, compact, iskey, isblockseq) { + state.tag = null; + state.dump = object; + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + var type2 = _toString.call(state.dump); + var inblock = block; + var tagStr; + if (block) { + block = state.flowLevel < 0 || state.flowLevel > level; + } + var objectOrArray = type2 === "[object Object]" || type2 === "[object Array]", duplicateIndex, duplicate; + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) { + compact = false; + } + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = "*ref_" + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type2 === "[object Object]") { + if (block && Object.keys(state.dump).length !== 0) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + state.dump; + } + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + " " + state.dump; + } + } + } else if (type2 === "[object Array]") { + if (block && state.dump.length !== 0) { + if (state.noArrayIndent && !isblockseq && level > 0) { + writeBlockSequence(state, level - 1, state.dump, compact); + } else { + writeBlockSequence(state, level, state.dump, compact); + } + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, level, state.dump); + if (duplicate) { + state.dump = "&ref_" + duplicateIndex + " " + state.dump; + } + } + } else if (type2 === "[object String]") { + if (state.tag !== "?") { + writeScalar(state, state.dump, level, iskey, inblock); + } + } else if (type2 === "[object Undefined]") { + return false; + } else { + if (state.skipInvalid) + return false; + throw new exception("unacceptable kind of an object to dump " + type2); + } + if (state.tag !== null && state.tag !== "?") { + tagStr = encodeURI( + state.tag[0] === "!" ? state.tag.slice(1) : state.tag + ).replace(/!/g, "%21"); + if (state.tag[0] === "!") { + tagStr = "!" + tagStr; + } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") { + tagStr = "!!" + tagStr.slice(18); + } else { + tagStr = "!<" + tagStr + ">"; + } + state.dump = tagStr + " " + state.dump; + } + } + return true; +} +function getDuplicateReferences(object, state) { + var objects = [], duplicatesIndexes = [], index, length; + inspectNode(object, objects, duplicatesIndexes); + for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { + state.duplicates.push(objects[duplicatesIndexes[index]]); + } + state.usedDuplicates = new Array(length); +} +function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, index, length; + if (object !== null && typeof object === "object") { + index = objects.indexOf(object); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); + } + } else { + objects.push(object); + if (Array.isArray(object)) { + for (index = 0, length = object.length; index < length; index += 1) { + inspectNode(object[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); + } + } + } + } +} +function dump$1(input, options) { + options = options || {}; + var state = new State(options); + if (!state.noRefs) + getDuplicateReferences(input, state); + var value = input; + if (state.replacer) { + value = state.replacer.call({ "": value }, "", value); + } + if (writeNode(state, 0, value, true, true)) + return state.dump + "\n"; + return ""; +} +var dump_1 = dump$1; +var dumper = { + dump: dump_1 +}; +function renamed(from, to) { + return function() { + throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default."); + }; +} +var Type = type; +var Schema = schema; +var FAILSAFE_SCHEMA = failsafe; +var JSON_SCHEMA = json; +var CORE_SCHEMA = core; +var DEFAULT_SCHEMA = _default; +var load$2 = loader.load; +var loadAll = loader.loadAll; +var dump = dumper.dump; +var YAMLException = exception; +var types = { + binary, + float, + map, + null: _null, + pairs, + set, + timestamp, + bool, + int, + merge, + omap, + seq, + str +}; +var safeLoad = renamed("safeLoad", "load"); +var safeLoadAll = renamed("safeLoadAll", "loadAll"); +var safeDump = renamed("safeDump", "dump"); +var jsYaml = { + Type, + Schema, + FAILSAFE_SCHEMA, + JSON_SCHEMA, + CORE_SCHEMA, + DEFAULT_SCHEMA, + load: load$2, + loadAll, + dump, + YAMLException, + types, + safeLoad, + safeLoadAll, + safeDump +}; +const CONFIG = jsYaml.load(` + +title: Web3Privacy Prague 2023 +shortname: Web3Privacy Summit +date: Monday, 5. June 2023 +venue: X10, Prague +themes: +- title: Human rights DAOs (pro-privacy) +- title: Identity (ID) +- title: Mixnets → Full-Stack Privacy +- title: Cryptography +- title: Tech journalists +- title: Asian community +- title: Privacy wars +- title: Privacy workforce +- title: "Privacy activist's" +- title: R&D (ZK, MPC) +- title: Network states (with a privacy focus) +- title: Solarpunk vs Lunarpunk +- title: Veksl +tickets: +- title: All-day Access + price: 2350 CZK (~99 EUR) + includes: + - All talks & panels + - Coffee breaks + - Buffet lunch + - Networking drinks with speakers & attendees +- title: "#Lunarpunk Party" + price: 350 CZK (~15 EUR) + includes: + - 20:00 - morning + - Prague rave from top DJs + - VJs and projections + - Networking with attendees, speakers & sponsors + note: "*Party access is included in the All-day Pass" +faq: +- title: Who is the event for? + text: | + Our event is for anyone interested in privacy topics in the Web3 industry. There will be space for about 300 enthusiasts. +- title: How do I get to the venue? + text: | + Venue X10 (full name "[Divadlo X10](https://divadlox10.cz)") is located in the centre of Prague near the metro station *Národní Třída* (Line B) and *Můstek* (Line A,C). The address is [Charvátova 10/39, Prague 1, 110 00](https://goo.gl/maps/Yh8qWagnqB1DvK676) ([Google Maps](https://goo.gl/maps/Yh8qWagnqB1DvK676)). +- title: Will there be any food or drink? + text: | + We don't know, but we'll do our best. This unfortunately depends on the sponsors. +program: +- time: 9:00 - 9:30 + title: Registration & networking +- time: 9:30 - 9:35 + title: Welcome to Web3Privacy + speakers: + - name: TBA + desc: | + Welcoming visitors to our private-centric research, community and conference +- time: 9:35 - 10:55 + title: Talks I. +- time: 10:55 - 11:20 + title: 25min Coffee Break +- time: 11:25 - 12:40 + title: Talks II. +- time: 12:40 - 14:00 + title: Lunch & Networking +- time: 14:00 - 15:40 + title: Talks III. +- time: 15:40 - 16:05 + title: 25min Coffee Break +- time: 16:10 - 18:30 + title: Talks IV. +- time: 18:30 - 18:35 + title: Closing Remarks + speakers: + - name: TBA +- time: 18:30 - 20:00 + title: Networking & Drinks +- time: 20:00 - 4:00 + title: "#Lunarpunk party" + desc: | + Enjoy our afterparty in Lunarpunk style with quality Prague rave DJs, which will take place in the same venue until the morning (4am). + +`); +async function load({ params, url, fetch }) { + return { + config: CONFIG + }; +} +const _layout = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + load +}, Symbol.toStringTag, { value: "Module" })); +export { + _layout as _, + load as l +}; diff --git a/_app/immutable/chunks/_layout-f7327cba.js b/_app/immutable/chunks/_layout-f7327cba.js deleted file mode 100644 index 7451fcb..0000000 --- a/_app/immutable/chunks/_layout-f7327cba.js +++ /dev/null @@ -1,38 +0,0 @@ -const config = { - title: "Web3Privacy Prague 2023", - shortname: "Web3Privacy Summit", - date: "Monday, 5. June 2023", - venue: "X10, Prague", - themes: [ - { title: "Human rights DAOs (pro-privacy)" }, - { title: "Identity (ID)" }, - { title: "Mixnets → Full-Stack Privacy" }, - { title: "Cryptography" }, - { title: "Tech journalists" }, - { title: "Asian community" }, - { title: "Privacy wars" }, - { title: "Privacy workforce" }, - { title: "Privacy activist's" }, - { title: "R&D (ZK, MPC)" }, - { title: "Network states (with a privacy focus)" }, - { title: "Solarpunk vs Lunarpunk" }, - { title: "Veksl" } - ], - tickets: [ - { title: "Conference ticket" }, - { title: "Party ticket" } - ] -}; -async function load({ params, url, fetch }) { - return { - config - }; -} -const _layout = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - load -}, Symbol.toStringTag, { value: "Module" })); -export { - _layout as _, - load as l -}; diff --git a/_app/immutable/chunks/index-dc145a1c.js b/_app/immutable/chunks/index-a17c58e1.js similarity index 79% rename from _app/immutable/chunks/index-dc145a1c.js rename to _app/immutable/chunks/index-a17c58e1.js index 81deadb..c469466 100644 --- a/_app/immutable/chunks/index-dc145a1c.js +++ b/_app/immutable/chunks/index-a17c58e1.js @@ -85,6 +85,21 @@ function get_all_dirty_from_scope($$scope) { } return -1; } +function exclude_internal_props(props) { + const result = {}; + for (const k in props) + if (k[0] !== "$") + result[k] = props[k]; + return result; +} +function compute_rest_props(props, keys) { + const rest = {}; + keys = new Set(keys); + for (const k in props) + if (!keys.has(k) && k[0] !== "$") + rest[k] = props[k]; + return rest; +} let is_hydrating = false; function start_hydrating() { is_hydrating = true; @@ -173,6 +188,9 @@ function append_hydration(target, node) { target.appendChild(node); } } +function insert(target, node, anchor) { + target.insertBefore(node, anchor || null); +} function insert_hydration(target, node, anchor) { if (is_hydrating && !anchor) { append_hydration(target, node); @@ -302,6 +320,32 @@ function claim_text(nodes, data) { function claim_space(nodes) { return claim_text(nodes, " "); } +function find_comment(nodes, text2, start) { + for (let i = start; i < nodes.length; i += 1) { + const node = nodes[i]; + if (node.nodeType === 8 && node.textContent.trim() === text2) { + return i; + } + } + return nodes.length; +} +function claim_html_tag(nodes, is_svg) { + const start_index = find_comment(nodes, "HTML_TAG_START", 0); + const end_index = find_comment(nodes, "HTML_TAG_END", start_index); + if (start_index === end_index) { + return new HtmlTagHydration(void 0, is_svg); + } + init_claim_info(nodes); + const html_tag_nodes = nodes.splice(start_index, end_index - start_index + 1); + detach(html_tag_nodes[0]); + detach(html_tag_nodes[html_tag_nodes.length - 1]); + const claimed_nodes = html_tag_nodes.slice(1, html_tag_nodes.length - 1); + for (const n of claimed_nodes) { + n.claim_order = nodes.claim_info.total_claimed; + nodes.claim_info.total_claimed += 1; + } + return new HtmlTagHydration(claimed_nodes, is_svg); +} function set_data(text2, data) { data = "" + data; if (text2.wholeText !== data) @@ -314,6 +358,11 @@ function set_style(node, key, value, important) { node.style.setProperty(key, value, important ? "important" : ""); } } +function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) { + const e = document.createEvent("CustomEvent"); + e.initCustomEvent(type, bubbles, cancelable, detail); + return e; +} function head_selector(nodeId, head) { const result = []; let started = 0; @@ -333,6 +382,63 @@ function head_selector(nodeId, head) { } return result; } +class HtmlTag { + constructor(is_svg = false) { + this.is_svg = false; + this.is_svg = is_svg; + this.e = this.n = null; + } + c(html) { + this.h(html); + } + m(html, target, anchor = null) { + if (!this.e) { + if (this.is_svg) + this.e = svg_element(target.nodeName); + else + this.e = element(target.nodeName); + this.t = target; + this.c(html); + } + this.i(anchor); + } + h(html) { + this.e.innerHTML = html; + this.n = Array.from(this.e.childNodes); + } + i(anchor) { + for (let i = 0; i < this.n.length; i += 1) { + insert(this.t, this.n[i], anchor); + } + } + p(html) { + this.d(); + this.h(html); + this.i(this.a); + } + d() { + this.n.forEach(detach); + } +} +class HtmlTagHydration extends HtmlTag { + constructor(claimed_nodes, is_svg = false) { + super(is_svg); + this.e = this.n = null; + this.l = claimed_nodes; + } + c(html) { + if (this.l) { + this.n = this.l; + } else { + super.c(html); + } + } + i(anchor) { + for (let i = 0; i < this.n.length; i += 1) { + insert_hydration(this.t, this.n[i], anchor); + } + } +} function construct_svelte_component(component, props) { return new component(props); } @@ -351,6 +457,27 @@ function onMount(fn) { function afterUpdate(fn) { get_current_component().$$.after_update.push(fn); } +function createEventDispatcher() { + const component = get_current_component(); + return (type, detail, { cancelable = false } = {}) => { + const callbacks = component.$$.callbacks[type]; + if (callbacks) { + const event = custom_event(type, detail, { cancelable }); + callbacks.slice().forEach((fn) => { + fn.call(component, event); + }); + return !event.defaultPrevented; + } + return true; + }; +} +function setContext(key, context) { + get_current_component().$$.context.set(key, context); + return context; +} +function getContext(key) { + return get_current_component().$$.context.get(key); +} const dirty_components = []; const binding_callbacks = []; const render_callbacks = []; @@ -461,6 +588,41 @@ function transition_out(block, local, detach2, callback) { callback(); } } +function get_spread_update(levels, updates) { + const update2 = {}; + const to_null_out = {}; + const accounted_for = { $$scope: 1 }; + let i = levels.length; + while (i--) { + const o = levels[i]; + const n = updates[i]; + if (n) { + for (const key in o) { + if (!(key in n)) + to_null_out[key] = 1; + } + for (const key in n) { + if (!accounted_for[key]) { + update2[key] = n[key]; + accounted_for[key] = 1; + } + } + levels[i] = n; + } else { + for (const key in o) { + accounted_for[key] = 1; + } + } + } + for (const key in to_null_out) { + if (!(key in update2)) + update2[key] = void 0; + } + return update2; +} +function get_spread_object(spread_props) { + return typeof spread_props === "object" && spread_props !== null ? spread_props : {}; +} function create_component(block) { block && block.c(); } @@ -596,8 +758,18 @@ export { get_slot_changes as K, destroy_each as L, component_subscribe as M, - head_selector as N, + compute_rest_props as N, + assign as O, + exclude_internal_props as P, + get_spread_update as Q, + get_spread_object as R, SvelteComponent as S, + getContext as T, + HtmlTagHydration as U, + claim_html_tag as V, + createEventDispatcher as W, + setContext as X, + head_selector as Y, space as a, insert_hydration as b, claim_space as c, diff --git a/_app/immutable/chunks/singletons-57b7ce3e.js b/_app/immutable/chunks/singletons-34f1d235.js similarity index 98% rename from _app/immutable/chunks/singletons-57b7ce3e.js rename to _app/immutable/chunks/singletons-34f1d235.js index b11dd5c..1bf4f02 100644 --- a/_app/immutable/chunks/singletons-57b7ce3e.js +++ b/_app/immutable/chunks/singletons-34f1d235.js @@ -1,4 +1,4 @@ -import { C as noop, s as safe_not_equal } from "./index-dc145a1c.js"; +import { C as noop, s as safe_not_equal } from "./index-a17c58e1.js"; const subscriber_queue = []; function writable(value, start = noop) { let stop; diff --git a/_app/immutable/components/error.svelte-63d63419.js b/_app/immutable/components/error.svelte-999441bb.js similarity index 95% rename from _app/immutable/components/error.svelte-63d63419.js rename to _app/immutable/components/error.svelte-999441bb.js index a69ce8a..b2577a7 100644 --- a/_app/immutable/components/error.svelte-63d63419.js +++ b/_app/immutable/components/error.svelte-999441bb.js @@ -1,5 +1,5 @@ -import { S as SvelteComponent, i as init, s as safe_not_equal, k as element, q as text, a as space, l as claim_element, m as children, r as claim_text, h as detach, c as claim_space, b as insert_hydration, H as append_hydration, u as set_data, C as noop, M as component_subscribe } from "../chunks/index-dc145a1c.js"; -import { s as stores } from "../chunks/singletons-57b7ce3e.js"; +import { S as SvelteComponent, i as init, s as safe_not_equal, k as element, q as text, a as space, l as claim_element, m as children, r as claim_text, h as detach, c as claim_space, b as insert_hydration, H as append_hydration, u as set_data, C as noop, M as component_subscribe } from "../chunks/index-a17c58e1.js"; +import { s as stores } from "../chunks/singletons-34f1d235.js"; const getStores = () => { const stores$1 = stores; return { diff --git a/_app/immutable/components/pages/_layout.svelte-ea2e7f73.js b/_app/immutable/components/pages/_layout.svelte-3137396c.js similarity index 90% rename from _app/immutable/components/pages/_layout.svelte-ea2e7f73.js rename to _app/immutable/components/pages/_layout.svelte-3137396c.js index 851c822..ed1f4b9 100644 --- a/_app/immutable/components/pages/_layout.svelte-ea2e7f73.js +++ b/_app/immutable/components/pages/_layout.svelte-3137396c.js @@ -1,4 +1,4 @@ -import { S as SvelteComponent, i as init, s as safe_not_equal, D as create_slot, k as element, a as space, q as text, E as svg_element, l as claim_element, m as children, h as detach, c as claim_space, r as claim_text, F as claim_svg_element, G as src_url_equal, n as attr, b as insert_hydration, H as append_hydration, u as set_data, I as update_slot_base, J as get_all_dirty_from_scope, K as get_slot_changes, f as transition_in, t as transition_out, L as destroy_each, C as noop } from "../../chunks/index-dc145a1c.js"; +import { S as SvelteComponent, i as init, s as safe_not_equal, D as create_slot, k as element, a as space, q as text, E as svg_element, l as claim_element, m as children, h as detach, c as claim_space, r as claim_text, F as claim_svg_element, G as src_url_equal, n as attr, b as insert_hydration, H as append_hydration, u as set_data, I as update_slot_base, J as get_all_dirty_from_scope, K as get_slot_changes, f as transition_in, t as transition_out, L as destroy_each, C as noop } from "../../chunks/index-a17c58e1.js"; const app = ""; function get_each_context(ctx, list, i) { const child_ctx = ctx.slice(); @@ -117,14 +117,17 @@ function create_fragment(ctx) { let svg; let path; let t14; - let div16; - let t15; let a4; + let t15; let t16; + let div16; let t17; let a5; let t18; let t19; + let a6; + let t20; + let t21; let current; let each_value = ( /*menu*/ @@ -198,14 +201,17 @@ function create_fragment(ctx) { svg = svg_element("svg"); path = svg_element("path"); t14 = space(); - div16 = element("div"); - t15 = text("💛 Collaboration of "); a4 = element("a"); - t16 = text("Web3Privacy Now"); - t17 = text(" & "); + t15 = text("@web3privacy"); + t16 = space(); + div16 = element("div"); + t17 = text("💛 Collaboration of "); a5 = element("a"); - t18 = text("ETHBrno"); - t19 = text(" team"); + t18 = text("Web3Privacy Now"); + t19 = text(" & "); + a6 = element("a"); + t20 = text("ETHBrno"); + t21 = text(" team"); this.h(); }, l(nodes) { @@ -302,35 +308,34 @@ function create_fragment(ctx) { var div17_nodes = children(div17); div15 = claim_element(div17_nodes, "DIV", { class: true }); var div15_nodes = children(div15); - a3 = claim_element(div15_nodes, "A", { href: true }); + a3 = claim_element(div15_nodes, "A", { class: true, href: true }); var a3_nodes = children(a3); - svg = claim_svg_element(a3_nodes, "svg", { - width: true, - height: true, - viewBox: true, - fill: true, - xmlns: true - }); + svg = claim_svg_element(a3_nodes, "svg", { viewBox: true, fill: true, xmlns: true }); var svg_nodes = children(svg); path = claim_svg_element(svg_nodes, "path", { d: true, fill: true }); children(path).forEach(detach); svg_nodes.forEach(detach); a3_nodes.forEach(detach); + t14 = claim_space(div15_nodes); + a4 = claim_element(div15_nodes, "A", { href: true, class: true }); + var a4_nodes = children(a4); + t15 = claim_text(a4_nodes, "@web3privacy"); + a4_nodes.forEach(detach); div15_nodes.forEach(detach); - t14 = claim_space(div17_nodes); + t16 = claim_space(div17_nodes); div16 = claim_element(div17_nodes, "DIV", { class: true }); var div16_nodes = children(div16); - t15 = claim_text(div16_nodes, "💛 Collaboration of "); - a4 = claim_element(div16_nodes, "A", { href: true }); - var a4_nodes = children(a4); - t16 = claim_text(a4_nodes, "Web3Privacy Now"); - a4_nodes.forEach(detach); - t17 = claim_text(div16_nodes, " & "); + t17 = claim_text(div16_nodes, "💛 Collaboration of "); a5 = claim_element(div16_nodes, "A", { href: true }); var a5_nodes = children(a5); - t18 = claim_text(a5_nodes, "ETHBrno"); + t18 = claim_text(a5_nodes, "Web3Privacy Now"); a5_nodes.forEach(detach); - t19 = claim_text(div16_nodes, " team"); + t19 = claim_text(div16_nodes, " & "); + a6 = claim_element(div16_nodes, "A", { href: true }); + var a6_nodes = children(a6); + t20 = claim_text(a6_nodes, "ETHBrno"); + a6_nodes.forEach(detach); + t21 = claim_text(div16_nodes, " team"); div16_nodes.forEach(detach); div17_nodes.forEach(detach); div18_nodes.forEach(detach); @@ -354,7 +359,7 @@ function create_fragment(ctx) { attr(div8, "class", "text-5xl"); attr(a1, "href", "https://prgblockweek.com"); attr(a1, "class", "underline hover:no-underline"); - attr(div9, "class", "mt-8 text-lg text-white/50"); + attr(div9, "class", "mt-8 text-lg text-mild"); attr(div10, "class", "mx-auto"); attr(div11, "class", "w-full h-full flex items-center text-center"); attr(div12, "class", "w-full h-screen"); @@ -365,16 +370,17 @@ function create_fragment(ctx) { attr(div14, "class", "grow"); attr(path, "d", "M28.0266 3.12733C26.9955 3.62938 25.8872 3.96853 24.7242 4.12112C25.9113 3.34005 26.8231 2.10325 27.2524 0.629411C26.1413 1.35279 24.9107 1.87791 23.6009 2.16092C22.5522 0.934264 21.0578 0.167969 19.4039 0.167969C16.2285 0.167969 13.6538 2.99367 13.6538 6.47907C13.6538 6.97373 13.7047 7.45548 13.8028 7.91738C9.02398 7.6542 4.78719 5.14151 1.95117 1.3231C1.45622 2.25521 1.17259 3.33929 1.17259 4.49596C1.17259 6.68564 2.18771 8.61738 3.73058 9.74913C2.78804 9.71637 1.90142 9.43244 1.1262 8.95977C1.12555 8.98607 1.12555 9.01252 1.12555 9.03913C1.12555 12.0969 3.1076 14.6476 5.73804 15.2278C5.25556 15.3721 4.74758 15.4491 4.2232 15.4491C3.85268 15.4491 3.49255 15.4095 3.14137 15.3359C3.87315 17.8432 5.99658 19.6679 8.51282 19.7187C6.54493 21.4115 4.06569 22.4206 1.37163 22.4206C0.907503 22.4206 0.449828 22.3906 0 22.3323C2.54468 24.1231 5.56708 25.168 8.81424 25.168C19.3905 25.168 25.1742 15.5511 25.1742 7.21076C25.1742 6.93712 25.1686 6.66503 25.1576 6.39416C26.2809 5.50451 27.2556 4.39306 28.0265 3.12733H28.0266Z"); attr(path, "fill", "white"); - attr(svg, "width", "29"); - attr(svg, "height", "26"); attr(svg, "viewBox", "0 0 29 26"); attr(svg, "fill", "none"); attr(svg, "xmlns", "http://www.w3.org/2000/svg"); + attr(a3, "class", "inline-block w-5 mr-1"); attr(a3, "href", "https://twitter.com/web3privacy"); - attr(div15, "class", "inline-block"); - attr(a4, "href", "https://web3privacy.info"); - attr(a5, "href", "https://ethbrno.cz"); - attr(div16, "class", "mt-4"); + attr(a4, "href", "https://twitter.com/web3privacy"); + attr(a4, "class", "text-2xl no-underline hover:underline"); + attr(div15, "class", ""); + attr(a5, "href", "https://web3privacy.info"); + attr(a6, "href", "https://ethbrno.cz"); + attr(div16, "class", "mt-4 text-mild"); attr(div17, "class", "text-right"); attr(div18, "class", "flex items-center"); attr(div19, "class", "middle-pane-big pt-6 mx-auto"); @@ -433,15 +439,18 @@ function create_fragment(ctx) { append_hydration(div15, a3); append_hydration(a3, svg); append_hydration(svg, path); - append_hydration(div17, t14); + append_hydration(div15, t14); + append_hydration(div15, a4); + append_hydration(a4, t15); + append_hydration(div17, t16); append_hydration(div17, div16); - append_hydration(div16, t15); - append_hydration(div16, a4); - append_hydration(a4, t16); append_hydration(div16, t17); append_hydration(div16, a5); append_hydration(a5, t18); append_hydration(div16, t19); + append_hydration(div16, a6); + append_hydration(a6, t20); + append_hydration(div16, t21); current = true; }, p(ctx2, [dirty]) { diff --git a/_app/immutable/components/pages/_page.svelte-9806a2aa.js b/_app/immutable/components/pages/_page.svelte-9806a2aa.js new file mode 100644 index 0000000..df97953 --- /dev/null +++ b/_app/immutable/components/pages/_page.svelte-9806a2aa.js @@ -0,0 +1,8623 @@ +import { o as onMount, S as SvelteComponent, i as init, s as safe_not_equal, e as empty, b as insert_hydration, g as group_outros, t as transition_out, d as check_outros, f as transition_in, h as detach, N as compute_rest_props, O as assign, P as exclude_internal_props, L as destroy_each, x as create_component, y as claim_component, z as mount_component, Q as get_spread_update, R as get_spread_object, A as destroy_component, w as construct_svelte_component, a as space, c as claim_space, q as text, r as claim_text, u as set_data, C as noop, T as getContext, D as create_slot, k as element, l as claim_element, m as children, n as attr, I as update_slot_base, J as get_all_dirty_from_scope, K as get_slot_changes, G as src_url_equal, H as append_hydration, U as HtmlTagHydration, V as claim_html_tag, W as createEventDispatcher, X as setContext, Y as head_selector } from "../../chunks/index-a17c58e1.js"; +function supressWarnings() { + const origWarn = console.warn; + console.warn = (message) => { + if (message.includes("unknown prop")) + return; + if (message.includes("unexpected slot")) + return; + origWarn(message); + }; + onMount(() => { + console.warn = origWarn; + }); +} +function get_each_context_5(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[18] = list[i]; + return child_ctx; +} +function get_each_context_4$1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[18] = list[i]; + return child_ctx; +} +function get_each_context_1$1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[10] = list[i]; + return child_ctx; +} +function get_each_context_2$1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[13] = list[i]; + child_ctx[15] = i; + return child_ctx; +} +function get_each_context_3$1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[16] = list[i]; + child_ctx[15] = i; + return child_ctx; +} +function get_each_context$1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[7] = list[i]; + return child_ctx; +} +function create_if_block_1$2(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [create_if_block_2$1, create_if_block_3$1, create_else_block_1]; + const if_blocks = []; + function select_block_type_1(ctx2, dirty) { + if ( + /*type*/ + ctx2[0] === "table" + ) + return 0; + if ( + /*type*/ + ctx2[0] === "list" + ) + return 1; + return 2; + } + current_block_type_index = select_block_type_1(ctx); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + if_block.c(); + if_block_anchor = empty(); + }, + l(nodes) { + if_block.l(nodes); + if_block_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert_hydration(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type_1(ctx2); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if_blocks[current_block_type_index].d(detaching); + if (detaching) + detach(if_block_anchor); + } + }; +} +function create_if_block$4(ctx) { + let each_1_anchor; + let current; + let each_value = ( + /*tokens*/ + ctx[1] + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block$1(get_each_context$1(ctx, each_value, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + l(nodes) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(nodes); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor); + } + insert_hydration(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty & /*tokens, renderers*/ + 34) { + each_value = /*tokens*/ + ctx2[1]; + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context$1(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block$1(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + destroy_each(each_blocks, detaching); + if (detaching) + detach(each_1_anchor); + } + }; +} +function create_else_block_1(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + const switch_instance_spread_levels = [ + /*$$restProps*/ + ctx[6] + ]; + var switch_value = ( + /*renderers*/ + ctx[5][ + /*type*/ + ctx[0] + ] + ); + function switch_props(ctx2) { + let switch_instance_props = { + $$slots: { default: [create_default_slot_11] }, + $$scope: { ctx: ctx2 } + }; + for (let i = 0; i < switch_instance_spread_levels.length; i += 1) { + switch_instance_props = assign(switch_instance_props, switch_instance_spread_levels[i]); + } + return { props: switch_instance_props }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = dirty & /*$$restProps*/ + 64 ? get_spread_update(switch_instance_spread_levels, [get_spread_object( + /*$$restProps*/ + ctx2[6] + )]) : {}; + if (dirty & /*$$scope, tokens, renderers, $$restProps*/ + 8388706) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5][ + /*type*/ + ctx2[0] + ])) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_if_block_3$1(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [create_if_block_4$1, create_else_block$3]; + const if_blocks = []; + function select_block_type_2(ctx2, dirty) { + if ( + /*ordered*/ + ctx2[4] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type_2(ctx); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + if_block.c(); + if_block_anchor = empty(); + }, + l(nodes) { + if_block.l(nodes); + if_block_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert_hydration(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type_2(ctx2); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if_blocks[current_block_type_index].d(detaching); + if (detaching) + detach(if_block_anchor); + } + }; +} +function create_if_block_2$1(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + var switch_value = ( + /*renderers*/ + ctx[5].table + ); + function switch_props(ctx2) { + return { + props: { + $$slots: { default: [create_default_slot] }, + $$scope: { ctx: ctx2 } + } + }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = {}; + if (dirty & /*$$scope, renderers, rows, $$restProps, header*/ + 8388716) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].table)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_else_block_2(ctx) { + let t_value = ( + /*$$restProps*/ + ctx[6].raw + "" + ); + let t; + return { + c() { + t = text(t_value); + }, + l(nodes) { + t = claim_text(nodes, t_value); + }, + m(target, anchor) { + insert_hydration(target, t, anchor); + }, + p(ctx2, dirty) { + if (dirty & /*$$restProps*/ + 64 && t_value !== (t_value = /*$$restProps*/ + ctx2[6].raw + "")) + set_data(t, t_value); + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(t); + } + }; +} +function create_if_block_5$1(ctx) { + let parser; + let current; + parser = new Parser$1({ + props: { + tokens: ( + /*tokens*/ + ctx[1] + ), + renderers: ( + /*renderers*/ + ctx[5] + ) + } + }); + return { + c() { + create_component(parser.$$.fragment); + }, + l(nodes) { + claim_component(parser.$$.fragment, nodes); + }, + m(target, anchor) { + mount_component(parser, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const parser_changes = {}; + if (dirty & /*tokens*/ + 2) + parser_changes.tokens = /*tokens*/ + ctx2[1]; + if (dirty & /*renderers*/ + 32) + parser_changes.renderers = /*renderers*/ + ctx2[5]; + parser.$set(parser_changes); + }, + i(local) { + if (current) + return; + transition_in(parser.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(parser.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(parser, detaching); + } + }; +} +function create_default_slot_11(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [create_if_block_5$1, create_else_block_2]; + const if_blocks = []; + function select_block_type_3(ctx2, dirty) { + if ( + /*tokens*/ + ctx2[1] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type_3(ctx); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + if_block.c(); + if_block_anchor = empty(); + }, + l(nodes) { + if_block.l(nodes); + if_block_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert_hydration(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type_3(ctx2); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if_blocks[current_block_type_index].d(detaching); + if (detaching) + detach(if_block_anchor); + } + }; +} +function create_else_block$3(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + const switch_instance_spread_levels = [ + { ordered: ( + /*ordered*/ + ctx[4] + ) }, + /*$$restProps*/ + ctx[6] + ]; + var switch_value = ( + /*renderers*/ + ctx[5].list + ); + function switch_props(ctx2) { + let switch_instance_props = { + $$slots: { default: [create_default_slot_9] }, + $$scope: { ctx: ctx2 } + }; + for (let i = 0; i < switch_instance_spread_levels.length; i += 1) { + switch_instance_props = assign(switch_instance_props, switch_instance_spread_levels[i]); + } + return { props: switch_instance_props }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = dirty & /*ordered, $$restProps*/ + 80 ? get_spread_update(switch_instance_spread_levels, [ + dirty & /*ordered*/ + 16 && { ordered: ( + /*ordered*/ + ctx2[4] + ) }, + dirty & /*$$restProps*/ + 64 && get_spread_object( + /*$$restProps*/ + ctx2[6] + ) + ]) : {}; + if (dirty & /*$$scope, $$restProps, renderers*/ + 8388704) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].list)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_if_block_4$1(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + const switch_instance_spread_levels = [ + { ordered: ( + /*ordered*/ + ctx[4] + ) }, + /*$$restProps*/ + ctx[6] + ]; + var switch_value = ( + /*renderers*/ + ctx[5].list + ); + function switch_props(ctx2) { + let switch_instance_props = { + $$slots: { default: [create_default_slot_7] }, + $$scope: { ctx: ctx2 } + }; + for (let i = 0; i < switch_instance_spread_levels.length; i += 1) { + switch_instance_props = assign(switch_instance_props, switch_instance_spread_levels[i]); + } + return { props: switch_instance_props }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = dirty & /*ordered, $$restProps*/ + 80 ? get_spread_update(switch_instance_spread_levels, [ + dirty & /*ordered*/ + 16 && { ordered: ( + /*ordered*/ + ctx2[4] + ) }, + dirty & /*$$restProps*/ + 64 && get_spread_object( + /*$$restProps*/ + ctx2[6] + ) + ]) : {}; + if (dirty & /*$$scope, $$restProps, renderers*/ + 8388704) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].list)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_default_slot_10(ctx) { + let parser; + let t; + let current; + parser = new Parser$1({ + props: { + tokens: ( + /*item*/ + ctx[18].tokens + ), + renderers: ( + /*renderers*/ + ctx[5] + ) + } + }); + return { + c() { + create_component(parser.$$.fragment); + t = space(); + }, + l(nodes) { + claim_component(parser.$$.fragment, nodes); + t = claim_space(nodes); + }, + m(target, anchor) { + mount_component(parser, target, anchor); + insert_hydration(target, t, anchor); + current = true; + }, + p(ctx2, dirty) { + const parser_changes = {}; + if (dirty & /*$$restProps*/ + 64) + parser_changes.tokens = /*item*/ + ctx2[18].tokens; + if (dirty & /*renderers*/ + 32) + parser_changes.renderers = /*renderers*/ + ctx2[5]; + parser.$set(parser_changes); + }, + i(local) { + if (current) + return; + transition_in(parser.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(parser.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(parser, detaching); + if (detaching) + detach(t); + } + }; +} +function create_each_block_5(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + const switch_instance_spread_levels = [ + /*item*/ + ctx[18] + ]; + var switch_value = ( + /*renderers*/ + ctx[5].unorderedlistitem || /*renderers*/ + ctx[5].listitem + ); + function switch_props(ctx2) { + let switch_instance_props = { + $$slots: { default: [create_default_slot_10] }, + $$scope: { ctx: ctx2 } + }; + for (let i = 0; i < switch_instance_spread_levels.length; i += 1) { + switch_instance_props = assign(switch_instance_props, switch_instance_spread_levels[i]); + } + return { props: switch_instance_props }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = dirty & /*$$restProps*/ + 64 ? get_spread_update(switch_instance_spread_levels, [get_spread_object( + /*item*/ + ctx2[18] + )]) : {}; + if (dirty & /*$$scope, $$restProps, renderers*/ + 8388704) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].unorderedlistitem || /*renderers*/ + ctx2[5].listitem)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_default_slot_9(ctx) { + let each_1_anchor; + let current; + let each_value_5 = ( + /*$$restProps*/ + ctx[6].items + ); + let each_blocks = []; + for (let i = 0; i < each_value_5.length; i += 1) { + each_blocks[i] = create_each_block_5(get_each_context_5(ctx, each_value_5, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + l(nodes) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(nodes); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor); + } + insert_hydration(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty & /*renderers, $$restProps*/ + 96) { + each_value_5 = /*$$restProps*/ + ctx2[6].items; + let i; + for (i = 0; i < each_value_5.length; i += 1) { + const child_ctx = get_each_context_5(ctx2, each_value_5, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block_5(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value_5.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value_5.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + destroy_each(each_blocks, detaching); + if (detaching) + detach(each_1_anchor); + } + }; +} +function create_default_slot_8(ctx) { + let parser; + let t; + let current; + parser = new Parser$1({ + props: { + tokens: ( + /*item*/ + ctx[18].tokens + ), + renderers: ( + /*renderers*/ + ctx[5] + ) + } + }); + return { + c() { + create_component(parser.$$.fragment); + t = space(); + }, + l(nodes) { + claim_component(parser.$$.fragment, nodes); + t = claim_space(nodes); + }, + m(target, anchor) { + mount_component(parser, target, anchor); + insert_hydration(target, t, anchor); + current = true; + }, + p(ctx2, dirty) { + const parser_changes = {}; + if (dirty & /*$$restProps*/ + 64) + parser_changes.tokens = /*item*/ + ctx2[18].tokens; + if (dirty & /*renderers*/ + 32) + parser_changes.renderers = /*renderers*/ + ctx2[5]; + parser.$set(parser_changes); + }, + i(local) { + if (current) + return; + transition_in(parser.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(parser.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(parser, detaching); + if (detaching) + detach(t); + } + }; +} +function create_each_block_4$1(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + const switch_instance_spread_levels = [ + /*item*/ + ctx[18] + ]; + var switch_value = ( + /*renderers*/ + ctx[5].orderedlistitem || /*renderers*/ + ctx[5].listitem + ); + function switch_props(ctx2) { + let switch_instance_props = { + $$slots: { default: [create_default_slot_8] }, + $$scope: { ctx: ctx2 } + }; + for (let i = 0; i < switch_instance_spread_levels.length; i += 1) { + switch_instance_props = assign(switch_instance_props, switch_instance_spread_levels[i]); + } + return { props: switch_instance_props }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = dirty & /*$$restProps*/ + 64 ? get_spread_update(switch_instance_spread_levels, [get_spread_object( + /*item*/ + ctx2[18] + )]) : {}; + if (dirty & /*$$scope, $$restProps, renderers*/ + 8388704) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].orderedlistitem || /*renderers*/ + ctx2[5].listitem)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_default_slot_7(ctx) { + let each_1_anchor; + let current; + let each_value_4 = ( + /*$$restProps*/ + ctx[6].items + ); + let each_blocks = []; + for (let i = 0; i < each_value_4.length; i += 1) { + each_blocks[i] = create_each_block_4$1(get_each_context_4$1(ctx, each_value_4, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + l(nodes) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(nodes); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor); + } + insert_hydration(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty & /*renderers, $$restProps*/ + 96) { + each_value_4 = /*$$restProps*/ + ctx2[6].items; + let i; + for (i = 0; i < each_value_4.length; i += 1) { + const child_ctx = get_each_context_4$1(ctx2, each_value_4, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block_4$1(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value_4.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value_4.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + destroy_each(each_blocks, detaching); + if (detaching) + detach(each_1_anchor); + } + }; +} +function create_default_slot_6(ctx) { + let parser; + let t; + let current; + parser = new Parser$1({ + props: { + tokens: ( + /*headerItem*/ + ctx[16].tokens + ), + renderers: ( + /*renderers*/ + ctx[5] + ) + } + }); + return { + c() { + create_component(parser.$$.fragment); + t = space(); + }, + l(nodes) { + claim_component(parser.$$.fragment, nodes); + t = claim_space(nodes); + }, + m(target, anchor) { + mount_component(parser, target, anchor); + insert_hydration(target, t, anchor); + current = true; + }, + p(ctx2, dirty) { + const parser_changes = {}; + if (dirty & /*header*/ + 4) + parser_changes.tokens = /*headerItem*/ + ctx2[16].tokens; + if (dirty & /*renderers*/ + 32) + parser_changes.renderers = /*renderers*/ + ctx2[5]; + parser.$set(parser_changes); + }, + i(local) { + if (current) + return; + transition_in(parser.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(parser.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(parser, detaching); + if (detaching) + detach(t); + } + }; +} +function create_each_block_3$1(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + var switch_value = ( + /*renderers*/ + ctx[5].tablecell + ); + function switch_props(ctx2) { + return { + props: { + header: true, + align: ( + /*$$restProps*/ + ctx2[6].align[ + /*i*/ + ctx2[15] + ] || "center" + ), + $$slots: { default: [create_default_slot_6] }, + $$scope: { ctx: ctx2 } + } + }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = {}; + if (dirty & /*$$restProps*/ + 64) + switch_instance_changes.align = /*$$restProps*/ + ctx2[6].align[ + /*i*/ + ctx2[15] + ] || "center"; + if (dirty & /*$$scope, header, renderers*/ + 8388644) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].tablecell)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_default_slot_5(ctx) { + let each_1_anchor; + let current; + let each_value_3 = ( + /*header*/ + ctx[2] + ); + let each_blocks = []; + for (let i = 0; i < each_value_3.length; i += 1) { + each_blocks[i] = create_each_block_3$1(get_each_context_3$1(ctx, each_value_3, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + l(nodes) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(nodes); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor); + } + insert_hydration(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty & /*renderers, $$restProps, header*/ + 100) { + each_value_3 = /*header*/ + ctx2[2]; + let i; + for (i = 0; i < each_value_3.length; i += 1) { + const child_ctx = get_each_context_3$1(ctx2, each_value_3, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block_3$1(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value_3.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value_3.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + destroy_each(each_blocks, detaching); + if (detaching) + detach(each_1_anchor); + } + }; +} +function create_default_slot_4(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + var switch_value = ( + /*renderers*/ + ctx[5].tablerow + ); + function switch_props(ctx2) { + return { + props: { + $$slots: { default: [create_default_slot_5] }, + $$scope: { ctx: ctx2 } + } + }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = {}; + if (dirty & /*$$scope, header, renderers, $$restProps*/ + 8388708) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].tablerow)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_default_slot_3(ctx) { + let parser; + let current; + parser = new Parser$1({ + props: { + tokens: ( + /*cells*/ + ctx[13].tokens + ), + renderers: ( + /*renderers*/ + ctx[5] + ) + } + }); + return { + c() { + create_component(parser.$$.fragment); + }, + l(nodes) { + claim_component(parser.$$.fragment, nodes); + }, + m(target, anchor) { + mount_component(parser, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const parser_changes = {}; + if (dirty & /*rows*/ + 8) + parser_changes.tokens = /*cells*/ + ctx2[13].tokens; + if (dirty & /*renderers*/ + 32) + parser_changes.renderers = /*renderers*/ + ctx2[5]; + parser.$set(parser_changes); + }, + i(local) { + if (current) + return; + transition_in(parser.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(parser.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(parser, detaching); + } + }; +} +function create_each_block_2$1(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + var switch_value = ( + /*renderers*/ + ctx[5].tablecell + ); + function switch_props(ctx2) { + return { + props: { + header: false, + align: ( + /*$$restProps*/ + ctx2[6].align[ + /*i*/ + ctx2[15] + ] || "center" + ), + $$slots: { default: [create_default_slot_3] }, + $$scope: { ctx: ctx2 } + } + }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = {}; + if (dirty & /*$$restProps*/ + 64) + switch_instance_changes.align = /*$$restProps*/ + ctx2[6].align[ + /*i*/ + ctx2[15] + ] || "center"; + if (dirty & /*$$scope, rows, renderers*/ + 8388648) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].tablecell)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_default_slot_2(ctx) { + let t; + let current; + let each_value_2 = ( + /*row*/ + ctx[10] + ); + let each_blocks = []; + for (let i = 0; i < each_value_2.length; i += 1) { + each_blocks[i] = create_each_block_2$1(get_each_context_2$1(ctx, each_value_2, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + t = space(); + }, + l(nodes) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(nodes); + } + t = claim_space(nodes); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor); + } + insert_hydration(target, t, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty & /*renderers, $$restProps, rows*/ + 104) { + each_value_2 = /*row*/ + ctx2[10]; + let i; + for (i = 0; i < each_value_2.length; i += 1) { + const child_ctx = get_each_context_2$1(ctx2, each_value_2, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block_2$1(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(t.parentNode, t); + } + } + group_outros(); + for (i = each_value_2.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value_2.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + destroy_each(each_blocks, detaching); + if (detaching) + detach(t); + } + }; +} +function create_each_block_1$1(ctx) { + let switch_instance; + let switch_instance_anchor; + let current; + var switch_value = ( + /*renderers*/ + ctx[5].tablerow + ); + function switch_props(ctx2) { + return { + props: { + $$slots: { default: [create_default_slot_2] }, + $$scope: { ctx: ctx2 } + } + }; + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx)); + } + return { + c() { + if (switch_instance) + create_component(switch_instance.$$.fragment); + switch_instance_anchor = empty(); + }, + l(nodes) { + if (switch_instance) + claim_component(switch_instance.$$.fragment, nodes); + switch_instance_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance) + mount_component(switch_instance, target, anchor); + insert_hydration(target, switch_instance_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance_changes = {}; + if (dirty & /*$$scope, rows, renderers, $$restProps*/ + 8388712) { + switch_instance_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].tablerow)) { + if (switch_instance) { + group_outros(); + const old_component = switch_instance; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance.$$.fragment); + transition_in(switch_instance.$$.fragment, 1); + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor); + } else { + switch_instance = null; + } + } else if (switch_value) { + switch_instance.$set(switch_instance_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance) + transition_in(switch_instance.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance) + transition_out(switch_instance.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(switch_instance_anchor); + if (switch_instance) + destroy_component(switch_instance, detaching); + } + }; +} +function create_default_slot_1(ctx) { + let each_1_anchor; + let current; + let each_value_1 = ( + /*rows*/ + ctx[3] + ); + let each_blocks = []; + for (let i = 0; i < each_value_1.length; i += 1) { + each_blocks[i] = create_each_block_1$1(get_each_context_1$1(ctx, each_value_1, i)); + } + const out = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + each_1_anchor = empty(); + }, + l(nodes) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(nodes); + } + each_1_anchor = empty(); + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor); + } + insert_hydration(target, each_1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + if (dirty & /*renderers, rows, $$restProps*/ + 104) { + each_value_1 = /*rows*/ + ctx2[3]; + let i; + for (i = 0; i < each_value_1.length; i += 1) { + const child_ctx = get_each_context_1$1(ctx2, each_value_1, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block_1$1(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor); + } + } + group_outros(); + for (i = each_value_1.length; i < each_blocks.length; i += 1) { + out(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value_1.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + destroy_each(each_blocks, detaching); + if (detaching) + detach(each_1_anchor); + } + }; +} +function create_default_slot(ctx) { + let switch_instance0; + let t; + let switch_instance1; + let switch_instance1_anchor; + let current; + var switch_value = ( + /*renderers*/ + ctx[5].tablehead + ); + function switch_props(ctx2) { + return { + props: { + $$slots: { default: [create_default_slot_4] }, + $$scope: { ctx: ctx2 } + } + }; + } + if (switch_value) { + switch_instance0 = construct_svelte_component(switch_value, switch_props(ctx)); + } + var switch_value_1 = ( + /*renderers*/ + ctx[5].tablebody + ); + function switch_props_1(ctx2) { + return { + props: { + $$slots: { default: [create_default_slot_1] }, + $$scope: { ctx: ctx2 } + } + }; + } + if (switch_value_1) { + switch_instance1 = construct_svelte_component(switch_value_1, switch_props_1(ctx)); + } + return { + c() { + if (switch_instance0) + create_component(switch_instance0.$$.fragment); + t = space(); + if (switch_instance1) + create_component(switch_instance1.$$.fragment); + switch_instance1_anchor = empty(); + }, + l(nodes) { + if (switch_instance0) + claim_component(switch_instance0.$$.fragment, nodes); + t = claim_space(nodes); + if (switch_instance1) + claim_component(switch_instance1.$$.fragment, nodes); + switch_instance1_anchor = empty(); + }, + m(target, anchor) { + if (switch_instance0) + mount_component(switch_instance0, target, anchor); + insert_hydration(target, t, anchor); + if (switch_instance1) + mount_component(switch_instance1, target, anchor); + insert_hydration(target, switch_instance1_anchor, anchor); + current = true; + }, + p(ctx2, dirty) { + const switch_instance0_changes = {}; + if (dirty & /*$$scope, renderers, header, $$restProps*/ + 8388708) { + switch_instance0_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value !== (switch_value = /*renderers*/ + ctx2[5].tablehead)) { + if (switch_instance0) { + group_outros(); + const old_component = switch_instance0; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value) { + switch_instance0 = construct_svelte_component(switch_value, switch_props(ctx2)); + create_component(switch_instance0.$$.fragment); + transition_in(switch_instance0.$$.fragment, 1); + mount_component(switch_instance0, t.parentNode, t); + } else { + switch_instance0 = null; + } + } else if (switch_value) { + switch_instance0.$set(switch_instance0_changes); + } + const switch_instance1_changes = {}; + if (dirty & /*$$scope, rows, renderers, $$restProps*/ + 8388712) { + switch_instance1_changes.$$scope = { dirty, ctx: ctx2 }; + } + if (switch_value_1 !== (switch_value_1 = /*renderers*/ + ctx2[5].tablebody)) { + if (switch_instance1) { + group_outros(); + const old_component = switch_instance1; + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1); + }); + check_outros(); + } + if (switch_value_1) { + switch_instance1 = construct_svelte_component(switch_value_1, switch_props_1(ctx2)); + create_component(switch_instance1.$$.fragment); + transition_in(switch_instance1.$$.fragment, 1); + mount_component(switch_instance1, switch_instance1_anchor.parentNode, switch_instance1_anchor); + } else { + switch_instance1 = null; + } + } else if (switch_value_1) { + switch_instance1.$set(switch_instance1_changes); + } + }, + i(local) { + if (current) + return; + if (switch_instance0) + transition_in(switch_instance0.$$.fragment, local); + if (switch_instance1) + transition_in(switch_instance1.$$.fragment, local); + current = true; + }, + o(local) { + if (switch_instance0) + transition_out(switch_instance0.$$.fragment, local); + if (switch_instance1) + transition_out(switch_instance1.$$.fragment, local); + current = false; + }, + d(detaching) { + if (switch_instance0) + destroy_component(switch_instance0, detaching); + if (detaching) + detach(t); + if (detaching) + detach(switch_instance1_anchor); + if (switch_instance1) + destroy_component(switch_instance1, detaching); + } + }; +} +function create_each_block$1(ctx) { + let parser; + let current; + const parser_spread_levels = [ + /*token*/ + ctx[7], + { renderers: ( + /*renderers*/ + ctx[5] + ) } + ]; + let parser_props = {}; + for (let i = 0; i < parser_spread_levels.length; i += 1) { + parser_props = assign(parser_props, parser_spread_levels[i]); + } + parser = new Parser$1({ props: parser_props }); + return { + c() { + create_component(parser.$$.fragment); + }, + l(nodes) { + claim_component(parser.$$.fragment, nodes); + }, + m(target, anchor) { + mount_component(parser, target, anchor); + current = true; + }, + p(ctx2, dirty) { + const parser_changes = dirty & /*tokens, renderers*/ + 34 ? get_spread_update(parser_spread_levels, [ + dirty & /*tokens*/ + 2 && get_spread_object( + /*token*/ + ctx2[7] + ), + dirty & /*renderers*/ + 32 && { renderers: ( + /*renderers*/ + ctx2[5] + ) } + ]) : {}; + parser.$set(parser_changes); + }, + i(local) { + if (current) + return; + transition_in(parser.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(parser.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(parser, detaching); + } + }; +} +function create_fragment$n(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [create_if_block$4, create_if_block_1$2]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if (!/*type*/ + ctx2[0]) + return 0; + if ( + /*renderers*/ + ctx2[5][ + /*type*/ + ctx2[0] + ] + ) + return 1; + return -1; + } + if (~(current_block_type_index = select_block_type(ctx))) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + } + return { + c() { + if (if_block) + if_block.c(); + if_block_anchor = empty(); + }, + l(nodes) { + if (if_block) + if_block.l(nodes); + if_block_anchor = empty(); + }, + m(target, anchor) { + if (~current_block_type_index) { + if_blocks[current_block_type_index].m(target, anchor); + } + insert_hydration(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, [dirty]) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2); + if (current_block_type_index === previous_block_index) { + if (~current_block_type_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } + } else { + if (if_block) { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + } + if (~current_block_type_index) { + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } else { + if_block = null; + } + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (~current_block_type_index) { + if_blocks[current_block_type_index].d(detaching); + } + if (detaching) + detach(if_block_anchor); + } + }; +} +function instance$m($$self, $$props, $$invalidate) { + const omit_props_names = ["type", "tokens", "header", "rows", "ordered", "renderers"]; + let $$restProps = compute_rest_props($$props, omit_props_names); + let { type = void 0 } = $$props; + let { tokens = void 0 } = $$props; + let { header = void 0 } = $$props; + let { rows = void 0 } = $$props; + let { ordered = false } = $$props; + let { renderers } = $$props; + supressWarnings(); + $$self.$$set = ($$new_props) => { + $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)); + $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names)); + if ("type" in $$new_props) + $$invalidate(0, type = $$new_props.type); + if ("tokens" in $$new_props) + $$invalidate(1, tokens = $$new_props.tokens); + if ("header" in $$new_props) + $$invalidate(2, header = $$new_props.header); + if ("rows" in $$new_props) + $$invalidate(3, rows = $$new_props.rows); + if ("ordered" in $$new_props) + $$invalidate(4, ordered = $$new_props.ordered); + if ("renderers" in $$new_props) + $$invalidate(5, renderers = $$new_props.renderers); + }; + return [type, tokens, header, rows, ordered, renderers, $$restProps]; +} +let Parser$1 = class Parser extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$m, create_fragment$n, safe_not_equal, { + type: 0, + tokens: 1, + header: 2, + rows: 3, + ordered: 4, + renderers: 5 + }); + } +}; +function getDefaults() { + return { + async: false, + baseUrl: null, + breaks: false, + extensions: null, + gfm: true, + headerIds: true, + headerPrefix: "", + highlight: null, + langPrefix: "language-", + mangle: true, + pedantic: false, + renderer: null, + sanitize: false, + sanitizer: null, + silent: false, + smartypants: false, + tokenizer: null, + walkTokens: null, + xhtml: false + }; +} +let defaults = getDefaults(); +function changeDefaults(newDefaults) { + defaults = newDefaults; +} +const escapeTest = /[&<>"']/; +const escapeReplace = new RegExp(escapeTest.source, "g"); +const escapeTestNoEncode = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/; +const escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, "g"); +const escapeReplacements = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'" +}; +const getEscapeReplacement = (ch) => escapeReplacements[ch]; +function escape(html, encode) { + if (encode) { + if (escapeTest.test(html)) { + return html.replace(escapeReplace, getEscapeReplacement); + } + } else { + if (escapeTestNoEncode.test(html)) { + return html.replace(escapeReplaceNoEncode, getEscapeReplacement); + } + } + return html; +} +const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig; +function unescape(html) { + return html.replace(unescapeTest, (_, n) => { + n = n.toLowerCase(); + if (n === "colon") + return ":"; + if (n.charAt(0) === "#") { + return n.charAt(1) === "x" ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1)); + } + return ""; + }); +} +const caret = /(^|[^\[])\^/g; +function edit(regex, opt) { + regex = typeof regex === "string" ? regex : regex.source; + opt = opt || ""; + const obj = { + replace: (name, val) => { + val = val.source || val; + val = val.replace(caret, "$1"); + regex = regex.replace(name, val); + return obj; + }, + getRegex: () => { + return new RegExp(regex, opt); + } + }; + return obj; +} +const nonWordAndColonTest = /[^\w:]/g; +const originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i; +function cleanUrl(sanitize, base, href) { + if (sanitize) { + let prot; + try { + prot = decodeURIComponent(unescape(href)).replace(nonWordAndColonTest, "").toLowerCase(); + } catch (e) { + return null; + } + if (prot.indexOf("javascript:") === 0 || prot.indexOf("vbscript:") === 0 || prot.indexOf("data:") === 0) { + return null; + } + } + if (base && !originIndependentUrl.test(href)) { + href = resolveUrl(base, href); + } + try { + href = encodeURI(href).replace(/%25/g, "%"); + } catch (e) { + return null; + } + return href; +} +const baseUrls = {}; +const justDomain = /^[^:]+:\/*[^/]*$/; +const protocol = /^([^:]+:)[\s\S]*$/; +const domain = /^([^:]+:\/*[^/]*)[\s\S]*$/; +function resolveUrl(base, href) { + if (!baseUrls[" " + base]) { + if (justDomain.test(base)) { + baseUrls[" " + base] = base + "/"; + } else { + baseUrls[" " + base] = rtrim(base, "/", true); + } + } + base = baseUrls[" " + base]; + const relativeBase = base.indexOf(":") === -1; + if (href.substring(0, 2) === "//") { + if (relativeBase) { + return href; + } + return base.replace(protocol, "$1") + href; + } else if (href.charAt(0) === "/") { + if (relativeBase) { + return href; + } + return base.replace(domain, "$1") + href; + } else { + return base + href; + } +} +const noopTest = { exec: function noopTest2() { +} }; +function merge(obj) { + let i = 1, target, key2; + for (; i < arguments.length; i++) { + target = arguments[i]; + for (key2 in target) { + if (Object.prototype.hasOwnProperty.call(target, key2)) { + obj[key2] = target[key2]; + } + } + } + return obj; +} +function splitCells(tableRow, count) { + const row = tableRow.replace(/\|/g, (match, offset, str) => { + let escaped = false, curr = offset; + while (--curr >= 0 && str[curr] === "\\") + escaped = !escaped; + if (escaped) { + return "|"; + } else { + return " |"; + } + }), cells = row.split(/ \|/); + let i = 0; + if (!cells[0].trim()) { + cells.shift(); + } + if (cells.length > 0 && !cells[cells.length - 1].trim()) { + cells.pop(); + } + if (cells.length > count) { + cells.splice(count); + } else { + while (cells.length < count) + cells.push(""); + } + for (; i < cells.length; i++) { + cells[i] = cells[i].trim().replace(/\\\|/g, "|"); + } + return cells; +} +function rtrim(str, c, invert) { + const l = str.length; + if (l === 0) { + return ""; + } + let suffLen = 0; + while (suffLen < l) { + const currChar = str.charAt(l - suffLen - 1); + if (currChar === c && !invert) { + suffLen++; + } else if (currChar !== c && invert) { + suffLen++; + } else { + break; + } + } + return str.slice(0, l - suffLen); +} +function findClosingBracket(str, b) { + if (str.indexOf(b[1]) === -1) { + return -1; + } + const l = str.length; + let level = 0, i = 0; + for (; i < l; i++) { + if (str[i] === "\\") { + i++; + } else if (str[i] === b[0]) { + level++; + } else if (str[i] === b[1]) { + level--; + if (level < 0) { + return i; + } + } + } + return -1; +} +function checkSanitizeDeprecation(opt) { + if (opt && opt.sanitize && !opt.silent) { + console.warn("marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options"); + } +} +function repeatString(pattern, count) { + if (count < 1) { + return ""; + } + let result = ""; + while (count > 1) { + if (count & 1) { + result += pattern; + } + count >>= 1; + pattern += pattern; + } + return result + pattern; +} +function outputLink(cap, link, raw, lexer) { + const href = link.href; + const title = link.title ? escape(link.title) : null; + const text2 = cap[1].replace(/\\([\[\]])/g, "$1"); + if (cap[0].charAt(0) !== "!") { + lexer.state.inLink = true; + const token = { + type: "link", + raw, + href, + title, + text: text2, + tokens: lexer.inlineTokens(text2) + }; + lexer.state.inLink = false; + return token; + } + return { + type: "image", + raw, + href, + title, + text: escape(text2) + }; +} +function indentCodeCompensation(raw, text2) { + const matchIndentToCode = raw.match(/^(\s+)(?:```)/); + if (matchIndentToCode === null) { + return text2; + } + const indentToCode = matchIndentToCode[1]; + return text2.split("\n").map((node) => { + const matchIndentInNode = node.match(/^\s+/); + if (matchIndentInNode === null) { + return node; + } + const [indentInNode] = matchIndentInNode; + if (indentInNode.length >= indentToCode.length) { + return node.slice(indentToCode.length); + } + return node; + }).join("\n"); +} +class Tokenizer { + constructor(options) { + this.options = options || defaults; + } + space(src) { + const cap = this.rules.block.newline.exec(src); + if (cap && cap[0].length > 0) { + return { + type: "space", + raw: cap[0] + }; + } + } + code(src) { + const cap = this.rules.block.code.exec(src); + if (cap) { + const text2 = cap[0].replace(/^ {1,4}/gm, ""); + return { + type: "code", + raw: cap[0], + codeBlockStyle: "indented", + text: !this.options.pedantic ? rtrim(text2, "\n") : text2 + }; + } + } + fences(src) { + const cap = this.rules.block.fences.exec(src); + if (cap) { + const raw = cap[0]; + const text2 = indentCodeCompensation(raw, cap[3] || ""); + return { + type: "code", + raw, + lang: cap[2] ? cap[2].trim().replace(this.rules.inline._escapes, "$1") : cap[2], + text: text2 + }; + } + } + heading(src) { + const cap = this.rules.block.heading.exec(src); + if (cap) { + let text2 = cap[2].trim(); + if (/#$/.test(text2)) { + const trimmed = rtrim(text2, "#"); + if (this.options.pedantic) { + text2 = trimmed.trim(); + } else if (!trimmed || / $/.test(trimmed)) { + text2 = trimmed.trim(); + } + } + return { + type: "heading", + raw: cap[0], + depth: cap[1].length, + text: text2, + tokens: this.lexer.inline(text2) + }; + } + } + hr(src) { + const cap = this.rules.block.hr.exec(src); + if (cap) { + return { + type: "hr", + raw: cap[0] + }; + } + } + blockquote(src) { + const cap = this.rules.block.blockquote.exec(src); + if (cap) { + const text2 = cap[0].replace(/^ *>[ \t]?/gm, ""); + const top = this.lexer.state.top; + this.lexer.state.top = true; + const tokens = this.lexer.blockTokens(text2); + this.lexer.state.top = top; + return { + type: "blockquote", + raw: cap[0], + tokens, + text: text2 + }; + } + } + list(src) { + let cap = this.rules.block.list.exec(src); + if (cap) { + let raw, istask, ischecked, indent, i, blankLine, endsWithBlankLine, line, nextLine, rawLine, itemContents, endEarly; + let bull = cap[1].trim(); + const isordered = bull.length > 1; + const list = { + type: "list", + raw: "", + ordered: isordered, + start: isordered ? +bull.slice(0, -1) : "", + loose: false, + items: [] + }; + bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`; + if (this.options.pedantic) { + bull = isordered ? bull : "[*+-]"; + } + const itemRegex = new RegExp(`^( {0,3}${bull})((?:[ ][^\\n]*)?(?:\\n|$))`); + while (src) { + endEarly = false; + if (!(cap = itemRegex.exec(src))) { + break; + } + if (this.rules.block.hr.test(src)) { + break; + } + raw = cap[0]; + src = src.substring(raw.length); + line = cap[2].split("\n", 1)[0].replace(/^\t+/, (t) => " ".repeat(3 * t.length)); + nextLine = src.split("\n", 1)[0]; + if (this.options.pedantic) { + indent = 2; + itemContents = line.trimLeft(); + } else { + indent = cap[2].search(/[^ ]/); + indent = indent > 4 ? 1 : indent; + itemContents = line.slice(indent); + indent += cap[1].length; + } + blankLine = false; + if (!line && /^ *$/.test(nextLine)) { + raw += nextLine + "\n"; + src = src.substring(nextLine.length + 1); + endEarly = true; + } + if (!endEarly) { + const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`); + const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`); + const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`); + const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`); + while (src) { + rawLine = src.split("\n", 1)[0]; + nextLine = rawLine; + if (this.options.pedantic) { + nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, " "); + } + if (fencesBeginRegex.test(nextLine)) { + break; + } + if (headingBeginRegex.test(nextLine)) { + break; + } + if (nextBulletRegex.test(nextLine)) { + break; + } + if (hrRegex.test(src)) { + break; + } + if (nextLine.search(/[^ ]/) >= indent || !nextLine.trim()) { + itemContents += "\n" + nextLine.slice(indent); + } else { + if (blankLine) { + break; + } + if (line.search(/[^ ]/) >= 4) { + break; + } + if (fencesBeginRegex.test(line)) { + break; + } + if (headingBeginRegex.test(line)) { + break; + } + if (hrRegex.test(line)) { + break; + } + itemContents += "\n" + nextLine; + } + if (!blankLine && !nextLine.trim()) { + blankLine = true; + } + raw += rawLine + "\n"; + src = src.substring(rawLine.length + 1); + line = nextLine.slice(indent); + } + } + if (!list.loose) { + if (endsWithBlankLine) { + list.loose = true; + } else if (/\n *\n *$/.test(raw)) { + endsWithBlankLine = true; + } + } + if (this.options.gfm) { + istask = /^\[[ xX]\] /.exec(itemContents); + if (istask) { + ischecked = istask[0] !== "[ ] "; + itemContents = itemContents.replace(/^\[[ xX]\] +/, ""); + } + } + list.items.push({ + type: "list_item", + raw, + task: !!istask, + checked: ischecked, + loose: false, + text: itemContents + }); + list.raw += raw; + } + list.items[list.items.length - 1].raw = raw.trimRight(); + list.items[list.items.length - 1].text = itemContents.trimRight(); + list.raw = list.raw.trimRight(); + const l = list.items.length; + for (i = 0; i < l; i++) { + this.lexer.state.top = false; + list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []); + if (!list.loose) { + const spacers = list.items[i].tokens.filter((t) => t.type === "space"); + const hasMultipleLineBreaks = spacers.length > 0 && spacers.some((t) => /\n.*\n/.test(t.raw)); + list.loose = hasMultipleLineBreaks; + } + } + if (list.loose) { + for (i = 0; i < l; i++) { + list.items[i].loose = true; + } + } + return list; + } + } + html(src) { + const cap = this.rules.block.html.exec(src); + if (cap) { + const token = { + type: "html", + raw: cap[0], + pre: !this.options.sanitizer && (cap[1] === "pre" || cap[1] === "script" || cap[1] === "style"), + text: cap[0] + }; + if (this.options.sanitize) { + const text2 = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]); + token.type = "paragraph"; + token.text = text2; + token.tokens = this.lexer.inline(text2); + } + return token; + } + } + def(src) { + const cap = this.rules.block.def.exec(src); + if (cap) { + const tag = cap[1].toLowerCase().replace(/\s+/g, " "); + const href = cap[2] ? cap[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline._escapes, "$1") : ""; + const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline._escapes, "$1") : cap[3]; + return { + type: "def", + tag, + raw: cap[0], + href, + title + }; + } + } + table(src) { + const cap = this.rules.block.table.exec(src); + if (cap) { + const item = { + type: "table", + header: splitCells(cap[1]).map((c) => { + return { text: c }; + }), + align: cap[2].replace(/^ *|\| *$/g, "").split(/ *\| */), + rows: cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, "").split("\n") : [] + }; + if (item.header.length === item.align.length) { + item.raw = cap[0]; + let l = item.align.length; + let i, j, k, row; + for (i = 0; i < l; i++) { + if (/^ *-+: *$/.test(item.align[i])) { + item.align[i] = "right"; + } else if (/^ *:-+: *$/.test(item.align[i])) { + item.align[i] = "center"; + } else if (/^ *:-+ *$/.test(item.align[i])) { + item.align[i] = "left"; + } else { + item.align[i] = null; + } + } + l = item.rows.length; + for (i = 0; i < l; i++) { + item.rows[i] = splitCells(item.rows[i], item.header.length).map((c) => { + return { text: c }; + }); + } + l = item.header.length; + for (j = 0; j < l; j++) { + item.header[j].tokens = this.lexer.inline(item.header[j].text); + } + l = item.rows.length; + for (j = 0; j < l; j++) { + row = item.rows[j]; + for (k = 0; k < row.length; k++) { + row[k].tokens = this.lexer.inline(row[k].text); + } + } + return item; + } + } + } + lheading(src) { + const cap = this.rules.block.lheading.exec(src); + if (cap) { + return { + type: "heading", + raw: cap[0], + depth: cap[2].charAt(0) === "=" ? 1 : 2, + text: cap[1], + tokens: this.lexer.inline(cap[1]) + }; + } + } + paragraph(src) { + const cap = this.rules.block.paragraph.exec(src); + if (cap) { + const text2 = cap[1].charAt(cap[1].length - 1) === "\n" ? cap[1].slice(0, -1) : cap[1]; + return { + type: "paragraph", + raw: cap[0], + text: text2, + tokens: this.lexer.inline(text2) + }; + } + } + text(src) { + const cap = this.rules.block.text.exec(src); + if (cap) { + return { + type: "text", + raw: cap[0], + text: cap[0], + tokens: this.lexer.inline(cap[0]) + }; + } + } + escape(src) { + const cap = this.rules.inline.escape.exec(src); + if (cap) { + return { + type: "escape", + raw: cap[0], + text: escape(cap[1]) + }; + } + } + tag(src) { + const cap = this.rules.inline.tag.exec(src); + if (cap) { + if (!this.lexer.state.inLink && /^/i.test(cap[0])) { + this.lexer.state.inLink = false; + } + if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) { + this.lexer.state.inRawBlock = true; + } else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) { + this.lexer.state.inRawBlock = false; + } + return { + type: this.options.sanitize ? "text" : "html", + raw: cap[0], + inLink: this.lexer.state.inLink, + inRawBlock: this.lexer.state.inRawBlock, + text: this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0] + }; + } + } + link(src) { + const cap = this.rules.inline.link.exec(src); + if (cap) { + const trimmedUrl = cap[2].trim(); + if (!this.options.pedantic && /^$/.test(trimmedUrl)) { + return; + } + const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\"); + if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) { + return; + } + } else { + const lastParenIndex = findClosingBracket(cap[2], "()"); + if (lastParenIndex > -1) { + const start = cap[0].indexOf("!") === 0 ? 5 : 4; + const linkLen = start + cap[1].length + lastParenIndex; + cap[2] = cap[2].substring(0, lastParenIndex); + cap[0] = cap[0].substring(0, linkLen).trim(); + cap[3] = ""; + } + } + let href = cap[2]; + let title = ""; + if (this.options.pedantic) { + const link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href); + if (link) { + href = link[1]; + title = link[3]; + } + } else { + title = cap[3] ? cap[3].slice(1, -1) : ""; + } + href = href.trim(); + if (/^$/.test(trimmedUrl)) { + href = href.slice(1); + } else { + href = href.slice(1, -1); + } + } + return outputLink(cap, { + href: href ? href.replace(this.rules.inline._escapes, "$1") : href, + title: title ? title.replace(this.rules.inline._escapes, "$1") : title + }, cap[0], this.lexer); + } + } + reflink(src, links) { + let cap; + if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) { + let link = (cap[2] || cap[1]).replace(/\s+/g, " "); + link = links[link.toLowerCase()]; + if (!link) { + const text2 = cap[0].charAt(0); + return { + type: "text", + raw: text2, + text: text2 + }; + } + return outputLink(cap, link, cap[0], this.lexer); + } + } + emStrong(src, maskedSrc, prevChar = "") { + let match = this.rules.inline.emStrong.lDelim.exec(src); + if (!match) + return; + if (match[3] && prevChar.match(/[\p{L}\p{N}]/u)) + return; + const nextChar = match[1] || match[2] || ""; + if (!nextChar || nextChar && (prevChar === "" || this.rules.inline.punctuation.exec(prevChar))) { + const lLength = match[0].length - 1; + let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0; + const endReg = match[0][0] === "*" ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd; + endReg.lastIndex = 0; + maskedSrc = maskedSrc.slice(-1 * src.length + lLength); + while ((match = endReg.exec(maskedSrc)) != null) { + rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6]; + if (!rDelim) + continue; + rLength = rDelim.length; + if (match[3] || match[4]) { + delimTotal += rLength; + continue; + } else if (match[5] || match[6]) { + if (lLength % 3 && !((lLength + rLength) % 3)) { + midDelimTotal += rLength; + continue; + } + } + delimTotal -= rLength; + if (delimTotal > 0) + continue; + rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal); + const raw = src.slice(0, lLength + match.index + (match[0].length - rDelim.length) + rLength); + if (Math.min(lLength, rLength) % 2) { + const text3 = raw.slice(1, -1); + return { + type: "em", + raw, + text: text3, + tokens: this.lexer.inlineTokens(text3) + }; + } + const text2 = raw.slice(2, -2); + return { + type: "strong", + raw, + text: text2, + tokens: this.lexer.inlineTokens(text2) + }; + } + } + } + codespan(src) { + const cap = this.rules.inline.code.exec(src); + if (cap) { + let text2 = cap[2].replace(/\n/g, " "); + const hasNonSpaceChars = /[^ ]/.test(text2); + const hasSpaceCharsOnBothEnds = /^ /.test(text2) && / $/.test(text2); + if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) { + text2 = text2.substring(1, text2.length - 1); + } + text2 = escape(text2, true); + return { + type: "codespan", + raw: cap[0], + text: text2 + }; + } + } + br(src) { + const cap = this.rules.inline.br.exec(src); + if (cap) { + return { + type: "br", + raw: cap[0] + }; + } + } + del(src) { + const cap = this.rules.inline.del.exec(src); + if (cap) { + return { + type: "del", + raw: cap[0], + text: cap[2], + tokens: this.lexer.inlineTokens(cap[2]) + }; + } + } + autolink(src, mangle2) { + const cap = this.rules.inline.autolink.exec(src); + if (cap) { + let text2, href; + if (cap[2] === "@") { + text2 = escape(this.options.mangle ? mangle2(cap[1]) : cap[1]); + href = "mailto:" + text2; + } else { + text2 = escape(cap[1]); + href = text2; + } + return { + type: "link", + raw: cap[0], + text: text2, + href, + tokens: [ + { + type: "text", + raw: text2, + text: text2 + } + ] + }; + } + } + url(src, mangle2) { + let cap; + if (cap = this.rules.inline.url.exec(src)) { + let text2, href; + if (cap[2] === "@") { + text2 = escape(this.options.mangle ? mangle2(cap[0]) : cap[0]); + href = "mailto:" + text2; + } else { + let prevCapZero; + do { + prevCapZero = cap[0]; + cap[0] = this.rules.inline._backpedal.exec(cap[0])[0]; + } while (prevCapZero !== cap[0]); + text2 = escape(cap[0]); + if (cap[1] === "www.") { + href = "http://" + cap[0]; + } else { + href = cap[0]; + } + } + return { + type: "link", + raw: cap[0], + text: text2, + href, + tokens: [ + { + type: "text", + raw: text2, + text: text2 + } + ] + }; + } + } + inlineText(src, smartypants2) { + const cap = this.rules.inline.text.exec(src); + if (cap) { + let text2; + if (this.lexer.state.inRawBlock) { + text2 = this.options.sanitize ? this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]) : cap[0]; + } else { + text2 = escape(this.options.smartypants ? smartypants2(cap[0]) : cap[0]); + } + return { + type: "text", + raw: cap[0], + text: text2 + }; + } + } +} +const block = { + newline: /^(?: *(?:\n|$))+/, + code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/, + fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?=\n|$)|$)/, + hr: /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, + heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/, + blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/, + list: /^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/, + html: "^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))", + def: /^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/, + table: noopTest, + lheading: /^((?:.|\n(?!\n))+?)\n {0,3}(=+|-+) *(?:\n+|$)/, + // regex template, placeholders will be replaced according to different paragraph + // interruption rules of commonmark and the original markdown spec: + _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/, + text: /^[^\n]+/ +}; +block._label = /(?!\s*\])(?:\\.|[^\[\]\\])+/; +block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/; +block.def = edit(block.def).replace("label", block._label).replace("title", block._title).getRegex(); +block.bullet = /(?:[*+-]|\d{1,9}[.)])/; +block.listItemStart = edit(/^( *)(bull) */).replace("bull", block.bullet).getRegex(); +block.list = edit(block.list).replace(/bull/g, block.bullet).replace("hr", "\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))").replace("def", "\\n+(?=" + block.def.source + ")").getRegex(); +block._tag = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul"; +block._comment = /|$)/; +block.html = edit(block.html, "i").replace("comment", block._comment).replace("tag", block._tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(); +block.paragraph = edit(block._paragraph).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex(); +block.blockquote = edit(block.blockquote).replace("paragraph", block.paragraph).getRegex(); +block.normal = merge({}, block); +block.gfm = merge({}, block.normal, { + table: "^ *([^\\n ].*\\|.*)\\n {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)" + // Cells +}); +block.gfm.table = edit(block.gfm.table).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex(); +block.gfm.paragraph = edit(block._paragraph).replace("hr", block.hr).replace("heading", " {0,3}#{1,6} ").replace("|lheading", "").replace("table", block.gfm.table).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", block._tag).getRegex(); +block.pedantic = merge({}, block.normal, { + html: edit( + `^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))` + ).replace("comment", block._comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), + def: /^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, + heading: /^(#{1,6})(.*)(?:\n+|$)/, + fences: noopTest, + // fences not supported + lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, + paragraph: edit(block.normal._paragraph).replace("hr", block.hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", block.lheading).replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").getRegex() +}); +const inline = { + escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, + autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/, + url: noopTest, + tag: "^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^", + // CDATA section + link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/, + reflink: /^!?\[(label)\]\[(ref)\]/, + nolink: /^!?\[(ref)\](?:\[\])?/, + reflinkSearch: "reflink|nolink(?!\\()", + emStrong: { + lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/, + // (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left. (5) and (6) can be either Left or Right. + // () Skip orphan inside strong () Consume to delim (1) #*** (2) a***#, a*** (3) #***a, ***a (4) ***# (5) #***# (6) a***a + rDelimAst: /^(?:[^_*\\]|\\.)*?\_\_(?:[^_*\\]|\\.)*?\*(?:[^_*\\]|\\.)*?(?=\_\_)|(?:[^*\\]|\\.)+(?=[^*])|[punct_](\*+)(?=[\s]|$)|(?:[^punct*_\s\\]|\\.)(\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|(?:[^punct*_\s\\]|\\.)(\*+)(?=[^punct*_\s])/, + rDelimUnd: /^(?:[^_*\\]|\\.)*?\*\*(?:[^_*\\]|\\.)*?\_(?:[^_*\\]|\\.)*?(?=\*\*)|(?:[^_\\]|\\.)+(?=[^_])|[punct*](\_+)(?=[\s]|$)|(?:[^punct*_\s\\]|\\.)(\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ + // ^- Not allowed for _ + }, + code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, + br: /^( {2,}|\\)\n(?!\s*$)/, + del: noopTest, + text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\?@\\[\\]`^{|}~"; +inline.punctuation = edit(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex(); +inline.blockSkip = /\[[^\]]*?\]\([^\)]*?\)|`[^`]*?`|<[^>]*?>/g; +inline.escapedEmSt = /(?:^|[^\\])(?:\\\\)*\\[*_]/g; +inline._comment = edit(block._comment).replace("(?:-->|$)", "-->").getRegex(); +inline.emStrong.lDelim = edit(inline.emStrong.lDelim).replace(/punct/g, inline._punctuation).getRegex(); +inline.emStrong.rDelimAst = edit(inline.emStrong.rDelimAst, "g").replace(/punct/g, inline._punctuation).getRegex(); +inline.emStrong.rDelimUnd = edit(inline.emStrong.rDelimUnd, "g").replace(/punct/g, inline._punctuation).getRegex(); +inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g; +inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/; +inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/; +inline.autolink = edit(inline.autolink).replace("scheme", inline._scheme).replace("email", inline._email).getRegex(); +inline._attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/; +inline.tag = edit(inline.tag).replace("comment", inline._comment).replace("attribute", inline._attribute).getRegex(); +inline._label = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/; +inline._href = /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/; +inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/; +inline.link = edit(inline.link).replace("label", inline._label).replace("href", inline._href).replace("title", inline._title).getRegex(); +inline.reflink = edit(inline.reflink).replace("label", inline._label).replace("ref", block._label).getRegex(); +inline.nolink = edit(inline.nolink).replace("ref", block._label).getRegex(); +inline.reflinkSearch = edit(inline.reflinkSearch, "g").replace("reflink", inline.reflink).replace("nolink", inline.nolink).getRegex(); +inline.normal = merge({}, inline); +inline.pedantic = merge({}, inline.normal, { + strong: { + start: /^__|\*\*/, + middle: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/, + endAst: /\*\*(?!\*)/g, + endUnd: /__(?!_)/g + }, + em: { + start: /^_|\*/, + middle: /^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/, + endAst: /\*(?!\*)/g, + endUnd: /_(?!_)/g + }, + link: edit(/^!?\[(label)\]\((.*?)\)/).replace("label", inline._label).getRegex(), + reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", inline._label).getRegex() +}); +inline.gfm = merge({}, inline.normal, { + escape: edit(inline.escape).replace("])", "~|])").getRegex(), + _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/, + url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, + _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, + del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/, + text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\ 0.5) { + ch = "x" + ch.toString(16); + } + out += "&#" + ch + ";"; + } + return out; +} +class Lexer { + constructor(options) { + this.tokens = []; + this.tokens.links = /* @__PURE__ */ Object.create(null); + this.options = options || defaults; + this.options.tokenizer = this.options.tokenizer || new Tokenizer(); + this.tokenizer = this.options.tokenizer; + this.tokenizer.options = this.options; + this.tokenizer.lexer = this; + this.inlineQueue = []; + this.state = { + inLink: false, + inRawBlock: false, + top: true + }; + const rules = { + block: block.normal, + inline: inline.normal + }; + if (this.options.pedantic) { + rules.block = block.pedantic; + rules.inline = inline.pedantic; + } else if (this.options.gfm) { + rules.block = block.gfm; + if (this.options.breaks) { + rules.inline = inline.breaks; + } else { + rules.inline = inline.gfm; + } + } + this.tokenizer.rules = rules; + } + /** + * Expose Rules + */ + static get rules() { + return { + block, + inline + }; + } + /** + * Static Lex Method + */ + static lex(src, options) { + const lexer = new Lexer(options); + return lexer.lex(src); + } + /** + * Static Lex Inline Method + */ + static lexInline(src, options) { + const lexer = new Lexer(options); + return lexer.inlineTokens(src); + } + /** + * Preprocessing + */ + lex(src) { + src = src.replace(/\r\n|\r/g, "\n"); + this.blockTokens(src, this.tokens); + let next; + while (next = this.inlineQueue.shift()) { + this.inlineTokens(next.src, next.tokens); + } + return this.tokens; + } + /** + * Lexing + */ + blockTokens(src, tokens = []) { + if (this.options.pedantic) { + src = src.replace(/\t/g, " ").replace(/^ +$/gm, ""); + } else { + src = src.replace(/^( *)(\t+)/gm, (_, leading, tabs) => { + return leading + " ".repeat(tabs.length); + }); + } + let token, lastToken, cutSrc, lastParagraphClipped; + while (src) { + if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((extTokenizer) => { + if (token = extTokenizer.call({ lexer: this }, src, tokens)) { + src = src.substring(token.raw.length); + tokens.push(token); + return true; + } + return false; + })) { + continue; + } + if (token = this.tokenizer.space(src)) { + src = src.substring(token.raw.length); + if (token.raw.length === 1 && tokens.length > 0) { + tokens[tokens.length - 1].raw += "\n"; + } else { + tokens.push(token); + } + continue; + } + if (token = this.tokenizer.code(src)) { + src = src.substring(token.raw.length); + lastToken = tokens[tokens.length - 1]; + if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) { + lastToken.raw += "\n" + token.raw; + lastToken.text += "\n" + token.text; + this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text; + } else { + tokens.push(token); + } + continue; + } + if (token = this.tokenizer.fences(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.heading(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.hr(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.blockquote(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.list(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.html(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.def(src)) { + src = src.substring(token.raw.length); + lastToken = tokens[tokens.length - 1]; + if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) { + lastToken.raw += "\n" + token.raw; + lastToken.text += "\n" + token.raw; + this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text; + } else if (!this.tokens.links[token.tag]) { + this.tokens.links[token.tag] = { + href: token.href, + title: token.title + }; + } + continue; + } + if (token = this.tokenizer.table(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.lheading(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + cutSrc = src; + if (this.options.extensions && this.options.extensions.startBlock) { + let startIndex = Infinity; + const tempSrc = src.slice(1); + let tempStart; + this.options.extensions.startBlock.forEach(function(getStartIndex) { + tempStart = getStartIndex.call({ lexer: this }, tempSrc); + if (typeof tempStart === "number" && tempStart >= 0) { + startIndex = Math.min(startIndex, tempStart); + } + }); + if (startIndex < Infinity && startIndex >= 0) { + cutSrc = src.substring(0, startIndex + 1); + } + } + if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) { + lastToken = tokens[tokens.length - 1]; + if (lastParagraphClipped && lastToken.type === "paragraph") { + lastToken.raw += "\n" + token.raw; + lastToken.text += "\n" + token.text; + this.inlineQueue.pop(); + this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text; + } else { + tokens.push(token); + } + lastParagraphClipped = cutSrc.length !== src.length; + src = src.substring(token.raw.length); + continue; + } + if (token = this.tokenizer.text(src)) { + src = src.substring(token.raw.length); + lastToken = tokens[tokens.length - 1]; + if (lastToken && lastToken.type === "text") { + lastToken.raw += "\n" + token.raw; + lastToken.text += "\n" + token.text; + this.inlineQueue.pop(); + this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text; + } else { + tokens.push(token); + } + continue; + } + if (src) { + const errMsg = "Infinite loop on byte: " + src.charCodeAt(0); + if (this.options.silent) { + console.error(errMsg); + break; + } else { + throw new Error(errMsg); + } + } + } + this.state.top = true; + return tokens; + } + inline(src, tokens = []) { + this.inlineQueue.push({ src, tokens }); + return tokens; + } + /** + * Lexing/Compiling + */ + inlineTokens(src, tokens = []) { + let token, lastToken, cutSrc; + let maskedSrc = src; + let match; + let keepPrevChar, prevChar; + if (this.tokens.links) { + const links = Object.keys(this.tokens.links); + if (links.length > 0) { + while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) { + if (links.includes(match[0].slice(match[0].lastIndexOf("[") + 1, -1))) { + maskedSrc = maskedSrc.slice(0, match.index) + "[" + repeatString("a", match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex); + } + } + } + } + while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) { + maskedSrc = maskedSrc.slice(0, match.index) + "[" + repeatString("a", match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex); + } + while ((match = this.tokenizer.rules.inline.escapedEmSt.exec(maskedSrc)) != null) { + maskedSrc = maskedSrc.slice(0, match.index + match[0].length - 2) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.escapedEmSt.lastIndex); + this.tokenizer.rules.inline.escapedEmSt.lastIndex--; + } + while (src) { + if (!keepPrevChar) { + prevChar = ""; + } + keepPrevChar = false; + if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((extTokenizer) => { + if (token = extTokenizer.call({ lexer: this }, src, tokens)) { + src = src.substring(token.raw.length); + tokens.push(token); + return true; + } + return false; + })) { + continue; + } + if (token = this.tokenizer.escape(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.tag(src)) { + src = src.substring(token.raw.length); + lastToken = tokens[tokens.length - 1]; + if (lastToken && token.type === "text" && lastToken.type === "text") { + lastToken.raw += token.raw; + lastToken.text += token.text; + } else { + tokens.push(token); + } + continue; + } + if (token = this.tokenizer.link(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.reflink(src, this.tokens.links)) { + src = src.substring(token.raw.length); + lastToken = tokens[tokens.length - 1]; + if (lastToken && token.type === "text" && lastToken.type === "text") { + lastToken.raw += token.raw; + lastToken.text += token.text; + } else { + tokens.push(token); + } + continue; + } + if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.codespan(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.br(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.del(src)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (token = this.tokenizer.autolink(src, mangle)) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + if (!this.state.inLink && (token = this.tokenizer.url(src, mangle))) { + src = src.substring(token.raw.length); + tokens.push(token); + continue; + } + cutSrc = src; + if (this.options.extensions && this.options.extensions.startInline) { + let startIndex = Infinity; + const tempSrc = src.slice(1); + let tempStart; + this.options.extensions.startInline.forEach(function(getStartIndex) { + tempStart = getStartIndex.call({ lexer: this }, tempSrc); + if (typeof tempStart === "number" && tempStart >= 0) { + startIndex = Math.min(startIndex, tempStart); + } + }); + if (startIndex < Infinity && startIndex >= 0) { + cutSrc = src.substring(0, startIndex + 1); + } + } + if (token = this.tokenizer.inlineText(cutSrc, smartypants)) { + src = src.substring(token.raw.length); + if (token.raw.slice(-1) !== "_") { + prevChar = token.raw.slice(-1); + } + keepPrevChar = true; + lastToken = tokens[tokens.length - 1]; + if (lastToken && lastToken.type === "text") { + lastToken.raw += token.raw; + lastToken.text += token.text; + } else { + tokens.push(token); + } + continue; + } + if (src) { + const errMsg = "Infinite loop on byte: " + src.charCodeAt(0); + if (this.options.silent) { + console.error(errMsg); + break; + } else { + throw new Error(errMsg); + } + } + } + return tokens; + } +} +class Renderer { + constructor(options) { + this.options = options || defaults; + } + code(code, infostring, escaped) { + const lang = (infostring || "").match(/\S*/)[0]; + if (this.options.highlight) { + const out = this.options.highlight(code, lang); + if (out != null && out !== code) { + escaped = true; + code = out; + } + } + code = code.replace(/\n$/, "") + "\n"; + if (!lang) { + return "
" + (escaped ? code : escape(code, true)) + "
\n"; + } + return '
' + (escaped ? code : escape(code, true)) + "
\n"; + } + /** + * @param {string} quote + */ + blockquote(quote) { + return `
+${quote}
+`; + } + html(html) { + return html; + } + /** + * @param {string} text + * @param {string} level + * @param {string} raw + * @param {any} slugger + */ + heading(text2, level, raw, slugger) { + if (this.options.headerIds) { + const id = this.options.headerPrefix + slugger.slug(raw); + return `${text2} +`; + } + return `${text2} +`; + } + hr() { + return this.options.xhtml ? "
\n" : "
\n"; + } + list(body, ordered, start) { + const type = ordered ? "ol" : "ul", startatt = ordered && start !== 1 ? ' start="' + start + '"' : ""; + return "<" + type + startatt + ">\n" + body + "\n"; + } + /** + * @param {string} text + */ + listitem(text2) { + return `
  • ${text2}
    • +`; + } + checkbox(checked) { + return " "; + } + /** + * @param {string} text + */ + paragraph(text2) { + return `

    ${text2}

    +`; + } + /** + * @param {string} header + * @param {string} body + */ + table(header, body) { + if (body) + body = `${body}`; + return "\n\n" + header + "\n" + body + "
    \n"; + } + /** + * @param {string} content + */ + tablerow(content) { + return ` +${content} +`; + } + tablecell(content, flags) { + const type = flags.header ? "th" : "td"; + const tag = flags.align ? `<${type} align="${flags.align}">` : `<${type}>`; + return tag + content + ` +`; + } + /** + * span level renderer + * @param {string} text + */ + strong(text2) { + return `${text2}`; + } + /** + * @param {string} text + */ + em(text2) { + return `${text2}`; + } + /** + * @param {string} text + */ + codespan(text2) { + return `${text2}`; + } + br() { + return this.options.xhtml ? "
    " : "
    "; + } + /** + * @param {string} text + */ + del(text2) { + return `${text2}`; + } + /** + * @param {string} href + * @param {string} title + * @param {string} text + */ + link(href, title, text2) { + href = cleanUrl(this.options.sanitize, this.options.baseUrl, href); + if (href === null) { + return text2; + } + let out = '    "; + return out; + } + /** + * @param {string} href + * @param {string} title + * @param {string} text + */ + image(href, title, text2) { + href = cleanUrl(this.options.sanitize, this.options.baseUrl, href); + if (href === null) { + return text2; + } + let out = `${text2}" : ">"; + return out; + } + text(text2) { + return text2; + } +} +class TextRenderer { + // no need for block level renderers + strong(text2) { + return text2; + } + em(text2) { + return text2; + } + codespan(text2) { + return text2; + } + del(text2) { + return text2; + } + html(text2) { + return text2; + } + text(text2) { + return text2; + } + link(href, title, text2) { + return "" + text2; + } + image(href, title, text2) { + return "" + text2; + } + br() { + return ""; + } +} +class Slugger { + constructor() { + this.seen = {}; + } + /** + * @param {string} value + */ + serialize(value) { + return value.toLowerCase().trim().replace(/<[!\/a-z].*?>/ig, "").replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, "").replace(/\s/g, "-"); + } + /** + * Finds the next safe (unique) slug to use + * @param {string} originalSlug + * @param {boolean} isDryRun + */ + getNextSafeSlug(originalSlug, isDryRun) { + let slug = originalSlug; + let occurenceAccumulator = 0; + if (this.seen.hasOwnProperty(slug)) { + occurenceAccumulator = this.seen[originalSlug]; + do { + occurenceAccumulator++; + slug = originalSlug + "-" + occurenceAccumulator; + } while (this.seen.hasOwnProperty(slug)); + } + if (!isDryRun) { + this.seen[originalSlug] = occurenceAccumulator; + this.seen[slug] = 0; + } + return slug; + } + /** + * Convert string to unique id + * @param {object} [options] + * @param {boolean} [options.dryrun] Generates the next unique slug without + * updating the internal accumulator. + */ + slug(value, options = {}) { + const slug = this.serialize(value); + return this.getNextSafeSlug(slug, options.dryrun); + } +} +class Parser2 { + constructor(options) { + this.options = options || defaults; + this.options.renderer = this.options.renderer || new Renderer(); + this.renderer = this.options.renderer; + this.renderer.options = this.options; + this.textRenderer = new TextRenderer(); + this.slugger = new Slugger(); + } + /** + * Static Parse Method + */ + static parse(tokens, options) { + const parser = new Parser2(options); + return parser.parse(tokens); + } + /** + * Static Parse Inline Method + */ + static parseInline(tokens, options) { + const parser = new Parser2(options); + return parser.parseInline(tokens); + } + /** + * Parse Loop + */ + parse(tokens, top = true) { + let out = "", i, j, k, l2, l3, row, cell, header, body, token, ordered, start, loose, itemBody, item, checked, task, checkbox, ret; + const l = tokens.length; + for (i = 0; i < l; i++) { + token = tokens[i]; + if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) { + ret = this.options.extensions.renderers[token.type].call({ parser: this }, token); + if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(token.type)) { + out += ret || ""; + continue; + } + } + switch (token.type) { + case "space": { + continue; + } + case "hr": { + out += this.renderer.hr(); + continue; + } + case "heading": { + out += this.renderer.heading( + this.parseInline(token.tokens), + token.depth, + unescape(this.parseInline(token.tokens, this.textRenderer)), + this.slugger + ); + continue; + } + case "code": { + out += this.renderer.code( + token.text, + token.lang, + token.escaped + ); + continue; + } + case "table": { + header = ""; + cell = ""; + l2 = token.header.length; + for (j = 0; j < l2; j++) { + cell += this.renderer.tablecell( + this.parseInline(token.header[j].tokens), + { header: true, align: token.align[j] } + ); + } + header += this.renderer.tablerow(cell); + body = ""; + l2 = token.rows.length; + for (j = 0; j < l2; j++) { + row = token.rows[j]; + cell = ""; + l3 = row.length; + for (k = 0; k < l3; k++) { + cell += this.renderer.tablecell( + this.parseInline(row[k].tokens), + { header: false, align: token.align[k] } + ); + } + body += this.renderer.tablerow(cell); + } + out += this.renderer.table(header, body); + continue; + } + case "blockquote": { + body = this.parse(token.tokens); + out += this.renderer.blockquote(body); + continue; + } + case "list": { + ordered = token.ordered; + start = token.start; + loose = token.loose; + l2 = token.items.length; + body = ""; + for (j = 0; j < l2; j++) { + item = token.items[j]; + checked = item.checked; + task = item.task; + itemBody = ""; + if (item.task) { + checkbox = this.renderer.checkbox(checked); + if (loose) { + if (item.tokens.length > 0 && item.tokens[0].type === "paragraph") { + item.tokens[0].text = checkbox + " " + item.tokens[0].text; + if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") { + item.tokens[0].tokens[0].text = checkbox + " " + item.tokens[0].tokens[0].text; + } + } else { + item.tokens.unshift({ + type: "text", + text: checkbox + }); + } + } else { + itemBody += checkbox; + } + } + itemBody += this.parse(item.tokens, loose); + body += this.renderer.listitem(itemBody, task, checked); + } + out += this.renderer.list(body, ordered, start); + continue; + } + case "html": { + out += this.renderer.html(token.text); + continue; + } + case "paragraph": { + out += this.renderer.paragraph(this.parseInline(token.tokens)); + continue; + } + case "text": { + body = token.tokens ? this.parseInline(token.tokens) : token.text; + while (i + 1 < l && tokens[i + 1].type === "text") { + token = tokens[++i]; + body += "\n" + (token.tokens ? this.parseInline(token.tokens) : token.text); + } + out += top ? this.renderer.paragraph(body) : body; + continue; + } + default: { + const errMsg = 'Token with "' + token.type + '" type was not found.'; + if (this.options.silent) { + console.error(errMsg); + return; + } else { + throw new Error(errMsg); + } + } + } + } + return out; + } + /** + * Parse Inline Tokens + */ + parseInline(tokens, renderer) { + renderer = renderer || this.renderer; + let out = "", i, token, ret; + const l = tokens.length; + for (i = 0; i < l; i++) { + token = tokens[i]; + if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) { + ret = this.options.extensions.renderers[token.type].call({ parser: this }, token); + if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(token.type)) { + out += ret || ""; + continue; + } + } + switch (token.type) { + case "escape": { + out += renderer.text(token.text); + break; + } + case "html": { + out += renderer.html(token.text); + break; + } + case "link": { + out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer)); + break; + } + case "image": { + out += renderer.image(token.href, token.title, token.text); + break; + } + case "strong": { + out += renderer.strong(this.parseInline(token.tokens, renderer)); + break; + } + case "em": { + out += renderer.em(this.parseInline(token.tokens, renderer)); + break; + } + case "codespan": { + out += renderer.codespan(token.text); + break; + } + case "br": { + out += renderer.br(); + break; + } + case "del": { + out += renderer.del(this.parseInline(token.tokens, renderer)); + break; + } + case "text": { + out += renderer.text(token.text); + break; + } + default: { + const errMsg = 'Token with "' + token.type + '" type was not found.'; + if (this.options.silent) { + console.error(errMsg); + return; + } else { + throw new Error(errMsg); + } + } + } + } + return out; + } +} +function marked(src, opt, callback) { + if (typeof src === "undefined" || src === null) { + throw new Error("marked(): input parameter is undefined or null"); + } + if (typeof src !== "string") { + throw new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"); + } + if (typeof opt === "function") { + callback = opt; + opt = null; + } + opt = merge({}, marked.defaults, opt || {}); + checkSanitizeDeprecation(opt); + if (callback) { + const highlight = opt.highlight; + let tokens; + try { + tokens = Lexer.lex(src, opt); + } catch (e) { + return callback(e); + } + const done = function(err) { + let out; + if (!err) { + try { + if (opt.walkTokens) { + marked.walkTokens(tokens, opt.walkTokens); + } + out = Parser2.parse(tokens, opt); + } catch (e) { + err = e; + } + } + opt.highlight = highlight; + return err ? callback(err) : callback(null, out); + }; + if (!highlight || highlight.length < 3) { + return done(); + } + delete opt.highlight; + if (!tokens.length) + return done(); + let pending = 0; + marked.walkTokens(tokens, function(token) { + if (token.type === "code") { + pending++; + setTimeout(() => { + highlight(token.text, token.lang, function(err, code) { + if (err) { + return done(err); + } + if (code != null && code !== token.text) { + token.text = code; + token.escaped = true; + } + pending--; + if (pending === 0) { + done(); + } + }); + }, 0); + } + }); + if (pending === 0) { + done(); + } + return; + } + function onError(e) { + e.message += "\nPlease report this to https://github.com/markedjs/marked."; + if (opt.silent) { + return "

    An error occurred:

    " + escape(e.message + "", true) + "
    "; + } + throw e; + } + try { + const tokens = Lexer.lex(src, opt); + if (opt.walkTokens) { + if (opt.async) { + return Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(() => { + return Parser2.parse(tokens, opt); + }).catch(onError); + } + marked.walkTokens(tokens, opt.walkTokens); + } + return Parser2.parse(tokens, opt); + } catch (e) { + onError(e); + } +} +marked.options = marked.setOptions = function(opt) { + merge(marked.defaults, opt); + changeDefaults(marked.defaults); + return marked; +}; +marked.getDefaults = getDefaults; +marked.defaults = defaults; +marked.use = function(...args) { + const extensions = marked.defaults.extensions || { renderers: {}, childTokens: {} }; + args.forEach((pack) => { + const opts = merge({}, pack); + opts.async = marked.defaults.async || opts.async; + if (pack.extensions) { + pack.extensions.forEach((ext) => { + if (!ext.name) { + throw new Error("extension name required"); + } + if (ext.renderer) { + const prevRenderer = extensions.renderers[ext.name]; + if (prevRenderer) { + extensions.renderers[ext.name] = function(...args2) { + let ret = ext.renderer.apply(this, args2); + if (ret === false) { + ret = prevRenderer.apply(this, args2); + } + return ret; + }; + } else { + extensions.renderers[ext.name] = ext.renderer; + } + } + if (ext.tokenizer) { + if (!ext.level || ext.level !== "block" && ext.level !== "inline") { + throw new Error("extension level must be 'block' or 'inline'"); + } + if (extensions[ext.level]) { + extensions[ext.level].unshift(ext.tokenizer); + } else { + extensions[ext.level] = [ext.tokenizer]; + } + if (ext.start) { + if (ext.level === "block") { + if (extensions.startBlock) { + extensions.startBlock.push(ext.start); + } else { + extensions.startBlock = [ext.start]; + } + } else if (ext.level === "inline") { + if (extensions.startInline) { + extensions.startInline.push(ext.start); + } else { + extensions.startInline = [ext.start]; + } + } + } + } + if (ext.childTokens) { + extensions.childTokens[ext.name] = ext.childTokens; + } + }); + opts.extensions = extensions; + } + if (pack.renderer) { + const renderer = marked.defaults.renderer || new Renderer(); + for (const prop in pack.renderer) { + const prevRenderer = renderer[prop]; + renderer[prop] = (...args2) => { + let ret = pack.renderer[prop].apply(renderer, args2); + if (ret === false) { + ret = prevRenderer.apply(renderer, args2); + } + return ret; + }; + } + opts.renderer = renderer; + } + if (pack.tokenizer) { + const tokenizer = marked.defaults.tokenizer || new Tokenizer(); + for (const prop in pack.tokenizer) { + const prevTokenizer = tokenizer[prop]; + tokenizer[prop] = (...args2) => { + let ret = pack.tokenizer[prop].apply(tokenizer, args2); + if (ret === false) { + ret = prevTokenizer.apply(tokenizer, args2); + } + return ret; + }; + } + opts.tokenizer = tokenizer; + } + if (pack.walkTokens) { + const walkTokens = marked.defaults.walkTokens; + opts.walkTokens = function(token) { + let values = []; + values.push(pack.walkTokens.call(this, token)); + if (walkTokens) { + values = values.concat(walkTokens.call(this, token)); + } + return values; + }; + } + marked.setOptions(opts); + }); +}; +marked.walkTokens = function(tokens, callback) { + let values = []; + for (const token of tokens) { + values = values.concat(callback.call(marked, token)); + switch (token.type) { + case "table": { + for (const cell of token.header) { + values = values.concat(marked.walkTokens(cell.tokens, callback)); + } + for (const row of token.rows) { + for (const cell of row) { + values = values.concat(marked.walkTokens(cell.tokens, callback)); + } + } + break; + } + case "list": { + values = values.concat(marked.walkTokens(token.items, callback)); + break; + } + default: { + if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) { + marked.defaults.extensions.childTokens[token.type].forEach(function(childTokens) { + values = values.concat(marked.walkTokens(token[childTokens], callback)); + }); + } else if (token.tokens) { + values = values.concat(marked.walkTokens(token.tokens, callback)); + } + } + } + } + return values; +}; +marked.parseInline = function(src, opt) { + if (typeof src === "undefined" || src === null) { + throw new Error("marked.parseInline(): input parameter is undefined or null"); + } + if (typeof src !== "string") { + throw new Error("marked.parseInline(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"); + } + opt = merge({}, marked.defaults, opt || {}); + checkSanitizeDeprecation(opt); + try { + const tokens = Lexer.lexInline(src, opt); + if (opt.walkTokens) { + marked.walkTokens(tokens, opt.walkTokens); + } + return Parser2.parseInline(tokens, opt); + } catch (e) { + e.message += "\nPlease report this to https://github.com/markedjs/marked."; + if (opt.silent) { + return "

    An error occurred:

    " + escape(e.message + "", true) + "
    "; + } + throw e; + } +}; +marked.Parser = Parser2; +marked.parser = Parser2.parse; +marked.Renderer = Renderer; +marked.TextRenderer = TextRenderer; +marked.Lexer = Lexer; +marked.lexer = Lexer.lex; +marked.Tokenizer = Tokenizer; +marked.Slugger = Slugger; +marked.parse = marked; +marked.options; +marked.setOptions; +marked.use; +marked.walkTokens; +marked.parseInline; +Parser2.parse; +Lexer.lex; +const key = {}; +function create_else_block$2(ctx) { + let t; + return { + c() { + t = text( + /*raw*/ + ctx[1] + ); + }, + l(nodes) { + t = claim_text( + nodes, + /*raw*/ + ctx[1] + ); + }, + m(target, anchor) { + insert_hydration(target, t, anchor); + }, + p(ctx2, dirty) { + if (dirty & /*raw*/ + 2) + set_data( + t, + /*raw*/ + ctx2[1] + ); + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(t); + } + }; +} +function create_if_block_5(ctx) { + let h6; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[5].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[4], + null + ); + return { + c() { + h6 = element("h6"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + h6 = claim_element(nodes, "H6", { id: true }); + var h6_nodes = children(h6); + if (default_slot) + default_slot.l(h6_nodes); + h6_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + h6, + "id", + /*id*/ + ctx[2] + ); + }, + m(target, anchor) { + insert_hydration(target, h6, anchor); + if (default_slot) { + default_slot.m(h6, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 16)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[4], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[4] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[4], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*id*/ + 4) { + attr( + h6, + "id", + /*id*/ + ctx2[2] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(h6); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_if_block_4(ctx) { + let h5; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[5].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[4], + null + ); + return { + c() { + h5 = element("h5"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + h5 = claim_element(nodes, "H5", { id: true }); + var h5_nodes = children(h5); + if (default_slot) + default_slot.l(h5_nodes); + h5_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + h5, + "id", + /*id*/ + ctx[2] + ); + }, + m(target, anchor) { + insert_hydration(target, h5, anchor); + if (default_slot) { + default_slot.m(h5, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 16)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[4], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[4] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[4], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*id*/ + 4) { + attr( + h5, + "id", + /*id*/ + ctx2[2] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(h5); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_if_block_3(ctx) { + let h4; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[5].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[4], + null + ); + return { + c() { + h4 = element("h4"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + h4 = claim_element(nodes, "H4", { id: true }); + var h4_nodes = children(h4); + if (default_slot) + default_slot.l(h4_nodes); + h4_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + h4, + "id", + /*id*/ + ctx[2] + ); + }, + m(target, anchor) { + insert_hydration(target, h4, anchor); + if (default_slot) { + default_slot.m(h4, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 16)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[4], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[4] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[4], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*id*/ + 4) { + attr( + h4, + "id", + /*id*/ + ctx2[2] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(h4); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_if_block_2(ctx) { + let h3; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[5].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[4], + null + ); + return { + c() { + h3 = element("h3"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + h3 = claim_element(nodes, "H3", { id: true }); + var h3_nodes = children(h3); + if (default_slot) + default_slot.l(h3_nodes); + h3_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + h3, + "id", + /*id*/ + ctx[2] + ); + }, + m(target, anchor) { + insert_hydration(target, h3, anchor); + if (default_slot) { + default_slot.m(h3, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 16)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[4], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[4] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[4], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*id*/ + 4) { + attr( + h3, + "id", + /*id*/ + ctx2[2] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(h3); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_if_block_1$1(ctx) { + let h2; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[5].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[4], + null + ); + return { + c() { + h2 = element("h2"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + h2 = claim_element(nodes, "H2", { id: true }); + var h2_nodes = children(h2); + if (default_slot) + default_slot.l(h2_nodes); + h2_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + h2, + "id", + /*id*/ + ctx[2] + ); + }, + m(target, anchor) { + insert_hydration(target, h2, anchor); + if (default_slot) { + default_slot.m(h2, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 16)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[4], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[4] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[4], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*id*/ + 4) { + attr( + h2, + "id", + /*id*/ + ctx2[2] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(h2); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_if_block$3(ctx) { + let h1; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[5].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[4], + null + ); + return { + c() { + h1 = element("h1"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + h1 = claim_element(nodes, "H1", { id: true }); + var h1_nodes = children(h1); + if (default_slot) + default_slot.l(h1_nodes); + h1_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + h1, + "id", + /*id*/ + ctx[2] + ); + }, + m(target, anchor) { + insert_hydration(target, h1, anchor); + if (default_slot) { + default_slot.m(h1, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 16)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[4], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[4] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[4], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*id*/ + 4) { + attr( + h1, + "id", + /*id*/ + ctx2[2] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(h1); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_fragment$m(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [ + create_if_block$3, + create_if_block_1$1, + create_if_block_2, + create_if_block_3, + create_if_block_4, + create_if_block_5, + create_else_block$2 + ]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if ( + /*depth*/ + ctx2[0] === 1 + ) + return 0; + if ( + /*depth*/ + ctx2[0] === 2 + ) + return 1; + if ( + /*depth*/ + ctx2[0] === 3 + ) + return 2; + if ( + /*depth*/ + ctx2[0] === 4 + ) + return 3; + if ( + /*depth*/ + ctx2[0] === 5 + ) + return 4; + if ( + /*depth*/ + ctx2[0] === 6 + ) + return 5; + return 6; + } + current_block_type_index = select_block_type(ctx); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + if_block.c(); + if_block_anchor = empty(); + }, + l(nodes) { + if_block.l(nodes); + if_block_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert_hydration(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, [dirty]) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if_blocks[current_block_type_index].d(detaching); + if (detaching) + detach(if_block_anchor); + } + }; +} +function instance$l($$self, $$props, $$invalidate) { + let id; + let { $$slots: slots = {}, $$scope } = $$props; + let { depth } = $$props; + let { raw } = $$props; + let { text: text2 } = $$props; + const { slug, getOptions } = getContext(key); + const options = getOptions(); + $$self.$$set = ($$props2) => { + if ("depth" in $$props2) + $$invalidate(0, depth = $$props2.depth); + if ("raw" in $$props2) + $$invalidate(1, raw = $$props2.raw); + if ("text" in $$props2) + $$invalidate(3, text2 = $$props2.text); + if ("$$scope" in $$props2) + $$invalidate(4, $$scope = $$props2.$$scope); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*text*/ + 8) { + $$invalidate(2, id = options.headerIds ? options.headerPrefix + slug(text2) : void 0); + } + }; + return [depth, raw, id, text2, $$scope, slots]; +} +class Heading extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$l, create_fragment$m, safe_not_equal, { depth: 0, raw: 1, text: 3 }); + } +} +function create_fragment$l(ctx) { + let p; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + p = element("p"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + p = claim_element(nodes, "P", {}); + var p_nodes = children(p); + if (default_slot) + default_slot.l(p_nodes); + p_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, p, anchor); + if (default_slot) { + default_slot.m(p, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(p); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$k($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class Paragraph extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$k, create_fragment$l, safe_not_equal, {}); + } +} +function create_fragment$k(ctx) { + let current; + const default_slot_template = ( + /*#slots*/ + ctx[3].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + null + ); + return { + c() { + if (default_slot) + default_slot.c(); + }, + l(nodes) { + if (default_slot) + default_slot.l(nodes); + }, + m(target, anchor) { + if (default_slot) { + default_slot.m(target, anchor); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[2], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[2] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[2], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$j($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + let { text: text2 } = $$props; + let { raw } = $$props; + $$self.$$set = ($$props2) => { + if ("text" in $$props2) + $$invalidate(0, text2 = $$props2.text); + if ("raw" in $$props2) + $$invalidate(1, raw = $$props2.raw); + if ("$$scope" in $$props2) + $$invalidate(2, $$scope = $$props2.$$scope); + }; + return [text2, raw, $$scope, slots]; +} +class Text extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$j, create_fragment$k, safe_not_equal, { text: 0, raw: 1 }); + } +} +function create_fragment$j(ctx) { + let img; + let img_src_value; + return { + c() { + img = element("img"); + this.h(); + }, + l(nodes) { + img = claim_element(nodes, "IMG", { src: true, title: true, alt: true }); + this.h(); + }, + h() { + if (!src_url_equal(img.src, img_src_value = /*href*/ + ctx[0])) + attr(img, "src", img_src_value); + attr( + img, + "title", + /*title*/ + ctx[1] + ); + attr( + img, + "alt", + /*text*/ + ctx[2] + ); + }, + m(target, anchor) { + insert_hydration(target, img, anchor); + }, + p(ctx2, [dirty]) { + if (dirty & /*href*/ + 1 && !src_url_equal(img.src, img_src_value = /*href*/ + ctx2[0])) { + attr(img, "src", img_src_value); + } + if (dirty & /*title*/ + 2) { + attr( + img, + "title", + /*title*/ + ctx2[1] + ); + } + if (dirty & /*text*/ + 4) { + attr( + img, + "alt", + /*text*/ + ctx2[2] + ); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(img); + } + }; +} +function instance$i($$self, $$props, $$invalidate) { + let { href = "" } = $$props; + let { title = void 0 } = $$props; + let { text: text2 = "" } = $$props; + $$self.$$set = ($$props2) => { + if ("href" in $$props2) + $$invalidate(0, href = $$props2.href); + if ("title" in $$props2) + $$invalidate(1, title = $$props2.title); + if ("text" in $$props2) + $$invalidate(2, text2 = $$props2.text); + }; + return [href, title, text2]; +} +class Image extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$i, create_fragment$j, safe_not_equal, { href: 0, title: 1, text: 2 }); + } +} +function create_fragment$i(ctx) { + let a; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[3].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + null + ); + return { + c() { + a = element("a"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + a = claim_element(nodes, "A", { href: true, title: true }); + var a_nodes = children(a); + if (default_slot) + default_slot.l(a_nodes); + a_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + a, + "href", + /*href*/ + ctx[0] + ); + attr( + a, + "title", + /*title*/ + ctx[1] + ); + }, + m(target, anchor) { + insert_hydration(target, a, anchor); + if (default_slot) { + default_slot.m(a, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[2], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[2] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[2], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*href*/ + 1) { + attr( + a, + "href", + /*href*/ + ctx2[0] + ); + } + if (!current || dirty & /*title*/ + 2) { + attr( + a, + "title", + /*title*/ + ctx2[1] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(a); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$h($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + let { href = "" } = $$props; + let { title = void 0 } = $$props; + $$self.$$set = ($$props2) => { + if ("href" in $$props2) + $$invalidate(0, href = $$props2.href); + if ("title" in $$props2) + $$invalidate(1, title = $$props2.title); + if ("$$scope" in $$props2) + $$invalidate(2, $$scope = $$props2.$$scope); + }; + return [href, title, $$scope, slots]; +} +class Link extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$h, create_fragment$i, safe_not_equal, { href: 0, title: 1 }); + } +} +function create_fragment$h(ctx) { + let em; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + em = element("em"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + em = claim_element(nodes, "EM", {}); + var em_nodes = children(em); + if (default_slot) + default_slot.l(em_nodes); + em_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, em, anchor); + if (default_slot) { + default_slot.m(em, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(em); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$g($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class Em extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$g, create_fragment$h, safe_not_equal, {}); + } +} +function create_fragment$g(ctx) { + let del; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + del = element("del"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + del = claim_element(nodes, "DEL", {}); + var del_nodes = children(del); + if (default_slot) + default_slot.l(del_nodes); + del_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, del, anchor); + if (default_slot) { + default_slot.m(del, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(del); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$f($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class Del extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$f, create_fragment$g, safe_not_equal, {}); + } +} +function create_fragment$f(ctx) { + let code; + let t_value = ( + /*raw*/ + ctx[0].replace(/`/g, "") + "" + ); + let t; + return { + c() { + code = element("code"); + t = text(t_value); + }, + l(nodes) { + code = claim_element(nodes, "CODE", {}); + var code_nodes = children(code); + t = claim_text(code_nodes, t_value); + code_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, code, anchor); + append_hydration(code, t); + }, + p(ctx2, [dirty]) { + if (dirty & /*raw*/ + 1 && t_value !== (t_value = /*raw*/ + ctx2[0].replace(/`/g, "") + "")) + set_data(t, t_value); + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(code); + } + }; +} +function instance$e($$self, $$props, $$invalidate) { + let { raw } = $$props; + $$self.$$set = ($$props2) => { + if ("raw" in $$props2) + $$invalidate(0, raw = $$props2.raw); + }; + return [raw]; +} +class Codespan extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$e, create_fragment$f, safe_not_equal, { raw: 0 }); + } +} +function create_fragment$e(ctx) { + let strong; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + strong = element("strong"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + strong = claim_element(nodes, "STRONG", {}); + var strong_nodes = children(strong); + if (default_slot) + default_slot.l(strong_nodes); + strong_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, strong, anchor); + if (default_slot) { + default_slot.m(strong, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(strong); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$d($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class Strong extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$d, create_fragment$e, safe_not_equal, {}); + } +} +function create_fragment$d(ctx) { + let table; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + table = element("table"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + table = claim_element(nodes, "TABLE", {}); + var table_nodes = children(table); + if (default_slot) + default_slot.l(table_nodes); + table_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, table, anchor); + if (default_slot) { + default_slot.m(table, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(table); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$c($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class Table extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$c, create_fragment$d, safe_not_equal, {}); + } +} +function create_fragment$c(ctx) { + let thead; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + thead = element("thead"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + thead = claim_element(nodes, "THEAD", {}); + var thead_nodes = children(thead); + if (default_slot) + default_slot.l(thead_nodes); + thead_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, thead, anchor); + if (default_slot) { + default_slot.m(thead, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(thead); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$b($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class TableHead extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$b, create_fragment$c, safe_not_equal, {}); + } +} +function create_fragment$b(ctx) { + let tbody; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + tbody = element("tbody"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + tbody = claim_element(nodes, "TBODY", {}); + var tbody_nodes = children(tbody); + if (default_slot) + default_slot.l(tbody_nodes); + tbody_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, tbody, anchor); + if (default_slot) { + default_slot.m(tbody, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(tbody); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$a($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class TableBody extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$a, create_fragment$b, safe_not_equal, {}); + } +} +function create_fragment$a(ctx) { + let tr; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + tr = element("tr"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + tr = claim_element(nodes, "TR", {}); + var tr_nodes = children(tr); + if (default_slot) + default_slot.l(tr_nodes); + tr_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, tr, anchor); + if (default_slot) { + default_slot.m(tr, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(tr); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$9($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class TableRow extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$9, create_fragment$a, safe_not_equal, {}); + } +} +function create_else_block$1(ctx) { + let td; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[3].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + null + ); + return { + c() { + td = element("td"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + td = claim_element(nodes, "TD", { align: true }); + var td_nodes = children(td); + if (default_slot) + default_slot.l(td_nodes); + td_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + td, + "align", + /*align*/ + ctx[1] + ); + }, + m(target, anchor) { + insert_hydration(target, td, anchor); + if (default_slot) { + default_slot.m(td, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[2], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[2] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[2], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*align*/ + 2) { + attr( + td, + "align", + /*align*/ + ctx2[1] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(td); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_if_block$2(ctx) { + let th; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[3].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + null + ); + return { + c() { + th = element("th"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + th = claim_element(nodes, "TH", { align: true }); + var th_nodes = children(th); + if (default_slot) + default_slot.l(th_nodes); + th_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + th, + "align", + /*align*/ + ctx[1] + ); + }, + m(target, anchor) { + insert_hydration(target, th, anchor); + if (default_slot) { + default_slot.m(th, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[2], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[2] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[2], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*align*/ + 2) { + attr( + th, + "align", + /*align*/ + ctx2[1] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(th); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_fragment$9(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [create_if_block$2, create_else_block$1]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if ( + /*header*/ + ctx2[0] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type(ctx); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + if_block.c(); + if_block_anchor = empty(); + }, + l(nodes) { + if_block.l(nodes); + if_block_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert_hydration(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, [dirty]) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if_blocks[current_block_type_index].d(detaching); + if (detaching) + detach(if_block_anchor); + } + }; +} +function instance$8($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + let { header } = $$props; + let { align } = $$props; + $$self.$$set = ($$props2) => { + if ("header" in $$props2) + $$invalidate(0, header = $$props2.header); + if ("align" in $$props2) + $$invalidate(1, align = $$props2.align); + if ("$$scope" in $$props2) + $$invalidate(2, $$scope = $$props2.$$scope); + }; + return [header, align, $$scope, slots]; +} +class TableCell extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$8, create_fragment$9, safe_not_equal, { header: 0, align: 1 }); + } +} +function create_else_block(ctx) { + let ul; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[3].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + null + ); + return { + c() { + ul = element("ul"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + ul = claim_element(nodes, "UL", {}); + var ul_nodes = children(ul); + if (default_slot) + default_slot.l(ul_nodes); + ul_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, ul, anchor); + if (default_slot) { + default_slot.m(ul, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[2], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[2] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[2], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(ul); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_if_block$1(ctx) { + let ol; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[3].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + null + ); + return { + c() { + ol = element("ol"); + if (default_slot) + default_slot.c(); + this.h(); + }, + l(nodes) { + ol = claim_element(nodes, "OL", { start: true }); + var ol_nodes = children(ol); + if (default_slot) + default_slot.l(ol_nodes); + ol_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + ol, + "start", + /*start*/ + ctx[1] + ); + }, + m(target, anchor) { + insert_hydration(target, ol, anchor); + if (default_slot) { + default_slot.m(ol, null); + } + current = true; + }, + p(ctx2, dirty) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[2], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[2] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[2], + dirty, + null + ), + null + ); + } + } + if (!current || dirty & /*start*/ + 2) { + attr( + ol, + "start", + /*start*/ + ctx2[1] + ); + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(ol); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function create_fragment$8(ctx) { + let current_block_type_index; + let if_block; + let if_block_anchor; + let current; + const if_block_creators = [create_if_block$1, create_else_block]; + const if_blocks = []; + function select_block_type(ctx2, dirty) { + if ( + /*ordered*/ + ctx2[0] + ) + return 0; + return 1; + } + current_block_type_index = select_block_type(ctx); + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx); + return { + c() { + if_block.c(); + if_block_anchor = empty(); + }, + l(nodes) { + if_block.l(nodes); + if_block_anchor = empty(); + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor); + insert_hydration(target, if_block_anchor, anchor); + current = true; + }, + p(ctx2, [dirty]) { + let previous_block_index = current_block_type_index; + current_block_type_index = select_block_type(ctx2); + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty); + } else { + group_outros(); + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null; + }); + check_outros(); + if_block = if_blocks[current_block_type_index]; + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2); + if_block.c(); + } else { + if_block.p(ctx2, dirty); + } + transition_in(if_block, 1); + if_block.m(if_block_anchor.parentNode, if_block_anchor); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if_blocks[current_block_type_index].d(detaching); + if (detaching) + detach(if_block_anchor); + } + }; +} +function instance$7($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + let { ordered } = $$props; + let { start } = $$props; + $$self.$$set = ($$props2) => { + if ("ordered" in $$props2) + $$invalidate(0, ordered = $$props2.ordered); + if ("start" in $$props2) + $$invalidate(1, start = $$props2.start); + if ("$$scope" in $$props2) + $$invalidate(2, $$scope = $$props2.$$scope); + }; + return [ordered, start, $$scope, slots]; +} +class List extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$7, create_fragment$8, safe_not_equal, { ordered: 0, start: 1 }); + } +} +function create_fragment$7(ctx) { + let li; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + li = element("li"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + li = claim_element(nodes, "LI", {}); + var li_nodes = children(li); + if (default_slot) + default_slot.l(li_nodes); + li_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, li, anchor); + if (default_slot) { + default_slot.m(li, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(li); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$6($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class ListItem extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$6, create_fragment$7, safe_not_equal, {}); + } +} +function create_fragment$6(ctx) { + let hr; + return { + c() { + hr = element("hr"); + }, + l(nodes) { + hr = claim_element(nodes, "HR", {}); + }, + m(target, anchor) { + insert_hydration(target, hr, anchor); + }, + p: noop, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(hr); + } + }; +} +class Hr extends SvelteComponent { + constructor(options) { + super(); + init(this, options, null, create_fragment$6, safe_not_equal, {}); + } +} +function create_fragment$5(ctx) { + let html_tag; + let html_anchor; + return { + c() { + html_tag = new HtmlTagHydration(false); + html_anchor = empty(); + this.h(); + }, + l(nodes) { + html_tag = claim_html_tag(nodes, false); + html_anchor = empty(); + this.h(); + }, + h() { + html_tag.a = html_anchor; + }, + m(target, anchor) { + html_tag.m( + /*text*/ + ctx[0], + target, + anchor + ); + insert_hydration(target, html_anchor, anchor); + }, + p(ctx2, [dirty]) { + if (dirty & /*text*/ + 1) + html_tag.p( + /*text*/ + ctx2[0] + ); + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(html_anchor); + if (detaching) + html_tag.d(); + } + }; +} +function instance$5($$self, $$props, $$invalidate) { + let { text: text2 } = $$props; + $$self.$$set = ($$props2) => { + if ("text" in $$props2) + $$invalidate(0, text2 = $$props2.text); + }; + return [text2]; +} +class Html extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$5, create_fragment$5, safe_not_equal, { text: 0 }); + } +} +function create_fragment$4(ctx) { + let blockquote; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + blockquote = element("blockquote"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + blockquote = claim_element(nodes, "BLOCKQUOTE", {}); + var blockquote_nodes = children(blockquote); + if (default_slot) + default_slot.l(blockquote_nodes); + blockquote_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, blockquote, anchor); + if (default_slot) { + default_slot.m(blockquote, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(blockquote); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$4($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class Blockquote extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$4, create_fragment$4, safe_not_equal, {}); + } +} +function create_fragment$3(ctx) { + let pre; + let code; + let t; + return { + c() { + pre = element("pre"); + code = element("code"); + t = text( + /*text*/ + ctx[1] + ); + this.h(); + }, + l(nodes) { + pre = claim_element(nodes, "PRE", { class: true }); + var pre_nodes = children(pre); + code = claim_element(pre_nodes, "CODE", {}); + var code_nodes = children(code); + t = claim_text( + code_nodes, + /*text*/ + ctx[1] + ); + code_nodes.forEach(detach); + pre_nodes.forEach(detach); + this.h(); + }, + h() { + attr( + pre, + "class", + /*lang*/ + ctx[0] + ); + }, + m(target, anchor) { + insert_hydration(target, pre, anchor); + append_hydration(pre, code); + append_hydration(code, t); + }, + p(ctx2, [dirty]) { + if (dirty & /*text*/ + 2) + set_data( + t, + /*text*/ + ctx2[1] + ); + if (dirty & /*lang*/ + 1) { + attr( + pre, + "class", + /*lang*/ + ctx2[0] + ); + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) + detach(pre); + } + }; +} +function instance$3($$self, $$props, $$invalidate) { + let { lang } = $$props; + let { text: text2 } = $$props; + $$self.$$set = ($$props2) => { + if ("lang" in $$props2) + $$invalidate(0, lang = $$props2.lang); + if ("text" in $$props2) + $$invalidate(1, text2 = $$props2.text); + }; + return [lang, text2]; +} +class Code extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$3, create_fragment$3, safe_not_equal, { lang: 0, text: 1 }); + } +} +function create_fragment$2(ctx) { + let br; + let current; + const default_slot_template = ( + /*#slots*/ + ctx[1].default + ); + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[0], + null + ); + return { + c() { + br = element("br"); + if (default_slot) + default_slot.c(); + }, + l(nodes) { + br = claim_element(nodes, "BR", {}); + if (default_slot) + default_slot.l(nodes); + }, + m(target, anchor) { + insert_hydration(target, br, anchor); + if (default_slot) { + default_slot.m(target, anchor); + } + current = true; + }, + p(ctx2, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ + 1)) { + update_slot_base( + default_slot, + default_slot_template, + ctx2, + /*$$scope*/ + ctx2[0], + !current ? get_all_dirty_from_scope( + /*$$scope*/ + ctx2[0] + ) : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx2[0], + dirty, + null + ), + null + ); + } + } + }, + i(local) { + if (current) + return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(br); + if (default_slot) + default_slot.d(detaching); + } + }; +} +function instance$2($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + $$self.$$set = ($$props2) => { + if ("$$scope" in $$props2) + $$invalidate(0, $$scope = $$props2.$$scope); + }; + return [$$scope, slots]; +} +class Br extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$2, create_fragment$2, safe_not_equal, {}); + } +} +const defaultRenderers = { + heading: Heading, + paragraph: Paragraph, + text: Text, + image: Image, + link: Link, + em: Em, + strong: Strong, + codespan: Codespan, + del: Del, + table: Table, + tablehead: TableHead, + tablebody: TableBody, + tablerow: TableRow, + tablecell: TableCell, + list: List, + orderedlistitem: null, + unorderedlistitem: null, + listitem: ListItem, + hr: Hr, + html: Html, + blockquote: Blockquote, + code: Code, + br: Br +}; +const defaultOptions = { + baseUrl: null, + breaks: false, + gfm: true, + headerIds: true, + headerPrefix: "", + highlight: null, + langPrefix: "language-", + mangle: true, + pedantic: false, + renderer: null, + sanitize: false, + sanitizer: null, + silent: false, + smartLists: false, + smartypants: false, + tokenizer: null, + xhtml: false +}; +function create_fragment$1(ctx) { + let parser; + let current; + parser = new Parser$1({ + props: { + tokens: ( + /*tokens*/ + ctx[0] + ), + renderers: ( + /*combinedRenderers*/ + ctx[1] + ) + } + }); + return { + c() { + create_component(parser.$$.fragment); + }, + l(nodes) { + claim_component(parser.$$.fragment, nodes); + }, + m(target, anchor) { + mount_component(parser, target, anchor); + current = true; + }, + p(ctx2, [dirty]) { + const parser_changes = {}; + if (dirty & /*tokens*/ + 1) + parser_changes.tokens = /*tokens*/ + ctx2[0]; + if (dirty & /*combinedRenderers*/ + 2) + parser_changes.renderers = /*combinedRenderers*/ + ctx2[1]; + parser.$set(parser_changes); + }, + i(local) { + if (current) + return; + transition_in(parser.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(parser.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(parser, detaching); + } + }; +} +function instance$1($$self, $$props, $$invalidate) { + let preprocessed; + let slugger; + let combinedOptions; + let combinedRenderers; + let { source = [] } = $$props; + let { renderers = {} } = $$props; + let { options = {} } = $$props; + let { isInline = false } = $$props; + const dispatch = createEventDispatcher(); + let tokens; + let lexer; + let mounted; + setContext(key, { + slug: (val) => slugger ? slugger.slug(val) : "", + getOptions: () => combinedOptions + }); + onMount(() => { + $$invalidate(7, mounted = true); + }); + $$self.$$set = ($$props2) => { + if ("source" in $$props2) + $$invalidate(2, source = $$props2.source); + if ("renderers" in $$props2) + $$invalidate(3, renderers = $$props2.renderers); + if ("options" in $$props2) + $$invalidate(4, options = $$props2.options); + if ("isInline" in $$props2) + $$invalidate(5, isInline = $$props2.isInline); + }; + $$self.$$.update = () => { + if ($$self.$$.dirty & /*source*/ + 4) { + $$invalidate(8, preprocessed = Array.isArray(source)); + } + if ($$self.$$.dirty & /*source*/ + 4) { + slugger = source ? new Slugger() : void 0; + } + if ($$self.$$.dirty & /*options*/ + 16) { + $$invalidate(9, combinedOptions = { ...defaultOptions, ...options }); + } + if ($$self.$$.dirty & /*preprocessed, source, combinedOptions, isInline, lexer, tokens*/ + 869) { + if (preprocessed) { + $$invalidate(0, tokens = source); + } else { + $$invalidate(6, lexer = new Lexer(combinedOptions)); + $$invalidate(0, tokens = isInline ? lexer.inlineTokens(source) : lexer.lex(source)); + dispatch("parsed", { tokens }); + } + } + if ($$self.$$.dirty & /*renderers*/ + 8) { + $$invalidate(1, combinedRenderers = { ...defaultRenderers, ...renderers }); + } + if ($$self.$$.dirty & /*mounted, preprocessed, tokens*/ + 385) { + mounted && !preprocessed && dispatch("parsed", { tokens }); + } + }; + return [ + tokens, + combinedRenderers, + source, + renderers, + options, + isInline, + lexer, + mounted, + preprocessed, + combinedOptions + ]; +} +class SvelteMarkdown extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$1, create_fragment$1, safe_not_equal, { + source: 2, + renderers: 3, + options: 4, + isInline: 5 + }); + } +} +function get_each_context(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[1] = list[i]; + return child_ctx; +} +function get_each_context_1(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[4] = list[i]; + return child_ctx; +} +function get_each_context_2(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[7] = list[i]; + return child_ctx; +} +function get_each_context_3(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[10] = list[i]; + return child_ctx; +} +function get_each_context_4(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[7] = list[i]; + return child_ctx; +} +function create_each_block_4(ctx) { + let div2; + let div0; + let t0_value = ( + /*ti*/ + ctx[7].title + "" + ); + let t0; + let t1; + let div1; + let t2; + let t3; + return { + c() { + div2 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + div1 = element("div"); + t2 = text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat."); + t3 = space(); + this.h(); + }, + l(nodes) { + div2 = claim_element(nodes, "DIV", { class: true }); + var div2_nodes = children(div2); + div0 = claim_element(div2_nodes, "DIV", { class: true }); + var div0_nodes = children(div0); + t0 = claim_text(div0_nodes, t0_value); + div0_nodes.forEach(detach); + t1 = claim_space(div2_nodes); + div1 = claim_element(div2_nodes, "DIV", { class: true }); + var div1_nodes = children(div1); + t2 = claim_text(div1_nodes, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat."); + div1_nodes.forEach(detach); + t3 = claim_space(div2_nodes); + div2_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div0, "class", "text-2xl uppercase"); + attr(div1, "class", "mt-4 text-lg"); + attr(div2, "class", "bg-[#0d1117] hover:text-black hover:bg-white px-4 py-6"); + }, + m(target, anchor) { + insert_hydration(target, div2, anchor); + append_hydration(div2, div0); + append_hydration(div0, t0); + append_hydration(div2, t1); + append_hydration(div2, div1); + append_hydration(div1, t2); + append_hydration(div2, t3); + }, + p(ctx2, dirty) { + if (dirty & /*data*/ + 1 && t0_value !== (t0_value = /*ti*/ + ctx2[7].title + "")) + set_data(t0, t0_value); + }, + d(detaching) { + if (detaching) + detach(div2); + } + }; +} +function create_if_block_1(ctx) { + let div; + let sveltemarkdown; + let current; + sveltemarkdown = new SvelteMarkdown({ props: { source: ( + /*pi*/ + ctx[10].desc + ) } }); + return { + c() { + div = element("div"); + create_component(sveltemarkdown.$$.fragment); + this.h(); + }, + l(nodes) { + div = claim_element(nodes, "DIV", { class: true }); + var div_nodes = children(div); + claim_component(sveltemarkdown.$$.fragment, div_nodes); + div_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div, "class", "mt-2 text-base description text-mild"); + }, + m(target, anchor) { + insert_hydration(target, div, anchor); + mount_component(sveltemarkdown, div, null); + current = true; + }, + p(ctx2, dirty) { + const sveltemarkdown_changes = {}; + if (dirty & /*data*/ + 1) + sveltemarkdown_changes.source = /*pi*/ + ctx2[10].desc; + sveltemarkdown.$set(sveltemarkdown_changes); + }, + i(local) { + if (current) + return; + transition_in(sveltemarkdown.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(sveltemarkdown.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(div); + destroy_component(sveltemarkdown); + } + }; +} +function create_each_block_3(ctx) { + var _a; + let tr; + let td0; + let t0_value = ( + /*pi*/ + ctx[10].time + "" + ); + let t0; + let t1; + let td1; + let div; + let t2_value = ( + /*pi*/ + ctx[10].title + "" + ); + let t2; + let t3; + let t4_value = ( + /*pi*/ + ctx[10].speakers ? "― " + /*pi*/ + ((_a = ctx[10].speakers[0]) == null ? void 0 : _a.name) : "" + ); + let t4; + let t5; + let t6; + let current; + let if_block = ( + /*pi*/ + ctx[10].desc && create_if_block_1(ctx) + ); + return { + c() { + tr = element("tr"); + td0 = element("td"); + t0 = text(t0_value); + t1 = space(); + td1 = element("td"); + div = element("div"); + t2 = text(t2_value); + t3 = space(); + t4 = text(t4_value); + t5 = space(); + if (if_block) + if_block.c(); + t6 = space(); + this.h(); + }, + l(nodes) { + tr = claim_element(nodes, "TR", { class: true }); + var tr_nodes = children(tr); + td0 = claim_element(tr_nodes, "TD", { class: true }); + var td0_nodes = children(td0); + t0 = claim_text(td0_nodes, t0_value); + td0_nodes.forEach(detach); + t1 = claim_space(tr_nodes); + td1 = claim_element(tr_nodes, "TD", { class: true }); + var td1_nodes = children(td1); + div = claim_element(td1_nodes, "DIV", { class: true }); + var div_nodes = children(div); + t2 = claim_text(div_nodes, t2_value); + t3 = claim_space(div_nodes); + t4 = claim_text(div_nodes, t4_value); + div_nodes.forEach(detach); + t5 = claim_space(td1_nodes); + if (if_block) + if_block.l(td1_nodes); + td1_nodes.forEach(detach); + t6 = claim_space(tr_nodes); + tr_nodes.forEach(detach); + this.h(); + }, + h() { + attr(td0, "class", "text-right"); + attr(div, "class", "text-xl"); + attr(td1, "class", "text-left"); + attr(tr, "class", ""); + }, + m(target, anchor) { + insert_hydration(target, tr, anchor); + append_hydration(tr, td0); + append_hydration(td0, t0); + append_hydration(tr, t1); + append_hydration(tr, td1); + append_hydration(td1, div); + append_hydration(div, t2); + append_hydration(div, t3); + append_hydration(div, t4); + append_hydration(td1, t5); + if (if_block) + if_block.m(td1, null); + append_hydration(tr, t6); + current = true; + }, + p(ctx2, dirty) { + var _a2; + if ((!current || dirty & /*data*/ + 1) && t0_value !== (t0_value = /*pi*/ + ctx2[10].time + "")) + set_data(t0, t0_value); + if ((!current || dirty & /*data*/ + 1) && t2_value !== (t2_value = /*pi*/ + ctx2[10].title + "")) + set_data(t2, t2_value); + if ((!current || dirty & /*data*/ + 1) && t4_value !== (t4_value = /*pi*/ + ctx2[10].speakers ? "― " + /*pi*/ + ((_a2 = ctx2[10].speakers[0]) == null ? void 0 : _a2.name) : "")) + set_data(t4, t4_value); + if ( + /*pi*/ + ctx2[10].desc + ) { + if (if_block) { + if_block.p(ctx2, dirty); + if (dirty & /*data*/ + 1) { + transition_in(if_block, 1); + } + } else { + if_block = create_if_block_1(ctx2); + if_block.c(); + transition_in(if_block, 1); + if_block.m(td1, null); + } + } else if (if_block) { + group_outros(); + transition_out(if_block, 1, 1, () => { + if_block = null; + }); + check_outros(); + } + }, + i(local) { + if (current) + return; + transition_in(if_block); + current = true; + }, + o(local) { + transition_out(if_block); + current = false; + }, + d(detaching) { + if (detaching) + detach(tr); + if (if_block) + if_block.d(); + } + }; +} +function create_each_block_2(ctx) { + let li; + let t_value = ( + /*ti*/ + ctx[7] + "" + ); + let t; + return { + c() { + li = element("li"); + t = text(t_value); + }, + l(nodes) { + li = claim_element(nodes, "LI", {}); + var li_nodes = children(li); + t = claim_text(li_nodes, t_value); + li_nodes.forEach(detach); + }, + m(target, anchor) { + insert_hydration(target, li, anchor); + append_hydration(li, t); + }, + p(ctx2, dirty) { + if (dirty & /*data*/ + 1 && t_value !== (t_value = /*ti*/ + ctx2[7] + "")) + set_data(t, t_value); + }, + d(detaching) { + if (detaching) + detach(li); + } + }; +} +function create_if_block(ctx) { + let div; + let t_value = ( + /*tt*/ + ctx[4].note + "" + ); + let t; + return { + c() { + div = element("div"); + t = text(t_value); + this.h(); + }, + l(nodes) { + div = claim_element(nodes, "DIV", { class: true }); + var div_nodes = children(div); + t = claim_text(div_nodes, t_value); + div_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div, "class", "mt-10 text-base"); + }, + m(target, anchor) { + insert_hydration(target, div, anchor); + append_hydration(div, t); + }, + p(ctx2, dirty) { + if (dirty & /*data*/ + 1 && t_value !== (t_value = /*tt*/ + ctx2[4].note + "")) + set_data(t, t_value); + }, + d(detaching) { + if (detaching) + detach(div); + } + }; +} +function create_each_block_1(ctx) { + let div2; + let div0; + let t0_value = ( + /*tt*/ + ctx[4].title + "" + ); + let t0; + let t1; + let div1; + let t2_value = ( + /*tt*/ + ctx[4].price + "" + ); + let t2; + let t3; + let ul; + let t4; + let t5; + let each_value_2 = ( + /*tt*/ + ctx[4].includes + ); + let each_blocks = []; + for (let i = 0; i < each_value_2.length; i += 1) { + each_blocks[i] = create_each_block_2(get_each_context_2(ctx, each_value_2, i)); + } + let if_block = ( + /*tt*/ + ctx[4].note && create_if_block(ctx) + ); + return { + c() { + div2 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + div1 = element("div"); + t2 = text(t2_value); + t3 = space(); + ul = element("ul"); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + t4 = space(); + if (if_block) + if_block.c(); + t5 = space(); + this.h(); + }, + l(nodes) { + div2 = claim_element(nodes, "DIV", { class: true }); + var div2_nodes = children(div2); + div0 = claim_element(div2_nodes, "DIV", { class: true }); + var div0_nodes = children(div0); + t0 = claim_text(div0_nodes, t0_value); + div0_nodes.forEach(detach); + t1 = claim_space(div2_nodes); + div1 = claim_element(div2_nodes, "DIV", { class: true }); + var div1_nodes = children(div1); + t2 = claim_text(div1_nodes, t2_value); + div1_nodes.forEach(detach); + t3 = claim_space(div2_nodes); + ul = claim_element(div2_nodes, "UL", { class: true }); + var ul_nodes = children(ul); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(ul_nodes); + } + ul_nodes.forEach(detach); + t4 = claim_space(div2_nodes); + if (if_block) + if_block.l(div2_nodes); + t5 = claim_space(div2_nodes); + div2_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div0, "class", "text-3xl"); + attr(div1, "class", "text-xl mt-6"); + attr(ul, "class", "mt-6 text-lg text-left list-disc px-6"); + attr(div2, "class", "bg-[#0d1117] hover:border-0 px-3 py-10 hover:text-black hover:bg-white px-10 cursor-pointer"); + }, + m(target, anchor) { + insert_hydration(target, div2, anchor); + append_hydration(div2, div0); + append_hydration(div0, t0); + append_hydration(div2, t1); + append_hydration(div2, div1); + append_hydration(div1, t2); + append_hydration(div2, t3); + append_hydration(div2, ul); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(ul, null); + } + append_hydration(div2, t4); + if (if_block) + if_block.m(div2, null); + append_hydration(div2, t5); + }, + p(ctx2, dirty) { + if (dirty & /*data*/ + 1 && t0_value !== (t0_value = /*tt*/ + ctx2[4].title + "")) + set_data(t0, t0_value); + if (dirty & /*data*/ + 1 && t2_value !== (t2_value = /*tt*/ + ctx2[4].price + "")) + set_data(t2, t2_value); + if (dirty & /*data*/ + 1) { + each_value_2 = /*tt*/ + ctx2[4].includes; + let i; + for (i = 0; i < each_value_2.length; i += 1) { + const child_ctx = get_each_context_2(ctx2, each_value_2, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + } else { + each_blocks[i] = create_each_block_2(child_ctx); + each_blocks[i].c(); + each_blocks[i].m(ul, null); + } + } + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1); + } + each_blocks.length = each_value_2.length; + } + if ( + /*tt*/ + ctx2[4].note + ) { + if (if_block) { + if_block.p(ctx2, dirty); + } else { + if_block = create_if_block(ctx2); + if_block.c(); + if_block.m(div2, t5); + } + } else if (if_block) { + if_block.d(1); + if_block = null; + } + }, + d(detaching) { + if (detaching) + detach(div2); + destroy_each(each_blocks, detaching); + if (if_block) + if_block.d(); + } + }; +} +function create_each_block(ctx) { + let div2; + let div0; + let t0_value = ( + /*fi*/ + ctx[1].title + "" + ); + let t0; + let t1; + let div1; + let sveltemarkdown; + let t2; + let current; + sveltemarkdown = new SvelteMarkdown({ props: { source: ( + /*fi*/ + ctx[1].text + ) } }); + return { + c() { + div2 = element("div"); + div0 = element("div"); + t0 = text(t0_value); + t1 = space(); + div1 = element("div"); + create_component(sveltemarkdown.$$.fragment); + t2 = space(); + this.h(); + }, + l(nodes) { + div2 = claim_element(nodes, "DIV", { class: true }); + var div2_nodes = children(div2); + div0 = claim_element(div2_nodes, "DIV", { class: true }); + var div0_nodes = children(div0); + t0 = claim_text(div0_nodes, t0_value); + div0_nodes.forEach(detach); + t1 = claim_space(div2_nodes); + div1 = claim_element(div2_nodes, "DIV", { class: true }); + var div1_nodes = children(div1); + claim_component(sveltemarkdown.$$.fragment, div1_nodes); + div1_nodes.forEach(detach); + t2 = claim_space(div2_nodes); + div2_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div0, "class", "text-2xl font-bold mb-6"); + attr(div1, "class", "text-lg markdown"); + attr(div2, "class", "py-10 px-4 hover:bg-white hover:text-black"); + }, + m(target, anchor) { + insert_hydration(target, div2, anchor); + append_hydration(div2, div0); + append_hydration(div0, t0); + append_hydration(div2, t1); + append_hydration(div2, div1); + mount_component(sveltemarkdown, div1, null); + append_hydration(div2, t2); + current = true; + }, + p(ctx2, dirty) { + if ((!current || dirty & /*data*/ + 1) && t0_value !== (t0_value = /*fi*/ + ctx2[1].title + "")) + set_data(t0, t0_value); + const sveltemarkdown_changes = {}; + if (dirty & /*data*/ + 1) + sveltemarkdown_changes.source = /*fi*/ + ctx2[1].text; + sveltemarkdown.$set(sveltemarkdown_changes); + }, + i(local) { + if (current) + return; + transition_in(sveltemarkdown.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(sveltemarkdown.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) + detach(div2); + destroy_component(sveltemarkdown); + } + }; +} +function create_fragment(ctx) { + let title_value; + let t0; + let div4; + let div3; + let div0; + let t1; + let t2; + let div1; + let t3; + let t4; + let div2; + let t5; + let div8; + let div7; + let div5; + let t6; + let t7; + let div6; + let t8; + let div11; + let div10; + let div9; + let t9; + let t10; + let table; + let thead; + let tr; + let th0; + let t11; + let t12; + let th1; + let t13; + let t14; + let tbody; + let t15; + let div14; + let div13; + let div12; + let t16; + let t17; + let div18; + let div17; + let div15; + let t18; + let t19; + let div16; + let t20; + let div22; + let div21; + let div19; + let t21; + let t22; + let div20; + let current; + document.title = title_value = /*data*/ + ctx[0].config.title + " | " + /*data*/ + ctx[0].config.date; + let each_value_4 = ( + /*data*/ + ctx[0].config.themes + ); + let each_blocks_3 = []; + for (let i = 0; i < each_value_4.length; i += 1) { + each_blocks_3[i] = create_each_block_4(get_each_context_4(ctx, each_value_4, i)); + } + let each_value_3 = ( + /*data*/ + ctx[0].config.program + ); + let each_blocks_2 = []; + for (let i = 0; i < each_value_3.length; i += 1) { + each_blocks_2[i] = create_each_block_3(get_each_context_3(ctx, each_value_3, i)); + } + const out = (i) => transition_out(each_blocks_2[i], 1, 1, () => { + each_blocks_2[i] = null; + }); + let each_value_1 = ( + /*data*/ + ctx[0].config.tickets + ); + let each_blocks_1 = []; + for (let i = 0; i < each_value_1.length; i += 1) { + each_blocks_1[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i)); + } + let each_value = ( + /*data*/ + ctx[0].config.faq + ); + let each_blocks = []; + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)); + } + const out_1 = (i) => transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null; + }); + return { + c() { + t0 = space(); + div4 = element("div"); + div3 = element("div"); + div0 = element("div"); + t1 = text("For the first time in the internet’s history, web3 has made meaningful ownership of our own data possible. DeData Salon will bring 18th Century salons up to speed, inviting leaders in the space to discuss what data ownership will mean in the Web3 economy."); + t2 = space(); + div1 = element("div"); + t3 = text("Key themes"); + t4 = space(); + div2 = element("div"); + for (let i = 0; i < each_blocks_3.length; i += 1) { + each_blocks_3[i].c(); + } + t5 = space(); + div8 = element("div"); + div7 = element("div"); + div5 = element("div"); + t6 = text("Speakers"); + t7 = space(); + div6 = element("div"); + t8 = space(); + div11 = element("div"); + div10 = element("div"); + div9 = element("div"); + t9 = text("Program"); + t10 = space(); + table = element("table"); + thead = element("thead"); + tr = element("tr"); + th0 = element("th"); + t11 = text("time"); + t12 = space(); + th1 = element("th"); + t13 = text("topic"); + t14 = space(); + tbody = element("tbody"); + for (let i = 0; i < each_blocks_2.length; i += 1) { + each_blocks_2[i].c(); + } + t15 = space(); + div14 = element("div"); + div13 = element("div"); + div12 = element("div"); + t16 = text("Sponsors"); + t17 = space(); + div18 = element("div"); + div17 = element("div"); + div15 = element("div"); + t18 = text("Ticket"); + t19 = space(); + div16 = element("div"); + for (let i = 0; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].c(); + } + t20 = space(); + div22 = element("div"); + div21 = element("div"); + div19 = element("div"); + t21 = text("FAQ"); + t22 = space(); + div20 = element("div"); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + this.h(); + }, + l(nodes) { + const head_nodes = head_selector("svelte-a0ctph", document.head); + head_nodes.forEach(detach); + t0 = claim_space(nodes); + div4 = claim_element(nodes, "DIV", { class: true, id: true }); + var div4_nodes = children(div4); + div3 = claim_element(div4_nodes, "DIV", { class: true }); + var div3_nodes = children(div3); + div0 = claim_element(div3_nodes, "DIV", { class: true }); + var div0_nodes = children(div0); + t1 = claim_text(div0_nodes, "For the first time in the internet’s history, web3 has made meaningful ownership of our own data possible. DeData Salon will bring 18th Century salons up to speed, inviting leaders in the space to discuss what data ownership will mean in the Web3 economy."); + div0_nodes.forEach(detach); + t2 = claim_space(div3_nodes); + div1 = claim_element(div3_nodes, "DIV", { class: true }); + var div1_nodes = children(div1); + t3 = claim_text(div1_nodes, "Key themes"); + div1_nodes.forEach(detach); + t4 = claim_space(div3_nodes); + div2 = claim_element(div3_nodes, "DIV", { class: true }); + var div2_nodes = children(div2); + for (let i = 0; i < each_blocks_3.length; i += 1) { + each_blocks_3[i].l(div2_nodes); + } + div2_nodes.forEach(detach); + div3_nodes.forEach(detach); + div4_nodes.forEach(detach); + t5 = claim_space(nodes); + div8 = claim_element(nodes, "DIV", { class: true, id: true }); + var div8_nodes = children(div8); + div7 = claim_element(div8_nodes, "DIV", { class: true }); + var div7_nodes = children(div7); + div5 = claim_element(div7_nodes, "DIV", { class: true }); + var div5_nodes = children(div5); + t6 = claim_text(div5_nodes, "Speakers"); + div5_nodes.forEach(detach); + t7 = claim_space(div7_nodes); + div6 = claim_element(div7_nodes, "DIV", { class: true }); + children(div6).forEach(detach); + div7_nodes.forEach(detach); + div8_nodes.forEach(detach); + t8 = claim_space(nodes); + div11 = claim_element(nodes, "DIV", { class: true, id: true }); + var div11_nodes = children(div11); + div10 = claim_element(div11_nodes, "DIV", { class: true }); + var div10_nodes = children(div10); + div9 = claim_element(div10_nodes, "DIV", { class: true }); + var div9_nodes = children(div9); + t9 = claim_text(div9_nodes, "Program"); + div9_nodes.forEach(detach); + t10 = claim_space(div10_nodes); + table = claim_element(div10_nodes, "TABLE", { class: true }); + var table_nodes = children(table); + thead = claim_element(table_nodes, "THEAD", {}); + var thead_nodes = children(thead); + tr = claim_element(thead_nodes, "TR", {}); + var tr_nodes = children(tr); + th0 = claim_element(tr_nodes, "TH", { class: true }); + var th0_nodes = children(th0); + t11 = claim_text(th0_nodes, "time"); + th0_nodes.forEach(detach); + t12 = claim_space(tr_nodes); + th1 = claim_element(tr_nodes, "TH", { class: true }); + var th1_nodes = children(th1); + t13 = claim_text(th1_nodes, "topic"); + th1_nodes.forEach(detach); + tr_nodes.forEach(detach); + thead_nodes.forEach(detach); + t14 = claim_space(table_nodes); + tbody = claim_element(table_nodes, "TBODY", {}); + var tbody_nodes = children(tbody); + for (let i = 0; i < each_blocks_2.length; i += 1) { + each_blocks_2[i].l(tbody_nodes); + } + tbody_nodes.forEach(detach); + table_nodes.forEach(detach); + div10_nodes.forEach(detach); + div11_nodes.forEach(detach); + t15 = claim_space(nodes); + div14 = claim_element(nodes, "DIV", { class: true, id: true }); + var div14_nodes = children(div14); + div13 = claim_element(div14_nodes, "DIV", { class: true }); + var div13_nodes = children(div13); + div12 = claim_element(div13_nodes, "DIV", { class: true }); + var div12_nodes = children(div12); + t16 = claim_text(div12_nodes, "Sponsors"); + div12_nodes.forEach(detach); + div13_nodes.forEach(detach); + div14_nodes.forEach(detach); + t17 = claim_space(nodes); + div18 = claim_element(nodes, "DIV", { class: true, id: true }); + var div18_nodes = children(div18); + div17 = claim_element(div18_nodes, "DIV", { class: true }); + var div17_nodes = children(div17); + div15 = claim_element(div17_nodes, "DIV", { class: true }); + var div15_nodes = children(div15); + t18 = claim_text(div15_nodes, "Ticket"); + div15_nodes.forEach(detach); + t19 = claim_space(div17_nodes); + div16 = claim_element(div17_nodes, "DIV", { class: true }); + var div16_nodes = children(div16); + for (let i = 0; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].l(div16_nodes); + } + div16_nodes.forEach(detach); + div17_nodes.forEach(detach); + div18_nodes.forEach(detach); + t20 = claim_space(nodes); + div22 = claim_element(nodes, "DIV", { class: true, id: true }); + var div22_nodes = children(div22); + div21 = claim_element(div22_nodes, "DIV", { class: true }); + var div21_nodes = children(div21); + div19 = claim_element(div21_nodes, "DIV", { class: true }); + var div19_nodes = children(div19); + t21 = claim_text(div19_nodes, "FAQ"); + div19_nodes.forEach(detach); + t22 = claim_space(div21_nodes); + div20 = claim_element(div21_nodes, "DIV", { class: true }); + var div20_nodes = children(div20); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].l(div20_nodes); + } + div20_nodes.forEach(detach); + div21_nodes.forEach(detach); + div22_nodes.forEach(detach); + this.h(); + }, + h() { + attr(div0, "class", "py-32 w-1/2 mx-auto"); + attr(div1, "class", "section-header"); + attr(div2, "class", "grid grid-cols-3 gap-10"); + attr(div3, "class", "middle-pane-medium pb-20 text-xl text-center mx-auto"); + attr(div4, "class", "bg-black"); + attr(div4, "id", "about"); + attr(div5, "class", "section-header"); + attr(div6, "class", "h-screen"); + attr(div7, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); + attr(div8, "class", ""); + attr(div8, "id", "speakers"); + attr(div9, "class", "section-header"); + attr(th0, "class", "text-right"); + attr(th1, "class", "text-left"); + attr(table, "class", "table-auto table-custom w-full"); + attr(div10, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto pb-32"); + attr(div11, "class", "bg-black"); + attr(div11, "id", "program"); + attr(div12, "class", "section-header"); + attr(div13, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto pb-32"); + attr(div14, "class", ""); + attr(div14, "id", "sponsors"); + attr(div15, "class", "section-header"); + attr(div16, "class", "grid grid-cols-2 gap-10 w-2/3 mx-auto"); + attr(div17, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto pb-32"); + attr(div18, "class", "bg-black"); + attr(div18, "id", "ticket"); + attr(div19, "class", "section-header"); + attr(div20, "class", "grid grid-cols-2 gap-10"); + attr(div21, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); + attr(div22, "class", "mb-36"); + attr(div22, "id", "faq"); + }, + m(target, anchor) { + insert_hydration(target, t0, anchor); + insert_hydration(target, div4, anchor); + append_hydration(div4, div3); + append_hydration(div3, div0); + append_hydration(div0, t1); + append_hydration(div3, t2); + append_hydration(div3, div1); + append_hydration(div1, t3); + append_hydration(div3, t4); + append_hydration(div3, div2); + for (let i = 0; i < each_blocks_3.length; i += 1) { + each_blocks_3[i].m(div2, null); + } + insert_hydration(target, t5, anchor); + insert_hydration(target, div8, anchor); + append_hydration(div8, div7); + append_hydration(div7, div5); + append_hydration(div5, t6); + append_hydration(div7, t7); + append_hydration(div7, div6); + insert_hydration(target, t8, anchor); + insert_hydration(target, div11, anchor); + append_hydration(div11, div10); + append_hydration(div10, div9); + append_hydration(div9, t9); + append_hydration(div10, t10); + append_hydration(div10, table); + append_hydration(table, thead); + append_hydration(thead, tr); + append_hydration(tr, th0); + append_hydration(th0, t11); + append_hydration(tr, t12); + append_hydration(tr, th1); + append_hydration(th1, t13); + append_hydration(table, t14); + append_hydration(table, tbody); + for (let i = 0; i < each_blocks_2.length; i += 1) { + each_blocks_2[i].m(tbody, null); + } + insert_hydration(target, t15, anchor); + insert_hydration(target, div14, anchor); + append_hydration(div14, div13); + append_hydration(div13, div12); + append_hydration(div12, t16); + insert_hydration(target, t17, anchor); + insert_hydration(target, div18, anchor); + append_hydration(div18, div17); + append_hydration(div17, div15); + append_hydration(div15, t18); + append_hydration(div17, t19); + append_hydration(div17, div16); + for (let i = 0; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].m(div16, null); + } + insert_hydration(target, t20, anchor); + insert_hydration(target, div22, anchor); + append_hydration(div22, div21); + append_hydration(div21, div19); + append_hydration(div19, t21); + append_hydration(div21, t22); + append_hydration(div21, div20); + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(div20, null); + } + current = true; + }, + p(ctx2, [dirty]) { + if ((!current || dirty & /*data*/ + 1) && title_value !== (title_value = /*data*/ + ctx2[0].config.title + " | " + /*data*/ + ctx2[0].config.date)) { + document.title = title_value; + } + if (dirty & /*data*/ + 1) { + each_value_4 = /*data*/ + ctx2[0].config.themes; + let i; + for (i = 0; i < each_value_4.length; i += 1) { + const child_ctx = get_each_context_4(ctx2, each_value_4, i); + if (each_blocks_3[i]) { + each_blocks_3[i].p(child_ctx, dirty); + } else { + each_blocks_3[i] = create_each_block_4(child_ctx); + each_blocks_3[i].c(); + each_blocks_3[i].m(div2, null); + } + } + for (; i < each_blocks_3.length; i += 1) { + each_blocks_3[i].d(1); + } + each_blocks_3.length = each_value_4.length; + } + if (dirty & /*data*/ + 1) { + each_value_3 = /*data*/ + ctx2[0].config.program; + let i; + for (i = 0; i < each_value_3.length; i += 1) { + const child_ctx = get_each_context_3(ctx2, each_value_3, i); + if (each_blocks_2[i]) { + each_blocks_2[i].p(child_ctx, dirty); + transition_in(each_blocks_2[i], 1); + } else { + each_blocks_2[i] = create_each_block_3(child_ctx); + each_blocks_2[i].c(); + transition_in(each_blocks_2[i], 1); + each_blocks_2[i].m(tbody, null); + } + } + group_outros(); + for (i = each_value_3.length; i < each_blocks_2.length; i += 1) { + out(i); + } + check_outros(); + } + if (dirty & /*data*/ + 1) { + each_value_1 = /*data*/ + ctx2[0].config.tickets; + let i; + for (i = 0; i < each_value_1.length; i += 1) { + const child_ctx = get_each_context_1(ctx2, each_value_1, i); + if (each_blocks_1[i]) { + each_blocks_1[i].p(child_ctx, dirty); + } else { + each_blocks_1[i] = create_each_block_1(child_ctx); + each_blocks_1[i].c(); + each_blocks_1[i].m(div16, null); + } + } + for (; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].d(1); + } + each_blocks_1.length = each_value_1.length; + } + if (dirty & /*data*/ + 1) { + each_value = /*data*/ + ctx2[0].config.faq; + let i; + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context(ctx2, each_value, i); + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + transition_in(each_blocks[i], 1); + } else { + each_blocks[i] = create_each_block(child_ctx); + each_blocks[i].c(); + transition_in(each_blocks[i], 1); + each_blocks[i].m(div20, null); + } + } + group_outros(); + for (i = each_value.length; i < each_blocks.length; i += 1) { + out_1(i); + } + check_outros(); + } + }, + i(local) { + if (current) + return; + for (let i = 0; i < each_value_3.length; i += 1) { + transition_in(each_blocks_2[i]); + } + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]); + } + current = true; + }, + o(local) { + each_blocks_2 = each_blocks_2.filter(Boolean); + for (let i = 0; i < each_blocks_2.length; i += 1) { + transition_out(each_blocks_2[i]); + } + each_blocks = each_blocks.filter(Boolean); + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]); + } + current = false; + }, + d(detaching) { + if (detaching) + detach(t0); + if (detaching) + detach(div4); + destroy_each(each_blocks_3, detaching); + if (detaching) + detach(t5); + if (detaching) + detach(div8); + if (detaching) + detach(t8); + if (detaching) + detach(div11); + destroy_each(each_blocks_2, detaching); + if (detaching) + detach(t15); + if (detaching) + detach(div14); + if (detaching) + detach(t17); + if (detaching) + detach(div18); + destroy_each(each_blocks_1, detaching); + if (detaching) + detach(t20); + if (detaching) + detach(div22); + destroy_each(each_blocks, detaching); + } + }; +} +function instance($$self, $$props, $$invalidate) { + let { data } = $$props; + $$self.$$set = ($$props2) => { + if ("data" in $$props2) + $$invalidate(0, data = $$props2.data); + }; + return [data]; +} +class Page extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance, create_fragment, safe_not_equal, { data: 0 }); + } +} +export { + Page as default +}; diff --git a/_app/immutable/components/pages/_page.svelte-d2237dc8.js b/_app/immutable/components/pages/_page.svelte-d2237dc8.js deleted file mode 100644 index f415a8f..0000000 --- a/_app/immutable/components/pages/_page.svelte-d2237dc8.js +++ /dev/null @@ -1,468 +0,0 @@ -import { S as SvelteComponent, i as init, s as safe_not_equal, a as space, k as element, q as text, N as head_selector, h as detach, c as claim_space, l as claim_element, m as children, r as claim_text, n as attr, b as insert_hydration, H as append_hydration, C as noop, L as destroy_each, u as set_data } from "../../chunks/index-dc145a1c.js"; -function get_each_context(ctx, list, i) { - const child_ctx = ctx.slice(); - child_ctx[1] = list[i]; - return child_ctx; -} -function get_each_context_1(ctx, list, i) { - const child_ctx = ctx.slice(); - child_ctx[4] = list[i]; - return child_ctx; -} -function create_each_block_1(ctx) { - let div2; - let div0; - let t0_value = ( - /*ti*/ - ctx[4].title + "" - ); - let t0; - let t1; - let div1; - let t2; - let t3; - return { - c() { - div2 = element("div"); - div0 = element("div"); - t0 = text(t0_value); - t1 = space(); - div1 = element("div"); - t2 = text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat."); - t3 = space(); - this.h(); - }, - l(nodes) { - div2 = claim_element(nodes, "DIV", { class: true }); - var div2_nodes = children(div2); - div0 = claim_element(div2_nodes, "DIV", { class: true }); - var div0_nodes = children(div0); - t0 = claim_text(div0_nodes, t0_value); - div0_nodes.forEach(detach); - t1 = claim_space(div2_nodes); - div1 = claim_element(div2_nodes, "DIV", { class: true }); - var div1_nodes = children(div1); - t2 = claim_text(div1_nodes, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat."); - div1_nodes.forEach(detach); - t3 = claim_space(div2_nodes); - div2_nodes.forEach(detach); - this.h(); - }, - h() { - attr(div0, "class", "text-2xl uppercase"); - attr(div1, "class", "mt-4 text-lg"); - attr(div2, "class", "bg-[#0d1117] hover:text-black hover:bg-white px-4 py-6 cursor-pointer"); - }, - m(target, anchor) { - insert_hydration(target, div2, anchor); - append_hydration(div2, div0); - append_hydration(div0, t0); - append_hydration(div2, t1); - append_hydration(div2, div1); - append_hydration(div1, t2); - append_hydration(div2, t3); - }, - p(ctx2, dirty) { - if (dirty & /*data*/ - 1 && t0_value !== (t0_value = /*ti*/ - ctx2[4].title + "")) - set_data(t0, t0_value); - }, - d(detaching) { - if (detaching) - detach(div2); - } - }; -} -function create_each_block(ctx) { - let div1; - let div0; - let t0_value = ( - /*tt*/ - ctx[1].title + "" - ); - let t0; - let t1; - return { - c() { - div1 = element("div"); - div0 = element("div"); - t0 = text(t0_value); - t1 = space(); - this.h(); - }, - l(nodes) { - div1 = claim_element(nodes, "DIV", { class: true }); - var div1_nodes = children(div1); - div0 = claim_element(div1_nodes, "DIV", { class: true }); - var div0_nodes = children(div0); - t0 = claim_text(div0_nodes, t0_value); - div0_nodes.forEach(detach); - t1 = claim_space(div1_nodes); - div1_nodes.forEach(detach); - this.h(); - }, - h() { - attr(div0, "class", "text-2xl"); - attr(div1, "class", "border px-3 py-10"); - }, - m(target, anchor) { - insert_hydration(target, div1, anchor); - append_hydration(div1, div0); - append_hydration(div0, t0); - append_hydration(div1, t1); - }, - p(ctx2, dirty) { - if (dirty & /*data*/ - 1 && t0_value !== (t0_value = /*tt*/ - ctx2[1].title + "")) - set_data(t0, t0_value); - }, - d(detaching) { - if (detaching) - detach(div1); - } - }; -} -function create_fragment(ctx) { - let title_value; - let t0; - let div4; - let div3; - let div0; - let t1; - let t2; - let div1; - let t3; - let t4; - let div2; - let t5; - let div8; - let div7; - let div5; - let t6; - let t7; - let div6; - let t8; - let div11; - let div10; - let div9; - let t9; - let t10; - let div14; - let div13; - let div12; - let t11; - let t12; - let div18; - let div17; - let div15; - let t13; - let t14; - let div16; - document.title = title_value = /*data*/ - ctx[0].config.title + " | " + /*data*/ - ctx[0].config.date; - let each_value_1 = ( - /*data*/ - ctx[0].config.themes - ); - let each_blocks_1 = []; - for (let i = 0; i < each_value_1.length; i += 1) { - each_blocks_1[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i)); - } - let each_value = ( - /*data*/ - ctx[0].config.tickets - ); - let each_blocks = []; - for (let i = 0; i < each_value.length; i += 1) { - each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)); - } - return { - c() { - t0 = space(); - div4 = element("div"); - div3 = element("div"); - div0 = element("div"); - t1 = text("For the first time in the internet’s history, web3 has made meaningful ownership of our own data possible. DeData Salon will bring 18th Century salons up to speed, inviting leaders in the space to discuss what data ownership will mean in the Web3 economy."); - t2 = space(); - div1 = element("div"); - t3 = text("Key themes"); - t4 = space(); - div2 = element("div"); - for (let i = 0; i < each_blocks_1.length; i += 1) { - each_blocks_1[i].c(); - } - t5 = space(); - div8 = element("div"); - div7 = element("div"); - div5 = element("div"); - t6 = text("Speakers"); - t7 = space(); - div6 = element("div"); - t8 = space(); - div11 = element("div"); - div10 = element("div"); - div9 = element("div"); - t9 = text("Program"); - t10 = space(); - div14 = element("div"); - div13 = element("div"); - div12 = element("div"); - t11 = text("Sponsors"); - t12 = space(); - div18 = element("div"); - div17 = element("div"); - div15 = element("div"); - t13 = text("Ticket"); - t14 = space(); - div16 = element("div"); - for (let i = 0; i < each_blocks.length; i += 1) { - each_blocks[i].c(); - } - this.h(); - }, - l(nodes) { - const head_nodes = head_selector("svelte-a0ctph", document.head); - head_nodes.forEach(detach); - t0 = claim_space(nodes); - div4 = claim_element(nodes, "DIV", { class: true, id: true }); - var div4_nodes = children(div4); - div3 = claim_element(div4_nodes, "DIV", { class: true }); - var div3_nodes = children(div3); - div0 = claim_element(div3_nodes, "DIV", { class: true }); - var div0_nodes = children(div0); - t1 = claim_text(div0_nodes, "For the first time in the internet’s history, web3 has made meaningful ownership of our own data possible. DeData Salon will bring 18th Century salons up to speed, inviting leaders in the space to discuss what data ownership will mean in the Web3 economy."); - div0_nodes.forEach(detach); - t2 = claim_space(div3_nodes); - div1 = claim_element(div3_nodes, "DIV", { class: true }); - var div1_nodes = children(div1); - t3 = claim_text(div1_nodes, "Key themes"); - div1_nodes.forEach(detach); - t4 = claim_space(div3_nodes); - div2 = claim_element(div3_nodes, "DIV", { class: true }); - var div2_nodes = children(div2); - for (let i = 0; i < each_blocks_1.length; i += 1) { - each_blocks_1[i].l(div2_nodes); - } - div2_nodes.forEach(detach); - div3_nodes.forEach(detach); - div4_nodes.forEach(detach); - t5 = claim_space(nodes); - div8 = claim_element(nodes, "DIV", { class: true, id: true }); - var div8_nodes = children(div8); - div7 = claim_element(div8_nodes, "DIV", { class: true }); - var div7_nodes = children(div7); - div5 = claim_element(div7_nodes, "DIV", { class: true }); - var div5_nodes = children(div5); - t6 = claim_text(div5_nodes, "Speakers"); - div5_nodes.forEach(detach); - t7 = claim_space(div7_nodes); - div6 = claim_element(div7_nodes, "DIV", { class: true }); - children(div6).forEach(detach); - div7_nodes.forEach(detach); - div8_nodes.forEach(detach); - t8 = claim_space(nodes); - div11 = claim_element(nodes, "DIV", { class: true, id: true }); - var div11_nodes = children(div11); - div10 = claim_element(div11_nodes, "DIV", { class: true }); - var div10_nodes = children(div10); - div9 = claim_element(div10_nodes, "DIV", { class: true }); - var div9_nodes = children(div9); - t9 = claim_text(div9_nodes, "Program"); - div9_nodes.forEach(detach); - div10_nodes.forEach(detach); - div11_nodes.forEach(detach); - t10 = claim_space(nodes); - div14 = claim_element(nodes, "DIV", { class: true, id: true }); - var div14_nodes = children(div14); - div13 = claim_element(div14_nodes, "DIV", { class: true }); - var div13_nodes = children(div13); - div12 = claim_element(div13_nodes, "DIV", { class: true }); - var div12_nodes = children(div12); - t11 = claim_text(div12_nodes, "Sponsors"); - div12_nodes.forEach(detach); - div13_nodes.forEach(detach); - div14_nodes.forEach(detach); - t12 = claim_space(nodes); - div18 = claim_element(nodes, "DIV", { class: true, id: true }); - var div18_nodes = children(div18); - div17 = claim_element(div18_nodes, "DIV", { class: true }); - var div17_nodes = children(div17); - div15 = claim_element(div17_nodes, "DIV", { class: true }); - var div15_nodes = children(div15); - t13 = claim_text(div15_nodes, "Ticket"); - div15_nodes.forEach(detach); - t14 = claim_space(div17_nodes); - div16 = claim_element(div17_nodes, "DIV", { class: true }); - var div16_nodes = children(div16); - for (let i = 0; i < each_blocks.length; i += 1) { - each_blocks[i].l(div16_nodes); - } - div16_nodes.forEach(detach); - div17_nodes.forEach(detach); - div18_nodes.forEach(detach); - this.h(); - }, - h() { - attr(div0, "class", "py-32 w-1/2 mx-auto"); - attr(div1, "class", "section-header"); - attr(div2, "class", "grid grid-cols-3 gap-10"); - attr(div3, "class", "middle-pane-medium pb-20 text-xl text-center mx-auto"); - attr(div4, "class", "bg-black"); - attr(div4, "id", "about"); - attr(div5, "class", "section-header"); - attr(div6, "class", "h-screen"); - attr(div7, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); - attr(div8, "class", ""); - attr(div8, "id", "speakers"); - attr(div9, "class", "section-header"); - attr(div10, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); - attr(div11, "class", ""); - attr(div11, "id", "program"); - attr(div12, "class", "section-header"); - attr(div13, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); - attr(div14, "class", ""); - attr(div14, "id", "sponsors"); - attr(div15, "class", "section-header"); - attr(div16, "class", "grid grid-cols-2 mb-48 gap-10 w-2/3 mx-auto"); - attr(div17, "class", "middle-pane-medium pt-20 text-xl text-center mx-auto"); - attr(div18, "class", ""); - attr(div18, "id", "ticket"); - }, - m(target, anchor) { - insert_hydration(target, t0, anchor); - insert_hydration(target, div4, anchor); - append_hydration(div4, div3); - append_hydration(div3, div0); - append_hydration(div0, t1); - append_hydration(div3, t2); - append_hydration(div3, div1); - append_hydration(div1, t3); - append_hydration(div3, t4); - append_hydration(div3, div2); - for (let i = 0; i < each_blocks_1.length; i += 1) { - each_blocks_1[i].m(div2, null); - } - insert_hydration(target, t5, anchor); - insert_hydration(target, div8, anchor); - append_hydration(div8, div7); - append_hydration(div7, div5); - append_hydration(div5, t6); - append_hydration(div7, t7); - append_hydration(div7, div6); - insert_hydration(target, t8, anchor); - insert_hydration(target, div11, anchor); - append_hydration(div11, div10); - append_hydration(div10, div9); - append_hydration(div9, t9); - insert_hydration(target, t10, anchor); - insert_hydration(target, div14, anchor); - append_hydration(div14, div13); - append_hydration(div13, div12); - append_hydration(div12, t11); - insert_hydration(target, t12, anchor); - insert_hydration(target, div18, anchor); - append_hydration(div18, div17); - append_hydration(div17, div15); - append_hydration(div15, t13); - append_hydration(div17, t14); - append_hydration(div17, div16); - for (let i = 0; i < each_blocks.length; i += 1) { - each_blocks[i].m(div16, null); - } - }, - p(ctx2, [dirty]) { - if (dirty & /*data*/ - 1 && title_value !== (title_value = /*data*/ - ctx2[0].config.title + " | " + /*data*/ - ctx2[0].config.date)) { - document.title = title_value; - } - if (dirty & /*data*/ - 1) { - each_value_1 = /*data*/ - ctx2[0].config.themes; - let i; - for (i = 0; i < each_value_1.length; i += 1) { - const child_ctx = get_each_context_1(ctx2, each_value_1, i); - if (each_blocks_1[i]) { - each_blocks_1[i].p(child_ctx, dirty); - } else { - each_blocks_1[i] = create_each_block_1(child_ctx); - each_blocks_1[i].c(); - each_blocks_1[i].m(div2, null); - } - } - for (; i < each_blocks_1.length; i += 1) { - each_blocks_1[i].d(1); - } - each_blocks_1.length = each_value_1.length; - } - if (dirty & /*data*/ - 1) { - each_value = /*data*/ - ctx2[0].config.tickets; - let i; - for (i = 0; i < each_value.length; i += 1) { - const child_ctx = get_each_context(ctx2, each_value, i); - if (each_blocks[i]) { - each_blocks[i].p(child_ctx, dirty); - } else { - each_blocks[i] = create_each_block(child_ctx); - each_blocks[i].c(); - each_blocks[i].m(div16, null); - } - } - for (; i < each_blocks.length; i += 1) { - each_blocks[i].d(1); - } - each_blocks.length = each_value.length; - } - }, - i: noop, - o: noop, - d(detaching) { - if (detaching) - detach(t0); - if (detaching) - detach(div4); - destroy_each(each_blocks_1, detaching); - if (detaching) - detach(t5); - if (detaching) - detach(div8); - if (detaching) - detach(t8); - if (detaching) - detach(div11); - if (detaching) - detach(t10); - if (detaching) - detach(div14); - if (detaching) - detach(t12); - if (detaching) - detach(div18); - destroy_each(each_blocks, detaching); - } - }; -} -function instance($$self, $$props, $$invalidate) { - let { data } = $$props; - $$self.$$set = ($$props2) => { - if ("data" in $$props2) - $$invalidate(0, data = $$props2.data); - }; - return [data]; -} -class Page extends SvelteComponent { - constructor(options) { - super(); - init(this, options, instance, create_fragment, safe_not_equal, { data: 0 }); - } -} -export { - Page as default -}; diff --git a/_app/immutable/modules/pages/_layout.js-7c44c194.js b/_app/immutable/modules/pages/_layout.js-7c44c194.js new file mode 100644 index 0000000..6adf020 --- /dev/null +++ b/_app/immutable/modules/pages/_layout.js-7c44c194.js @@ -0,0 +1,4 @@ +import { l } from "../../chunks/_layout-1187a9e2.js"; +export { + l as load +}; diff --git a/_app/immutable/modules/pages/_layout.js-8202dbd8.js b/_app/immutable/modules/pages/_layout.js-8202dbd8.js deleted file mode 100644 index ed41837..0000000 --- a/_app/immutable/modules/pages/_layout.js-8202dbd8.js +++ /dev/null @@ -1,4 +0,0 @@ -import { l } from "../../chunks/_layout-f7327cba.js"; -export { - l as load -}; diff --git a/_app/immutable/start-f0507d42.js b/_app/immutable/start-8808e009.js similarity index 98% rename from _app/immutable/start-f0507d42.js rename to _app/immutable/start-8808e009.js index bf340c7..e5b6d7c 100644 --- a/_app/immutable/start-f0507d42.js +++ b/_app/immutable/start-8808e009.js @@ -1,5 +1,5 @@ -import { S as SvelteComponent, i as init, s as safe_not_equal, a as space, e as empty, c as claim_space, b as insert_hydration, g as group_outros, t as transition_out, d as check_outros, f as transition_in, h as detach, j as afterUpdate, o as onMount, k as element, l as claim_element, m as children, n as attr, p as set_style, q as text, r as claim_text, u as set_data, v as binding_callbacks, w as construct_svelte_component, x as create_component, y as claim_component, z as mount_component, A as destroy_component, B as tick } from "./chunks/index-dc145a1c.js"; -import { S as SCROLL_KEY, a as SNAPSHOT_KEY, I as INDEX_KEY, g as get_base_uri, f as find_anchor, b as get_link_info, c as get_router_options, s as stores, i as is_external_url, d as scroll_state, e as base, P as PRELOAD_PRIORITIES, h as init$1, j as set_assets, k as set_version } from "./chunks/singletons-57b7ce3e.js"; +import { S as SvelteComponent, i as init, s as safe_not_equal, a as space, e as empty, c as claim_space, b as insert_hydration, g as group_outros, t as transition_out, d as check_outros, f as transition_in, h as detach, j as afterUpdate, o as onMount, k as element, l as claim_element, m as children, n as attr, p as set_style, q as text, r as claim_text, u as set_data, v as binding_callbacks, w as construct_svelte_component, x as create_component, y as claim_component, z as mount_component, A as destroy_component, B as tick } from "./chunks/index-a17c58e1.js"; +import { S as SCROLL_KEY, a as SNAPSHOT_KEY, I as INDEX_KEY, g as get_base_uri, f as find_anchor, b as get_link_info, c as get_router_options, s as stores, i as is_external_url, d as scroll_state, e as base, P as PRELOAD_PRIORITIES, h as init$1, j as set_assets, k as set_version } from "./chunks/singletons-34f1d235.js"; function normalize_path(path, trailing_slash) { if (path === "/" || trailing_slash === "ignore") return path; @@ -900,9 +900,9 @@ const __vitePreload = function preload(baseModule, deps, importerUrl) { }; const matchers = {}; const nodes = [ - () => __vitePreload(() => import("./chunks/0-29f0da6c.js"), true ? ["./chunks/0-29f0da6c.js","./chunks/_layout-f7327cba.js","./components/pages/_layout.svelte-ea2e7f73.js","./chunks/index-dc145a1c.js","./assets/_layout-2e854d4e.css"] : void 0, import.meta.url), - () => __vitePreload(() => import("./chunks/1-1cedc3a7.js"), true ? ["./chunks/1-1cedc3a7.js","./components/error.svelte-63d63419.js","./chunks/index-dc145a1c.js","./chunks/singletons-57b7ce3e.js"] : void 0, import.meta.url), - () => __vitePreload(() => import("./chunks/2-cb606a98.js"), true ? ["./chunks/2-cb606a98.js","./components/pages/_page.svelte-d2237dc8.js","./chunks/index-dc145a1c.js"] : void 0, import.meta.url) + () => __vitePreload(() => import("./chunks/0-ef72d454.js"), true ? ["./chunks/0-ef72d454.js","./chunks/_layout-1187a9e2.js","./components/pages/_layout.svelte-3137396c.js","./chunks/index-a17c58e1.js","./assets/_layout-594d971c.css"] : void 0, import.meta.url), + () => __vitePreload(() => import("./chunks/1-1568ac60.js"), true ? ["./chunks/1-1568ac60.js","./components/error.svelte-999441bb.js","./chunks/index-a17c58e1.js","./chunks/singletons-34f1d235.js"] : void 0, import.meta.url), + () => __vitePreload(() => import("./chunks/2-9f7ee5b3.js"), true ? ["./chunks/2-9f7ee5b3.js","./components/pages/_page.svelte-9806a2aa.js","./chunks/index-a17c58e1.js"] : void 0, import.meta.url) ]; const server_loads = []; const dictionary = { diff --git a/_app/version.json b/_app/version.json index 8035a11..e4ab4f4 100644 --- a/_app/version.json +++ b/_app/version.json @@ -1 +1 @@ -{"version":"1676151338660"} \ No newline at end of file +{"version":"1676160493015"} \ No newline at end of file diff --git a/index.html b/index.html index f46d697..a4fff84 100644 --- a/index.html +++ b/index.html @@ -5,14 +5,14 @@ - - - - - - - - Web3Privacy Prague 2023 | Monday, 5. June 2023 + + + + + + + + Web3Privacy Prague 2023 | Monday, 5. June 2023
    @@ -24,7 +24,7 @@
    Web3Privacy Summit
    Monday, 5. June 2023
    X10, Prague
    -

    Diving into the culture of the Web3 privacy industry

    +

    Diving into the culture of the Web3 privacy industry

    Prague Blockchain Week 2023

    @@ -32,59 +32,120 @@
    For the first time in the internet’s history, web3 has made meaningful ownership of our own data possible. DeData Salon will bring 18th Century salons up to speed, inviting leaders in the space to discuss what data ownership will mean in the Web3 economy.
    Key themes
    -
    Human rights DAOs (pro-privacy)
    +
    Human rights DAOs (pro-privacy)
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Identity (ID)
    +
    Identity (ID)
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Mixnets → Full-Stack Privacy
    +
    Mixnets → Full-Stack Privacy
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Cryptography
    +
    Cryptography
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Tech journalists
    +
    Tech journalists
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Asian community
    +
    Asian community
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Privacy wars
    +
    Privacy wars
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Privacy workforce
    +
    Privacy workforce
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Privacy activist's
    +
    Privacy activist's
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    R&D (ZK, MPC)
    +
    R&D (ZK, MPC)
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Network states (with a privacy focus)
    +
    Network states (with a privacy focus)
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Solarpunk vs Lunarpunk
    +
    Solarpunk vs Lunarpunk
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    -
    Veksl
    +
    Veksl
    Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras interdum tincidunt eros eu malesuada. Vivamus in urna at ex dictum pretium quis a erat.
    Speakers
    -
    Program
    +
    Program
    + + + + + + + + + + + + + + + + + + + + + + + + + + +
    timetopic
    9:00 - 9:30
    Registration & networking
    +
    9:30 - 9:35
    Welcome to Web3Privacy ― TBA
    +

    Welcoming visitors to our private-centric research, community and conference

    +
    9:35 - 10:55
    Talks I.
    +
    10:55 - 11:20
    25min Coffee Break
    +
    11:25 - 12:40
    Talks II.
    +
    12:40 - 14:00
    Lunch & Networking
    +
    14:00 - 15:40
    Talks III.
    +
    15:40 - 16:05
    25min Coffee Break
    +
    16:10 - 18:30
    Talks IV.
    +
    18:30 - 18:35
    Closing Remarks ― TBA
    +
    18:30 - 20:00
    Networking & Drinks
    +
    20:00 - 4:00
    #Lunarpunk party
    +

    Enjoy our afterparty in Lunarpunk style with quality Prague rave DJs, which will take place in the same venue until the morning (4am).

    +
    -
    Sponsors
    +
    Sponsors
    -
    Ticket
    -
    Conference ticket
    -
    Party ticket
    +
    Ticket
    +
    All-day Access
    +
    2350 CZK (~99 EUR)
    +
    • All talks & panels
    • Coffee breaks
    • Buffet lunch
    • Networking drinks with speakers & attendees
    + + +
    #Lunarpunk Party
    +
    350 CZK (~15 EUR)
    +
    • 20:00 - morning
    • Prague rave from top DJs
    • VJs and projections
    • Networking with attendees, speakers & sponsors
    + +
    *Party access is included in the All-day Pass
    +
    + +
    FAQ
    +
    Who is the event for?
    +

    Our event is for anyone interested in privacy topics in the Web3 industry. There will be space for about 300 enthusiasts.

    +
    How do I get to the venue?
    +

    Venue X10 (full name "Divadlo X10") is located in the centre of Prague near the metro station Národní Třída (Line B) and Můstek (Line A,C). The address is Charvátova 10/39, Prague 1, 110 00 (Google Maps).

    +
    Will there be any food or drink?
    +

    We don't know, but we'll do our best. This unfortunately depends on the sponsors.

    +
    +
    💛 Collaboration of Web3Privacy Now & ETHBrno team +
    -