cngpac 0.0.1

package/dist/src/node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.mjs

@@ -0,0 +1,73 @@
+import { splice } from "../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.mjs";
+//#region node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.js
+/**
+* @import {
+*   Extension,
+*   Handles,
+*   HtmlExtension,
+*   NormalizedExtension
+* } from 'micromark-util-types'
+*/
+const hasOwnProperty = {}.hasOwnProperty;
+/**
+* Combine multiple syntax extensions into one.
+*
+* @param {ReadonlyArray<Extension>} extensions
+*   List of syntax extensions.
+* @returns {NormalizedExtension}
+*   A single combined extension.
+*/
+function combineExtensions(extensions) {
+	/** @type {NormalizedExtension} */
+	const all = {};
+	let index = -1;
+	while (++index < extensions.length) syntaxExtension(all, extensions[index]);
+	return all;
+}
+/**
+* Merge `extension` into `all`.
+*
+* @param {NormalizedExtension} all
+*   Extension to merge into.
+* @param {Extension} extension
+*   Extension to merge.
+* @returns {undefined}
+*   Nothing.
+*/
+function syntaxExtension(all, extension) {
+	/** @type {keyof Extension} */
+	let hook;
+	for (hook in extension) {
+		/** @type {Record<string, unknown>} */
+		const left = (hasOwnProperty.call(all, hook) ? all[hook] : void 0) || (all[hook] = {});
+		/** @type {Record<string, unknown> | undefined} */
+		const right = extension[hook];
+		/** @type {string} */
+		let code;
+		if (right) for (code in right) {
+			if (!hasOwnProperty.call(left, code)) left[code] = [];
+			const value = right[code];
+			constructs(left[code], Array.isArray(value) ? value : value ? [value] : []);
+		}
+	}
+}
+/**
+* Merge `list` into `existing` (both lists of constructs).
+* Mutates `existing`.
+*
+* @param {Array<unknown>} existing
+*   List of constructs to merge into.
+* @param {Array<unknown>} list
+*   List of constructs to merge.
+* @returns {undefined}
+*   Nothing.
+*/
+function constructs(existing, list) {
+	let index = -1;
+	/** @type {Array<unknown>} */
+	const before = [];
+	while (++index < list.length) (list[index].add === "after" ? existing : before).push(list[index]);
+	splice(existing, 0, 0, before);
+}
+//#endregion
+export { combineExtensions };

package/dist/src/node_modules/.pnpm/micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.mjs

@@ -0,0 +1,22 @@
+//#region node_modules/.pnpm/micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.js
+/**
+* Turn the number (in string form as either hexa- or plain decimal) coming from
+* a numeric character reference into a character.
+*
+* Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes
+* non-characters and control characters safe.
+*
+* @param {string} value
+*   Value to decode.
+* @param {number} base
+*   Numeric base.
+* @returns {string}
+*   Character.
+*/
+function decodeNumericCharacterReference(value, base) {
+	const code = Number.parseInt(value, base);
+	if (code < 9 || code === 11 || code > 13 && code < 32 || code > 126 && code < 160 || code > 55295 && code < 57344 || code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || code > 1114111) return "�";
+	return String.fromCodePoint(code);
+}
+//#endregion
+export { decodeNumericCharacterReference };

package/dist/src/node_modules/.pnpm/micromark-util-decode-string@2.0.1/node_modules/micromark-util-decode-string/index.mjs

@@ -0,0 +1,40 @@
+import { decodeNamedCharacterReference } from "../../../decode-named-character-reference@1.3.0/node_modules/decode-named-character-reference/index.mjs";
+import { decodeNumericCharacterReference } from "../../../micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.mjs";
+//#region node_modules/.pnpm/micromark-util-decode-string@2.0.1/node_modules/micromark-util-decode-string/index.js
+const characterEscapeOrReference = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
+/**
+* Decode markdown strings (which occur in places such as fenced code info
+* strings, destinations, labels, and titles).
+*
+* The “string” content type allows character escapes and -references.
+* This decodes those.
+*
+* @param {string} value
+*   Value to decode.
+* @returns {string}
+*   Decoded value.
+*/
+function decodeString(value) {
+	return value.replace(characterEscapeOrReference, decode);
+}
+/**
+* @param {string} $0
+*   Match.
+* @param {string} $1
+*   Character escape.
+* @param {string} $2
+*   Character reference.
+* @returns {string}
+*   Decoded value
+*/
+function decode($0, $1, $2) {
+	if ($1) return $1;
+	if ($2.charCodeAt(0) === 35) {
+		const head = $2.charCodeAt(1);
+		const hex = head === 120 || head === 88;
+		return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);
+	}
+	return decodeNamedCharacterReference($2) || $0;
+}
+//#endregion
+export { decodeString };

package/dist/src/node_modules/.pnpm/micromark-util-html-tag-name@2.0.1/node_modules/micromark-util-html-tag-name/index.mjs

@@ -0,0 +1,100 @@
+//#region node_modules/.pnpm/micromark-util-html-tag-name@2.0.1/node_modules/micromark-util-html-tag-name/index.js
+/**
+* List of lowercase HTML “block” tag names.
+*
+* The list, when parsing HTML (flow), results in more relaxed rules (condition
+* 6).
+* Because they are known blocks, the HTML-like syntax doesn’t have to be
+* strictly parsed.
+* For tag names not in this list, a more strict algorithm (condition 7) is used
+* to detect whether the HTML-like syntax is seen as HTML (flow) or not.
+*
+* This is copied from:
+* <https://spec.commonmark.org/0.30/#html-blocks>.
+*
+* > 👉 **Note**: `search` was added in `CommonMark@0.31`.
+*/
+const htmlBlockNames = [
+	"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",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"head",
+	"header",
+	"hr",
+	"html",
+	"iframe",
+	"legend",
+	"li",
+	"link",
+	"main",
+	"menu",
+	"menuitem",
+	"nav",
+	"noframes",
+	"ol",
+	"optgroup",
+	"option",
+	"p",
+	"param",
+	"search",
+	"section",
+	"summary",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"title",
+	"tr",
+	"track",
+	"ul"
+];
+/**
+* List of lowercase HTML “raw” tag names.
+*
+* The list, when parsing HTML (flow), results in HTML that can include lines
+* without exiting, until a closing tag also in this list is found (condition
+* 1).
+*
+* This module is copied from:
+* <https://spec.commonmark.org/0.30/#html-blocks>.
+*
+* > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.
+*/
+const htmlRawNames = [
+	"pre",
+	"script",
+	"style",
+	"textarea"
+];
+//#endregion
+export { htmlBlockNames, htmlRawNames };

package/dist/src/node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.mjs

@@ -0,0 +1,25 @@
+//#region node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.js
+/**
+* Normalize an identifier (as found in references, definitions).
+*
+* Collapses markdown whitespace, trim, and then lower- and uppercase.
+*
+* Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their
+* lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different
+* uppercase character (U+0398 (`Θ`)).
+* So, to get a canonical form, we perform both lower- and uppercase.
+*
+* Using uppercase last makes sure keys will never interact with default
+* prototypal values (such as `constructor`): nothing in the prototype of
+* `Object` is uppercase.
+*
+* @param {string} value
+*   Identifier to normalize.
+* @returns {string}
+*   Normalized identifier.
+*/
+function normalizeIdentifier(value) {
+	return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
+}
+//#endregion
+export { normalizeIdentifier };

package/dist/src/node_modules/.pnpm/micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.mjs

@@ -0,0 +1,31 @@
+//#region node_modules/.pnpm/micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.js
+/**
+* @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'
+*/
+/**
+* Call all `resolveAll`s.
+*
+* @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs
+*   List of constructs, optionally with `resolveAll`s.
+* @param {Array<Event>} events
+*   List of events.
+* @param {TokenizeContext} context
+*   Context used by `tokenize`.
+* @returns {Array<Event>}
+*   Changed events.
+*/
+function resolveAll(constructs, events, context) {
+	/** @type {Array<Resolver>} */
+	const called = [];
+	let index = -1;
+	while (++index < constructs.length) {
+		const resolve = constructs[index].resolveAll;
+		if (resolve && !called.includes(resolve)) {
+			events = resolve(events, context);
+			called.push(resolve);
+		}
+	}
+	return events;
+}
+//#endregion
+export { resolveAll };

package/dist/src/node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.mjs

@@ -0,0 +1,158 @@
+import { splice } from "../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.mjs";
+import { SpliceBuffer } from "./lib/splice-buffer.mjs";
+//#region node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.js
+/**
+* @import {Chunk, Event, Token} from 'micromark-util-types'
+*/
+/**
+* Tokenize subcontent.
+*
+* @param {Array<Event>} eventsArray
+*   List of events.
+* @returns {boolean}
+*   Whether subtokens were found.
+*/
+function subtokenize(eventsArray) {
+	/** @type {Record<string, number>} */
+	const jumps = {};
+	let index = -1;
+	/** @type {Event} */
+	let event;
+	/** @type {number | undefined} */
+	let lineIndex;
+	/** @type {number} */
+	let otherIndex;
+	/** @type {Event} */
+	let otherEvent;
+	/** @type {Array<Event>} */
+	let parameters;
+	/** @type {Array<Event>} */
+	let subevents;
+	/** @type {boolean | undefined} */
+	let more;
+	const events = new SpliceBuffer(eventsArray);
+	while (++index < events.length) {
+		while (index in jumps) index = jumps[index];
+		event = events.get(index);
+		if (index && event[1].type === "chunkFlow" && events.get(index - 1)[1].type === "listItemPrefix") {
+			subevents = event[1]._tokenizer.events;
+			otherIndex = 0;
+			if (otherIndex < subevents.length && subevents[otherIndex][1].type === "lineEndingBlank") otherIndex += 2;
+			if (otherIndex < subevents.length && subevents[otherIndex][1].type === "content") while (++otherIndex < subevents.length) {
+				if (subevents[otherIndex][1].type === "content") break;
+				if (subevents[otherIndex][1].type === "chunkText") {
+					subevents[otherIndex][1]._isInFirstContentOfListItem = true;
+					otherIndex++;
+				}
+			}
+		}
+		if (event[0] === "enter") {
+			if (event[1].contentType) {
+				Object.assign(jumps, subcontent(events, index));
+				index = jumps[index];
+				more = true;
+			}
+		} else if (event[1]._container) {
+			otherIndex = index;
+			lineIndex = void 0;
+			while (otherIndex--) {
+				otherEvent = events.get(otherIndex);
+				if (otherEvent[1].type === "lineEnding" || otherEvent[1].type === "lineEndingBlank") {
+					if (otherEvent[0] === "enter") {
+						if (lineIndex) events.get(lineIndex)[1].type = "lineEndingBlank";
+						otherEvent[1].type = "lineEnding";
+						lineIndex = otherIndex;
+					}
+				} else if (otherEvent[1].type === "linePrefix" || otherEvent[1].type === "listItemIndent") {} else break;
+			}
+			if (lineIndex) {
+				event[1].end = { ...events.get(lineIndex)[1].start };
+				parameters = events.slice(lineIndex, index);
+				parameters.unshift(event);
+				events.splice(lineIndex, index - lineIndex + 1, parameters);
+			}
+		}
+	}
+	splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));
+	return !more;
+}
+/**
+* Tokenize embedded tokens.
+*
+* @param {SpliceBuffer<Event>} events
+*   Events.
+* @param {number} eventIndex
+*   Index.
+* @returns {Record<string, number>}
+*   Gaps.
+*/
+function subcontent(events, eventIndex) {
+	const token = events.get(eventIndex)[1];
+	const context = events.get(eventIndex)[2];
+	let startPosition = eventIndex - 1;
+	/** @type {Array<number>} */
+	const startPositions = [];
+	let tokenizer = token._tokenizer;
+	if (!tokenizer) {
+		tokenizer = context.parser[token.contentType](token.start);
+		if (token._contentTypeTextTrailing) tokenizer._contentTypeTextTrailing = true;
+	}
+	const childEvents = tokenizer.events;
+	/** @type {Array<[number, number]>} */
+	const jumps = [];
+	/** @type {Record<string, number>} */
+	const gaps = {};
+	/** @type {Array<Chunk>} */
+	let stream;
+	/** @type {Token | undefined} */
+	let previous;
+	let index = -1;
+	/** @type {Token | undefined} */
+	let current = token;
+	let adjust = 0;
+	let start = 0;
+	const breaks = [start];
+	while (current) {
+		while (events.get(++startPosition)[1] !== current);
+		startPositions.push(startPosition);
+		if (!current._tokenizer) {
+			stream = context.sliceStream(current);
+			if (!current.next) stream.push(null);
+			if (previous) tokenizer.defineSkip(current.start);
+			if (current._isInFirstContentOfListItem) tokenizer._gfmTasklistFirstContentOfListItem = true;
+			tokenizer.write(stream);
+			if (current._isInFirstContentOfListItem) tokenizer._gfmTasklistFirstContentOfListItem = void 0;
+		}
+		previous = current;
+		current = current.next;
+	}
+	current = token;
+	while (++index < childEvents.length) if (childEvents[index][0] === "exit" && childEvents[index - 1][0] === "enter" && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {
+		start = index + 1;
+		breaks.push(start);
+		current._tokenizer = void 0;
+		current.previous = void 0;
+		current = current.next;
+	}
+	tokenizer.events = [];
+	if (current) {
+		current._tokenizer = void 0;
+		current.previous = void 0;
+	} else breaks.pop();
+	index = breaks.length;
+	while (index--) {
+		const slice = childEvents.slice(breaks[index], breaks[index + 1]);
+		const start = startPositions.pop();
+		jumps.push([start, start + slice.length - 1]);
+		events.splice(start, 2, slice);
+	}
+	jumps.reverse();
+	index = -1;
+	while (++index < jumps.length) {
+		gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];
+		adjust += jumps[index][1] - jumps[index][0] - 1;
+	}
+	return gaps;
+}
+//#endregion
+export { subtokenize };

package/dist/src/node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/lib/splice-buffer.mjs

@@ -0,0 +1,231 @@
+//#region node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/lib/splice-buffer.js
+/**
+* Some of the internal operations of micromark do lots of editing
+* operations on very large arrays. This runs into problems with two
+* properties of most circa-2020 JavaScript interpreters:
+*
+*  - Array-length modifications at the high end of an array (push/pop) are
+*    expected to be common and are implemented in (amortized) time
+*    proportional to the number of elements added or removed, whereas
+*    other operations (shift/unshift and splice) are much less efficient.
+*  - Function arguments are passed on the stack, so adding tens of thousands
+*    of elements to an array with `arr.push(...newElements)` will frequently
+*    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)
+*
+* SpliceBuffers are an implementation of gap buffers, which are a
+* generalization of the "queue made of two stacks" idea. The splice buffer
+* maintains a cursor, and moving the cursor has cost proportional to the
+* distance the cursor moves, but inserting, deleting, or splicing in
+* new information at the cursor is as efficient as the push/pop operation.
+* This allows for an efficient sequence of splices (or pushes, pops, shifts,
+* or unshifts) as long such edits happen at the same part of the array or
+* generally sweep through the array from the beginning to the end.
+*
+* The interface for splice buffers also supports large numbers of inputs by
+* passing a single array argument rather passing multiple arguments on the
+* function call stack.
+*
+* @template T
+*   Item type.
+*/
+var SpliceBuffer = class {
+	/**
+	* @param {ReadonlyArray<T> | null | undefined} [initial]
+	*   Initial items (optional).
+	* @returns
+	*   Splice buffer.
+	*/
+	constructor(initial) {
+		/** @type {Array<T>} */
+		this.left = initial ? [...initial] : [];
+		/** @type {Array<T>} */
+		this.right = [];
+	}
+	/**
+	* Array access;
+	* does not move the cursor.
+	*
+	* @param {number} index
+	*   Index.
+	* @return {T}
+	*   Item.
+	*/
+	get(index) {
+		if (index < 0 || index >= this.left.length + this.right.length) throw new RangeError("Cannot access index `" + index + "` in a splice buffer of size `" + (this.left.length + this.right.length) + "`");
+		if (index < this.left.length) return this.left[index];
+		return this.right[this.right.length - index + this.left.length - 1];
+	}
+	/**
+	* The length of the splice buffer, one greater than the largest index in the
+	* array.
+	*/
+	get length() {
+		return this.left.length + this.right.length;
+	}
+	/**
+	* Remove and return `list[0]`;
+	* moves the cursor to `0`.
+	*
+	* @returns {T | undefined}
+	*   Item, optional.
+	*/
+	shift() {
+		this.setCursor(0);
+		return this.right.pop();
+	}
+	/**
+	* Slice the buffer to get an array;
+	* does not move the cursor.
+	*
+	* @param {number} start
+	*   Start.
+	* @param {number | null | undefined} [end]
+	*   End (optional).
+	* @returns {Array<T>}
+	*   Array of items.
+	*/
+	slice(start, end) {
+		/** @type {number} */
+		const stop = end === null || end === void 0 ? Number.POSITIVE_INFINITY : end;
+		if (stop < this.left.length) return this.left.slice(start, stop);
+		if (start > this.left.length) return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();
+		return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());
+	}
+	/**
+	* Mimics the behavior of Array.prototype.splice() except for the change of
+	* interface necessary to avoid segfaults when patching in very large arrays.
+	*
+	* This operation moves cursor is moved to `start` and results in the cursor
+	* placed after any inserted items.
+	*
+	* @param {number} start
+	*   Start;
+	*   zero-based index at which to start changing the array;
+	*   negative numbers count backwards from the end of the array and values
+	*   that are out-of bounds are clamped to the appropriate end of the array.
+	* @param {number | null | undefined} [deleteCount=0]
+	*   Delete count (default: `0`);
+	*   maximum number of elements to delete, starting from start.
+	* @param {Array<T> | null | undefined} [items=[]]
+	*   Items to include in place of the deleted items (default: `[]`).
+	* @return {Array<T>}
+	*   Any removed items.
+	*/
+	splice(start, deleteCount, items) {
+		/** @type {number} */
+		const count = deleteCount || 0;
+		this.setCursor(Math.trunc(start));
+		const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);
+		if (items) chunkedPush(this.left, items);
+		return removed.reverse();
+	}
+	/**
+	* Remove and return the highest-numbered item in the array, so
+	* `list[list.length - 1]`;
+	* Moves the cursor to `length`.
+	*
+	* @returns {T | undefined}
+	*   Item, optional.
+	*/
+	pop() {
+		this.setCursor(Number.POSITIVE_INFINITY);
+		return this.left.pop();
+	}
+	/**
+	* Inserts a single item to the high-numbered side of the array;
+	* moves the cursor to `length`.
+	*
+	* @param {T} item
+	*   Item.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	push(item) {
+		this.setCursor(Number.POSITIVE_INFINITY);
+		this.left.push(item);
+	}
+	/**
+	* Inserts many items to the high-numbered side of the array.
+	* Moves the cursor to `length`.
+	*
+	* @param {Array<T>} items
+	*   Items.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	pushMany(items) {
+		this.setCursor(Number.POSITIVE_INFINITY);
+		chunkedPush(this.left, items);
+	}
+	/**
+	* Inserts a single item to the low-numbered side of the array;
+	* Moves the cursor to `0`.
+	*
+	* @param {T} item
+	*   Item.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	unshift(item) {
+		this.setCursor(0);
+		this.right.push(item);
+	}
+	/**
+	* Inserts many items to the low-numbered side of the array;
+	* moves the cursor to `0`.
+	*
+	* @param {Array<T>} items
+	*   Items.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	unshiftMany(items) {
+		this.setCursor(0);
+		chunkedPush(this.right, items.reverse());
+	}
+	/**
+	* Move the cursor to a specific position in the array. Requires
+	* time proportional to the distance moved.
+	*
+	* If `n < 0`, the cursor will end up at the beginning.
+	* If `n > length`, the cursor will end up at the end.
+	*
+	* @param {number} n
+	*   Position.
+	* @return {undefined}
+	*   Nothing.
+	*/
+	setCursor(n) {
+		if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;
+		if (n < this.left.length) {
+			const removed = this.left.splice(n, Number.POSITIVE_INFINITY);
+			chunkedPush(this.right, removed.reverse());
+		} else {
+			const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);
+			chunkedPush(this.left, removed.reverse());
+		}
+	}
+};
+/**
+* Avoid stack overflow by pushing items onto the stack in segments
+*
+* @template T
+*   Item type.
+* @param {Array<T>} list
+*   List to inject into.
+* @param {ReadonlyArray<T>} right
+*   Items to inject.
+* @return {undefined}
+*   Nothing.
+*/
+function chunkedPush(list, right) {
+	/** @type {number} */
+	let chunkStart = 0;
+	if (right.length < 1e4) list.push(...right);
+	else while (chunkStart < right.length) {
+		list.push(...right.slice(chunkStart, chunkStart + 1e4));
+		chunkStart += 1e4;
+	}
+}
+//#endregion
+export { SpliceBuffer };