' + esc(title) + '

<' + labelTagName + ' id="footnote-label"' + (labelAttributes ? ' ' + labelAttributes : '') + '>'); this.raw(this.encode(label)); this.tag(''); this.lineEndingIfNeeded(); this.tag('

} */ const references = []; while (++referenceIndex <= counts[id]) { references.push('↩' + (referenceIndex > 1 ? '^{' + referenceIndex + '}' : '') + ''); } const reference = references.join(' '); let injected = false; this.lineEndingIfNeeded(); this.tag('

'); this.lineEndingIfNeeded(); this.tag(definitions[id].replace(/<\/p>(?:\r?\n|\r)?$/, function ($0) { injected = true; return ' ' + reference + $0; })); if (!injected) { this.lineEndingIfNeeded(); this.tag(reference); } this.lineEndingIfNeeded(); this.tag('

'); } if (calls.length > 0) { this.lineEndingIfNeeded(); this.tag('

'); this.lineEndingIfNeeded(); this.tag('

* ^ * | * ``` * * @type {State} */ function start(code) { effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); return effects.attempt(blankLine, ok, nok); } }/** * @import { * Code, * Construct, * State, * TokenizeContext, * Tokenizer * } from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character'; /** @type {Construct} */ export const htmlText = { name: 'htmlText', tokenize: tokenizeHtmlText }; /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeHtmlText(effects, ok, nok) { const self = this; /** @type {NonNullable| undefined} */ let marker; /** @type {number} */ let index; /** @type {State} */ let returnState; return start; /** * Start of HTML (text). * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function start(code) { effects.enter("htmlText"); effects.enter("htmlTextData"); effects.consume(code); return open; } /** * After `<`, at tag name or other stuff. * * ```markdown * > | a c * ^ * > | a c * ^ * > | a c * ^ * ``` * * @type {State} */ function open(code) { if (code === 33) { effects.consume(code); return declarationOpen; } if (code === 47) { effects.consume(code); return tagCloseStart; } if (code === 63) { effects.consume(code); return instruction; } // ASCII alphabetical. if (asciiAlpha(code)) { effects.consume(code); return tagOpen; } return nok(code); } /** * After ` | a c * ^ * > | a c * ^ * > | a &<]]> c * ^ * ``` * * @type {State} */ function declarationOpen(code) { if (code === 45) { effects.consume(code); return commentOpenInside; } if (code === 91) { effects.consume(code); index = 0; return cdataOpenInside; } if (asciiAlpha(code)) { effects.consume(code); return declaration; } return nok(code); } /** * In a comment, after ` | a c * ^ * ``` * * @type {State} */ function commentOpenInside(code) { if (code === 45) { effects.consume(code); return commentEnd; } return nok(code); } /** * In comment. * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function comment(code) { if (code === null) { return nok(code); } if (code === 45) { effects.consume(code); return commentClose; } if (markdownLineEnding(code)) { returnState = comment; return lineEndingBefore(code); } effects.consume(code); return comment; } /** * In comment, after `-`. * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function commentClose(code) { if (code === 45) { effects.consume(code); return commentEnd; } return comment(code); } /** * In comment, after `--`. * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function commentEnd(code) { return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code); } /** * After ` | a &<]]> b * ^^^^^^ * ``` * * @type {State} */ function cdataOpenInside(code) { const value = "CDATA["; if (code === value.charCodeAt(index++)) { effects.consume(code); return index === value.length ? cdata : cdataOpenInside; } return nok(code); } /** * In CDATA. * * ```markdown * > | a &<]]> b * ^^^ * ``` * * @type {State} */ function cdata(code) { if (code === null) { return nok(code); } if (code === 93) { effects.consume(code); return cdataClose; } if (markdownLineEnding(code)) { returnState = cdata; return lineEndingBefore(code); } effects.consume(code); return cdata; } /** * In CDATA, after `]`, at another `]`. * * ```markdown * > | a &<]]> b * ^ * ``` * * @type {State} */ function cdataClose(code) { if (code === 93) { effects.consume(code); return cdataEnd; } return cdata(code); } /** * In CDATA, after `]]`, at `>`. * * ```markdown * > | a &<]]> b * ^ * ``` * * @type {State} */ function cdataEnd(code) { if (code === 62) { return end(code); } if (code === 93) { effects.consume(code); return cdataEnd; } return cdata(code); } /** * In declaration. * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function declaration(code) { if (code === null || code === 62) { return end(code); } if (markdownLineEnding(code)) { returnState = declaration; return lineEndingBefore(code); } effects.consume(code); return declaration; } /** * In instruction. * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function instruction(code) { if (code === null) { return nok(code); } if (code === 63) { effects.consume(code); return instructionClose; } if (markdownLineEnding(code)) { returnState = instruction; return lineEndingBefore(code); } effects.consume(code); return instruction; } /** * In instruction, after `?`, at `>`. * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function instructionClose(code) { return code === 62 ? end(code) : instruction(code); } /** * After ` | a c * ^ * ``` * * @type {State} */ function tagCloseStart(code) { // ASCII alphabetical. if (asciiAlpha(code)) { effects.consume(code); return tagClose; } return nok(code); } /** * After ` | a c * ^ * ``` * * @type {State} */ function tagClose(code) { // ASCII alphanumerical and `-`. if (code === 45 || asciiAlphanumeric(code)) { effects.consume(code); return tagClose; } return tagCloseBetween(code); } /** * In closing tag, after tag name. * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function tagCloseBetween(code) { if (markdownLineEnding(code)) { returnState = tagCloseBetween; return lineEndingBefore(code); } if (markdownSpace(code)) { effects.consume(code); return tagCloseBetween; } return end(code); } /** * After ` | a c * ^ * ``` * * @type {State} */ function tagOpen(code) { // ASCII alphanumerical and `-`. if (code === 45 || asciiAlphanumeric(code)) { effects.consume(code); return tagOpen; } if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { return tagOpenBetween(code); } return nok(code); } /** * In opening tag, after tag name. * * ```markdown * > | a c * ^ * ``` * * @type {State} */ function tagOpenBetween(code) { if (code === 47) { effects.consume(code); return end; } // ASCII alphabetical and `:` and `_`. if (code === 58 || code === 95 || asciiAlpha(code)) { effects.consume(code); return tagOpenAttributeName; } if (markdownLineEnding(code)) { returnState = tagOpenBetween; return lineEndingBefore(code); } if (markdownSpace(code)) { effects.consume(code); return tagOpenBetween; } return end(code); } /** * In attribute name. * * ```markdown * > | a d * ^ * ``` * * @type {State} */ function tagOpenAttributeName(code) { // ASCII alphabetical and `-`, `.`, `:`, and `_`. if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) { effects.consume(code); return tagOpenAttributeName; } return tagOpenAttributeNameAfter(code); } /** * After attribute name, before initializer, the end of the tag, or * whitespace. * * ```markdown * > | a d * ^ * ``` * * @type {State} */ function tagOpenAttributeNameAfter(code) { if (code === 61) { effects.consume(code); return tagOpenAttributeValueBefore; } if (markdownLineEnding(code)) { returnState = tagOpenAttributeNameAfter; return lineEndingBefore(code); } if (markdownSpace(code)) { effects.consume(code); return tagOpenAttributeNameAfter; } return tagOpenBetween(code); } /** * Before unquoted, double quoted, or single quoted attribute value, allowing * whitespace. * * ```markdown * > | a e * ^ * ``` * * @type {State} */ function tagOpenAttributeValueBefore(code) { if (code === null || code === 60 || code === 61 || code === 62 || code === 96) { return nok(code); } if (code === 34 || code === 39) { effects.consume(code); marker = code; return tagOpenAttributeValueQuoted; } if (markdownLineEnding(code)) { returnState = tagOpenAttributeValueBefore; return lineEndingBefore(code); } if (markdownSpace(code)) { effects.consume(code); return tagOpenAttributeValueBefore; } effects.consume(code); return tagOpenAttributeValueUnquoted; } /** * In double or single quoted attribute value. * * ```markdown * > | a e * ^ * ``` * * @type {State} */ function tagOpenAttributeValueQuoted(code) { if (code === marker) { effects.consume(code); marker = undefined; return tagOpenAttributeValueQuotedAfter; } if (code === null) { return nok(code); } if (markdownLineEnding(code)) { returnState = tagOpenAttributeValueQuoted; return lineEndingBefore(code); } effects.consume(code); return tagOpenAttributeValueQuoted; } /** * In unquoted attribute value. * * ```markdown * > | a e * ^ * ``` * * @type {State} */ function tagOpenAttributeValueUnquoted(code) { if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) { return nok(code); } if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { return tagOpenBetween(code); } effects.consume(code); return tagOpenAttributeValueUnquoted; } /** * After double or single quoted attribute value, before whitespace or the end * of the tag. * * ```markdown * > | a e * ^ * ``` * * @type {State} */ function tagOpenAttributeValueQuotedAfter(code) { if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { return tagOpenBetween(code); } return nok(code); } /** * In certain circumstances of a tag where only an `>` is allowed. * * ```markdown * > | a e * ^ * ``` * * @type {State} */ function end(code) { if (code === 62) { effects.consume(code); effects.exit("htmlTextData"); effects.exit("htmlText"); return ok; } return nok(code); } /** * At eol. * * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about * > empty tokens. * * ```markdown * > | a * ``` * * @type {State} */ function lineEndingBefore(code) { effects.exit("htmlTextData"); effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); return lineEndingAfter; } /** * After eol, at optional whitespace. * * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about * > empty tokens. * * ```markdown * | a * ^ * ``` * * @type {State} */ function lineEndingAfter(code) { // Always populated by defaults. return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, "linePrefix", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code); } /** * After eol, after optional whitespace. * * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about * > empty tokens. * * ```markdown * | a * ^ * ``` * * @type {State} */ function lineEndingAfterPrefix(code) { effects.enter("htmlTextData"); return returnState(code); } }/** * @import { * Construct, * Event, * Resolver, * State, * TokenizeContext, * Tokenizer, * Token * } from 'micromark-util-types' */ import { factoryDestination } from 'micromark-factory-destination'; import { factoryLabel } from 'micromark-factory-label'; import { factoryTitle } from 'micromark-factory-title'; import { factoryWhitespace } from 'micromark-factory-whitespace'; import { markdownLineEndingOrSpace } from 'micromark-util-character'; import { push, splice } from 'micromark-util-chunked'; import { normalizeIdentifier } from 'micromark-util-normalize-identifier'; import { resolveAll } from 'micromark-util-resolve-all'; /** @type {Construct} */ export const labelEnd = { name: 'labelEnd', resolveAll: resolveAllLabelEnd, resolveTo: resolveToLabelEnd, tokenize: tokenizeLabelEnd }; /** @type {Construct} */ const resourceConstruct = { tokenize: tokenizeResource }; /** @type {Construct} */ const referenceFullConstruct = { tokenize: tokenizeReferenceFull }; /** @type {Construct} */ const referenceCollapsedConstruct = { tokenize: tokenizeReferenceCollapsed }; /** @type {Resolver} */ function resolveAllLabelEnd(events) { let index = -1; /** @type {Array} */ const newEvents = []; while (++index < events.length) { const token = events[index][1]; newEvents.push(events[index]); if (token.type === "labelImage" || token.type === "labelLink" || token.type === "labelEnd") { // Remove the marker. const offset = token.type === "labelImage" ? 4 : 2; token.type = "data"; index += offset; } } // If the events are equal, we don't have to copy newEvents to events if (events.length !== newEvents.length) { splice(events, 0, events.length, newEvents); } return events; } /** @type {Resolver} */ function resolveToLabelEnd(events, context) { let index = events.length; let offset = 0; /** @type {Token} */ let token; /** @type {number | undefined} */ let open; /** @type {number | undefined} */ let close; /** @type {Array} */ let media; // Find an opening. while (index--) { token = events[index][1]; if (open) { // If we see another link, or inactive link label, we’ve been here before. if (token.type === "link" || token.type === "labelLink" && token._inactive) { break; } // Mark other link openings as inactive, as we can’t have links in // links. if (events[index][0] === 'enter' && token.type === "labelLink") { token._inactive = true; } } else if (close) { if (events[index][0] === 'enter' && (token.type === "labelImage" || token.type === "labelLink") && !token._balanced) { open = index; if (token.type !== "labelLink") { offset = 2; break; } } } else if (token.type === "labelEnd") { close = index; } } const group = { type: events[open][1].type === "labelLink" ? "link" : "image", start: { ...events[open][1].start }, end: { ...events[events.length - 1][1].end } }; const label = { type: "label", start: { ...events[open][1].start }, end: { ...events[close][1].end } }; const text = { type: "labelText", start: { ...events[open + offset + 2][1].end }, end: { ...events[close - 2][1].start } }; media = [['enter', group, context], ['enter', label, context]]; // Opening marker. media = push(media, events.slice(open + 1, open + offset + 3)); // Text open. media = push(media, [['enter', text, context]]); // Always populated by defaults. // Between. media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context)); // Text close, marker close, label close. media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]); // Reference, resource, or so. media = push(media, events.slice(close + 1)); // Media close. media = push(media, [['exit', group, context]]); splice(events, open, events.length, media); return events; } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeLabelEnd(effects, ok, nok) { const self = this; let index = self.events.length; /** @type {Token} */ let labelStart; /** @type {boolean} */ let defined; // Find an opening. while (index--) { if ((self.events[index][1].type === "labelImage" || self.events[index][1].type === "labelLink") && !self.events[index][1]._balanced) { labelStart = self.events[index][1]; break; } } return start; /** * Start of label end. * * ```markdown * > | [a](b) c * ^ * > | [a][b] c * ^ * > | [a][] b * ^ * > | [a] b * ``` * * @type {State} */ function start(code) { // If there is not an okay opening. if (!labelStart) { return nok(code); } // If the corresponding label (link) start is marked as inactive, // it means we’d be wrapping a link, like this: // // ```markdown // > | a [b [c](d) e](f) g. // ^ // ``` // // We can’t have that, so it’s just balanced brackets. if (labelStart._inactive) { return labelEndNok(code); } defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({ start: labelStart.end, end: self.now() }))); effects.enter("labelEnd"); effects.enter("labelMarker"); effects.consume(code); effects.exit("labelMarker"); effects.exit("labelEnd"); return after; } /** * After `]`. * * ```markdown * > | [a](b) c * ^ * > | [a][b] c * ^ * > | [a][] b * ^ * > | [a] b * ^ * ``` * * @type {State} */ function after(code) { // Note: `markdown-rs` also parses GFM footnotes here, which for us is in // an extension. // Resource (`[asd](fgh)`)? if (code === 40) { return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code); } // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference? if (code === 91) { return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code); } // Shortcut (`[asd]`) reference? return defined ? labelEndOk(code) : labelEndNok(code); } /** * After `]`, at `[`, but not at a full reference. * * > 👉 **Note**: we only get here if the label is defined. * * ```markdown * > | [a][] b * ^ * > | [a] b * ^ * ``` * * @type {State} */ function referenceNotFull(code) { return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code); } /** * Done, we found something. * * ```markdown * > | [a](b) c * ^ * > | [a][b] c * ^ * > | [a][] b * ^ * > | [a] b * ^ * ``` * * @type {State} */ function labelEndOk(code) { // Note: `markdown-rs` does a bunch of stuff here. return ok(code); } /** * Done, it’s nothing. * * There was an okay opening, but we didn’t match anything. * * ```markdown * > | [a](b c * ^ * > | [a][b c * ^ * > | [a] b * ^ * ``` * * @type {State} */ function labelEndNok(code) { labelStart._balanced = true; return nok(code); } } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeResource(effects, ok, nok) { return resourceStart; /** * At a resource. * * ```markdown * > | [a](b) c * ^ * ``` * * @type {State} */ function resourceStart(code) { effects.enter("resource"); effects.enter("resourceMarker"); effects.consume(code); effects.exit("resourceMarker"); return resourceBefore; } /** * In resource, after `(`, at optional whitespace. * * ```markdown * > | [a](b) c * ^ * ``` * * @type {State} */ function resourceBefore(code) { return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code); } /** * In resource, after optional whitespace, at `)` or a destination. * * ```markdown * > | [a](b) c * ^ * ``` * * @type {State} */ function resourceOpen(code) { if (code === 41) { return resourceEnd(code); } return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, "resourceDestination", "resourceDestinationLiteral", "resourceDestinationLiteralMarker", "resourceDestinationRaw", "resourceDestinationString", 32)(code); } /** * In resource, after destination, at optional whitespace. * * ```markdown * > | [a](b) c * ^ * ``` * * @type {State} */ function resourceDestinationAfter(code) { return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code); } /** * At invalid destination. * * ```markdown * > | [a](<<) b * ^ * ``` * * @type {State} */ function resourceDestinationMissing(code) { return nok(code); } /** * In resource, after destination and whitespace, at `(` or title. * * ```markdown * > | [a](b ) c * ^ * ``` * * @type {State} */ function resourceBetween(code) { if (code === 34 || code === 39 || code === 40) { return factoryTitle(effects, resourceTitleAfter, nok, "resourceTitle", "resourceTitleMarker", "resourceTitleString")(code); } return resourceEnd(code); } /** * In resource, after title, at optional whitespace. * * ```markdown * > | [a](b "c") d * ^ * ``` * * @type {State} */ function resourceTitleAfter(code) { return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code); } /** * In resource, at `)`. * * ```markdown * > | [a](b) d * ^ * ``` * * @type {State} */ function resourceEnd(code) { if (code === 41) { effects.enter("resourceMarker"); effects.consume(code); effects.exit("resourceMarker"); effects.exit("resource"); return ok; } return nok(code); } } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeReferenceFull(effects, ok, nok) { const self = this; return referenceFull; /** * In a reference (full), at the `[`. * * ```markdown * > | [a][b] d * ^ * ``` * * @type {State} */ function referenceFull(code) { return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, "reference", "referenceMarker", "referenceString")(code); } /** * In a reference (full), after `]`. * * ```markdown * > | [a][b] d * ^ * ``` * * @type {State} */ function referenceFullAfter(code) { return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code); } /** * In reference (full) that was missing. * * ```markdown * > | [a][b d * ^ * ``` * * @type {State} */ function referenceFullMissing(code) { return nok(code); } } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeReferenceCollapsed(effects, ok, nok) { return referenceCollapsedStart; /** * In reference (collapsed), at `[`. * * > 👉 **Note**: we only get here if the label is defined. * * ```markdown * > | [a][] d * ^ * ``` * * @type {State} */ function referenceCollapsedStart(code) { // We only attempt a collapsed label if there’s a `[`. effects.enter("reference"); effects.enter("referenceMarker"); effects.consume(code); effects.exit("referenceMarker"); return referenceCollapsedOpen; } /** * In reference (collapsed), at `]`. * * > 👉 **Note**: we only get here if the label is defined. * * ```markdown * > | [a][] d * ^ * ``` * * @type {State} */ function referenceCollapsedOpen(code) { if (code === 93) { effects.enter("referenceMarker"); effects.consume(code); effects.exit("referenceMarker"); effects.exit("reference"); return ok; } return nok(code); } }/** * @import { * Construct, * State, * TokenizeContext, * Tokenizer * } from 'micromark-util-types' */ import { labelEnd } from './label-end.js'; /** @type {Construct} */ export const labelStartImage = { name: 'labelStartImage', resolveAll: labelEnd.resolveAll, tokenize: tokenizeLabelStartImage }; /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeLabelStartImage(effects, ok, nok) { const self = this; return start; /** * Start of label (image) start. * * ```markdown * > | a ![b] c * ^ * ``` * * @type {State} */ function start(code) { effects.enter("labelImage"); effects.enter("labelImageMarker"); effects.consume(code); effects.exit("labelImageMarker"); return open; } /** * After `!`, at `[`. * * ```markdown * > | a ![b] c * ^ * ``` * * @type {State} */ function open(code) { if (code === 91) { effects.enter("labelMarker"); effects.consume(code); effects.exit("labelMarker"); effects.exit("labelImage"); return after; } return nok(code); } /** * After `![`. * * ```markdown * > | a ![b] c * ^ * ``` * * This is needed in because, when GFM footnotes are enabled, images never * form when started with a `^`. * Instead, links form: * * ```markdown * ![^a](b) * * ![^a][b] * * [b]: c * ``` * * ```html *!^a
*
!^a
* ``` * * @type {State} */ function after(code) { // To do: use a new field to do this, this is still needed for // `micromark-extension-gfm-footnote`, but the `label-start-link` // behavior isn’t. // Hidden footnotes hook. /* c8 ignore next 3 */ return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code); } }/** * @import { * Construct, * State, * TokenizeContext, * Tokenizer * } from 'micromark-util-types' */ import { labelEnd } from './label-end.js'; /** @type {Construct} */ export const labelStartLink = { name: 'labelStartLink', resolveAll: labelEnd.resolveAll, tokenize: tokenizeLabelStartLink }; /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeLabelStartLink(effects, ok, nok) { const self = this; return start; /** * Start of label (link) start. * * ```markdown * > | a [b] c * ^ * ``` * * @type {State} */ function start(code) { effects.enter("labelLink"); effects.enter("labelMarker"); effects.consume(code); effects.exit("labelMarker"); effects.exit("labelLink"); return after; } /** @type {State} */ function after(code) { // To do: this isn’t needed in `micromark-extension-gfm-footnote`, // remove. // Hidden footnotes hook. /* c8 ignore next 3 */ return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code); } }/** * @import { * Construct, * State, * TokenizeContext, * Tokenizer * } from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding } from 'micromark-util-character'; /** @type {Construct} */ export const lineEnding = { name: 'lineEnding', tokenize: tokenizeLineEnding }; /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeLineEnding(effects, ok) { return start; /** @type {State} */ function start(code) { effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); return factorySpace(effects, ok, "linePrefix"); } }/** * @import { * Code, * Construct, * Exiter, * State, * TokenizeContext, * Tokenizer * } from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { asciiDigit, markdownSpace } from 'micromark-util-character'; import { blankLine } from './blank-line.js'; import { thematicBreak } from './thematic-break.js'; /** @type {Construct} */ export const list = { continuation: { tokenize: tokenizeListContinuation }, exit: tokenizeListEnd, name: 'list', tokenize: tokenizeListStart }; /** @type {Construct} */ const listItemPrefixWhitespaceConstruct = { partial: true, tokenize: tokenizeListItemPrefixWhitespace }; /** @type {Construct} */ const indentConstruct = { partial: true, tokenize: tokenizeIndent }; // To do: `markdown-rs` parses list items on their own and later stitches them // together. /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeListStart(effects, ok, nok) { const self = this; const tail = self.events[self.events.length - 1]; let initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0; let size = 0; return start; /** @type {State} */ function start(code) { const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? "listUnordered" : "listOrdered"); if (kind === "listUnordered" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) { if (!self.containerState.type) { self.containerState.type = kind; effects.enter(kind, { _container: true }); } if (kind === "listUnordered") { effects.enter("listItemPrefix"); return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code); } if (!self.interrupt || code === 49) { effects.enter("listItemPrefix"); effects.enter("listItemValue"); return inside(code); } } return nok(code); } /** @type {State} */ function inside(code) { if (asciiDigit(code) && ++size < 10) { effects.consume(code); return inside; } if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) { effects.exit("listItemValue"); return atMarker(code); } return nok(code); } /** * @type {State} **/ function atMarker(code) { effects.enter("listItemMarker"); effects.consume(code); effects.exit("listItemMarker"); self.containerState.marker = self.containerState.marker || code; return effects.check(blankLine, // Can’t be empty when interrupting. self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix)); } /** @type {State} */ function onBlank(code) { self.containerState.initialBlankLine = true; initialSize++; return endOfPrefix(code); } /** @type {State} */ function otherPrefix(code) { if (markdownSpace(code)) { effects.enter("listItemPrefixWhitespace"); effects.consume(code); effects.exit("listItemPrefixWhitespace"); return endOfPrefix; } return nok(code); } /** @type {State} */ function endOfPrefix(code) { self.containerState.size = initialSize + self.sliceSerialize(effects.exit("listItemPrefix"), true).length; return ok(code); } } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeListContinuation(effects, ok, nok) { const self = this; self.containerState._closeFlow = undefined; return effects.check(blankLine, onBlank, notBlank); /** @type {State} */ function onBlank(code) { self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine; // We have a blank line. // Still, try to consume at most the items size. return factorySpace(effects, ok, "listItemIndent", self.containerState.size + 1)(code); } /** @type {State} */ function notBlank(code) { if (self.containerState.furtherBlankLines || !markdownSpace(code)) { self.containerState.furtherBlankLines = undefined; self.containerState.initialBlankLine = undefined; return notInCurrentItem(code); } self.containerState.furtherBlankLines = undefined; self.containerState.initialBlankLine = undefined; return effects.attempt(indentConstruct, ok, notInCurrentItem)(code); } /** @type {State} */ function notInCurrentItem(code) { // While we do continue, we signal that the flow should be closed. self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting. self.interrupt = undefined; // Always populated by defaults. return factorySpace(effects, effects.attempt(list, ok, nok), "linePrefix", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code); } } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeIndent(effects, ok, nok) { const self = this; return factorySpace(effects, afterPrefix, "listItemIndent", self.containerState.size + 1); /** @type {State} */ function afterPrefix(code) { const tail = self.events[self.events.length - 1]; return tail && tail[1].type === "listItemIndent" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code); } } /** * @this {TokenizeContext} * Context. * @type {Exiter} */ function tokenizeListEnd(effects) { effects.exit(this.containerState.type); } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeListItemPrefixWhitespace(effects, ok, nok) { const self = this; // Always populated by defaults. return factorySpace(effects, afterPrefix, "listItemPrefixWhitespace", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1); /** @type {State} */ function afterPrefix(code) { const tail = self.events[self.events.length - 1]; return !markdownSpace(code) && tail && tail[1].type === "listItemPrefixWhitespace" ? ok(code) : nok(code); } }/** * @import { * Code, * Construct, * Resolver, * State, * TokenizeContext, * Tokenizer * } from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding, markdownSpace } from 'micromark-util-character'; /** @type {Construct} */ export const setextUnderline = { name: 'setextUnderline', resolveTo: resolveToSetextUnderline, tokenize: tokenizeSetextUnderline }; /** @type {Resolver} */ function resolveToSetextUnderline(events, context) { // To do: resolve like `markdown-rs`. let index = events.length; /** @type {number | undefined} */ let content; /** @type {number | undefined} */ let text; /** @type {number | undefined} */ let definition; // Find the opening of the content. // It’ll always exist: we don’t tokenize if it isn’t there. while (index--) { if (events[index][0] === 'enter') { if (events[index][1].type === "content") { content = index; break; } if (events[index][1].type === "paragraph") { text = index; } } // Exit else { if (events[index][1].type === "content") { // Remove the content end (if needed we’ll add it later) events.splice(index, 1); } if (!definition && events[index][1].type === "definition") { definition = index; } } } const heading = { type: "setextHeading", start: { ...events[content][1].start }, end: { ...events[events.length - 1][1].end } }; // Change the paragraph to setext heading text. events[text][1].type = "setextHeadingText"; // If we have definitions in the content, we’ll keep on having content, // but we need move it. if (definition) { events.splice(text, 0, ['enter', heading, context]); events.splice(definition + 1, 0, ['exit', events[content][1], context]); events[content][1].end = { ...events[definition][1].end }; } else { events[content][1] = heading; } // Add the heading exit at the end. events.push(['exit', heading, context]); return events; } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeSetextUnderline(effects, ok, nok) { const self = this; /** @type {NonNullable} */ let marker; return start; /** * At start of heading (setext) underline. * * ```markdown * | aa * > | == * ^ * ``` * * @type {State} */ function start(code) { let index = self.events.length; /** @type {boolean | undefined} */ let paragraph; // Find an opening. while (index--) { // Skip enter/exit of line ending, line prefix, and content. // We can now either have a definition or a paragraph. if (self.events[index][1].type !== "lineEnding" && self.events[index][1].type !== "linePrefix" && self.events[index][1].type !== "content") { paragraph = self.events[index][1].type === "paragraph"; break; } } // To do: handle lazy/pierce like `markdown-rs`. // To do: parse indent like `markdown-rs`. if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) { effects.enter("setextHeadingLine"); marker = code; return before(code); } return nok(code); } /** * After optional whitespace, at `-` or `=`. * * ```markdown * | aa * > | == * ^ * ``` * * @type {State} */ function before(code) { effects.enter("setextHeadingLineSequence"); return inside(code); } /** * In sequence. * * ```markdown * | aa * > | == * ^ * ``` * * @type {State} */ function inside(code) { if (code === marker) { effects.consume(code); return inside; } effects.exit("setextHeadingLineSequence"); return markdownSpace(code) ? factorySpace(effects, after, "lineSuffix")(code) : after(code); } /** * After sequence, after optional whitespace. * * ```markdown * | aa * > | == * ^ * ``` * * @type {State} */ function after(code) { if (code === null || markdownLineEnding(code)) { effects.exit("setextHeadingLine"); return ok(code); } return nok(code); } }/** * @import { * Code, * Construct, * State, * TokenizeContext, * Tokenizer * } from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding, markdownSpace } from 'micromark-util-character'; /** @type {Construct} */ export const thematicBreak = { name: 'thematicBreak', tokenize: tokenizeThematicBreak }; /** * @this {TokenizeContext} * Context. * @type {Tokenizer} */ function tokenizeThematicBreak(effects, ok, nok) { let size = 0; /** @type {NonNullable} */ let marker; return start; /** * Start of thematic break. * * ```markdown * > | *** * ^ * ``` * * @type {State} */ function start(code) { effects.enter("thematicBreak"); // To do: parse indent like `markdown-rs`. return before(code); } /** * After optional whitespace, at marker. * * ```markdown * > | *** * ^ * ``` * * @type {State} */ function before(code) { marker = code; return atBreak(code); } /** * After something, before something else. * * ```markdown * > | *** * ^ * ``` * * @type {State} */ function atBreak(code) { if (code === marker) { effects.enter("thematicBreakSequence"); return sequence(code); } if (size >= 3 && (code === null || markdownLineEnding(code))) { effects.exit("thematicBreak"); return ok(code); } return nok(code); } /** * In sequence. * * ```markdown * > | *** * ^ * ``` * * @type {State} */ function sequence(code) { if (code === marker) { effects.consume(code); size++; return sequence; } effects.exit("thematicBreakSequence"); return markdownSpace(code) ? factorySpace(effects, atBreak, "whitespace")(code) : atBreak(code); } }{ "name": "micromark-core-commonmark", "version": "2.0.3", "description": "The CommonMark markdown constructs", "license": "MIT", "keywords": [ "micromark", "core", "commonmark" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-core-commonmark", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "lib/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-factory-destination": "^2.0.0", "micromark-factory-label": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-title": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-html-tag-name": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "logical-assignment-operators": "off", "max-depth": "off", "unicorn/no-this-assignment": "off", "unicorn/prefer-at": "off", "unicorn/prefer-code-point": "off" } } } // Note: more types exported from `index.d.ts`. export { directive } from './lib/syntax.js'; export { directiveHtml } from './lib/html.js';/** * @import {Construct, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding } from 'micromark-util-character'; import { factoryAttributes } from './factory-attributes.js'; import { factoryLabel } from './factory-label.js'; import { factoryName } from './factory-name.js'; /** @type {Construct} */ export const directiveContainer = { tokenize: tokenizeDirectiveContainer, concrete: true }; const label = { tokenize: tokenizeLabel, partial: true }; const attributes = { tokenize: tokenizeAttributes, partial: true }; const nonLazyLine = { tokenize: tokenizeNonLazyLine, partial: true }; /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeDirectiveContainer(effects, ok, nok) { const self = this; const tail = self.events[self.events.length - 1]; const initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0; let sizeOpen = 0; /** @type {Token} */ let previous; return start; /** @type {State} */ function start(code) { effects.enter('directiveContainer'); effects.enter('directiveContainerFence'); effects.enter('directiveContainerSequence'); return sequenceOpen(code); } /** @type {State} */ function sequenceOpen(code) { if (code === 58) { effects.consume(code); sizeOpen++; return sequenceOpen; } if (sizeOpen < 3) { return nok(code); } effects.exit('directiveContainerSequence'); return factoryName.call(self, effects, afterName, nok, 'directiveContainerName')(code); } /** @type {State} */ function afterName(code) { return code === 91 ? effects.attempt(label, afterLabel, afterLabel)(code) : afterLabel(code); } /** @type {State} */ function afterLabel(code) { return code === 123 ? effects.attempt(attributes, afterAttributes, afterAttributes)(code) : afterAttributes(code); } /** @type {State} */ function afterAttributes(code) { return factorySpace(effects, openAfter, "whitespace")(code); } /** @type {State} */ function openAfter(code) { effects.exit('directiveContainerFence'); if (code === null) { return after(code); } if (markdownLineEnding(code)) { if (self.interrupt) { return ok(code); } return effects.attempt(nonLazyLine, contentStart, after)(code); } return nok(code); } /** @type {State} */ function contentStart(code) { if (code === null) { return after(code); } if (markdownLineEnding(code)) { return effects.check(nonLazyLine, emptyContentNonLazyLineAfter, after)(code); } effects.enter('directiveContainerContent'); return lineStart(code); } /** @type {State} */ function lineStart(code) { return effects.attempt({ tokenize: tokenizeClosingFence, partial: true }, afterContent, initialSize ? factorySpace(effects, chunkStart, "linePrefix", initialSize + 1) : chunkStart)(code); } /** @type {State} */ function chunkStart(code) { if (code === null) { return afterContent(code); } if (markdownLineEnding(code)) { return effects.check(nonLazyLine, chunkNonLazyStart, afterContent)(code); } return chunkNonLazyStart(code); } /** @type {State} */ function contentContinue(code) { if (code === null) { const t = effects.exit("chunkDocument"); self.parser.lazy[t.start.line] = false; return afterContent(code); } if (markdownLineEnding(code)) { return effects.check(nonLazyLine, nonLazyLineAfter, lineAfter)(code); } effects.consume(code); return contentContinue; } /** @type {State} */ function chunkNonLazyStart(code) { const token = effects.enter("chunkDocument", { contentType: "document", previous }); if (previous) previous.next = token; previous = token; return contentContinue(code); } /** @type {State} */ function emptyContentNonLazyLineAfter(code) { effects.enter('directiveContainerContent'); return lineStart(code); } /** @type {State} */ function nonLazyLineAfter(code) { effects.consume(code); const t = effects.exit("chunkDocument"); self.parser.lazy[t.start.line] = false; return lineStart; } /** @type {State} */ function lineAfter(code) { const t = effects.exit("chunkDocument"); self.parser.lazy[t.start.line] = false; return afterContent(code); } /** @type {State} */ function afterContent(code) { effects.exit('directiveContainerContent'); return after(code); } /** @type {State} */ function after(code) { effects.exit('directiveContainer'); return ok(code); } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeClosingFence(effects, ok, nok) { let size = 0; return factorySpace(effects, closingPrefixAfter, "linePrefix", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4); /** @type {State} */ function closingPrefixAfter(code) { effects.enter('directiveContainerFence'); effects.enter('directiveContainerSequence'); return closingSequence(code); } /** @type {State} */ function closingSequence(code) { if (code === 58) { effects.consume(code); size++; return closingSequence; } if (size < sizeOpen) return nok(code); effects.exit('directiveContainerSequence'); return factorySpace(effects, closingSequenceEnd, "whitespace")(code); } /** @type {State} */ function closingSequenceEnd(code) { if (code === null || markdownLineEnding(code)) { effects.exit('directiveContainerFence'); return ok(code); } return nok(code); } } } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeLabel(effects, ok, nok) { // Always a `[` return factoryLabel(effects, ok, nok, 'directiveContainerLabel', 'directiveContainerLabelMarker', 'directiveContainerLabelString', true); } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeAttributes(effects, ok, nok) { // Always a `{` return factoryAttributes(effects, ok, nok, 'directiveContainerAttributes', 'directiveContainerAttributesMarker', 'directiveContainerAttribute', 'directiveContainerAttributeId', 'directiveContainerAttributeClass', 'directiveContainerAttributeName', 'directiveContainerAttributeInitializerMarker', 'directiveContainerAttributeValueLiteral', 'directiveContainerAttributeValue', 'directiveContainerAttributeValueMarker', 'directiveContainerAttributeValueData', true); } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeNonLazyLine(effects, ok, nok) { const self = this; return start; /** @type {State} */ function start(code) { effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); return lineStart; } /** @type {State} */ function lineStart(code) { return self.parser.lazy[self.now().line] ? nok(code) : ok(code); } }/** * @import {Construct, State, TokenizeContext, Tokenizer} from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding } from 'micromark-util-character'; import { factoryAttributes } from './factory-attributes.js'; import { factoryLabel } from './factory-label.js'; import { factoryName } from './factory-name.js'; /** @type {Construct} */ export const directiveLeaf = { tokenize: tokenizeDirectiveLeaf }; const label = { tokenize: tokenizeLabel, partial: true }; const attributes = { tokenize: tokenizeAttributes, partial: true }; /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeDirectiveLeaf(effects, ok, nok) { const self = this; return start; /** @type {State} */ function start(code) { effects.enter('directiveLeaf'); effects.enter('directiveLeafSequence'); effects.consume(code); return inStart; } /** @type {State} */ function inStart(code) { if (code === 58) { effects.consume(code); effects.exit('directiveLeafSequence'); return factoryName.call(self, effects, afterName, nok, 'directiveLeafName'); } return nok(code); } /** @type {State} */ function afterName(code) { return code === 91 ? effects.attempt(label, afterLabel, afterLabel)(code) : afterLabel(code); } /** @type {State} */ function afterLabel(code) { return code === 123 ? effects.attempt(attributes, afterAttributes, afterAttributes)(code) : afterAttributes(code); } /** @type {State} */ function afterAttributes(code) { return factorySpace(effects, end, "whitespace")(code); } /** @type {State} */ function end(code) { if (code === null || markdownLineEnding(code)) { effects.exit('directiveLeaf'); return ok(code); } return nok(code); } } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeLabel(effects, ok, nok) { // Always a `[` return factoryLabel(effects, ok, nok, 'directiveLeafLabel', 'directiveLeafLabelMarker', 'directiveLeafLabelString', true); } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeAttributes(effects, ok, nok) { // Always a `{` return factoryAttributes(effects, ok, nok, 'directiveLeafAttributes', 'directiveLeafAttributesMarker', 'directiveLeafAttribute', 'directiveLeafAttributeId', 'directiveLeafAttributeClass', 'directiveLeafAttributeName', 'directiveLeafAttributeInitializerMarker', 'directiveLeafAttributeValueLiteral', 'directiveLeafAttributeValue', 'directiveLeafAttributeValueMarker', 'directiveLeafAttributeValueData', true); }/** * @import {Construct, Previous, State, TokenizeContext, Tokenizer} from 'micromark-util-types' */ import { factoryAttributes } from './factory-attributes.js'; import { factoryLabel } from './factory-label.js'; import { factoryName } from './factory-name.js'; /** @type {Construct} */ export const directiveText = { tokenize: tokenizeDirectiveText, previous }; const label = { tokenize: tokenizeLabel, partial: true }; const attributes = { tokenize: tokenizeAttributes, partial: true }; /** * @this {TokenizeContext} * @type {Previous} */ function previous(code) { // If there is a previous code, there will always be a tail. return code !== 58 || this.events[this.events.length - 1][1].type === "characterEscape"; } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeDirectiveText(effects, ok, nok) { const self = this; return start; /** @type {State} */ function start(code) { effects.enter('directiveText'); effects.enter('directiveTextMarker'); effects.consume(code); effects.exit('directiveTextMarker'); return factoryName.call(self, effects, afterName, nok, 'directiveTextName'); } /** @type {State} */ function afterName(code) { return code === 58 ? nok(code) : code === 91 ? effects.attempt(label, afterLabel, afterLabel)(code) : afterLabel(code); } /** @type {State} */ function afterLabel(code) { return code === 123 ? effects.attempt(attributes, afterAttributes, afterAttributes)(code) : afterAttributes(code); } /** @type {State} */ function afterAttributes(code) { effects.exit('directiveText'); return ok(code); } } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeLabel(effects, ok, nok) { // Always a `[` return factoryLabel(effects, ok, nok, 'directiveTextLabel', 'directiveTextLabelMarker', 'directiveTextLabelString'); } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeAttributes(effects, ok, nok) { // Always a `{` return factoryAttributes(effects, ok, nok, 'directiveTextAttributes', 'directiveTextAttributesMarker', 'directiveTextAttribute', 'directiveTextAttributeId', 'directiveTextAttributeClass', 'directiveTextAttributeName', 'directiveTextAttributeInitializerMarker', 'directiveTextAttributeValueLiteral', 'directiveTextAttributeValue', 'directiveTextAttributeValueMarker', 'directiveTextAttributeValueData'); }/** * @import {Code, Effects, State, TokenType} from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { factoryWhitespace } from 'micromark-factory-whitespace'; import { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character'; /** * @param {Effects} effects * @param {State} ok * @param {State} nok * @param {TokenType} attributesType * @param {TokenType} attributesMarkerType * @param {TokenType} attributeType * @param {TokenType} attributeIdType * @param {TokenType} attributeClassType * @param {TokenType} attributeNameType * @param {TokenType} attributeInitializerType * @param {TokenType} attributeValueLiteralType * @param {TokenType} attributeValueType * @param {TokenType} attributeValueMarker * @param {TokenType} attributeValueData * @param {boolean | undefined} [disallowEol=false] */ export function factoryAttributes(effects, ok, nok, attributesType, attributesMarkerType, attributeType, attributeIdType, attributeClassType, attributeNameType, attributeInitializerType, attributeValueLiteralType, attributeValueType, attributeValueMarker, attributeValueData, disallowEol) { /** @type {TokenType} */ let type; /** @type {Code | undefined} */ let marker; return start; /** @type {State} */ function start(code) { effects.enter(attributesType); effects.enter(attributesMarkerType); effects.consume(code); effects.exit(attributesMarkerType); return between; } /** @type {State} */ function between(code) { if (code === 35) { type = attributeIdType; return shortcutStart(code); } if (code === 46) { type = attributeClassType; return shortcutStart(code); } if (disallowEol && markdownSpace(code)) { return factorySpace(effects, between, "whitespace")(code); } if (!disallowEol && markdownLineEndingOrSpace(code)) { return factoryWhitespace(effects, between)(code); } if (code === null || markdownLineEnding(code) || unicodeWhitespace(code) || unicodePunctuation(code) && code !== 45 && code !== 95) { return end(code); } effects.enter(attributeType); effects.enter(attributeNameType); effects.consume(code); return name; } /** @type {State} */ function shortcutStart(code) { // Assume it’s registered. const markerType = /** @type {TokenType} */type + 'Marker'; effects.enter(attributeType); effects.enter(type); effects.enter(markerType); effects.consume(code); effects.exit(markerType); return shortcutStartAfter; } /** @type {State} */ function shortcutStartAfter(code) { if (code === null || code === 34 || code === 35 || code === 39 || code === 46 || code === 60 || code === 61 || code === 62 || code === 96 || code === 125 || markdownLineEndingOrSpace(code)) { return nok(code); } // Assume it’s registered. const valueType = /** @type {TokenType} */type + 'Value'; effects.enter(valueType); effects.consume(code); return shortcut; } /** @type {State} */ function shortcut(code) { if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96) { return nok(code); } if (code === 35 || code === 46 || code === 125 || markdownLineEndingOrSpace(code)) { // Assume it’s registered. const valueType = /** @type {TokenType} */type + 'Value'; effects.exit(valueType); effects.exit(type); effects.exit(attributeType); return between(code); } effects.consume(code); return shortcut; } /** @type {State} */ function name(code) { if (code === null || markdownLineEnding(code) || unicodeWhitespace(code) || unicodePunctuation(code) && code !== 45 && code !== 46 && code !== 58 && code !== 95) { effects.exit(attributeNameType); if (disallowEol && markdownSpace(code)) { return factorySpace(effects, nameAfter, "whitespace")(code); } if (!disallowEol && markdownLineEndingOrSpace(code)) { return factoryWhitespace(effects, nameAfter)(code); } return nameAfter(code); } effects.consume(code); return name; } /** @type {State} */ function nameAfter(code) { if (code === 61) { effects.enter(attributeInitializerType); effects.consume(code); effects.exit(attributeInitializerType); return valueBefore; } // Attribute w/o value. effects.exit(attributeType); return between(code); } /** @type {State} */ function valueBefore(code) { if (code === null || code === 60 || code === 61 || code === 62 || code === 96 || code === 125 || disallowEol && markdownLineEnding(code)) { return nok(code); } if (code === 34 || code === 39) { effects.enter(attributeValueLiteralType); effects.enter(attributeValueMarker); effects.consume(code); effects.exit(attributeValueMarker); marker = code; return valueQuotedStart; } if (disallowEol && markdownSpace(code)) { return factorySpace(effects, valueBefore, "whitespace")(code); } if (!disallowEol && markdownLineEndingOrSpace(code)) { return factoryWhitespace(effects, valueBefore)(code); } effects.enter(attributeValueType); effects.enter(attributeValueData); effects.consume(code); marker = undefined; return valueUnquoted; } /** @type {State} */ function valueUnquoted(code) { if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96) { return nok(code); } if (code === 125 || markdownLineEndingOrSpace(code)) { effects.exit(attributeValueData); effects.exit(attributeValueType); effects.exit(attributeType); return between(code); } effects.consume(code); return valueUnquoted; } /** @type {State} */ function valueQuotedStart(code) { if (code === marker) { effects.enter(attributeValueMarker); effects.consume(code); effects.exit(attributeValueMarker); effects.exit(attributeValueLiteralType); effects.exit(attributeType); return valueQuotedAfter; } effects.enter(attributeValueType); return valueQuotedBetween(code); } /** @type {State} */ function valueQuotedBetween(code) { if (code === marker) { effects.exit(attributeValueType); return valueQuotedStart(code); } if (code === null) { return nok(code); } // Note: blank lines can’t exist in content. if (markdownLineEnding(code)) { return disallowEol ? nok(code) : factoryWhitespace(effects, valueQuotedBetween)(code); } effects.enter(attributeValueData); effects.consume(code); return valueQuoted; } /** @type {State} */ function valueQuoted(code) { if (code === marker || code === null || markdownLineEnding(code)) { effects.exit(attributeValueData); return valueQuotedBetween(code); } effects.consume(code); return valueQuoted; } /** @type {State} */ function valueQuotedAfter(code) { return code === 125 || markdownLineEndingOrSpace(code) ? between(code) : end(code); } /** @type {State} */ function end(code) { if (code === 125) { effects.enter(attributesMarkerType); effects.consume(code); effects.exit(attributesMarkerType); effects.exit(attributesType); return ok; } return nok(code); } }/** * @import {Code, Effects, State, Token, TokenType} from 'micromark-util-types' */ import { markdownLineEnding } from 'micromark-util-character'; // This is a fork of: // // to allow empty labels, balanced brackets (such as for nested directives), // text instead of strings, and optionally disallows EOLs. /** * @param {Effects} effects * @param {State} ok * @param {State} nok * @param {TokenType} type * @param {TokenType} markerType * @param {TokenType} stringType * @param {boolean | undefined} [disallowEol=false] */ export function factoryLabel(effects, ok, nok, type, markerType, stringType, disallowEol) { let size = 0; let balance = 0; /** @type {Token | undefined} */ let previous; return start; /** @type {State} */ function start(code) { effects.enter(type); effects.enter(markerType); effects.consume(code); effects.exit(markerType); return afterStart; } /** @type {State} */ function afterStart(code) { if (code === 93) { effects.enter(markerType); effects.consume(code); effects.exit(markerType); effects.exit(type); return ok; } effects.enter(stringType); return lineStart(code); } /** @type {State} */ function lineStart(code) { if (code === 93 && !balance) { return atClosingBrace(code); } const token = effects.enter("chunkText", { _contentTypeTextTrailing: true, contentType: "text", previous }); if (previous) previous.next = token; previous = token; return data(code); } /** @type {State} */ function data(code) { if (code === null || size > 999) { return nok(code); } if (code === 91 && ++balance > 32) { return nok(code); } if (code === 93 && !balance--) { effects.exit("chunkText"); return atClosingBrace(code); } if (markdownLineEnding(code)) { if (disallowEol) { return nok(code); } effects.consume(code); effects.exit("chunkText"); return lineStart; } effects.consume(code); return code === 92 ? dataEscape : data; } /** @type {State} */ function dataEscape(code) { if (code === 91 || code === 92 || code === 93) { effects.consume(code); size++; return data; } return data(code); } /** @type {State} */ function atClosingBrace(code) { effects.exit(stringType); effects.enter(markerType); effects.consume(code); effects.exit(markerType); effects.exit(type); return ok; } }/** * @import {Code, Effects, State, TokenizeContext, TokenType} from 'micromark-util-types' */ import { markdownLineEnding, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character'; /** * @this {TokenizeContext} * @param {Effects} effects * @param {State} ok * @param {State} nok * @param {TokenType} type */ export function factoryName(effects, ok, nok, type) { const self = this; return start; /** @type {State} */ function start(code) { if (code === null || markdownLineEnding(code) || unicodePunctuation(code) || unicodeWhitespace(code)) { return nok(code); } effects.enter(type); effects.consume(code); return name; } /** @type {State} */ function name(code) { if (code === null || markdownLineEnding(code) || unicodeWhitespace(code) || unicodePunctuation(code) && code !== 45 && code !== 95) { effects.exit(type); return self.previous === 45 || self.previous === 95 ? nok(code) : ok(code); } effects.consume(code); return name; } }/** * @import {Directive, HtmlOptions} from 'micromark-extension-directive' * @import {CompileContext, Handle as MicromarkHandle, HtmlExtension} from 'micromark-util-types' */ import { parseEntities } from 'parse-entities'; const own = {}.hasOwnProperty; /** * Create an extension for `micromark` to support directives when serializing * to HTML. * * @param {HtmlOptions | null | undefined} [options={}] * Configuration (default: `{}`). * @returns {HtmlExtension} * Extension for `micromark` that can be passed in `htmlExtensions`, to * support directives when serializing to HTML. */ export function directiveHtml(options) { const options_ = options || {}; return { enter: { directiveContainer() { enter.call(this, 'containerDirective'); }, directiveContainerAttributes: enterAttributes, directiveContainerLabel: enterLabel, directiveContainerContent() { this.buffer(); }, directiveLeaf() { enter.call(this, 'leafDirective'); }, directiveLeafAttributes: enterAttributes, directiveLeafLabel: enterLabel, directiveText() { enter.call(this, 'textDirective'); }, directiveTextAttributes: enterAttributes, directiveTextLabel: enterLabel }, exit: { directiveContainer: exit, directiveContainerAttributeClassValue: exitAttributeClassValue, directiveContainerAttributeIdValue: exitAttributeIdValue, directiveContainerAttributeName: exitAttributeName, directiveContainerAttributeValue: exitAttributeValue, directiveContainerAttributes: exitAttributes, directiveContainerContent: exitContainerContent, directiveContainerFence: exitContainerFence, directiveContainerLabel: exitLabel, directiveContainerName: exitName, directiveLeaf: exit, directiveLeafAttributeClassValue: exitAttributeClassValue, directiveLeafAttributeIdValue: exitAttributeIdValue, directiveLeafAttributeName: exitAttributeName, directiveLeafAttributeValue: exitAttributeValue, directiveLeafAttributes: exitAttributes, directiveLeafLabel: exitLabel, directiveLeafName: exitName, directiveText: exit, directiveTextAttributeClassValue: exitAttributeClassValue, directiveTextAttributeIdValue: exitAttributeIdValue, directiveTextAttributeName: exitAttributeName, directiveTextAttributeValue: exitAttributeValue, directiveTextAttributes: exitAttributes, directiveTextLabel: exitLabel, directiveTextName: exitName } }; /** * @this {CompileContext} * @param {Directive['type']} type */ function enter(type) { let stack = this.getData('directiveStack'); if (!stack) this.setData('directiveStack', stack = []); stack.push({ type, name: '' }); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitName(token) { const stack = this.getData('directiveStack'); stack[stack.length - 1].name = this.sliceSerialize(token); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function enterLabel() { this.buffer(); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitLabel() { const data = this.resume(); const stack = this.getData('directiveStack'); stack[stack.length - 1].label = data; } /** * @this {CompileContext} * @type {MicromarkHandle} */ function enterAttributes() { this.buffer(); this.setData('directiveAttributes', []); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitAttributeIdValue(token) { const attributes = this.getData('directiveAttributes'); attributes.push(['id', parseEntities(this.sliceSerialize(token), { attribute: true })]); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitAttributeClassValue(token) { const attributes = this.getData('directiveAttributes'); attributes.push(['class', parseEntities(this.sliceSerialize(token), { attribute: true })]); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitAttributeName(token) { // Attribute names in CommonMark are significantly limited, so character // references can’t exist. const attributes = this.getData('directiveAttributes'); attributes.push([this.sliceSerialize(token), '']); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitAttributeValue(token) { const attributes = this.getData('directiveAttributes'); attributes[attributes.length - 1][1] = parseEntities(this.sliceSerialize(token), { attribute: true }); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitAttributes() { const stack = this.getData('directiveStack'); const attributes = this.getData('directiveAttributes'); /** @type {Record} */ const cleaned = {}; let index = -1; while (++index < attributes.length) { const attribute = attributes[index]; if (attribute[0] === 'class' && cleaned.class) { cleaned.class += ' ' + attribute[1]; } else { cleaned[attribute[0]] = attribute[1]; } } this.resume(); this.setData('directiveAttributes'); stack[stack.length - 1].attributes = cleaned; } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitContainerContent() { const data = this.resume(); const stack = this.getData('directiveStack'); stack[stack.length - 1].content = data; } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exitContainerFence() { const stack = this.getData('directiveStack'); const directive = stack[stack.length - 1]; if (!directive._fenceCount) directive._fenceCount = 0; directive._fenceCount++; if (directive._fenceCount === 1) this.setData('slurpOneLineEnding', true); } /** * @this {CompileContext} * @type {MicromarkHandle} */ function exit() { const stack = this.getData('directiveStack'); const directive = stack.pop(); /** @type {boolean | undefined} */ let found; /** @type {boolean | undefined} */ let result; if (own.call(options_, directive.name)) { result = options_[directive.name].call(this, directive); found = result !== false; } if (!found && own.call(options_, '*')) { result = options_['*'].call(this, directive); found = result !== false; } if (!found && directive.type !== 'textDirective') { this.setData('slurpOneLineEnding', true); } } }/** * @import {Extension} from 'micromark-util-types' */ import { directiveContainer } from './directive-container.js'; import { directiveLeaf } from './directive-leaf.js'; import { directiveText } from './directive-text.js'; /** * Create an extension for `micromark` to enable directive syntax. * * @returns {Extension} * Extension for `micromark` that can be passed in `extensions`, to * enable directive syntax. */ export function directive() { return { text: { [58]: directiveText }, flow: { [58]: [directiveContainer, directiveLeaf] } }; }{ "author": "Titus Wormer (https://wooorm.com)", "bugs": "https://github.com/micromark/micromark-extension-directive/issues", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0", "parse-entities": "^4.0.0" }, "description": "micromark extension to support generic directives (`:cite[smith04]`)", "devDependencies": { "@types/node": "^22.0.0", "c8": "^10.0.0", "html-void-elements": "^3.0.0", "micromark": "^4.0.0", "micromark-build": "^2.0.0", "prettier": "^3.0.0", "remark-cli": "^12.0.0", "remark-preset-wooorm": "^11.0.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.60.0" }, "exports": { "development": "./dev/index.js", "default": "./index.js" }, "files": [ "dev/", "index.d.ts", "index.js", "lib/" ], "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" }, "keywords": [ "container", "directive", "extension", "generic", "markdown", "micromark-extension", "micromark", "unified" ], "license": "MIT", "name": "micromark-extension-directive", "prettier": { "bracketSpacing": false, "semi": false, "singleQuote": true, "tabWidth": 2, "trailingComma": "none", "useTabs": false }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "repository": "micromark/micromark-extension-directive", "scripts": { "build": "tsc --build --clean && tsc --build && type-coverage && micromark-build", "format": "remark --frail --output --quiet -- . && prettier --log-level warn --write -- . && xo --fix", "test-api-prod": "node --conditions production test/index.js", "test-api-dev": "node --conditions development test/index.js", "test-api": "npm run test-api-dev && npm run test-api-prod", "test-coverage": "c8 --100 --reporter lcov -- npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "sideEffects": false, "typeCoverage": { "atLeast": 100, "strict": true }, "type": "module", "version": "4.0.0", "xo": { "overrides": [ { "files": [ "**/*.d.ts" ], "rules": { "@typescript-eslint/array-type": [ "error", { "default": "generic" } ], "@typescript-eslint/ban-types": [ "error", { "extendDefaults": true } ], "@typescript-eslint/consistent-indexed-object-style": [ "error", "index-signature" ], "@typescript-eslint/consistent-type-definitions": [ "error", "interface" ] } } ], "prettier": true, "rules": { "logical-assignment-operators": "off", "max-params": "off", "unicorn/no-this-assignment": "off", "unicorn/prefer-at": "off" } } } // Note: types are exported from `dev/index.d.ts`. export { gfmFootnote } from './lib/syntax.js'; export { gfmFootnoteHtml, defaultBackLabel } from './lib/html.js';/** * @import {HtmlOptions as Options} from 'micromark-extension-gfm-footnote' * @import {HtmlExtension} from 'micromark-util-types' */ import { normalizeIdentifier } from 'micromark-util-normalize-identifier'; import { sanitizeUri } from 'micromark-util-sanitize-uri'; const own = {}.hasOwnProperty; /** @type {Options} */ const emptyOptions = {}; /** * Generate the default label that GitHub uses on backreferences. * * @param {number} referenceIndex * Index of the definition in the order that they are first referenced, * 0-indexed. * @param {number} rereferenceIndex * Index of calls to the same definition, 0-indexed. * @returns {string} * Default label. */ export function defaultBackLabel(referenceIndex, rereferenceIndex) { return 'Back to reference ' + (referenceIndex + 1) + (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''); } /** * Create an extension for `micromark` to support GFM footnotes when * serializing to HTML. * * @param {Options | null | undefined} [options={}] * Configuration (optional). * @returns {HtmlExtension} * Extension for `micromark` that can be passed in `htmlExtensions` to * support GFM footnotes when serializing to HTML. */ export function gfmFootnoteHtml(options) { const config = options || emptyOptions; const label = config.label || 'Footnotes'; const labelTagName = config.labelTagName || 'h2'; const labelAttributes = config.labelAttributes === null || config.labelAttributes === undefined ? 'class="sr-only"' : config.labelAttributes; const backLabel = config.backLabel || defaultBackLabel; const clobberPrefix = config.clobberPrefix === null || config.clobberPrefix === undefined ? 'user-content-' : config.clobberPrefix; return { enter: { gfmFootnoteDefinition() { const stack = this.getData('tightStack'); stack.push(false); }, gfmFootnoteDefinitionLabelString() { this.buffer(); }, gfmFootnoteCallString() { this.buffer(); } }, exit: { gfmFootnoteDefinition() { let definitions = this.getData('gfmFootnoteDefinitions'); const footnoteStack = this.getData('gfmFootnoteDefinitionStack'); const tightStack = this.getData('tightStack'); const current = footnoteStack.pop(); const value = this.resume(); if (!definitions) { this.setData('gfmFootnoteDefinitions', definitions = {}); } if (!own.call(definitions, current)) definitions[current] = value; tightStack.pop(); this.setData('slurpOneLineEnding', true); // “Hack” to prevent a line ending from showing up if we’re in a definition in // an empty list item. this.setData('lastWasTag'); }, gfmFootnoteDefinitionLabelString(token) { let footnoteStack = this.getData('gfmFootnoteDefinitionStack'); if (!footnoteStack) { this.setData('gfmFootnoteDefinitionStack', footnoteStack = []); } footnoteStack.push(normalizeIdentifier(this.sliceSerialize(token))); this.resume(); // Drop the label. this.buffer(); // Get ready for a value. }, gfmFootnoteCallString(token) { let calls = this.getData('gfmFootnoteCallOrder'); let counts = this.getData('gfmFootnoteCallCounts'); const id = normalizeIdentifier(this.sliceSerialize(token)); /** @type {number} */ let counter; this.resume(); if (!calls) this.setData('gfmFootnoteCallOrder', calls = []); if (!counts) this.setData('gfmFootnoteCallCounts', counts = {}); const index = calls.indexOf(id); const safeId = sanitizeUri(id.toLowerCase()); if (index === -1) { calls.push(id); counts[id] = 1; counter = calls.length; } else { counts[id]++; counter = index + 1; } const reuseCounter = counts[id]; this.tag('^{' + String(counter) + '}'); }, null() { const calls = this.getData('gfmFootnoteCallOrder') || []; const counts = this.getData('gfmFootnoteCallCounts') || {}; const definitions = this.getData('gfmFootnoteDefinitions') || {}; let index = -1; if (calls.length > 0) { this.lineEndingIfNeeded(); this.tag('<' + labelTagName + ' id="footnote-label"' + (labelAttributes ? ' ' + labelAttributes : '') + '>'); this.raw(this.encode(label)); this.tag(''); this.lineEndingIfNeeded(); this.tag(''); } while (++index < calls.length) { // Called definitions are always defined. const id = calls[index]; const safeId = sanitizeUri(id.toLowerCase()); let referenceIndex = 0; /** @type {Array} */ const references = []; while (++referenceIndex <= counts[id]) { references.push('↩' + (referenceIndex > 1 ? '^{' + referenceIndex + '}' : '') + ''); } const reference = references.join(' '); let injected = false; this.lineEndingIfNeeded(); this.tag(''); this.lineEndingIfNeeded(); this.tag(definitions[id].replace(/<\/p>(?:\r?\n|\r)?$/, function ($0) { injected = true; return ' ' + reference + $0; })); if (!injected) { this.lineEndingIfNeeded(); this.tag(reference); } this.lineEndingIfNeeded(); this.tag(''); } if (calls.length > 0) { this.lineEndingIfNeeded(); this.tag(''); this.lineEndingIfNeeded(); this.tag(''); } } } }; }/** * @import {Event, Exiter, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types' */ import { blankLine } from 'micromark-core-commonmark'; import { factorySpace } from 'micromark-factory-space'; import { markdownLineEndingOrSpace } from 'micromark-util-character'; import { normalizeIdentifier } from 'micromark-util-normalize-identifier'; const indent = { tokenize: tokenizeIndent, partial: true }; // To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only // affects label start (image). // That will let us drop `tokenizePotentialGfmFootnote*`. // It currently has a `_hiddenFootnoteSupport`, which affects that and more. // That can be removed when `micromark-extension-footnote` is archived. /** * Create an extension for `micromark` to enable GFM footnote syntax. * * @returns {Extension} * Extension for `micromark` that can be passed in `extensions` to * enable GFM footnote syntax. */ export function gfmFootnote() { /** @type {Extension} */ return { document: { [91]: { name: 'gfmFootnoteDefinition', tokenize: tokenizeDefinitionStart, continuation: { tokenize: tokenizeDefinitionContinuation }, exit: gfmFootnoteDefinitionEnd } }, text: { [91]: { name: 'gfmFootnoteCall', tokenize: tokenizeGfmFootnoteCall }, [93]: { name: 'gfmPotentialFootnoteCall', add: 'after', tokenize: tokenizePotentialGfmFootnoteCall, resolveTo: resolveToPotentialGfmFootnoteCall } } }; } // To do: remove after micromark update. /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizePotentialGfmFootnoteCall(effects, ok, nok) { const self = this; let index = self.events.length; const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []); /** @type {Token} */ let labelStart; // Find an opening. while (index--) { const token = self.events[index][1]; if (token.type === "labelImage") { labelStart = token; break; } // Exit if we’ve walked far enough. if (token.type === 'gfmFootnoteCall' || token.type === "labelLink" || token.type === "label" || token.type === "image" || token.type === "link") { break; } } return start; /** * @type {State} */ function start(code) { if (!labelStart || !labelStart._balanced) { return nok(code); } const id = normalizeIdentifier(self.sliceSerialize({ start: labelStart.end, end: self.now() })); if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) { return nok(code); } effects.enter('gfmFootnoteCallLabelMarker'); effects.consume(code); effects.exit('gfmFootnoteCallLabelMarker'); return ok(code); } } // To do: remove after micromark update. /** @type {Resolver} */ function resolveToPotentialGfmFootnoteCall(events, context) { let index = events.length; /** @type {Token | undefined} */ let labelStart; // Find an opening. while (index--) { if (events[index][1].type === "labelImage" && events[index][0] === 'enter') { labelStart = events[index][1]; break; } } // Change the `labelImageMarker` to a `data`. events[index + 1][1].type = "data"; events[index + 3][1].type = 'gfmFootnoteCallLabelMarker'; // The whole (without `!`): /** @type {Token} */ const call = { type: 'gfmFootnoteCall', start: Object.assign({}, events[index + 3][1].start), end: Object.assign({}, events[events.length - 1][1].end) }; // The `^` marker /** @type {Token} */ const marker = { type: 'gfmFootnoteCallMarker', start: Object.assign({}, events[index + 3][1].end), end: Object.assign({}, events[index + 3][1].end) }; // Increment the end 1 character. marker.end.column++; marker.end.offset++; marker.end._bufferIndex++; /** @type {Token} */ const string = { type: 'gfmFootnoteCallString', start: Object.assign({}, marker.end), end: Object.assign({}, events[events.length - 1][1].start) }; /** @type {Token} */ const chunk = { type: "chunkString", contentType: 'string', start: Object.assign({}, string.start), end: Object.assign({}, string.end) }; /** @type {Array} */ const replacement = [ // Take the `labelImageMarker` (now `data`, the `!`) events[index + 1], events[index + 2], ['enter', call, context], // The `[` events[index + 3], events[index + 4], // The `^`. ['enter', marker, context], ['exit', marker, context], // Everything in between. ['enter', string, context], ['enter', chunk, context], ['exit', chunk, context], ['exit', string, context], // The ending (`]`, properly parsed and labelled). events[events.length - 2], events[events.length - 1], ['exit', call, context]]; events.splice(index, events.length - index + 1, ...replacement); return events; } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeGfmFootnoteCall(effects, ok, nok) { const self = this; const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []); let size = 0; /** @type {boolean} */ let data; // Note: the implementation of `markdown-rs` is different, because it houses // core *and* extensions in one project. // Therefore, it can include footnote logic inside `label-end`. // We can’t do that, but luckily, we can parse footnotes in a simpler way than // needed for labels. return start; /** * Start of footnote label. * * ```markdown * > | a [^b] c * ^ * ``` * * @type {State} */ function start(code) { effects.enter('gfmFootnoteCall'); effects.enter('gfmFootnoteCallLabelMarker'); effects.consume(code); effects.exit('gfmFootnoteCallLabelMarker'); return callStart; } /** * After `[`, at `^`. * * ```markdown * > | a [^b] c * ^ * ``` * * @type {State} */ function callStart(code) { if (code !== 94) return nok(code); effects.enter('gfmFootnoteCallMarker'); effects.consume(code); effects.exit('gfmFootnoteCallMarker'); effects.enter('gfmFootnoteCallString'); effects.enter('chunkString').contentType = 'string'; return callData; } /** * In label. * * ```markdown * > | a [^b] c * ^ * ``` * * @type {State} */ function callData(code) { if ( // Too long. size > 999 || // Closing brace with nothing. code === 93 && !data || // Space or tab is not supported by GFM for some reason. // `\n` and `[` not being supported makes sense. code === null || code === 91 || markdownLineEndingOrSpace(code)) { return nok(code); } if (code === 93) { effects.exit('chunkString'); const token = effects.exit('gfmFootnoteCallString'); if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) { return nok(code); } effects.enter('gfmFootnoteCallLabelMarker'); effects.consume(code); effects.exit('gfmFootnoteCallLabelMarker'); effects.exit('gfmFootnoteCall'); return ok; } if (!markdownLineEndingOrSpace(code)) { data = true; } size++; effects.consume(code); return code === 92 ? callEscape : callData; } /** * On character after escape. * * ```markdown * > | a [^b\c] d * ^ * ``` * * @type {State} */ function callEscape(code) { if (code === 91 || code === 92 || code === 93) { effects.consume(code); size++; return callData; } return callData(code); } } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeDefinitionStart(effects, ok, nok) { const self = this; const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []); /** @type {string} */ let identifier; let size = 0; /** @type {boolean | undefined} */ let data; return start; /** * Start of GFM footnote definition. * * ```markdown * > | [^a]: b * ^ * ``` * * @type {State} */ function start(code) { effects.enter('gfmFootnoteDefinition')._container = true; effects.enter('gfmFootnoteDefinitionLabel'); effects.enter('gfmFootnoteDefinitionLabelMarker'); effects.consume(code); effects.exit('gfmFootnoteDefinitionLabelMarker'); return labelAtMarker; } /** * In label, at caret. * * ```markdown * > | [^a]: b * ^ * ``` * * @type {State} */ function labelAtMarker(code) { if (code === 94) { effects.enter('gfmFootnoteDefinitionMarker'); effects.consume(code); effects.exit('gfmFootnoteDefinitionMarker'); effects.enter('gfmFootnoteDefinitionLabelString'); effects.enter('chunkString').contentType = 'string'; return labelInside; } return nok(code); } /** * In label. * * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote * > definition labels. * * ```markdown * > | [^a]: b * ^ * ``` * * @type {State} */ function labelInside(code) { if ( // Too long. size > 999 || // Closing brace with nothing. code === 93 && !data || // Space or tab is not supported by GFM for some reason. // `\n` and `[` not being supported makes sense. code === null || code === 91 || markdownLineEndingOrSpace(code)) { return nok(code); } if (code === 93) { effects.exit('chunkString'); const token = effects.exit('gfmFootnoteDefinitionLabelString'); identifier = normalizeIdentifier(self.sliceSerialize(token)); effects.enter('gfmFootnoteDefinitionLabelMarker'); effects.consume(code); effects.exit('gfmFootnoteDefinitionLabelMarker'); effects.exit('gfmFootnoteDefinitionLabel'); return labelAfter; } if (!markdownLineEndingOrSpace(code)) { data = true; } size++; effects.consume(code); return code === 92 ? labelEscape : labelInside; } /** * After `\`, at a special character. * * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets: * > * * ```markdown * > | [^a\*b]: c * ^ * ``` * * @type {State} */ function labelEscape(code) { if (code === 91 || code === 92 || code === 93) { effects.consume(code); size++; return labelInside; } return labelInside(code); } /** * After definition label. * * ```markdown * > | [^a]: b * ^ * ``` * * @type {State} */ function labelAfter(code) { if (code === 58) { effects.enter('definitionMarker'); effects.consume(code); effects.exit('definitionMarker'); if (!defined.includes(identifier)) { defined.push(identifier); } // Any whitespace after the marker is eaten, forming indented code // is not possible. // No space is also fine, just like a block quote marker. return factorySpace(effects, whitespaceAfter, 'gfmFootnoteDefinitionWhitespace'); } return nok(code); } /** * After definition prefix. * * ```markdown * > | [^a]: b * ^ * ``` * * @type {State} */ function whitespaceAfter(code) { // `markdown-rs` has a wrapping token for the prefix that is closed here. return ok(code); } } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeDefinitionContinuation(effects, ok, nok) { /// Start of footnote definition continuation. /// /// ```markdown /// | [^a]: b /// > | c /// ^ /// ``` // // Either a blank line, which is okay, or an indented thing. return effects.check(blankLine, ok, effects.attempt(indent, ok, nok)); } /** @type {Exiter} */ function gfmFootnoteDefinitionEnd(effects) { effects.exit('gfmFootnoteDefinition'); } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeIndent(effects, ok, nok) { const self = this; return factorySpace(effects, afterPrefix, 'gfmFootnoteDefinitionIndent', 4 + 1); /** * @type {State} */ function afterPrefix(code) { const tail = self.events[self.events.length - 1]; return tail && tail[1].type === 'gfmFootnoteDefinitionIndent' && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok(code) : nok(code); } }{ "name": "micromark-extension-gfm-footnote", "version": "2.1.0", "description": "micromark extension to support GFM footnotes", "license": "MIT", "keywords": [ "micromark", "micromark-extension", "gfm", "footnote", "note", "definition", "markdown", "unified" ], "repository": "micromark/micromark-extension-gfm-footnote", "bugs": "https://github.com/micromark/micromark-extension-gfm-footnote/issues", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "lib/", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "devDependencies": { "@types/node": "^20.0.0", "c8": "^10.0.0", "create-gfm-fixtures": "^1.0.0", "micromark": "^4.0.0", "micromark-build": "^2.0.0", "prettier": "^3.0.0", "remark-cli": "^12.0.0", "remark-preset-wooorm": "^10.0.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.58.0" }, "scripts": { "prepack": "npm run build && npm run format", "build": "tsc --build --clean && tsc --build && type-coverage && micromark-build", "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix", "test-api-prod": "node --conditions production test/index.js", "test-api-dev": "node --conditions development test/index.js", "test-api": "npm run test-api-dev && npm run test-api-prod", "test-coverage": "c8 --100 --reporter lcov npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "prettier": { "bracketSpacing": false, "semi": false, "singleQuote": true, "tabWidth": 2, "trailingComma": "none", "useTabs": false }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "ignoreCatch": true, "strict": true }, "xo": { "prettier": true, "rules": { "logical-assignment-operators": "off", "unicorn/no-this-assignment": "off", "unicorn/prefer-at": "off", "unicorn/prefer-string-replace-all": "off" }, "overrides": [ { "files": [ "**/*.d.ts" ], "rules": { "@typescript-eslint/array-type": [ "error", { "default": "generic" } ], "@typescript-eslint/ban-types": [ "error", { "extendDefaults": true } ], "@typescript-eslint/consistent-type-definitions": [ "error", "interface" ] } }, { "files": [ "test/**/*.js" ], "rules": { "no-await-in-loop": 0 } } ] } } // Note: more types exposed from `index.d.ts`. export { gfmStrikethroughHtml } from './lib/html.js'; export { gfmStrikethrough } from './lib/syntax.js';/** * @import {HtmlExtension} from 'micromark-util-types' */ /** * Create an HTML extension for `micromark` to support GFM strikethrough when * serializing to HTML. * * @returns {HtmlExtension} * Extension for `micromark` that can be passed in `htmlExtensions`, to * support GFM strikethrough when serializing to HTML. */ export function gfmStrikethroughHtml() { return { enter: { strikethrough() { this.tag(''); } }, exit: { strikethrough() { this.tag(''); } } }; }/** * @import {Options} from 'micromark-extension-gfm-strikethrough' * @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types' */ import { splice } from 'micromark-util-chunked'; import { classifyCharacter } from 'micromark-util-classify-character'; import { resolveAll } from 'micromark-util-resolve-all'; /** * Create an extension for `micromark` to enable GFM strikethrough syntax. * * @param {Options | null | undefined} [options={}] * Configuration. * @returns {Extension} * Extension for `micromark` that can be passed in `extensions`, to * enable GFM strikethrough syntax. */ export function gfmStrikethrough(options) { const options_ = options || {}; let single = options_.singleTilde; const tokenizer = { name: 'strikethrough', tokenize: tokenizeStrikethrough, resolveAll: resolveAllStrikethrough }; if (single === null || single === undefined) { single = true; } return { text: { [126]: tokenizer }, insideSpan: { null: [tokenizer] }, attentionMarkers: { null: [126] } }; /** * Take events and resolve strikethrough. * * @type {Resolver} */ function resolveAllStrikethrough(events, context) { let index = -1; // Walk through all events. while (++index < events.length) { // Find a token that can close. if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && events[index][1]._close) { let open = index; // Now walk back to find an opener. while (open--) { // Find a token that can open the closer. if (events[open][0] === 'exit' && events[open][1].type === 'strikethroughSequenceTemporary' && events[open][1]._open && // If the sizes are the same: events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) { events[index][1].type = 'strikethroughSequence'; events[open][1].type = 'strikethroughSequence'; /** @type {Token} */ const strikethrough = { type: 'strikethrough', start: Object.assign({}, events[open][1].start), end: Object.assign({}, events[index][1].end) }; /** @type {Token} */ const text = { type: 'strikethroughText', start: Object.assign({}, events[open][1].end), end: Object.assign({}, events[index][1].start) }; // Opening. /** @type {Array} */ const nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]]; const insideSpan = context.parser.constructs.insideSpan.null; if (insideSpan) { // Between. splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context)); } // Closing. splice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]); splice(events, open - 1, index - open + 3, nextEvents); index = open + nextEvents.length - 2; break; } } } } index = -1; while (++index < events.length) { if (events[index][1].type === 'strikethroughSequenceTemporary') { events[index][1].type = "data"; } } return events; } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeStrikethrough(effects, ok, nok) { const previous = this.previous; const events = this.events; let size = 0; return start; /** @type {State} */ function start(code) { if (previous === 126 && events[events.length - 1][1].type !== "characterEscape") { return nok(code); } effects.enter('strikethroughSequenceTemporary'); return more(code); } /** @type {State} */ function more(code) { const before = classifyCharacter(previous); if (code === 126) { // If this is the third marker, exit. if (size > 1) return nok(code); effects.consume(code); size++; return more; } if (size < 2 && !single) return nok(code); const token = effects.exit('strikethroughSequenceTemporary'); const after = classifyCharacter(code); token._open = !after || after === 2 && Boolean(before); token._close = !before || before === 2 && Boolean(after); return ok(code); } } }{ "name": "micromark-extension-gfm-strikethrough", "version": "2.1.0", "description": "micromark extension to support GFM strikethrough", "license": "MIT", "keywords": [ "micromark", "micromark-extension", "strikethrough", "strike", "through", "del", "delete", "deletion", "gfm", "markdown", "unified" ], "repository": "micromark/micromark-extension-gfm-strikethrough", "bugs": "https://github.com/micromark/micromark-extension-gfm-strikethrough/issues", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "lib/", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "devlop": "^1.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "devDependencies": { "@types/node": "^20.0.0", "c8": "^10.0.0", "create-gfm-fixtures": "^1.0.0", "micromark": "^4.0.0", "micromark-build": "^2.0.0", "prettier": "^3.0.0", "remark-cli": "^12.0.0", "remark-preset-wooorm": "^10.0.0", "tape": "^5.0.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.58.0" }, "scripts": { "prepack": "npm run build && npm run format", "build": "tsc --build --clean && tsc --build && type-coverage && micromark-build", "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix", "test-api-prod": "node --conditions production test/index.js", "test-api-dev": "node --conditions development test/index.js", "test-api": "npm run test-api-dev && npm run test-api-prod", "test-coverage": "c8 --100 --reporter lcov npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "prettier": { "bracketSpacing": false, "semi": false, "singleQuote": true, "tabWidth": 2, "trailingComma": "none", "useTabs": false }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "ignoreCatch": true, "strict": true }, "xo": { "prettier": true, "rules": { "logical-assignment-operators": "off", "max-depth": "off", "unicorn/prefer-at": "off" }, "overrides": [ { "files": "**/*.ts", "rules": { "@typescript-eslint/array-type": [ "error", { "default": "generic" } ], "@typescript-eslint/ban-types": [ "error", { "extendDefaults": true } ], "@typescript-eslint/consistent-type-definitions": [ "error", "interface" ] } }, { "files": "test/**/*.js", "rules": { "no-await-in-loop": 0 } } ] } } export { gfmTableHtml } from './lib/html.js'; export { gfmTable } from './lib/syntax.js';/** * @import {Event} from 'micromark-util-types' */ // Port of `edit_map.rs` from `markdown-rs`. // This should move to `markdown-js` later. // Deal with several changes in events, batching them together. // // Preferably, changes should be kept to a minimum. // Sometimes, it’s needed to change the list of events, because parsing can be // messy, and it helps to expose a cleaner interface of events to the compiler // and other users. // It can also help to merge many adjacent similar events. // And, in other cases, it’s needed to parse subcontent: pass some events // through another tokenizer and inject the result. /** * @typedef {[number, number, Array]} Change * @typedef {[number, number, number]} Jump */ /** * Tracks a bunch of edits. */ export class EditMap { /** * Create a new edit map. */ constructor() { /** * Record of changes. * * @type {Array} */ this.map = []; } /** * Create an edit: a remove and/or add at a certain place. * * @param {number} index * @param {number} remove * @param {Array} add * @returns {undefined} */ add(index, remove, add) { addImplementation(this, index, remove, add); } // To do: add this when moving to `micromark`. // /** // * Create an edit: but insert `add` before existing additions. // * // * @param {number} index // * @param {number} remove // * @param {Array} add // * @returns {undefined} // */ // addBefore(index, remove, add) { // addImplementation(this, index, remove, add, true) // } /** * Done, change the events. * * @param {Array} events * @returns {undefined} */ consume(events) { this.map.sort(function (a, b) { return a[0] - b[0]; }); /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */ if (this.map.length === 0) { return; } // To do: if links are added in events, like they are in `markdown-rs`, // this is needed. // // Calculate jumps: where items in the current list move to. // /** @type {Array} */ // const jumps = [] // let index = 0 // let addAcc = 0 // let removeAcc = 0 // while (index < this.map.length) { // const [at, remove, add] = this.map[index] // removeAcc += remove // addAcc += add.length // jumps.push([at, removeAcc, addAcc]) // index += 1 // } // // . shiftLinks(events, jumps) let index = this.map.length; /** @type {Array>} */ const vecs = []; while (index > 0) { index -= 1; vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]); // Truncate rest. events.length = this.map[index][0]; } vecs.push(events.slice()); events.length = 0; let slice = vecs.pop(); while (slice) { for (const element of slice) { events.push(element); } slice = vecs.pop(); } // Truncate everything. this.map.length = 0; } } /** * Create an edit. * * @param {EditMap} editMap * @param {number} at * @param {number} remove * @param {Array} add * @returns {undefined} */ function addImplementation(editMap, at, remove, add) { let index = 0; /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */ if (remove === 0 && add.length === 0) { return; } while (index < editMap.map.length) { if (editMap.map[index][0] === at) { editMap.map[index][1] += remove; // To do: before not used by tables, use when moving to micromark. // if (before) { // add.push(...editMap.map[index][2]) // editMap.map[index][2] = add // } else { editMap.map[index][2].push(...add); // } return; } index += 1; } editMap.map.push([at, remove, add]); } // /** // * Shift `previous` and `next` links according to `jumps`. // * // * This fixes links in case there are events removed or added between them. // * // * @param {Array} events // * @param {Array} jumps // */ // function shiftLinks(events, jumps) { // let jumpIndex = 0 // let index = 0 // let add = 0 // let rm = 0 // while (index < events.length) { // const rmCurr = rm // while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) { // add = jumps[jumpIndex][2] // rm = jumps[jumpIndex][1] // jumpIndex += 1 // } // // Ignore items that will be removed. // if (rm > rmCurr) { // index += rm - rmCurr // } else { // // ? // // if let Some(link) = &events[index].link { // // if let Some(next) = link.next { // // events[next].link.as_mut().unwrap().previous = Some(index + add - rm); // // while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next { // // add = jumps[jumpIndex].2; // // rm = jumps[jumpIndex].1; // // jumpIndex += 1; // // } // // events[index].link.as_mut().unwrap().next = Some(next + add - rm); // // index = next; // // continue; // // } // // } // index += 1 // } // } // }/** * @import {HtmlExtension} from 'micromark-util-types' */ const alignment = { none: '', left: ' align="left"', right: ' align="right"', center: ' align="center"' }; // To do: micromark@5: use `infer` here, when all events are exposed. /** * Create an HTML extension for `micromark` to support GitHub tables when * serializing to HTML. * * @returns {HtmlExtension} * Extension for `micromark` that can be passed in `htmlExtensions` to * support GitHub tables when serializing to HTML. */ export function gfmTableHtml() { return { enter: { table(token) { const tableAlign = token._align; this.lineEndingIfNeeded(); this.tag(''); this.setData('tableAlign', tableAlign); }, tableBody() { this.tag(''); }, tableData() { const tableAlign = this.getData('tableAlign'); const tableColumn = this.getData('tableColumn'); const align = alignment[tableAlign[tableColumn]]; if (align === undefined) { // Capture results to ignore them. this.buffer(); } else { this.lineEndingIfNeeded(); this.tag(''); } }, tableHead() { this.lineEndingIfNeeded(); this.tag(''); }, tableHeader() { const tableAlign = this.getData('tableAlign'); const tableColumn = this.getData('tableColumn'); const align = alignment[tableAlign[tableColumn]]; this.lineEndingIfNeeded(); this.tag(''); }, tableRow() { this.setData('tableColumn', 0); this.lineEndingIfNeeded(); this.tag(''); } }, exit: { // Overwrite the default code text data handler to unescape escaped pipes when // they are in tables. codeTextData(token) { let value = this.sliceSerialize(token); if (this.getData('tableAlign')) { value = value.replace(/\\([\\|])/g, replace); } this.raw(this.encode(value)); }, table() { this.setData('tableAlign'); // Note: we don’t set `slurpAllLineEndings` anymore, in delimiter rows, // but we do need to reset it to match a funky newline GH generates for // list items combined with tables. this.setData('slurpAllLineEndings'); this.lineEndingIfNeeded(); this.tag(' '); }, tableBody() { this.lineEndingIfNeeded(); this.tag(''); }, tableData() { const tableAlign = this.getData('tableAlign'); const tableColumn = this.getData('tableColumn'); if (tableColumn in tableAlign) { this.tag(''); this.setData('tableColumn', tableColumn + 1); } else { // Stop capturing. this.resume(); } }, tableHead() { this.lineEndingIfNeeded(); this.tag(''); }, tableHeader() { const tableColumn = this.getData('tableColumn'); this.tag(''); this.setData('tableColumn', tableColumn + 1); }, tableRow() { const tableAlign = this.getData('tableAlign'); let tableColumn = this.getData('tableColumn'); while (tableColumn < tableAlign.length) { this.lineEndingIfNeeded(); this.tag(''); tableColumn++; } this.setData('tableColumn', tableColumn); this.lineEndingIfNeeded(); this.tag(''); } } }; } /** * @param {string} $0 * @param {string} $1 * @returns {string} */ function replace($0, $1) { // Pipes work, backslashes don’t (but can’t escape pipes). return $1 === '|' ? $1 : $0; }/** * @import {Event} from 'micromark-util-types' */ /** * @typedef {'center' | 'left' | 'none' | 'right'} Align */ /** * Figure out the alignment of a GFM table. * * @param {Readonly>} events * List of events. * @param {number} index * Table enter event. * @returns {Array} * List of aligns. */ export function gfmTableAlign(events, index) { let inDelimiterRow = false; /** @type {Array} */ const align = []; while (index < events.length) { const event = events[index]; if (inDelimiterRow) { if (event[0] === 'enter') { // Start of alignment value: set a new column. // To do: `markdown-rs` uses `tableDelimiterCellValue`. if (event[1].type === 'tableContent') { align.push(events[index + 1][1].type === 'tableDelimiterMarker' ? 'left' : 'none'); } } // Exits: // End of alignment value: change the column. // To do: `markdown-rs` uses `tableDelimiterCellValue`. else if (event[1].type === 'tableContent') { if (events[index - 1][1].type === 'tableDelimiterMarker') { const alignIndex = align.length - 1; align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right'; } } // Done! else if (event[1].type === 'tableDelimiterRow') { break; } } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') { inDelimiterRow = true; } index += 1; } return align; }/** * @import {Event, Extension, Point, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types' */ /** * @typedef {[number, number, number, number]} Range * Cell info. * * @typedef {0 | 1 | 2 | 3} RowKind * Where we are: `1` for head row, `2` for delimiter row, `3` for body row. */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character'; import { EditMap } from './edit-map.js'; import { gfmTableAlign } from './infer.js'; /** * Create an HTML extension for `micromark` to support GitHub tables syntax. * * @returns {Extension} * Extension for `micromark` that can be passed in `extensions` to enable GFM * table syntax. */ export function gfmTable() { return { flow: { null: { name: 'table', tokenize: tokenizeTable, resolveAll: resolveTable } } }; } /** * @this {TokenizeContext} * @type {Tokenizer} */ function tokenizeTable(effects, ok, nok) { const self = this; let size = 0; let sizeB = 0; /** @type {boolean | undefined} */ let seen; return start; /** * Start of a GFM table. * * If there is a valid table row or table head before, then we try to parse * another row. * Otherwise, we try to parse a head. * * ```markdown * > | | a | * ^ * | | - | * > | | b | * ^ * ``` * @type {State} */ function start(code) { let index = self.events.length - 1; while (index > -1) { const type = self.events[index][1].type; if (type === "lineEnding" || // Note: markdown-rs uses `whitespace` instead of `linePrefix` type === "linePrefix") index--;else break; } const tail = index > -1 ? self.events[index][1].type : null; const next = tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore; // Don’t allow lazy body rows. if (next === bodyRowStart && self.parser.lazy[self.now().line]) { return nok(code); } return next(code); } /** * Before table head row. * * ```markdown * > | | a | * ^ * | | - | * | | b | * ``` * * @type {State} */ function headRowBefore(code) { effects.enter('tableHead'); effects.enter('tableRow'); return headRowStart(code); } /** * Before table head row, after whitespace. * * ```markdown * > | | a | * ^ * | | - | * | | b | * ``` * * @type {State} */ function headRowStart(code) { if (code === 124) { return headRowBreak(code); } // To do: micromark-js should let us parse our own whitespace in extensions, // like `markdown-rs`: // // ```js // // 4+ spaces. // if (markdownSpace(code)) { // return nok(code) // } // ``` seen = true; // Count the first character, that isn’t a pipe, double. sizeB += 1; return headRowBreak(code); } /** * At break in table head row. * * ```markdown * > | | a | * ^ * ^ * ^ * | | - | * | | b | * ``` * * @type {State} */ function headRowBreak(code) { if (code === null) { // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t. return nok(code); } if (markdownLineEnding(code)) { // If anything other than one pipe (ignoring whitespace) was used, it’s fine. if (sizeB > 1) { sizeB = 0; // To do: check if this works. // Feel free to interrupt: self.interrupt = true; effects.exit('tableRow'); effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); return headDelimiterStart; } // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t. return nok(code); } if (markdownSpace(code)) { // To do: check if this is fine. // effects.attempt(State::Next(StateName::GfmTableHeadRowBreak), State::Nok) // State::Retry(space_or_tab(tokenizer)) return factorySpace(effects, headRowBreak, "whitespace")(code); } sizeB += 1; if (seen) { seen = false; // Header cell count. size += 1; } if (code === 124) { effects.enter('tableCellDivider'); effects.consume(code); effects.exit('tableCellDivider'); // Whether a delimiter was seen. seen = true; return headRowBreak; } // Anything else is cell data. effects.enter("data"); return headRowData(code); } /** * In table head row data. * * ```markdown * > | | a | * ^ * | | - | * | | b | * ``` * * @type {State} */ function headRowData(code) { if (code === null || code === 124 || markdownLineEndingOrSpace(code)) { effects.exit("data"); return headRowBreak(code); } effects.consume(code); return code === 92 ? headRowEscape : headRowData; } /** * In table head row escape. * * ```markdown * > | | a\-b | * ^ * | | ---- | * | | c | * ``` * * @type {State} */ function headRowEscape(code) { if (code === 92 || code === 124) { effects.consume(code); return headRowData; } return headRowData(code); } /** * Before delimiter row. * * ```markdown * | | a | * > | | - | * ^ * | | b | * ``` * * @type {State} */ function headDelimiterStart(code) { // Reset `interrupt`. self.interrupt = false; // Note: in `markdown-rs`, we need to handle piercing here too. if (self.parser.lazy[self.now().line]) { return nok(code); } effects.enter('tableDelimiterRow'); // Track if we’ve seen a `:` or `|`. seen = false; if (markdownSpace(code)) { return factorySpace(effects, headDelimiterBefore, "linePrefix", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code); } return headDelimiterBefore(code); } /** * Before delimiter row, after optional whitespace. * * Reused when a `|` is found later, to parse another cell. * * ```markdown * | | a | * > | | - | * ^ * | | b | * ``` * * @type {State} */ function headDelimiterBefore(code) { if (code === 45 || code === 58) { return headDelimiterValueBefore(code); } if (code === 124) { seen = true; // If we start with a pipe, we open a cell marker. effects.enter('tableCellDivider'); effects.consume(code); effects.exit('tableCellDivider'); return headDelimiterCellBefore; } // More whitespace / empty row not allowed at start. return headDelimiterNok(code); } /** * After `|`, before delimiter cell. * * ```markdown * | | a | * > | | - | * ^ * ``` * * @type {State} */ function headDelimiterCellBefore(code) { if (markdownSpace(code)) { return factorySpace(effects, headDelimiterValueBefore, "whitespace")(code); } return headDelimiterValueBefore(code); } /** * Before delimiter cell value. * * ```markdown * | | a | * > | | - | * ^ * ``` * * @type {State} */ function headDelimiterValueBefore(code) { // Align: left. if (code === 58) { sizeB += 1; seen = true; effects.enter('tableDelimiterMarker'); effects.consume(code); effects.exit('tableDelimiterMarker'); return headDelimiterLeftAlignmentAfter; } // Align: none. if (code === 45) { sizeB += 1; // To do: seems weird that this *isn’t* left aligned, but that state is used? return headDelimiterLeftAlignmentAfter(code); } if (code === null || markdownLineEnding(code)) { return headDelimiterCellAfter(code); } return headDelimiterNok(code); } /** * After delimiter cell left alignment marker. * * ```markdown * | | a | * > | | :- | * ^ * ``` * * @type {State} */ function headDelimiterLeftAlignmentAfter(code) { if (code === 45) { effects.enter('tableDelimiterFiller'); return headDelimiterFiller(code); } // Anything else is not ok after the left-align colon. return headDelimiterNok(code); } /** * In delimiter cell filler. * * ```markdown * | | a | * > | | - | * ^ * ``` * * @type {State} */ function headDelimiterFiller(code) { if (code === 45) { effects.consume(code); return headDelimiterFiller; } // Align is `center` if it was `left`, `right` otherwise. if (code === 58) { seen = true; effects.exit('tableDelimiterFiller'); effects.enter('tableDelimiterMarker'); effects.consume(code); effects.exit('tableDelimiterMarker'); return headDelimiterRightAlignmentAfter; } effects.exit('tableDelimiterFiller'); return headDelimiterRightAlignmentAfter(code); } /** * After delimiter cell right alignment marker. * * ```markdown * | | a | * > | | -: | * ^ * ``` * * @type {State} */ function headDelimiterRightAlignmentAfter(code) { if (markdownSpace(code)) { return factorySpace(effects, headDelimiterCellAfter, "whitespace")(code); } return headDelimiterCellAfter(code); } /** * After delimiter cell. * * ```markdown * | | a | * > | | -: | * ^ * ``` * * @type {State} */ function headDelimiterCellAfter(code) { if (code === 124) { return headDelimiterBefore(code); } if (code === null || markdownLineEnding(code)) { // Exit when: // * there was no `:` or `|` at all (it’s a thematic break or setext // underline instead) // * the header cell count is not the delimiter cell count if (!seen || size !== sizeB) { return headDelimiterNok(code); } // Note: in markdown-rs`, a reset is needed here. effects.exit('tableDelimiterRow'); effects.exit('tableHead'); // To do: in `markdown-rs`, resolvers need to be registered manually. // effects.register_resolver(ResolveName::GfmTable) return ok(code); } return headDelimiterNok(code); } /** * In delimiter row, at a disallowed byte. * * ```markdown * | | a | * > | | x | * ^ * ``` * * @type {State} */ function headDelimiterNok(code) { // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t. return nok(code); } /** * Before table body row. * * ```markdown * | | a | * | | - | * > | | b | * ^ * ``` * * @type {State} */ function bodyRowStart(code) { // Note: in `markdown-rs` we need to manually take care of a prefix, // but in `micromark-js` that is done for us, so if we’re here, we’re // never at whitespace. effects.enter('tableRow'); return bodyRowBreak(code); } /** * At break in table body row. * * ```markdown * | | a | * | | - | * > | | b | * ^ * ^ * ^ * ``` * * @type {State} */ function bodyRowBreak(code) { if (code === 124) { effects.enter('tableCellDivider'); effects.consume(code); effects.exit('tableCellDivider'); return bodyRowBreak; } if (code === null || markdownLineEnding(code)) { effects.exit('tableRow'); return ok(code); } if (markdownSpace(code)) { return factorySpace(effects, bodyRowBreak, "whitespace")(code); } // Anything else is cell content. effects.enter("data"); return bodyRowData(code); } /** * In table body row data. * * ```markdown * | | a | * | | - | * > | | b | * ^ * ``` * * @type {State} */ function bodyRowData(code) { if (code === null || code === 124 || markdownLineEndingOrSpace(code)) { effects.exit("data"); return bodyRowBreak(code); } effects.consume(code); return code === 92 ? bodyRowEscape : bodyRowData; } /** * In table body row escape. * * ```markdown * | | a | * | | ---- | * > | | b\-c | * ^ * ``` * * @type {State} */ function bodyRowEscape(code) { if (code === 92 || code === 124) { effects.consume(code); return bodyRowData; } return bodyRowData(code); } } /** @type {Resolver} */ function resolveTable(events, context) { let index = -1; let inFirstCellAwaitingPipe = true; /** @type {RowKind} */ let rowKind = 0; /** @type {Range} */ let lastCell = [0, 0, 0, 0]; /** @type {Range} */ let cell = [0, 0, 0, 0]; let afterHeadAwaitingFirstBodyRow = false; let lastTableEnd = 0; /** @type {Token | undefined} */ let currentTable; /** @type {Token | undefined} */ let currentBody; /** @type {Token | undefined} */ let currentCell; const map = new EditMap(); while (++index < events.length) { const event = events[index]; const token = event[1]; if (event[0] === 'enter') { // Start of head. if (token.type === 'tableHead') { afterHeadAwaitingFirstBodyRow = false; // Inject previous (body end and) table end. if (lastTableEnd !== 0) { flushTableEnd(map, context, lastTableEnd, currentTable, currentBody); currentBody = undefined; lastTableEnd = 0; } // Inject table start. currentTable = { type: 'table', start: Object.assign({}, token.start), // Note: correct end is set later. end: Object.assign({}, token.end) }; map.add(index, 0, [['enter', currentTable, context]]); } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') { inFirstCellAwaitingPipe = true; currentCell = undefined; lastCell = [0, 0, 0, 0]; cell = [0, index + 1, 0, 0]; // Inject table body start. if (afterHeadAwaitingFirstBodyRow) { afterHeadAwaitingFirstBodyRow = false; currentBody = { type: 'tableBody', start: Object.assign({}, token.start), // Note: correct end is set later. end: Object.assign({}, token.end) }; map.add(index, 0, [['enter', currentBody, context]]); } rowKind = token.type === 'tableDelimiterRow' ? 2 : currentBody ? 3 : 1; } // Cell data. else if (rowKind && (token.type === "data" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) { inFirstCellAwaitingPipe = false; // First value in cell. if (cell[2] === 0) { if (lastCell[1] !== 0) { cell[0] = cell[1]; currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell); lastCell = [0, 0, 0, 0]; } cell[2] = index; } } else if (token.type === 'tableCellDivider') { if (inFirstCellAwaitingPipe) { inFirstCellAwaitingPipe = false; } else { if (lastCell[1] !== 0) { cell[0] = cell[1]; currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell); } lastCell = cell; cell = [lastCell[1], index, 0, 0]; } } } // Exit events. else if (token.type === 'tableHead') { afterHeadAwaitingFirstBodyRow = true; lastTableEnd = index; } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') { lastTableEnd = index; if (lastCell[1] !== 0) { cell[0] = cell[1]; currentCell = flushCell(map, context, lastCell, rowKind, index, currentCell); } else if (cell[1] !== 0) { currentCell = flushCell(map, context, cell, rowKind, index, currentCell); } rowKind = 0; } else if (rowKind && (token.type === "data" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) { cell[3] = index; } } if (lastTableEnd !== 0) { flushTableEnd(map, context, lastTableEnd, currentTable, currentBody); } map.consume(context.events); // To do: move this into `html`, when events are exposed there. // That’s what `markdown-rs` does. // That needs updates to `mdast-util-gfm-table`. index = -1; while (++index < context.events.length) { const event = context.events[index]; if (event[0] === 'enter' && event[1].type === 'table') { event[1]._align = gfmTableAlign(context.events, index); } } return events; } /** * Generate a cell. * * @param {EditMap} map * @param {Readonly} context * @param {Readonly} range * @param {RowKind} rowKind * @param {number | undefined} rowEnd * @param {Token | undefined} previousCell * @returns {Token | undefined} */ // eslint-disable-next-line max-params function flushCell(map, context, range, rowKind, rowEnd, previousCell) { // `markdown-rs` uses: // rowKind === 2 ? 'tableDelimiterCell' : 'tableCell' const groupName = rowKind === 1 ? 'tableHeader' : rowKind === 2 ? 'tableDelimiter' : 'tableData'; // `markdown-rs` uses: // rowKind === 2 ? 'tableDelimiterCellValue' : 'tableCellText' const valueName = 'tableContent'; // Insert an exit for the previous cell, if there is one. // // ```markdown // > | | aa | bb | cc | // ^-- exit // ^^^^-- this cell // ``` if (range[0] !== 0) { previousCell.end = Object.assign({}, getPoint(context.events, range[0])); map.add(range[0], 0, [['exit', previousCell, context]]); } // Insert enter of this cell. // // ```markdown // > | | aa | bb | cc | // ^-- enter // ^^^^-- this cell // ``` const now = getPoint(context.events, range[1]); previousCell = { type: groupName, start: Object.assign({}, now), // Note: correct end is set later. end: Object.assign({}, now) }; map.add(range[1], 0, [['enter', previousCell, context]]); // Insert text start at first data start and end at last data end, and // remove events between. // // ```markdown // > | | aa | bb | cc | // ^-- enter // ^-- exit // ^^^^-- this cell // ``` if (range[2] !== 0) { const relatedStart = getPoint(context.events, range[2]); const relatedEnd = getPoint(context.events, range[3]); /** @type {Token} */ const valueToken = { type: valueName, start: Object.assign({}, relatedStart), end: Object.assign({}, relatedEnd) }; map.add(range[2], 0, [['enter', valueToken, context]]); if (rowKind !== 2) { // Fix positional info on remaining events const start = context.events[range[2]]; const end = context.events[range[3]]; start[1].end = Object.assign({}, end[1].end); start[1].type = "chunkText"; start[1].contentType = "text"; // Remove if needed. if (range[3] > range[2] + 1) { const a = range[2] + 1; const b = range[3] - range[2] - 1; map.add(a, b, []); } } map.add(range[3] + 1, 0, [['exit', valueToken, context]]); } // Insert an exit for the last cell, if at the row end. // // ```markdown // > | | aa | bb | cc | // ^-- exit // ^^^^^^-- this cell (the last one contains two “between” parts) // ``` if (rowEnd !== undefined) { previousCell.end = Object.assign({}, getPoint(context.events, rowEnd)); map.add(rowEnd, 0, [['exit', previousCell, context]]); previousCell = undefined; } return previousCell; } /** * Generate table end (and table body end). * * @param {Readonly} map * @param {Readonly} context * @param {number} index * @param {Token} table * @param {Token | undefined} tableBody */ // eslint-disable-next-line max-params function flushTableEnd(map, context, index, table, tableBody) { /** @type {Array} */ const exits = []; const related = getPoint(context.events, index); if (tableBody) { tableBody.end = Object.assign({}, related); exits.push(['exit', tableBody, context]); } table.end = Object.assign({}, related); exits.push(['exit', table, context]); map.add(index + 1, 0, exits); } /** * @param {Readonly>} events * @param {number} index * @returns {Readonly} */ function getPoint(events, index) { const event = events[index]; const side = event[0] === 'enter' ? 'start' : 'end'; return event[1][side]; }{ "author": "Titus Wormer (https://wooorm.com)", "bugs": "https://github.com/micromark/micromark-extension-gfm-table/issues", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "description": "micromark extension to support GFM tables", "devDependencies": { "@types/node": "^22.0.0", "c8": "^10.0.0", "create-gfm-fixtures": "^2.0.0", "micromark": "^4.0.0", "micromark-build": "^2.0.0", "prettier": "^3.0.0", "remark-cli": "^12.0.0", "remark-preset-wooorm": "^10.0.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.60.0" }, "exports": { "development": "./dev/index.js", "default": "./index.js" }, "files": [ "dev/", "index.d.ts", "index.js", "lib/" ], "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" }, "keywords": [ "cell", "column", "gfm", "markdown", "micromark-extension", "micromark", "row", "table", "tabular", "unified" ], "license": "MIT", "name": "micromark-extension-gfm-table", "prettier": { "bracketSpacing": false, "semi": false, "singleQuote": true, "tabWidth": 2, "trailingComma": "none", "useTabs": false }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "repository": "micromark/micromark-extension-gfm-table", "scripts": { "build": "tsc --build --clean && tsc --build && type-coverage && micromark-build", "format": "remark --frail --quiet --output -- . && prettier --log-level warn --write -- . && xo --fix", "test-api-dev": "node --conditions development test/index.js", "test-api-prod": "node --conditions production test/index.js", "test-api": "npm run test-api-dev && npm run test-api-prod", "test-coverage": "c8 --100 --reporter lcov -- npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "sideEffects": false, "typeCoverage": { "atLeast": 100, "strict": true }, "type": "module", "version": "2.1.1", "xo": { "overrides": [ { "files": [ "**/*.d.ts" ], "rules": { "@typescript-eslint/array-type": [ "error", { "default": "generic" } ], "@typescript-eslint/ban-types": [ "error", { "extendDefaults": true } ], "@typescript-eslint/consistent-type-definitions": [ "error", "interface" ] } }, { "files": [ "test/**/*.js" ], "rules": { "no-await-in-loop": "off" } } ], "prettier": true, "rules": { "complexity": "off", "max-depth": "off", "unicorn/no-this-assignment": "off", "unicorn/prefer-string-replace-all": "off" } } } /** * @import {Effects, State, TokenType} from 'micromark-util-types' */ import { asciiControl, markdownLineEndingOrSpace, markdownLineEnding } from 'micromark-util-character'; /** * Parse destinations. * * ###### Examples * * ```markdown * * b> * * * a * a\)b * a(b)c * a(b) * ``` * * @param {Effects} effects * Context. * @param {State} ok * State switched to when successful. * @param {State} nok * State switched to when unsuccessful. * @param {TokenType} type * Type for whole (`` or `b`). * @param {TokenType} literalType * Type when enclosed (``). * @param {TokenType} literalMarkerType * Type for enclosing (`<` and `>`). * @param {TokenType} rawType * Type when not enclosed (`b`). * @param {TokenType} stringType * Type for the value (`a` or `b`). * @param {number | undefined} [max=Infinity] * Depth of nested parens (inclusive). * @returns {State} * Start state. */ export function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) { const limit = max || Number.POSITIVE_INFINITY; let balance = 0; return start; /** * Start of destination. * * ```markdown * > | * ^ * > | aa * ^ * ``` * * @type {State} */ function start(code) { if (code === 60) { effects.enter(type); effects.enter(literalType); effects.enter(literalMarkerType); effects.consume(code); effects.exit(literalMarkerType); return enclosedBefore; } // ASCII control, space, closing paren. if (code === null || code === 32 || code === 41 || asciiControl(code)) { return nok(code); } effects.enter(type); effects.enter(rawType); effects.enter(stringType); effects.enter("chunkString", { contentType: "string" }); return raw(code); } /** * After `<`, at an enclosed destination. * * ```markdown * > | * ^ * ``` * * @type {State} */ function enclosedBefore(code) { if (code === 62) { effects.enter(literalMarkerType); effects.consume(code); effects.exit(literalMarkerType); effects.exit(literalType); effects.exit(type); return ok; } effects.enter(stringType); effects.enter("chunkString", { contentType: "string" }); return enclosed(code); } /** * In enclosed destination. * * ```markdown * > | * ^ * ``` * * @type {State} */ function enclosed(code) { if (code === 62) { effects.exit("chunkString"); effects.exit(stringType); return enclosedBefore(code); } if (code === null || code === 60 || markdownLineEnding(code)) { return nok(code); } effects.consume(code); return code === 92 ? enclosedEscape : enclosed; } /** * After `\`, at a special character. * * ```markdown * > | * ^ * ``` * * @type {State} */ function enclosedEscape(code) { if (code === 60 || code === 62 || code === 92) { effects.consume(code); return enclosed; } return enclosed(code); } /** * In raw destination. * * ```markdown * > | aa * ^ * ``` * * @type {State} */ function raw(code) { if (!balance && (code === null || code === 41 || markdownLineEndingOrSpace(code))) { effects.exit("chunkString"); effects.exit(stringType); effects.exit(rawType); effects.exit(type); return ok(code); } if (balance < limit && code === 40) { effects.consume(code); balance++; return raw; } if (code === 41) { effects.consume(code); balance--; return raw; } // ASCII control (but *not* `\0`) and space and `(`. // Note: in `markdown-rs`, `\0` exists in codes, in `micromark-js` it // doesn’t. if (code === null || code === 32 || code === 40 || asciiControl(code)) { return nok(code); } effects.consume(code); return code === 92 ? rawEscape : raw; } /** * After `\`, at special character. * * ```markdown * > | a\*a * ^ * ``` * * @type {State} */ function rawEscape(code) { if (code === 40 || code === 41 || code === 92) { effects.consume(code); return raw; } return raw(code); } }{ "name": "micromark-factory-destination", "version": "2.0.1", "description": "micromark factory to parse destinations (found in resources, definitions)", "license": "MIT", "keywords": [ "micromark", "factory", "destination" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-factory-destination", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "max-params": "off", "unicorn/prefer-code-point": "off" } } } /** * @import { * Effects, * State, * TokenizeContext, * TokenType * } from 'micromark-util-types' */ import { markdownLineEnding, markdownSpace } from 'micromark-util-character'; /** * Parse labels. * * > 👉 **Note**: labels in markdown are capped at 999 characters in the string. * * ###### Examples * * ```markdown * [a] * [a * b] * [a\]b] * ``` * * @this {TokenizeContext} * Tokenize context. * @param {Effects} effects * Context. * @param {State} ok * State switched to when successful. * @param {State} nok * State switched to when unsuccessful. * @param {TokenType} type * Type of the whole label (`[a]`). * @param {TokenType} markerType * Type for the markers (`[` and `]`). * @param {TokenType} stringType * Type for the identifier (`a`). * @returns {State} * Start state. */ export function factoryLabel(effects, ok, nok, type, markerType, stringType) { const self = this; let size = 0; /** @type {boolean} */ let seen; return start; /** * Start of label. * * ```markdown * > | [a] * ^ * ``` * * @type {State} */ function start(code) { effects.enter(type); effects.enter(markerType); effects.consume(code); effects.exit(markerType); effects.enter(stringType); return atBreak; } /** * In label, at something, before something else. * * ```markdown * > | [a] * ^ * ``` * * @type {State} */ function atBreak(code) { if (size > 999 || code === null || code === 91 || code === 93 && !seen || // To do: remove in the future once we’ve switched from // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`, // which doesn’t need this. // Hidden footnotes hook. /* c8 ignore next 3 */ code === 94 && !size && '_hiddenFootnoteSupport' in self.parser.constructs) { return nok(code); } if (code === 93) { effects.exit(stringType); effects.enter(markerType); effects.consume(code); effects.exit(markerType); effects.exit(type); return ok; } // To do: indent? Link chunks and EOLs together? if (markdownLineEnding(code)) { effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); return atBreak; } effects.enter("chunkString", { contentType: "string" }); return labelInside(code); } /** * In label, in text. * * ```markdown * > | [a] * ^ * ``` * * @type {State} */ function labelInside(code) { if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) { effects.exit("chunkString"); return atBreak(code); } effects.consume(code); if (!seen) seen = !markdownSpace(code); return code === 92 ? labelEscape : labelInside; } /** * After `\`, at a special character. * * ```markdown * > | [a\*a] * ^ * ``` * * @type {State} */ function labelEscape(code) { if (code === 91 || code === 92 || code === 93) { effects.consume(code); size++; return labelInside; } return labelInside(code); } }{ "name": "micromark-factory-label", "version": "2.0.1", "description": "micromark factory to parse labels (found in media, definitions)", "license": "MIT", "keywords": [ "micromark", "factory", "label" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-factory-label", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "devlop": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "logical-assignment-operators": "off", "max-params": "off", "unicorn/no-this-assignment": "off", "unicorn/prefer-code-point": "off" } } } /** * @import {Effects, State, TokenType} from 'micromark-util-types' */ import { markdownSpace } from 'micromark-util-character'; // To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`. /** * Parse spaces and tabs. * * There is no `nok` parameter: * * * spaces in markdown are often optional, in which case this factory can be * used and `ok` will be switched to whether spaces were found or not * * one line ending or space can be detected with `markdownSpace(code)` right * before using `factorySpace` * * ###### Examples * * Where `␉` represents a tab (plus how much it expands) and `␠` represents a * single space. * * ```markdown * ␉ * ␠␠␠␠ * ␉␠ * ``` * * @param {Effects} effects * Context. * @param {State} ok * State switched to when successful. * @param {TokenType} type * Type (`' \t'`). * @param {number | undefined} [max=Infinity] * Max (exclusive). * @returns {State} * Start state. */ export function factorySpace(effects, ok, type, max) { const limit = max ? max - 1 : Number.POSITIVE_INFINITY; let size = 0; return start; /** @type {State} */ function start(code) { if (markdownSpace(code)) { effects.enter(type); return prefix(code); } return ok(code); } /** @type {State} */ function prefix(code) { if (markdownSpace(code) && size++ < limit) { effects.consume(code); return prefix; } effects.exit(type); return ok(code); } }{ "name": "micromark-factory-space", "version": "2.0.1", "description": "micromark factory to parse markdown space (found in lots of places)", "license": "MIT", "keywords": [ "micromark", "factory", "space" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-factory-space", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } /** * @import { * Code, * Effects, * State, * TokenType * } from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding } from 'micromark-util-character'; /** * Parse titles. * * ###### Examples * * ```markdown * "a" * 'b' * (c) * "a * b" * 'a * b' * (a\)b) * ``` * * @param {Effects} effects * Context. * @param {State} ok * State switched to when successful. * @param {State} nok * State switched to when unsuccessful. * @param {TokenType} type * Type of the whole title (`"a"`, `'b'`, `(c)`). * @param {TokenType} markerType * Type for the markers (`"`, `'`, `(`, and `)`). * @param {TokenType} stringType * Type for the value (`a`). * @returns {State} * Start state. */ export function factoryTitle(effects, ok, nok, type, markerType, stringType) { /** @type {NonNullable} */ let marker; return start; /** * Start of title. * * ```markdown * > | "a" * ^ * ``` * * @type {State} */ function start(code) { if (code === 34 || code === 39 || code === 40) { effects.enter(type); effects.enter(markerType); effects.consume(code); effects.exit(markerType); marker = code === 40 ? 41 : code; return begin; } return nok(code); } /** * After opening marker. * * This is also used at the closing marker. * * ```markdown * > | "a" * ^ * ``` * * @type {State} */ function begin(code) { if (code === marker) { effects.enter(markerType); effects.consume(code); effects.exit(markerType); effects.exit(type); return ok; } effects.enter(stringType); return atBreak(code); } /** * At something, before something else. * * ```markdown * > | "a" * ^ * ``` * * @type {State} */ function atBreak(code) { if (code === marker) { effects.exit(stringType); return begin(marker); } if (code === null) { return nok(code); } // Note: blank lines can’t exist in content. if (markdownLineEnding(code)) { // To do: use `space_or_tab_eol_with_options`, connect. effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); return factorySpace(effects, atBreak, "linePrefix"); } effects.enter("chunkString", { contentType: "string" }); return inside(code); } /** * * * @type {State} */ function inside(code) { if (code === marker || code === null || markdownLineEnding(code)) { effects.exit("chunkString"); return atBreak(code); } effects.consume(code); return code === 92 ? escape : inside; } /** * After `\`, at a special character. * * ```markdown * > | "a\*b" * ^ * ``` * * @type {State} */ function escape(code) { if (code === marker || code === 92) { effects.consume(code); return inside; } return inside(code); } }{ "name": "micromark-factory-title", "version": "2.0.1", "description": "micromark factory to parse markdown titles (found in resources, definitions)", "license": "MIT", "keywords": [ "micromark", "factory", "title" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-factory-title", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "max-params": "off", "unicorn/prefer-code-point": "off" } } } /** * @import {Effects, State} from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding, markdownSpace } from 'micromark-util-character'; /** * Parse spaces and tabs. * * There is no `nok` parameter: * * * line endings or spaces in markdown are often optional, in which case this * factory can be used and `ok` will be switched to whether spaces were found * or not * * one line ending or space can be detected with * `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace` * * @param {Effects} effects * Context. * @param {State} ok * State switched to when successful. * @returns {State} * Start state. */ export function factoryWhitespace(effects, ok) { /** @type {boolean} */ let seen; return start; /** @type {State} */ function start(code) { if (markdownLineEnding(code)) { effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); seen = true; return start; } if (markdownSpace(code)) { return factorySpace(effects, start, seen ? "linePrefix" : "lineSuffix")(code); } return ok(code); } }{ "name": "micromark-factory-whitespace", "version": "2.0.1", "description": "micromark factory to parse markdown whitespace (found in lots of places)", "license": "MIT", "keywords": [ "micromark", "factory", "whitespace" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-factory-whitespace", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } /** * @import {Code} from 'micromark-util-types' */ /** * Check whether the character code represents an ASCII alpha (`a` through `z`, * case insensitive). * * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha. * * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`) * to U+005A (`Z`). * * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`) * to U+007A (`z`). * * @param code * Code. * @returns {boolean} * Whether it matches. */ export const asciiAlpha = regexCheck(/[A-Za-z]/); /** * Check whether the character code represents an ASCII alphanumeric (`a` * through `z`, case insensitive, or `0` through `9`). * * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha * (see `asciiAlpha`). * * @param code * Code. * @returns {boolean} * Whether it matches. */ export const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/); /** * Check whether the character code represents an ASCII atext. * * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`), * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE * (`{`) to U+007E TILDE (`~`). * * See: * **\[RFC5322]**: * [Internet Message Format](https://tools.ietf.org/html/rfc5322). * P. Resnick. * IETF. * * @param code * Code. * @returns {boolean} * Whether it matches. */ export const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/); /** * Check whether a character code is an ASCII control character. * * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL) * to U+001F (US), or U+007F (DEL). * * @param {Code} code * Code. * @returns {boolean} * Whether it matches. */ export function asciiControl(code) { return ( // Special whitespace codes (which have negative values), C0 and Control // character DEL code !== null && (code < 32 || code === 127) ); } /** * Check whether the character code represents an ASCII digit (`0` through `9`). * * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to * U+0039 (`9`). * * @param code * Code. * @returns {boolean} * Whether it matches. */ export const asciiDigit = regexCheck(/\d/); /** * Check whether the character code represents an ASCII hex digit (`a` through * `f`, case insensitive, or `0` through `9`). * * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex * digit, or an ASCII lower hex digit. * * An **ASCII upper hex digit** is a character in the inclusive range U+0041 * (`A`) to U+0046 (`F`). * * An **ASCII lower hex digit** is a character in the inclusive range U+0061 * (`a`) to U+0066 (`f`). * * @param code * Code. * @returns {boolean} * Whether it matches. */ export const asciiHexDigit = regexCheck(/[\dA-Fa-f]/); /** * Check whether the character code represents ASCII punctuation. * * An **ASCII punctuation** is a character in the inclusive ranges U+0021 * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`). * * @param code * Code. * @returns {boolean} * Whether it matches. */ export const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/); /** * Check whether a character code is a markdown line ending. * * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR). * * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE * RETURN (CR) are replaced by these virtual characters depending on whether * they occurred together. * * @param {Code} code * Code. * @returns {boolean} * Whether it matches. */ export function markdownLineEnding(code) { return code !== null && code < -2; } /** * Check whether a character code is a markdown line ending (see * `markdownLineEnding`) or markdown space (see `markdownSpace`). * * @param {Code} code * Code. * @returns {boolean} * Whether it matches. */ export function markdownLineEndingOrSpace(code) { return code !== null && (code < 0 || code === 32); } /** * Check whether a character code is a markdown space. * * A **markdown space** is the concrete character U+0020 SPACE (SP) and the * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT). * * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL * SPACE (VS) characters, depending on the column at which the tab occurred. * * @param {Code} code * Code. * @returns {boolean} * Whether it matches. */ export function markdownSpace(code) { return code === -2 || code === -1 || code === 32; } // Size note: removing ASCII from the regex and using `asciiPunctuation` here // In fact adds to the bundle size. /** * Check whether the character code represents Unicode punctuation. * * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation, * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf` * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po` * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII * punctuation (see `asciiPunctuation`). * * See: * **\[UNICODE]**: * [The Unicode Standard](https://www.unicode.org/versions/). * Unicode Consortium. * * @param code * Code. * @returns * Whether it matches. */ export const unicodePunctuation = regexCheck(/\p{P}|\p{S}/u); /** * Check whether the character code represents Unicode whitespace. * * Note that this does handle micromark specific markdown whitespace characters. * See `markdownLineEndingOrSpace` to check that. * * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator, * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF), * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**). * * See: * **\[UNICODE]**: * [The Unicode Standard](https://www.unicode.org/versions/). * Unicode Consortium. * * @param code * Code. * @returns * Whether it matches. */ export const unicodeWhitespace = regexCheck(/\s/); /** * Create a code check from a regex. * * @param {RegExp} regex * Expression. * @returns {(code: Code) => boolean} * Check. */ function regexCheck(regex) { return check; /** * Check whether a code matches the bound regex. * * @param {Code} code * Character code. * @returns {boolean} * Whether the character code matches the bound regex. */ function check(code) { return code !== null && code > -1 && regex.test(String.fromCharCode(code)); } }{ "name": "micromark-util-character", "version": "2.1.1", "description": "micromark utility to handle character codes", "license": "MIT", "keywords": [ "micromark", "util", "utility", "character" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-character", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "lib/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } /** * Like `Array#splice`, but smarter for giant arrays. * * `Array#splice` takes all items to be inserted as individual argument which * causes a stack overflow in V8 when trying to insert 100k items for instance. * * Otherwise, this does not return the removed items, and takes `items` as an * array instead of rest parameters. * * @template {unknown} T * Item type. * @param {Array} list * List to operate on. * @param {number} start * Index to remove/insert at (can be negative). * @param {number} remove * Number of items to remove. * @param {Array} items * Items to inject into `list`. * @returns {undefined} * Nothing. */ export function splice(list, start, remove, items) { const end = list.length; let chunkStart = 0; /** @type {Array} */ let parameters; // Make start between zero and `end` (included). if (start < 0) { start = -start > end ? 0 : end + start; } else { start = start > end ? end : start; } remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items. if (items.length < 10000) { parameters = Array.from(items); parameters.unshift(start, remove); // @ts-expect-error Hush, it’s fine. list.splice(...parameters); } else { // Delete `remove` items starting from `start` if (remove) list.splice(start, remove); // Insert the items in chunks to not cause stack overflows. while (chunkStart < items.length) { parameters = items.slice(chunkStart, chunkStart + 10000); parameters.unshift(start, 0); // @ts-expect-error Hush, it’s fine. list.splice(...parameters); chunkStart += 10000; start += 10000; } } } /** * Append `items` (an array) at the end of `list` (another array). * When `list` was empty, returns `items` instead. * * This prevents a potentially expensive operation when `list` is empty, * and adds items in batches to prevent V8 from hanging. * * @template {unknown} T * Item type. * @param {Array} list * List to operate on. * @param {Array} items * Items to add to `list`. * @returns {Array} * Either `list` or `items`. */ export function push(list, items) { if (list.length > 0) { splice(list, list.length, 0, items); return list; } return items; }{ "name": "micromark-util-chunked", "version": "2.0.1", "description": "micromark utility to splice and push with giant arrays", "license": "MIT", "keywords": [ "micromark", "util", "utility", "chunk", "splice", "push" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-chunked", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-symbol": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } /** * @import {Code} from 'micromark-util-types' */ import { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character'; /** * Classify whether a code represents whitespace, punctuation, or something * else. * * Used for attention (emphasis, strong), whose sequences can open or close * based on the class of surrounding characters. * * > 👉 **Note**: eof (`null`) is seen as whitespace. * * @param {Code} code * Code. * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined} * Group. */ export function classifyCharacter(code) { if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) { return 1; } if (unicodePunctuation(code)) { return 2; } }{ "name": "micromark-util-classify-character", "version": "2.0.1", "description": "micromark utility to classify whether a character is whitespace or punctuation", "license": "MIT", "keywords": [ "micromark", "util", "utility", "attention", "classify", "character" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-classify-character", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } /** * @import { * Extension, * Handles, * HtmlExtension, * NormalizedExtension * } from 'micromark-util-types' */ import {splice} from 'micromark-util-chunked' const hasOwnProperty = {}.hasOwnProperty /** * Combine multiple syntax extensions into one. * * @param {ReadonlyArray} extensions * List of syntax extensions. * @returns {NormalizedExtension} * A single combined extension. */ export 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) { const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined /** @type {Record} */ const left = maybe || (all[hook] = {}) /** @type {Record | 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( // @ts-expect-error Looks like a list. left[code], Array.isArray(value) ? value : value ? [value] : [] ) } } } } /** * Merge `list` into `existing` (both lists of constructs). * Mutates `existing`. * * @param {Array} existing * List of constructs to merge into. * @param {Array} list * List of constructs to merge. * @returns {undefined} * Nothing. */ function constructs(existing, list) { let index = -1 /** @type {Array} */ const before = [] while (++index < list.length) { // @ts-expect-error Looks like an object. ;(list[index].add === 'after' ? existing : before).push(list[index]) } splice(existing, 0, 0, before) } /** * Combine multiple HTML extensions into one. * * @param {ReadonlyArray} htmlExtensions * List of HTML extensions. * @returns {HtmlExtension} * Single combined HTML extension. */ export function combineHtmlExtensions(htmlExtensions) { /** @type {HtmlExtension} */ const handlers = {} let index = -1 while (++index < htmlExtensions.length) { htmlExtension(handlers, htmlExtensions[index]) } return handlers } /** * Merge `extension` into `all`. * * @param {HtmlExtension} all * Extension to merge into. * @param {HtmlExtension} extension * Extension to merge. * @returns {undefined} * Nothing. */ function htmlExtension(all, extension) { /** @type {keyof HtmlExtension} */ let hook for (hook in extension) { const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined const left = maybe || (all[hook] = {}) const right = extension[hook] /** @type {keyof Handles} */ let type if (right) { for (type in right) { // @ts-expect-error assume document vs regular handler are managed correctly. left[type] = right[type] } } } } { "name": "micromark-util-combine-extensions", "version": "2.0.1", "description": "micromark utility to combine syntax or html extensions", "license": "MIT", "keywords": [ "micromark", "util", "utility", "extension", "combine", "merge" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-combine-extensions", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "index.d.ts.map", "index.d.ts", "index.js" ], "exports": "./index.js", "dependencies": { "micromark-util-chunked": "^2.0.0", "micromark-util-types": "^2.0.0" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "guard-for-in": "off", "unicorn/prefer-code-point": "off" } } } /** * 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. */ export function decodeNumericCharacterReference(value, base) { const code = Number.parseInt(value, base); if ( // C0 except for HT, LF, FF, CR, space. code < 9 || code === 11 || code > 13 && code < 32 || // Control character (DEL) of C0, and C1 controls. code > 126 && code < 160 || // Lone high surrogates and low surrogates. code > 55_295 && code < 57_344 || // Noncharacters. code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */ (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */ // Out of range code > 1_114_111) { return "\uFFFD"; } return String.fromCodePoint(code); }{ "name": "micromark-util-decode-numeric-character-reference", "version": "2.0.2", "description": "micromark utility to decode numeric character references", "license": "MIT", "keywords": [ "micromark", "util", "utility", "decode", "numeric", "number", "character", "reference" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-decode-numeric-character-reference", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-symbol": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } import { decodeNamedCharacterReference } from 'decode-named-character-reference'; import { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference'; 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. */ export 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) { // Escape. return $1; } // Reference. const head = $2.charCodeAt(0); if (head === 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; }{ "name": "micromark-util-decode-string", "version": "2.0.1", "description": "micromark utility to decode markdown strings", "license": "MIT", "keywords": [ "micromark", "util", "utility", "decode", "character", "reference", "escape", "string" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-decode-string", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-symbol": "^2.0.0", "decode-named-character-reference": "^1.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off", "unicorn/prefer-string-replace-all": "off" } } } const characterReferences = {'"': 'quot', '&': 'amp', '<': 'lt', '>': 'gt'} /** * Encode only the dangerous HTML characters. * * This ensures that certain characters which have special meaning in HTML are * dealt with. * Technically, we can skip `>` and `"` in many cases, but CM includes them. * * @param {string} value * Value to encode. * @returns {string} * Encoded value. */ export function encode(value) { return value.replace(/["&<>]/g, replace) /** * @param {string} value * Value to replace. * @returns {string} * Encoded value. */ function replace(value) { return ( '&' + characterReferences[ /** @type {keyof typeof characterReferences} */ (value) ] + ';' ) } } { "name": "micromark-util-encode", "version": "2.0.1", "description": "micromark utility to encode dangerous html characters", "license": "MIT", "keywords": [ "micromark", "util", "utility", "html", "encode" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-encode", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "index.d.ts.map", "index.d.ts", "index.js" ], "exports": "./index.js", "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-string-replace-all": "off", "unicorn/prefer-code-point": "off" } } } /** * 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: * . * * > 👉 **Note**: `search` was added in `CommonMark@0.31`. */ export 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: * . * * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`. */ export const htmlRawNames = ['pre', 'script', 'style', 'textarea'] { "name": "micromark-util-html-tag-name", "version": "2.0.1", "description": "micromark utility with list of html tag names", "license": "MIT", "keywords": [ "micromark", "util", "utility", "html", "tag", "name" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-html-tag-name", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "index.d.ts.map", "index.d.ts", "index.js" ], "exports": "./index.js", "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } /** * 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. */ export function normalizeIdentifier(value) { return value // Collapse markdown whitespace. .replace(/[\t\n\r ]+/g, " ") // Trim. .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase // counterpart is uppercased will result in a different uppercase // character. // Hence, to get that form, we perform both lower- and uppercase. // Upper case makes sure keys will not interact with default prototypal // methods: no method is uppercase. .toLowerCase().toUpperCase(); }{ "name": "micromark-util-normalize-identifier", "version": "2.0.1", "description": "micromark utility normalize identifiers (as found in references, definitions)", "license": "MIT", "keywords": [ "micromark", "util", "utility", "normalize", "id", "identifier" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-normalize-identifier", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-symbol": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off", "unicorn/prefer-string-replace-all": "off" } } } /** * @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} events * List of events. * @param {TokenizeContext} context * Context used by `tokenize`. * @returns {Array} * Changed events. */ export function resolveAll(constructs, events, context) { /** @type {Array} */ 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 } { "name": "micromark-util-resolve-all", "version": "2.0.1", "description": "micromark utility to resolve subtokens", "license": "MIT", "keywords": [ "micromark", "util", "utility", "resolve" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-resolve-all", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "index.d.ts.map", "index.d.ts", "index.js" ], "exports": "./index.js", "dependencies": { "micromark-util-types": "^2.0.0" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } import { asciiAlphanumeric } from 'micromark-util-character'; import { encode } from 'micromark-util-encode'; /** * Make a value safe for injection as a URL. * * This encodes unsafe characters with percent-encoding and skips already * encoded sequences (see `normalizeUri`). * Further unsafe characters are encoded as character references (see * `micromark-util-encode`). * * A regex of allowed protocols can be given, in which case the URL is * sanitized. * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or * `/^https?$/i` for `img[src]` (this is what `github.com` allows). * If the URL includes an unknown protocol (one not matched by `protocol`, such * as a dangerous example, `javascript:`), the value is ignored. * * @param {string | null | undefined} url * URI to sanitize. * @param {RegExp | null | undefined} [protocol] * Allowed protocols. * @returns {string} * Sanitized URI. */ export function sanitizeUri(url, protocol) { const value = encode(normalizeUri(url || '')); if (!protocol) { return value; } const colon = value.indexOf(':'); const questionMark = value.indexOf('?'); const numberSign = value.indexOf('#'); const slash = value.indexOf('/'); if ( // If there is no protocol, it’s relative. colon < 0 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol. slash > -1 && colon > slash || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign || // It is a protocol, it should be allowed. protocol.test(value.slice(0, colon))) { return value; } return ''; } /** * Normalize a URL. * * Encode unsafe characters with percent-encoding, skipping already encoded * sequences. * * @param {string} value * URI to normalize. * @returns {string} * Normalized URI. */ export function normalizeUri(value) { /** @type {Array} */ const result = []; let index = -1; let start = 0; let skip = 0; while (++index < value.length) { const code = value.charCodeAt(index); /** @type {string} */ let replace = ''; // A correct percent encoded value. if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) { skip = 2; } // ASCII. else if (code < 128) { if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) { replace = String.fromCharCode(code); } } // Astral. else if (code > 55_295 && code < 57_344) { const next = value.charCodeAt(index + 1); // A correct surrogate pair. if (code < 56_320 && next > 56_319 && next < 57_344) { replace = String.fromCharCode(code, next); skip = 1; } // Lone surrogate. else { replace = "\uFFFD"; } } // Unicode. else { replace = String.fromCharCode(code); } if (replace) { result.push(value.slice(start, index), encodeURIComponent(replace)); start = index + skip + 1; replace = ''; } if (skip) { index += skip; skip = 0; } } return result.join('') + value.slice(start); }{ "name": "micromark-util-sanitize-uri", "version": "2.0.1", "description": "micromark utility to sanitize urls", "license": "MIT", "keywords": [ "micromark", "util", "utility", "sanitize", "clear", "url" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-sanitize-uri", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-symbol": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "unicorn/prefer-code-point": "off" } } } /** * @import {Chunk, Event, Token} from 'micromark-util-types' */ import { splice } from 'micromark-util-chunked'; import { SpliceBuffer } from './lib/splice-buffer.js'; // Hidden API exposed for testing. export { SpliceBuffer } from './lib/splice-buffer.js'; /** * Tokenize subcontent. * * @param {Array} eventsArray * List of events. * @returns {boolean} * Whether subtokens were found. */ // eslint-disable-next-line complexity export function subtokenize(eventsArray) { /** @type {Record} */ const jumps = {}; let index = -1; /** @type {Event} */ let event; /** @type {number | undefined} */ let lineIndex; /** @type {number} */ let otherIndex; /** @type {Event} */ let otherEvent; /** @type {Array} */ let parameters; /** @type {Array} */ 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); // Add a hook for the GFM tasklist extension, which needs to know if text // is in the first content of a list item. 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++; } } } } // Enter. if (event[0] === 'enter') { if (event[1].contentType) { Object.assign(jumps, subcontent(events, index)); index = jumps[index]; more = true; } } // Exit. else if (event[1]._container) { otherIndex = index; lineIndex = undefined; 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") { // Move past. } else { break; } } if (lineIndex) { // Fix position. event[1].end = { ...events.get(lineIndex)[1].start }; // Switch container exit w/ line endings. parameters = events.slice(lineIndex, index); parameters.unshift(event); events.splice(lineIndex, index - lineIndex + 1, parameters); } } } // The changes to the `events` buffer must be copied back into the eventsArray splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0)); return !more; } /** * Tokenize embedded tokens. * * @param {SpliceBuffer} events * Events. * @param {number} eventIndex * Index. * @returns {Record} * Gaps. */ function subcontent(events, eventIndex) { const token = events.get(eventIndex)[1]; const context = events.get(eventIndex)[2]; let startPosition = eventIndex - 1; /** @type {Array} */ 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} */ const gaps = {}; /** @type {Array} */ 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]; // Loop forward through the linked tokens to pass them in order to the // subtokenizer. while (current) { // Find the position of the event for this token. while (events.get(++startPosition)[1] !== current) { // Empty. } 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 = undefined; } } // Unravel the next token. previous = current; current = current.next; } // Now, loop back through all events (and linked tokens), to figure out which // parts belong where. current = token; while (++index < childEvents.length) { if ( // Find a void token that includes a break. 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); // Help GC. current._tokenizer = undefined; current.previous = undefined; current = current.next; } } // Help GC. tokenizer.events = []; // If there’s one more token (which is the cases for lines that end in an // EOF), that’s perfect: the last point we found starts it. // If there isn’t then make sure any remaining content is added to it. if (current) { // Help GC. current._tokenizer = undefined; current.previous = undefined; } else { breaks.pop(); } // Now splice the events from the subtokenizer into the current events, // moving back to front so that splice indices aren’t affected. 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; }/** * 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 ) * * 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. */ export class SpliceBuffer { /** * @param {ReadonlyArray | null | undefined} [initial] * Initial items (optional). * @returns * Splice buffer. */ constructor(initial) { /** @type {Array} */ this.left = initial ? [...initial] : []; /** @type {Array} */ 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} * Array of items. */ slice(start, end) { /** @type {number} */ const stop = end === null || end === undefined ? 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 | null | undefined} [items=[]] * Items to include in place of the deleted items (default: `[]`). * @return {Array} * 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} 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} 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) { // Move cursor to the this.left const removed = this.left.splice(n, Number.POSITIVE_INFINITY); chunkedPush(this.right, removed.reverse()); } else { // Move cursor to the this.right 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} list * List to inject into. * @param {ReadonlyArray} right * Items to inject. * @return {undefined} * Nothing. */ function chunkedPush(list, right) { /** @type {number} */ let chunkStart = 0; if (right.length < 10000) { list.push(...right); } else { while (chunkStart < right.length) { list.push(...right.slice(chunkStart, chunkStart + 10000)); chunkStart += 10000; } } }{ "name": "micromark-util-subtokenize", "version": "2.1.0", "description": "micromark utility to tokenize subtokens", "license": "MIT", "keywords": [ "micromark", "util", "utility", "tokenize" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-subtokenize", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "lib/", "index.d.ts.map", "index.d.ts", "index.js" ], "exports": { "development": "./dev/index.js", "default": "./index.js" }, "dependencies": { "devlop": "^1.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "max-depth": "off", "unicorn/prefer-code-point": "off" } } } /** * @import {Encoding, Value} from 'micromark-util-types' */ /** * @typedef {import('micromark-util-types').Options} Options */ import { compile } from './lib/compile.js'; import { parse } from './lib/parse.js'; import { postprocess } from './lib/postprocess.js'; import { preprocess } from './lib/preprocess.js'; export { compile } from './lib/compile.js'; export { parse } from './lib/parse.js'; export { postprocess } from './lib/postprocess.js'; export { preprocess } from './lib/preprocess.js'; /** * Compile markdown to HTML. * * > Note: which encodings are supported depends on the engine. * > For info on Node.js, see: * > . * * @overload * @param {Value} value * Markdown to parse (`string` or `Uint8Array`). * @param {Encoding | null | undefined} encoding * Character encoding to understand `value` as when it’s a `Uint8Array` * (`string`, default: `'utf8'`). * @param {Options | null | undefined} [options] * Configuration. * @returns {string} * Compiled HTML. * * @overload * @param {Value} value * Markdown to parse (`string` or `Uint8Array`). * @param {Options | null | undefined} [options] * Configuration. * @returns {string} * Compiled HTML. * * @param {Value} value * Markdown to parse (`string` or `Uint8Array`). * @param {Encoding | Options | null | undefined} [encoding] * Character encoding to understand `value` as when it’s a `Uint8Array` * (`string`, default: `'utf8'`). * @param {Options | null | undefined} [options] * Configuration. * @returns {string} * Compiled HTML. */ export function micromark(value, encoding, options) { if (typeof encoding !== 'string') { options = encoding; encoding = undefined; } return compile(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true)))); }/** * While micromark is a lexer/tokenizer, the common case of going from markdown * to html is currently built in as this module, even though the parts can be * used separately to build ASTs, CSTs, or many other output formats. * * Having an HTML compiler built in is useful because it allows us to check for * compliancy to CommonMark, the de facto norm of markdown, specified in roughly * 600 input/output cases. * * This module has an interface that accepts lists of events instead of the * whole at once, however, because markdown can’t be truly streaming, we buffer * events before processing and outputting the final result. */ /** * @import { * CompileContext, * CompileData, * CompileOptions, * Compile, * Definition, * Event, * Handle, * HtmlExtension, * LineEnding, * NormalizedHtmlExtension, * Token * } from 'micromark-util-types' */ /** * @typedef Media * @property {boolean | undefined} [image] * @property {string | undefined} [labelId] * @property {string | undefined} [label] * @property {string | undefined} [referenceId] * @property {string | undefined} [destination] * @property {string | undefined} [title] */ import { decodeNamedCharacterReference } from 'decode-named-character-reference'; import { push } from 'micromark-util-chunked'; import { combineHtmlExtensions } from 'micromark-util-combine-extensions'; import { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference'; import { encode as _encode } from 'micromark-util-encode'; import { normalizeIdentifier } from 'micromark-util-normalize-identifier'; import { sanitizeUri } from 'micromark-util-sanitize-uri'; const hasOwnProperty = {}.hasOwnProperty; /** * These two are allowlists of safe protocols for full URLs in respectively the * `href` (on ``) and `src` (on ``) attributes. * They are based on what is allowed on GitHub, * */ const protocolHref = /^(https?|ircs?|mailto|xmpp)$/i; const protocolSource = /^https?$/i; /** * @param {CompileOptions | null | undefined} [options] * @returns {Compile} */ export function compile(options) { const settings = options || {}; /** * Tags is needed because according to markdown, links and emphasis and * whatnot can exist in images, however, as HTML doesn’t allow content in * images, the tags are ignored in the `alt` attribute, but the content * remains. * * @type {boolean | undefined} */ let tags = true; /** * An object to track identifiers to media (URLs and titles) defined with * definitions. * * @type {Record} */ const definitions = {}; /** * A lot of the handlers need to capture some of the output data, modify it * somehow, and then deal with it. * We do that by tracking a stack of buffers, that can be opened (with * `buffer`) and closed (with `resume`) to access them. * * @type {Array>} */ const buffers = [[]]; /** * As we can have links in images and the other way around, where the deepest * ones are closed first, we need to track which one we’re in. * * @type {Array} */ const mediaStack = []; /** * Same as `mediaStack` for tightness, which is specific to lists. * We need to track if we’re currently in a tight or loose container. * * @type {Array} */ const tightStack = []; /** @type {HtmlExtension} */ const defaultHandlers = { enter: { blockQuote: onenterblockquote, codeFenced: onentercodefenced, codeFencedFenceInfo: buffer, codeFencedFenceMeta: buffer, codeIndented: onentercodeindented, codeText: onentercodetext, content: onentercontent, definition: onenterdefinition, definitionDestinationString: onenterdefinitiondestinationstring, definitionLabelString: buffer, definitionTitleString: buffer, emphasis: onenteremphasis, htmlFlow: onenterhtmlflow, htmlText: onenterhtml, image: onenterimage, label: buffer, link: onenterlink, listItemMarker: onenterlistitemmarker, listItemValue: onenterlistitemvalue, listOrdered: onenterlistordered, listUnordered: onenterlistunordered, paragraph: onenterparagraph, reference: buffer, resource: onenterresource, resourceDestinationString: onenterresourcedestinationstring, resourceTitleString: buffer, setextHeading: onentersetextheading, strong: onenterstrong }, exit: { atxHeading: onexitatxheading, atxHeadingSequence: onexitatxheadingsequence, autolinkEmail: onexitautolinkemail, autolinkProtocol: onexitautolinkprotocol, blockQuote: onexitblockquote, characterEscapeValue: onexitdata, characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker, characterReferenceMarkerNumeric: onexitcharacterreferencemarker, characterReferenceValue: onexitcharacterreferencevalue, codeFenced: onexitflowcode, codeFencedFence: onexitcodefencedfence, codeFencedFenceInfo: onexitcodefencedfenceinfo, codeFencedFenceMeta: onresumedrop, codeFlowValue: onexitcodeflowvalue, codeIndented: onexitflowcode, codeText: onexitcodetext, codeTextData: onexitdata, data: onexitdata, definition: onexitdefinition, definitionDestinationString: onexitdefinitiondestinationstring, definitionLabelString: onexitdefinitionlabelstring, definitionTitleString: onexitdefinitiontitlestring, emphasis: onexitemphasis, hardBreakEscape: onexithardbreak, hardBreakTrailing: onexithardbreak, htmlFlow: onexithtml, htmlFlowData: onexitdata, htmlText: onexithtml, htmlTextData: onexitdata, image: onexitmedia, label: onexitlabel, labelText: onexitlabeltext, lineEnding: onexitlineending, link: onexitmedia, listOrdered: onexitlistordered, listUnordered: onexitlistunordered, paragraph: onexitparagraph, reference: onresumedrop, referenceString: onexitreferencestring, resource: onresumedrop, resourceDestinationString: onexitresourcedestinationstring, resourceTitleString: onexitresourcetitlestring, setextHeading: onexitsetextheading, setextHeadingLineSequence: onexitsetextheadinglinesequence, setextHeadingText: onexitsetextheadingtext, strong: onexitstrong, thematicBreak: onexitthematicbreak } }; /** * Combine the HTML extensions with the default handlers. * An HTML extension is an object whose fields are either `enter` or `exit` * (reflecting whether a token is entered or exited). * The values at such objects are names of tokens mapping to handlers. * Handlers are called, respectively when a token is opener or closed, with * that token, and a context as `this`. */ const handlers = /** @type {NormalizedHtmlExtension} */ combineHtmlExtensions([defaultHandlers, ...(settings.htmlExtensions || [])]); /** * Handlers do often need to keep track of some state. * That state is provided here as a key-value store (an object). * * @type {CompileData} */ const data = { definitions, tightStack }; /** * The context for handlers references a couple of useful functions. * In handlers from extensions, those can be accessed at `this`. * For the handlers here, they can be accessed directly. * * @type {Omit} */ const context = { buffer, encode, getData, lineEndingIfNeeded, options: settings, raw, resume, setData, tag }; /** * Generally, micromark copies line endings (`'\r'`, `'\n'`, `'\r\n'`) in the * markdown document over to the compiled HTML. * In some cases, such as `> a`, CommonMark requires that extra line endings * are added: `\na \n`. * This variable hold the default line ending when given (or `undefined`), * and in the latter case will be updated to the first found line ending if * there is one. */ let lineEndingStyle = settings.defaultLineEnding; // Return the function that handles a slice of events. return compile; /** * Deal w/ a slice of events. * Return either the empty string if there’s nothing of note to return, or the * result when done. * * @param {ReadonlyArray} events * @returns {string} */ function compile(events) { let index = -1; let start = 0; /** @type {Array} */ const listStack = []; // As definitions can come after references, we need to figure out the media // (urls and titles) defined by them before handling the references. // So, we do sort of what HTML does: put metadata at the start (in head), and // then put content after (`body`). /** @type {Array} */ let head = []; /** @type {Array} */ let body = []; while (++index < events.length) { // Figure out the line ending style used in the document. if (!lineEndingStyle && (events[index][1].type === "lineEnding" || events[index][1].type === "lineEndingBlank")) { lineEndingStyle = /** @type {LineEnding} */ events[index][2].sliceSerialize(events[index][1]); } // Preprocess lists to infer whether the list is loose or not. if (events[index][1].type === "listOrdered" || events[index][1].type === "listUnordered") { if (events[index][0] === 'enter') { listStack.push(index); } else { prepareList(events.slice(listStack.pop(), index)); } } // Move definitions to the front. if (events[index][1].type === "definition") { if (events[index][0] === 'enter') { body = push(body, events.slice(start, index)); start = index; } else { head = push(head, events.slice(start, index + 1)); start = index + 1; } } } head = push(head, body); head = push(head, events.slice(start)); index = -1; const result = head; // Handle the start of the document, if defined. if (handlers.enter.null) { handlers.enter.null.call(context); } // Handle all events. while (++index < events.length) { const handles = handlers[result[index][0]]; const kind = result[index][1].type; const handle = handles[kind]; if (hasOwnProperty.call(handles, kind) && handle) { handle.call({ sliceSerialize: result[index][2].sliceSerialize, ...context }, result[index][1]); } } // Handle the end of the document, if defined. if (handlers.exit.null) { handlers.exit.null.call(context); } return buffers[0].join(''); } /** * Figure out whether lists are loose or not. * * @param {ReadonlyArray} slice * @returns {undefined} */ function prepareList(slice) { const length = slice.length; let index = 0; // Skip open. let containerBalance = 0; let loose = false; /** @type {boolean | undefined} */ let atMarker; while (++index < length) { const event = slice[index]; if (event[1]._container) { atMarker = undefined; if (event[0] === 'enter') { containerBalance++; } else { containerBalance--; } } else switch (event[1].type) { case "listItemPrefix": { if (event[0] === 'exit') { atMarker = true; } break; } case "linePrefix": { // Ignore break; } case "lineEndingBlank": { if (event[0] === 'enter' && !containerBalance) { if (atMarker) { atMarker = undefined; } else { loose = true; } } break; } default: { atMarker = undefined; } } } slice[0][1]._loose = loose; } /** * @type {CompileContext['setData']} */ function setData(key, value) { // @ts-expect-error: assume `value` is omitted (`undefined` is passed) only // if allowed. data[key] = value; } /** * @type {CompileContext['getData']} */ function getData(key) { return data[key]; } /** @type {CompileContext['buffer']} */ function buffer() { buffers.push([]); } /** @type {CompileContext['resume']} */ function resume() { const buf = buffers.pop(); return buf.join(''); } /** @type {CompileContext['tag']} */ function tag(value) { if (!tags) return; setData('lastWasTag', true); buffers[buffers.length - 1].push(value); } /** @type {CompileContext['raw']} */ function raw(value) { setData('lastWasTag'); buffers[buffers.length - 1].push(value); } /** * Output an extra line ending. * * @returns {undefined} */ function lineEnding() { raw(lineEndingStyle || '\n'); } /** @type {CompileContext['lineEndingIfNeeded']} */ function lineEndingIfNeeded() { const buffer = buffers[buffers.length - 1]; const slice = buffer[buffer.length - 1]; const previous = slice ? slice.charCodeAt(slice.length - 1) : null; if (previous === 10 || previous === 13 || previous === null) { return; } lineEnding(); } /** @type {CompileContext['encode']} */ function encode(value) { return getData('ignoreEncode') ? value : _encode(value); } // // Handlers. // /** * @returns {undefined} */ function onresumedrop() { resume(); } /** * @this {CompileContext} * @type {Handle} */ function onenterlistordered(token) { tightStack.push(!token._loose); lineEndingIfNeeded(); tag(''); } else { onexitlistitem(); } lineEndingIfNeeded(); tag(''); setData('expectFirstItem'); // “Hack” to prevent a line ending from showing up if the item is empty. setData('lastWasTag'); } /** * @returns {undefined} */ function onexitlistordered() { onexitlistitem(); tightStack.pop(); lineEnding(); tag(''); } /** * @returns {undefined} */ function onexitlistunordered() { onexitlistitem(); tightStack.pop(); lineEnding(); tag(''); } /** * @returns {undefined} */ function onexitlistitem() { if (getData('lastWasTag') && !getData('slurpAllLineEndings')) { lineEndingIfNeeded(); } tag(''); setData('slurpAllLineEndings'); } /** * @this {CompileContext} * @type {Handle} */ function onenterblockquote() { tightStack.push(false); lineEndingIfNeeded(); tag(''); } /** * @this {CompileContext} * @type {Handle} */ function onexitblockquote() { tightStack.pop(); lineEndingIfNeeded(); tag(''); setData('slurpAllLineEndings'); } /** * @this {CompileContext} * @type {Handle} */ function onenterparagraph() { if (!tightStack[tightStack.length - 1]) { lineEndingIfNeeded(); tag(''); } setData('slurpAllLineEndings'); } /** * @this {CompileContext} * @type {Handle} */ function onexitparagraph() { if (tightStack[tightStack.length - 1]) { setData('slurpAllLineEndings', true); } else { tag(''); } } /** * @this {CompileContext} * @type {Handle} */ function onentercodefenced() { lineEndingIfNeeded(); tag(''); setData('slurpOneLineEnding', true); } setData('fencesCount', count + 1); } /** * @this {CompileContext} * @type {Handle} */ function onentercodeindented() { lineEndingIfNeeded(); tag(''); } /** * @this {CompileContext} * @type {Handle} */ function onexitflowcode() { const count = getData('fencesCount'); // One special case is if we are inside a container, and the fenced code was // not closed (meaning it runs to the end). // In that case, the following line ending, is considered *outside* the // fenced code and block quote by micromark, but CM wants to treat that // ending as part of the code. if (count !== undefined && count < 2 && data.tightStack.length > 0 && !getData('lastWasTag')) { lineEnding(); } // But in most cases, it’s simpler: when we’ve seen some data, emit an extra // line ending when needed. if (getData('flowCodeSeenData')) { lineEndingIfNeeded(); } tag(''); if (count !== undefined && count < 2) lineEndingIfNeeded(); setData('flowCodeSeenData'); setData('fencesCount'); setData('slurpOneLineEnding'); } /** * @this {CompileContext} * @type {Handle} */ function onenterimage() { mediaStack.push({ image: true }); tags = undefined; // Disallow tags. } /** * @this {CompileContext} * @type {Handle} */ function onenterlink() { mediaStack.push({}); } /** * @this {CompileContext} * @type {Handle} */ function onexitlabeltext(token) { mediaStack[mediaStack.length - 1].labelId = this.sliceSerialize(token); } /** * @this {CompileContext} * @type {Handle} */ function onexitlabel() { mediaStack[mediaStack.length - 1].label = resume(); } /** * @this {CompileContext} * @type {Handle} */ function onexitreferencestring(token) { mediaStack[mediaStack.length - 1].referenceId = this.sliceSerialize(token); } /** * @this {CompileContext} * @type {Handle} */ function onenterresource() { buffer(); // We can have line endings in the resource, ignore them. mediaStack[mediaStack.length - 1].destination = ''; } /** * @this {CompileContext} * @type {Handle} */ function onenterresourcedestinationstring() { buffer(); // Ignore encoding the result, as we’ll first percent encode the url and // encode manually after. setData('ignoreEncode', true); } /** * @this {CompileContext} * @type {Handle} */ function onexitresourcedestinationstring() { mediaStack[mediaStack.length - 1].destination = resume(); setData('ignoreEncode'); } /** * @this {CompileContext} * @type {Handle} */ function onexitresourcetitlestring() { mediaStack[mediaStack.length - 1].title = resume(); } /** * @this {CompileContext} * @type {Handle} */ function onexitmedia() { let index = mediaStack.length - 1; // Skip current. const media = mediaStack[index]; const id = media.referenceId || media.labelId; const context = media.destination === undefined ? definitions[normalizeIdentifier(id)] : media; tags = true; while (index--) { if (mediaStack[index].image) { tags = undefined; break; } } if (media.image) { tag(''); } else { tag('>'); raw(media.label); tag(''); } mediaStack.pop(); } /** * @this {CompileContext} * @type {Handle} */ function onenterdefinition() { buffer(); mediaStack.push({}); } /** * @this {CompileContext} * @type {Handle} */ function onexitdefinitionlabelstring(token) { // Discard label, use the source content instead. resume(); mediaStack[mediaStack.length - 1].labelId = this.sliceSerialize(token); } /** * @this {CompileContext} * @type {Handle} */ function onenterdefinitiondestinationstring() { buffer(); setData('ignoreEncode', true); } /** * @this {CompileContext} * @type {Handle} */ function onexitdefinitiondestinationstring() { mediaStack[mediaStack.length - 1].destination = resume(); setData('ignoreEncode'); } /** * @this {CompileContext} * @type {Handle} */ function onexitdefinitiontitlestring() { mediaStack[mediaStack.length - 1].title = resume(); } /** * @this {CompileContext} * @type {Handle} */ function onexitdefinition() { const media = mediaStack[mediaStack.length - 1]; const id = normalizeIdentifier(media.labelId); resume(); if (!hasOwnProperty.call(definitions, id)) { definitions[id] = mediaStack[mediaStack.length - 1]; } mediaStack.pop(); } /** * @this {CompileContext} * @type {Handle} */ function onentercontent() { setData('slurpAllLineEndings', true); } /** * @this {CompileContext} * @type {Handle} */ function onexitatxheadingsequence(token) { // Exit for further sequences. if (getData('headingRank')) return; setData('headingRank', this.sliceSerialize(token).length); lineEndingIfNeeded(); tag(''); } /** * @this {CompileContext} * @type {Handle} */ function onentersetextheading() { buffer(); setData('slurpAllLineEndings'); } /** * @this {CompileContext} * @type {Handle} */ function onexitsetextheadingtext() { setData('slurpAllLineEndings', true); } /** * @this {CompileContext} * @type {Handle} */ function onexitatxheading() { tag(''); setData('headingRank'); } /** * @this {CompileContext} * @type {Handle} */ function onexitsetextheadinglinesequence(token) { setData('headingRank', this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2); } /** * @this {CompileContext} * @type {Handle} */ function onexitsetextheading() { const value = resume(); lineEndingIfNeeded(); tag(''); raw(value); tag(''); setData('slurpAllLineEndings'); setData('headingRank'); } /** * @this {CompileContext} * @type {Handle} */ function onexitdata(token) { raw(encode(this.sliceSerialize(token))); } /** * @this {CompileContext} * @type {Handle} */ function onexitlineending(token) { if (getData('slurpAllLineEndings')) { return; } if (getData('slurpOneLineEnding')) { setData('slurpOneLineEnding'); return; } if (getData('inCodeText')) { raw(' '); return; } raw(encode(this.sliceSerialize(token))); } /** * @this {CompileContext} * @type {Handle} */ function onexitcodeflowvalue(token) { raw(encode(this.sliceSerialize(token))); setData('flowCodeSeenData', true); } /** * @this {CompileContext} * @type {Handle} */ function onexithardbreak() { tag(' '); } /** * @returns {undefined} */ function onenterhtmlflow() { lineEndingIfNeeded(); onenterhtml(); } /** * @returns {undefined} */ function onexithtml() { setData('ignoreEncode'); } /** * @returns {undefined} */ function onenterhtml() { if (settings.allowDangerousHtml) { setData('ignoreEncode', true); } } /** * @returns {undefined} */ function onenteremphasis() { tag(''); } /** * @returns {undefined} */ function onenterstrong() { tag(''); } /** * @returns {undefined} */ function onentercodetext() { setData('inCodeText', true); tag(''); } /** * @returns {undefined} */ function onexitcodetext() { setData('inCodeText'); tag(''); } /** * @returns {undefined} */ function onexitemphasis() { tag(''); } /** * @returns {undefined} */ function onexitstrong() { tag(''); } /** * @returns {undefined} */ function onexitthematicbreak() { lineEndingIfNeeded(); tag(''); } /** * @this {CompileContext} * @param {Token} token * @returns {undefined} */ function onexitcharacterreferencemarker(token) { setData('characterReferenceType', token.type); } /** * @this {CompileContext} * @type {Handle} */ function onexitcharacterreferencevalue(token) { const value = this.sliceSerialize(token); const decoded = getData('characterReferenceType') ? decodeNumericCharacterReference(value, getData('characterReferenceType') === "characterReferenceMarkerNumeric" ? 10 : 16) : decodeNamedCharacterReference(value); // `decodeNamedCharacterReference` can return `false` for invalid named // character references, // but everything we’ve tokenized is valid. raw(encode(/** @type {string} */decoded)); setData('characterReferenceType'); } /** * @this {CompileContext} * @type {Handle} */ function onexitautolinkprotocol(token) { const uri = this.sliceSerialize(token); tag(''); raw(encode(uri)); tag(''); } /** * @this {CompileContext} * @type {Handle} */ function onexitautolinkemail(token) { const uri = this.sliceSerialize(token); tag(''); raw(encode(uri)); tag(''); } }/** * @import {Extension} from 'micromark-util-types' */ import { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } from 'micromark-core-commonmark'; import { resolver as resolveText } from './initialize/text.js'; /** @satisfies {Extension['document']} */ export const document = { [42]: list, [43]: list, [45]: list, [48]: list, [49]: list, [50]: list, [51]: list, [52]: list, [53]: list, [54]: list, [55]: list, [56]: list, [57]: list, [62]: blockQuote }; /** @satisfies {Extension['contentInitial']} */ export const contentInitial = { [91]: definition }; /** @satisfies {Extension['flowInitial']} */ export const flowInitial = { [-2]: codeIndented, [-1]: codeIndented, [32]: codeIndented }; /** @satisfies {Extension['flow']} */ export const flow = { [35]: headingAtx, [42]: thematicBreak, [45]: [setextUnderline, thematicBreak], [60]: htmlFlow, [61]: setextUnderline, [95]: thematicBreak, [96]: codeFenced, [126]: codeFenced }; /** @satisfies {Extension['string']} */ export const string = { [38]: characterReference, [92]: characterEscape }; /** @satisfies {Extension['text']} */ export const text = { [-5]: lineEnding, [-4]: lineEnding, [-3]: lineEnding, [33]: labelStartImage, [38]: characterReference, [42]: attention, [60]: [autolink, htmlText], [91]: labelStartLink, [92]: [hardBreakEscape, characterEscape], [93]: labelEnd, [95]: attention, [96]: codeText }; /** @satisfies {Extension['insideSpan']} */ export const insideSpan = { null: [attention, resolveText] }; /** @satisfies {Extension['attentionMarkers']} */ export const attentionMarkers = { null: [42, 95] }; /** @satisfies {Extension['disable']} */ export const disable = { null: [] };/** * @import { * Chunk, * Code, * ConstructRecord, * Construct, * Effects, * InitialConstruct, * ParseContext, * Point, * State, * TokenizeContext, * Token * } from 'micromark-util-types' */ /** * @callback Restore * Restore the state. * @returns {undefined} * Nothing. * * @typedef Info * Info. * @property {Restore} restore * Restore. * @property {number} from * From. * * @callback ReturnHandle * Handle a successful run. * @param {Construct} construct * Construct. * @param {Info} info * Info. * @returns {undefined} * Nothing. */ import { markdownLineEnding } from 'micromark-util-character'; import { push, splice } from 'micromark-util-chunked'; import { resolveAll } from 'micromark-util-resolve-all'; /** * Create a tokenizer. * Tokenizers deal with one type of data (e.g., containers, flow, text). * The parser is the object dealing with it all. * `initialize` works like other constructs, except that only its `tokenize` * function is used, in which case it doesn’t receive an `ok` or `nok`. * `from` can be given to set the point before the first character, although * when further lines are indented, they must be set with `defineSkip`. * * @param {ParseContext} parser * Parser. * @param {InitialConstruct} initialize * Construct. * @param {Omit | undefined} [from] * Point (optional). * @returns {TokenizeContext} * Context. */ export function createTokenizer(parser, initialize, from) { /** @type {Point} */ let point = { _bufferIndex: -1, _index: 0, line: from && from.line || 1, column: from && from.column || 1, offset: from && from.offset || 0 }; /** @type {Record} */ const columnStart = {}; /** @type {Array} */ const resolveAllConstructs = []; /** @type {Array} */ let chunks = []; /** @type {Array} */ let stack = []; /** @type {boolean | undefined} */ let consumed = true; /** * Tools used for tokenizing. * * @type {Effects} */ const effects = { attempt: constructFactory(onsuccessfulconstruct), check: constructFactory(onsuccessfulcheck), consume, enter, exit, interrupt: constructFactory(onsuccessfulcheck, { interrupt: true }) }; /** * State and tools for resolving and serializing. * * @type {TokenizeContext} */ const context = { code: null, containerState: {}, defineSkip, events: [], now, parser, previous: null, sliceSerialize, sliceStream, write }; /** * The state function. * * @type {State | undefined} */ let state = initialize.tokenize.call(context, effects); /** * Track which character we expect to be consumed, to catch bugs. * * @type {Code} */ let expectedCode; if (initialize.resolveAll) { resolveAllConstructs.push(initialize); } return context; /** @type {TokenizeContext['write']} */ function write(slice) { chunks = push(chunks, slice); main(); // Exit if we’re not done, resolve might change stuff. if (chunks[chunks.length - 1] !== null) { return []; } addResult(initialize, 0); // Otherwise, resolve, and exit. context.events = resolveAll(resolveAllConstructs, context.events, context); return context.events; } // // Tools. // /** @type {TokenizeContext['sliceSerialize']} */ function sliceSerialize(token, expandTabs) { return serializeChunks(sliceStream(token), expandTabs); } /** @type {TokenizeContext['sliceStream']} */ function sliceStream(token) { return sliceChunks(chunks, token); } /** @type {TokenizeContext['now']} */ function now() { // This is a hot path, so we clone manually instead of `Object.assign({}, point)` const { _bufferIndex, _index, line, column, offset } = point; return { _bufferIndex, _index, line, column, offset }; } /** @type {TokenizeContext['defineSkip']} */ function defineSkip(value) { columnStart[value.line] = value.column; accountForPotentialSkip(); } // // State management. // /** * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by * `consume`). * Here is where we walk through the chunks, which either include strings of * several characters, or numerical character codes. * The reason to do this in a loop instead of a call is so the stack can * drain. * * @returns {undefined} * Nothing. */ function main() { /** @type {number} */ let chunkIndex; while (point._index < chunks.length) { const chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it. if (typeof chunk === 'string') { chunkIndex = point._index; if (point._bufferIndex < 0) { point._bufferIndex = 0; } while (point._index === chunkIndex && point._bufferIndex < chunk.length) { go(chunk.charCodeAt(point._bufferIndex)); } } else { go(chunk); } } } /** * Deal with one code. * * @param {Code} code * Code. * @returns {undefined} * Nothing. */ function go(code) { consumed = undefined; expectedCode = code; state = state(code); } /** @type {Effects['consume']} */ function consume(code) { if (markdownLineEnding(code)) { point.line++; point.column = 1; point.offset += code === -3 ? 2 : 1; accountForPotentialSkip(); } else if (code !== -1) { point.column++; point.offset++; } // Not in a string chunk. if (point._bufferIndex < 0) { point._index++; } else { point._bufferIndex++; // At end of string chunk. if (point._bufferIndex === // Points w/ non-negative `_bufferIndex` reference // strings. /** @type {string} */ chunks[point._index].length) { point._bufferIndex = -1; point._index++; } } // Expose the previous character. context.previous = code; // Mark as consumed. consumed = true; } /** @type {Effects['enter']} */ function enter(type, fields) { /** @type {Token} */ // @ts-expect-error Patch instead of assign required fields to help GC. const token = fields || {}; token.type = type; token.start = now(); context.events.push(['enter', token, context]); stack.push(token); return token; } /** @type {Effects['exit']} */ function exit(type) { const token = stack.pop(); token.end = now(); context.events.push(['exit', token, context]); return token; } /** * Use results. * * @type {ReturnHandle} */ function onsuccessfulconstruct(construct, info) { addResult(construct, info.from); } /** * Discard results. * * @type {ReturnHandle} */ function onsuccessfulcheck(_, info) { info.restore(); } /** * Factory to attempt/check/interrupt. * * @param {ReturnHandle} onreturn * Callback. * @param {{interrupt?: boolean | undefined} | undefined} [fields] * Fields. */ function constructFactory(onreturn, fields) { return hook; /** * Handle either an object mapping codes to constructs, a list of * constructs, or a single construct. * * @param {Array | ConstructRecord | Construct} constructs * Constructs. * @param {State} returnState * State. * @param {State | undefined} [bogusState] * State. * @returns {State} * State. */ function hook(constructs, returnState, bogusState) { /** @type {ReadonlyArray} */ let listOfConstructs; /** @type {number} */ let constructIndex; /** @type {Construct} */ let currentConstruct; /** @type {Info} */ let info; return Array.isArray(constructs) ? /* c8 ignore next 1 */ handleListOfConstructs(constructs) : 'tokenize' in constructs ? // Looks like a construct. handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs); /** * Handle a list of construct. * * @param {ConstructRecord} map * Constructs. * @returns {State} * State. */ function handleMapOfConstructs(map) { return start; /** @type {State} */ function start(code) { const left = code !== null && map[code]; const all = code !== null && map.null; const list = [ // To do: add more extension tests. /* c8 ignore next 2 */ ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])]; return handleListOfConstructs(list)(code); } } /** * Handle a list of construct. * * @param {ReadonlyArray} list * Constructs. * @returns {State} * State. */ function handleListOfConstructs(list) { listOfConstructs = list; constructIndex = 0; if (list.length === 0) { return bogusState; } return handleConstruct(list[constructIndex]); } /** * Handle a single construct. * * @param {Construct} construct * Construct. * @returns {State} * State. */ function handleConstruct(construct) { return start; /** @type {State} */ function start(code) { // To do: not needed to store if there is no bogus state, probably? // Currently doesn’t work because `inspect` in document does a check // w/o a bogus, which doesn’t make sense. But it does seem to help perf // by not storing. info = store(); currentConstruct = construct; if (!construct.partial) { context.currentConstruct = construct; } // Always populated by defaults. if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) { return nok(code); } return construct.tokenize.call( // If we do have fields, create an object w/ `context` as its // prototype. // This allows a “live binding”, which is needed for `interrupt`. fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code); } } /** @type {State} */ function ok(code) { consumed = true; onreturn(currentConstruct, info); return returnState; } /** @type {State} */ function nok(code) { consumed = true; info.restore(); if (++constructIndex < listOfConstructs.length) { return handleConstruct(listOfConstructs[constructIndex]); } return bogusState; } } } /** * @param {Construct} construct * Construct. * @param {number} from * From. * @returns {undefined} * Nothing. */ function addResult(construct, from) { if (construct.resolveAll && !resolveAllConstructs.includes(construct)) { resolveAllConstructs.push(construct); } if (construct.resolve) { splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context)); } if (construct.resolveTo) { context.events = construct.resolveTo(context.events, context); } } /** * Store state. * * @returns {Info} * Info. */ function store() { const startPoint = now(); const startPrevious = context.previous; const startCurrentConstruct = context.currentConstruct; const startEventsIndex = context.events.length; const startStack = Array.from(stack); return { from: startEventsIndex, restore }; /** * Restore state. * * @returns {undefined} * Nothing. */ function restore() { point = startPoint; context.previous = startPrevious; context.currentConstruct = startCurrentConstruct; context.events.length = startEventsIndex; stack = startStack; accountForPotentialSkip(); } } /** * Move the current point a bit forward in the line when it’s on a column * skip. * * @returns {undefined} * Nothing. */ function accountForPotentialSkip() { if (point.line in columnStart && point.column < 2) { point.column = columnStart[point.line]; point.offset += columnStart[point.line] - 1; } } } /** * Get the chunks from a slice of chunks in the range of a token. * * @param {ReadonlyArray} chunks * Chunks. * @param {Pick} token * Token. * @returns {Array} * Chunks. */ function sliceChunks(chunks, token) { const startIndex = token.start._index; const startBufferIndex = token.start._bufferIndex; const endIndex = token.end._index; const endBufferIndex = token.end._bufferIndex; /** @type {Array} */ let view; if (startIndex === endIndex) { // @ts-expect-error `_bufferIndex` is used on string chunks. view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]; } else { view = chunks.slice(startIndex, endIndex); if (startBufferIndex > -1) { const head = view[0]; if (typeof head === 'string') { view[0] = head.slice(startBufferIndex); /* c8 ignore next 4 -- used to be used, no longer */ } else { view.shift(); } } if (endBufferIndex > 0) { // @ts-expect-error `_bufferIndex` is used on string chunks. view.push(chunks[endIndex].slice(0, endBufferIndex)); } } return view; } /** * Get the string value of a slice of chunks. * * @param {ReadonlyArray} chunks * Chunks. * @param {boolean | undefined} [expandTabs=false] * Whether to expand tabs (default: `false`). * @returns {string} * Result. */ function serializeChunks(chunks, expandTabs) { let index = -1; /** @type {Array} */ const result = []; /** @type {boolean | undefined} */ let atTab; while (++index < chunks.length) { const chunk = chunks[index]; /** @type {string} */ let value; if (typeof chunk === 'string') { value = chunk; } else switch (chunk) { case -5: { value = "\r"; break; } case -4: { value = "\n"; break; } case -3: { value = "\r" + "\n"; break; } case -2: { value = expandTabs ? " " : "\t"; break; } case -1: { if (!expandTabs && atTab) continue; value = " "; break; } default: { // Currently only replacement character. value = String.fromCharCode(chunk); } } atTab = chunk === -2; result.push(value); } return result.join(''); }/** * @import { * InitialConstruct, * Initializer, * State, * TokenizeContext, * Token * } from 'micromark-util-types' */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding } from 'micromark-util-character'; /** @type {InitialConstruct} */ export const content = { tokenize: initializeContent }; /** * @this {TokenizeContext} * Context. * @type {Initializer} * Content. */ function initializeContent(effects) { const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial); /** @type {Token} */ let previous; return contentStart; /** @type {State} */ function afterContentStartConstruct(code) { if (code === null) { effects.consume(code); return; } effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); return factorySpace(effects, contentStart, "linePrefix"); } /** @type {State} */ function paragraphInitial(code) { effects.enter("paragraph"); return lineStart(code); } /** @type {State} */ function lineStart(code) { const token = effects.enter("chunkText", { contentType: "text", previous }); if (previous) { previous.next = token; } previous = token; return data(code); } /** @type {State} */ function data(code) { if (code === null) { effects.exit("chunkText"); effects.exit("paragraph"); effects.consume(code); return; } if (markdownLineEnding(code)) { effects.consume(code); effects.exit("chunkText"); return lineStart; } // Data. effects.consume(code); return data; } }/** * @import { * Construct, * ContainerState, * InitialConstruct, * Initializer, * Point, * State, * TokenizeContext, * Tokenizer, * Token * } from 'micromark-util-types' */ /** * @typedef {[Construct, ContainerState]} StackItem * Construct and its state. */ import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding } from 'micromark-util-character'; import { splice } from 'micromark-util-chunked'; /** @type {InitialConstruct} */ export const document = { tokenize: initializeDocument }; /** @type {Construct} */ const containerConstruct = { tokenize: tokenizeContainer }; /** * @this {TokenizeContext} * Self. * @type {Initializer} * Initializer. */ function initializeDocument(effects) { const self = this; /** @type {Array} */ const stack = []; let continued = 0; /** @type {TokenizeContext | undefined} */ let childFlow; /** @type {Token | undefined} */ let childToken; /** @type {number} */ let lineStartOffset; return start; /** @type {State} */ function start(code) { // First we iterate through the open blocks, starting with the root // document, and descending through last children down to the last open // block. // Each block imposes a condition that the line must satisfy if the block is // to remain open. // For example, a block quote requires a `>` character. // A paragraph requires a non-blank line. // In this phase we may match all or just some of the open blocks. // But we cannot close unmatched blocks yet, because we may have a lazy // continuation line. if (continued < stack.length) { const item = stack[continued]; self.containerState = item[1]; return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code); } // Done. return checkNewContainers(code); } /** @type {State} */ function documentContinue(code) { continued++; // Note: this field is called `_closeFlow` but it also closes containers. // Perhaps a good idea to rename it but it’s already used in the wild by // extensions. if (self.containerState._closeFlow) { self.containerState._closeFlow = undefined; if (childFlow) { closeFlow(); } // Note: this algorithm for moving events around is similar to the // algorithm when dealing with lazy lines in `writeToChild`. const indexBeforeExits = self.events.length; let indexBeforeFlow = indexBeforeExits; /** @type {Point | undefined} */ let point; // Find the flow chunk. while (indexBeforeFlow--) { if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === "chunkFlow") { point = self.events[indexBeforeFlow][1].end; break; } } exitContainers(continued); // Fix positions. let index = indexBeforeExits; while (index < self.events.length) { self.events[index][1].end = { ...point }; index++; } // Inject the exits earlier (they’re still also at the end). splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits)); // Discard the duplicate exits. self.events.length = index; return checkNewContainers(code); } return start(code); } /** @type {State} */ function checkNewContainers(code) { // Next, after consuming the continuation markers for existing blocks, we // look for new block starts (e.g. `>` for a block quote). // If we encounter a new block start, we close any blocks unmatched in // step 1 before creating the new block as a child of the last matched // block. if (continued === stack.length) { // No need to `check` whether there’s a container, of `exitContainers` // would be moot. // We can instead immediately `attempt` to parse one. if (!childFlow) { return documentContinued(code); } // If we have concrete content, such as block HTML or fenced code, // we can’t have containers “pierce” into them, so we can immediately // start. if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) { return flowStart(code); } // If we do have flow, it could still be a blank line, // but we’d be interrupting it w/ a new container if there’s a current // construct. // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer // needed in micromark-extension-gfm-table@1.0.6). self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack); } // Check if there is a new container. self.containerState = {}; return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code); } /** @type {State} */ function thereIsANewContainer(code) { if (childFlow) closeFlow(); exitContainers(continued); return documentContinued(code); } /** @type {State} */ function thereIsNoNewContainer(code) { self.parser.lazy[self.now().line] = continued !== stack.length; lineStartOffset = self.now().offset; return flowStart(code); } /** @type {State} */ function documentContinued(code) { // Try new containers. self.containerState = {}; return effects.attempt(containerConstruct, containerContinue, flowStart)(code); } /** @type {State} */ function containerContinue(code) { continued++; stack.push([self.currentConstruct, self.containerState]); // Try another. return documentContinued(code); } /** @type {State} */ function flowStart(code) { if (code === null) { if (childFlow) closeFlow(); exitContainers(0); effects.consume(code); return; } childFlow = childFlow || self.parser.flow(self.now()); effects.enter("chunkFlow", { _tokenizer: childFlow, contentType: "flow", previous: childToken }); return flowContinue(code); } /** @type {State} */ function flowContinue(code) { if (code === null) { writeToChild(effects.exit("chunkFlow"), true); exitContainers(0); effects.consume(code); return; } if (markdownLineEnding(code)) { effects.consume(code); writeToChild(effects.exit("chunkFlow")); // Get ready for the next line. continued = 0; self.interrupt = undefined; return start; } effects.consume(code); return flowContinue; } /** * @param {Token} token * Token. * @param {boolean | undefined} [endOfFile] * Whether the token is at the end of the file (default: `false`). * @returns {undefined} * Nothing. */ function writeToChild(token, endOfFile) { const stream = self.sliceStream(token); if (endOfFile) stream.push(null); token.previous = childToken; if (childToken) childToken.next = token; childToken = token; childFlow.defineSkip(token.start); childFlow.write(stream); // Alright, so we just added a lazy line: // // ```markdown // > a // b. // // Or: // // > ~~~c // d // // Or: // // > | e | // f // ``` // // The construct in the second example (fenced code) does not accept lazy // lines, so it marked itself as done at the end of its first line, and // then the content construct parses `d`. // Most constructs in markdown match on the first line: if the first line // forms a construct, a non-lazy line can’t “unmake” it. // // The construct in the third example is potentially a GFM table, and // those are *weird*. // It *could* be a table, from the first line, if the following line // matches a condition. // In this case, that second line is lazy, which “unmakes” the first line // and turns the whole into one content block. // // We’ve now parsed the non-lazy and the lazy line, and can figure out // whether the lazy line started a new flow block. // If it did, we exit the current containers between the two flow blocks. if (self.parser.lazy[token.start.line]) { let index = childFlow.events.length; while (index--) { if ( // The token starts before the line ending… childFlow.events[index][1].start.offset < lineStartOffset && ( // …and either is not ended yet… !childFlow.events[index][1].end || // …or ends after it. childFlow.events[index][1].end.offset > lineStartOffset)) { // Exit: there’s still something open, which means it’s a lazy line // part of something. return; } } // Note: this algorithm for moving events around is similar to the // algorithm when closing flow in `documentContinue`. const indexBeforeExits = self.events.length; let indexBeforeFlow = indexBeforeExits; /** @type {boolean | undefined} */ let seen; /** @type {Point | undefined} */ let point; // Find the previous chunk (the one before the lazy line). while (indexBeforeFlow--) { if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === "chunkFlow") { if (seen) { point = self.events[indexBeforeFlow][1].end; break; } seen = true; } } exitContainers(continued); // Fix positions. index = indexBeforeExits; while (index < self.events.length) { self.events[index][1].end = { ...point }; index++; } // Inject the exits earlier (they’re still also at the end). splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits)); // Discard the duplicate exits. self.events.length = index; } } /** * @param {number} size * Size. * @returns {undefined} * Nothing. */ function exitContainers(size) { let index = stack.length; // Exit open containers. while (index-- > size) { const entry = stack[index]; self.containerState = entry[1]; entry[0].exit.call(self, effects); } stack.length = size; } function closeFlow() { childFlow.write([null]); childToken = undefined; childFlow = undefined; self.containerState._closeFlow = undefined; } } /** * @this {TokenizeContext} * Context. * @type {Tokenizer} * Tokenizer. */ function tokenizeContainer(effects, ok, nok) { // Always populated by defaults. return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), "linePrefix", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4); }/** * @import { * InitialConstruct, * Initializer, * State, * TokenizeContext * } from 'micromark-util-types' */ import { blankLine, content } from 'micromark-core-commonmark'; import { factorySpace } from 'micromark-factory-space'; import { markdownLineEnding } from 'micromark-util-character'; /** @type {InitialConstruct} */ export const flow = { tokenize: initializeFlow }; /** * @this {TokenizeContext} * Self. * @type {Initializer} * Initializer. */ function initializeFlow(effects) { const self = this; const initial = effects.attempt( // Try to parse a blank line. blankLine, atBlankEnding, // Try to parse initial flow (essentially, only code). effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), "linePrefix"))); return initial; /** @type {State} */ function atBlankEnding(code) { if (code === null) { effects.consume(code); return; } effects.enter("lineEndingBlank"); effects.consume(code); effects.exit("lineEndingBlank"); self.currentConstruct = undefined; return initial; } /** @type {State} */ function afterConstruct(code) { if (code === null) { effects.consume(code); return; } effects.enter("lineEnding"); effects.consume(code); effects.exit("lineEnding"); self.currentConstruct = undefined; return initial; } }/** * @import { * Code, * InitialConstruct, * Initializer, * Resolver, * State, * TokenizeContext * } from 'micromark-util-types' */ export const resolver = { resolveAll: createResolver() }; export const string = initializeFactory('string'); export const text = initializeFactory('text'); /** * @param {'string' | 'text'} field * Field. * @returns {InitialConstruct} * Construct. */ function initializeFactory(field) { return { resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined), tokenize: initializeText }; /** * @this {TokenizeContext} * Context. * @type {Initializer} */ function initializeText(effects) { const self = this; const constructs = this.parser.constructs[field]; const text = effects.attempt(constructs, start, notText); return start; /** @type {State} */ function start(code) { return atBreak(code) ? text(code) : notText(code); } /** @type {State} */ function notText(code) { if (code === null) { effects.consume(code); return; } effects.enter("data"); effects.consume(code); return data; } /** @type {State} */ function data(code) { if (atBreak(code)) { effects.exit("data"); return text(code); } // Data. effects.consume(code); return data; } /** * @param {Code} code * Code. * @returns {boolean} * Whether the code is a break. */ function atBreak(code) { if (code === null) { return true; } const list = constructs[code]; let index = -1; if (list) { // Always populated by defaults. while (++index < list.length) { const item = list[index]; if (!item.previous || item.previous.call(self, self.previous)) { return true; } } } return false; } } } /** * @param {Resolver | undefined} [extraResolver] * Resolver. * @returns {Resolver} * Resolver. */ function createResolver(extraResolver) { return resolveAllText; /** @type {Resolver} */ function resolveAllText(events, context) { let index = -1; /** @type {number | undefined} */ let enter; // A rather boring computation (to merge adjacent `data` events) which // improves mm performance by 29%. while (++index <= events.length) { if (enter === undefined) { if (events[index] && events[index][1].type === "data") { enter = index; index++; } } else if (!events[index] || events[index][1].type !== "data") { // Don’t do anything if there is one data token. if (index !== enter + 2) { events[enter][1].end = events[index - 1][1].end; events.splice(enter + 2, index - enter - 2); index = enter + 2; } enter = undefined; } } return extraResolver ? extraResolver(events, context) : events; } } /** * A rather ugly set of instructions which again looks at chunks in the input * stream. * The reason to do this here is that it is *much* faster to parse in reverse. * And that we can’t hook into `null` to split the line suffix before an EOF. * To do: figure out if we can make this into a clean utility, or even in core. * As it will be useful for GFMs literal autolink extension (and maybe even * tables?) * * @type {Resolver} */ function resolveAllLineSuffixes(events, context) { let eventIndex = 0; // Skip first. while (++eventIndex <= events.length) { if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") { const data = events[eventIndex - 1][1]; const chunks = context.sliceStream(data); let index = chunks.length; let bufferIndex = -1; let size = 0; /** @type {boolean | undefined} */ let tabs; while (index--) { const chunk = chunks[index]; if (typeof chunk === 'string') { bufferIndex = chunk.length; while (chunk.charCodeAt(bufferIndex - 1) === 32) { size++; bufferIndex--; } if (bufferIndex) break; bufferIndex = -1; } // Number else if (chunk === -2) { tabs = true; size++; } else if (chunk === -1) { // Empty } else { // Replacement character, exit. index++; break; } } // Allow final trailing whitespace. if (context._contentTypeTextTrailing && eventIndex === events.length) { size = 0; } if (size) { const token = { type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing", start: { _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex, _index: data.start._index + index, line: data.end.line, column: data.end.column - size, offset: data.end.offset - size }, end: { ...data.end } }; data.end = { ...token.start }; if (data.start.offset === data.end.offset) { Object.assign(data, token); } else { events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]); eventIndex += 2; } } eventIndex++; } } return events; }/** * @import { * Create, * FullNormalizedExtension, * InitialConstruct, * ParseContext, * ParseOptions * } from 'micromark-util-types' */ import { combineExtensions } from 'micromark-util-combine-extensions'; import { content } from './initialize/content.js'; import { document } from './initialize/document.js'; import { flow } from './initialize/flow.js'; import { string, text } from './initialize/text.js'; import * as defaultConstructs from './constructs.js'; import { createTokenizer } from './create-tokenizer.js'; /** * @param {ParseOptions | null | undefined} [options] * Configuration (optional). * @returns {ParseContext} * Parser. */ export function parse(options) { const settings = options || {}; const constructs = /** @type {FullNormalizedExtension} */ combineExtensions([defaultConstructs, ...(settings.extensions || [])]); /** @type {ParseContext} */ const parser = { constructs, content: create(content), defined: [], document: create(document), flow: create(flow), lazy: {}, string: create(string), text: create(text) }; return parser; /** * @param {InitialConstruct} initial * Construct to start with. * @returns {Create} * Create a tokenizer. */ function create(initial) { return creator; /** @type {Create} */ function creator(from) { return createTokenizer(parser, initial, from); } } }/** * @import {Event} from 'micromark-util-types' */ import { subtokenize } from 'micromark-util-subtokenize'; /** * @param {Array} events * Events. * @returns {Array} * Events. */ export function postprocess(events) { while (!subtokenize(events)) { // Empty } return events; }/** * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types' */ /** * @callback Preprocessor * Preprocess a value. * @param {Value} value * Value. * @param {Encoding | null | undefined} [encoding] * Encoding when `value` is a typed array (optional). * @param {boolean | null | undefined} [end=false] * Whether this is the last chunk (default: `false`). * @returns {Array} * Chunks. */ const search = /[\0\t\n\r]/g; /** * @returns {Preprocessor} * Preprocess a value. */ export function preprocess() { let column = 1; let buffer = ''; /** @type {boolean | undefined} */ let start = true; /** @type {boolean | undefined} */ let atCarriageReturn; return preprocessor; /** @type {Preprocessor} */ // eslint-disable-next-line complexity function preprocessor(value, encoding, end) { /** @type {Array} */ const chunks = []; /** @type {RegExpMatchArray | null} */ let match; /** @type {number} */ let next; /** @type {number} */ let startPosition; /** @type {number} */ let endPosition; /** @type {Code} */ let code; value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value)); startPosition = 0; buffer = ''; if (start) { // To do: `markdown-rs` actually parses BOMs (byte order mark). if (value.charCodeAt(0) === 65279) { startPosition++; } start = undefined; } while (startPosition < value.length) { search.lastIndex = startPosition; match = search.exec(value); endPosition = match && match.index !== undefined ? match.index : value.length; code = value.charCodeAt(endPosition); if (!match) { buffer = value.slice(startPosition); break; } if (code === 10 && startPosition === endPosition && atCarriageReturn) { chunks.push(-3); atCarriageReturn = undefined; } else { if (atCarriageReturn) { chunks.push(-5); atCarriageReturn = undefined; } if (startPosition < endPosition) { chunks.push(value.slice(startPosition, endPosition)); column += endPosition - startPosition; } switch (code) { case 0: { chunks.push(65533); column++; break; } case 9: { next = Math.ceil(column / 4) * 4; chunks.push(-2); while (column++ < next) chunks.push(-1); break; } case 10: { chunks.push(-4); column = 1; break; } default: { atCarriageReturn = true; column = 1; } } } startPosition = endPosition + 1; } if (end) { if (atCarriageReturn) chunks.push(-5); if (buffer) chunks.push(buffer); chunks.push(null); } return chunks; } }{ "name": "micromark", "version": "4.0.2", "description": "small commonmark compliant markdown parser with positional info and concrete tokens", "license": "MIT", "keywords": [ "commonmark", "compiler", "gfm", "html", "lexer", "markdown", "markup", "md", "unified", "parse", "parser", "plugin", "process", "remark", "render", "renderer", "token", "tokenizer" ], "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark", "bugs": "https://github.com/micromark/micromark/issues", "funding": [ { "type": "GitHub Sponsors", "url": "https://github.com/sponsors/unifiedjs" }, { "type": "OpenCollective", "url": "https://opencollective.com/unified" } ], "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "files": [ "dev/", "lib/", "index.d.ts.map", "index.d.ts", "index.js", "stream.d.ts.map", "stream.d.ts", "stream.js" ], "exports": { ".": { "development": "./dev/index.js", "default": "./index.js" }, "./stream": { "development": "./dev/stream.js", "default": "./stream.js" } }, "dependencies": { "@types/debug": "^4.0.0", "debug": "^4.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" }, "scripts": { "build": "micromark-build" }, "xo": { "envs": [ "shared-node-browser" ], "prettier": true, "rules": { "logical-assignment-operators": "off", "max-depth": "off", "unicorn/no-this-assignment": "off", "unicorn/prefer-at": "off", "unicorn/prefer-code-point": "off", "unicorn/prefer-event-target": "off" } } } // Note: more types exposed from `index.d.ts`. // To do: refactor to include type parameters in JS. export {parseEntities} from './lib/index.js' /** * @import {Point} from 'unist' * @import {Options} from '../index.js' */ import {characterEntitiesLegacy} from 'character-entities-legacy' import {characterReferenceInvalid} from 'character-reference-invalid' import {isDecimal} from 'is-decimal' import {isHexadecimal} from 'is-hexadecimal' import {isAlphanumerical} from 'is-alphanumerical' import {decodeNamedCharacterReference} from 'decode-named-character-reference' // Warning messages. const messages = [ '', /* 1: Non terminated (named) */ 'Named character references must be terminated by a semicolon', /* 2: Non terminated (numeric) */ 'Numeric character references must be terminated by a semicolon', /* 3: Empty (named) */ 'Named character references cannot be empty', /* 4: Empty (numeric) */ 'Numeric character references cannot be empty', /* 5: Unknown (named) */ 'Named character references must be known', /* 6: Disallowed (numeric) */ 'Numeric character references cannot be disallowed', /* 7: Prohibited (numeric) */ 'Numeric character references cannot be outside the permissible Unicode range' ] /** * Parse HTML character references. * * @param {string} value * @param {Readonly | null | undefined} [options] */ export function parseEntities(value, options) { const settings = options || {} const additional = typeof settings.additional === 'string' ? settings.additional.charCodeAt(0) : settings.additional /** @type {Array} */ const result = [] let index = 0 let lines = -1 let queue = '' /** @type {Point | undefined} */ let point /** @type {Array|undefined} */ let indent if (settings.position) { if ('start' in settings.position || 'indent' in settings.position) { // @ts-expect-error: points don’t have indent. indent = settings.position.indent // @ts-expect-error: points don’t have indent. point = settings.position.start } else { point = settings.position } } let line = (point ? point.line : 0) || 1 let column = (point ? point.column : 0) || 1 // Cache the current point. let previous = now() /** @type {number|undefined} */ let character // Ensure the algorithm walks over the first character (inclusive). index-- while (++index <= value.length) { // If the previous character was a newline. if (character === 10 /* `\n` */) { column = (indent ? indent[lines] : 0) || 1 } character = value.charCodeAt(index) if (character === 38 /* `&` */) { const following = value.charCodeAt(index + 1) // The behavior depends on the identity of the next character. if ( following === 9 /* `\t` */ || following === 10 /* `\n` */ || following === 12 /* `\f` */ || following === 32 /* ` ` */ || following === 38 /* `&` */ || following === 60 /* `<` */ || Number.isNaN(following) || (additional && following === additional) ) { // Not a character reference. // No characters are consumed, and nothing is returned. // This is not an error, either. queue += String.fromCharCode(character) column++ continue } const start = index + 1 let begin = start let end = start /** @type {string} */ let type if (following === 35 /* `#` */) { // Numerical reference. end = ++begin // The behavior further depends on the next character. const following = value.charCodeAt(end) if (following === 88 /* `X` */ || following === 120 /* `x` */) { // ASCII hexadecimal digits. type = 'hexadecimal' end = ++begin } else { // ASCII decimal digits. type = 'decimal' } } else { // Named reference. type = 'named' } let characterReferenceCharacters = '' let characterReference = '' let characters = '' // Each type of character reference accepts different characters. // This test is used to detect whether a reference has ended (as the semicolon // is not strictly needed). const test = type === 'named' ? isAlphanumerical : type === 'decimal' ? isDecimal : isHexadecimal end-- while (++end <= value.length) { const following = value.charCodeAt(end) if (!test(following)) { break } characters += String.fromCharCode(following) // Check if we can match a legacy named reference. // If so, we cache that as the last viable named reference. // This ensures we do not need to walk backwards later. if (type === 'named' && characterEntitiesLegacy.includes(characters)) { characterReferenceCharacters = characters // @ts-expect-error: always able to decode. characterReference = decodeNamedCharacterReference(characters) } } let terminated = value.charCodeAt(end) === 59 /* `;` */ if (terminated) { end++ const namedReference = type === 'named' ? decodeNamedCharacterReference(characters) : false if (namedReference) { characterReferenceCharacters = characters characterReference = namedReference } } let diff = 1 + end - start let reference = '' if (!terminated && settings.nonTerminated === false) { // Empty. } else if (!characters) { // An empty (possible) reference is valid, unless it’s numeric (thus an // ampersand followed by an octothorp). if (type !== 'named') { warning(4 /* Empty (numeric) */, diff) } } else if (type === 'named') { // An ampersand followed by anything unknown, and not terminated, is // invalid. if (terminated && !characterReference) { warning(5 /* Unknown (named) */, 1) } else { // If there’s something after an named reference which is not known, // cap the reference. if (characterReferenceCharacters !== characters) { end = begin + characterReferenceCharacters.length diff = 1 + end - begin terminated = false } // If the reference is not terminated, warn. if (!terminated) { const reason = characterReferenceCharacters ? 1 /* Non terminated (named) */ : 3 /* Empty (named) */ if (settings.attribute) { const following = value.charCodeAt(end) if (following === 61 /* `=` */) { warning(reason, diff) characterReference = '' } else if (isAlphanumerical(following)) { characterReference = '' } else { warning(reason, diff) } } else { warning(reason, diff) } } } reference = characterReference } else { if (!terminated) { // All nonterminated numeric references are not rendered, and emit a // warning. warning(2 /* Non terminated (numeric) */, diff) } // When terminated and numerical, parse as either hexadecimal or // decimal. let referenceCode = Number.parseInt( characters, type === 'hexadecimal' ? 16 : 10 ) // Emit a warning when the parsed number is prohibited, and replace with // replacement character. if (prohibited(referenceCode)) { warning(7 /* Prohibited (numeric) */, diff) reference = String.fromCharCode(65533 /* `�` */) } else if (referenceCode in characterReferenceInvalid) { // Emit a warning when the parsed number is disallowed, and replace by // an alternative. warning(6 /* Disallowed (numeric) */, diff) reference = characterReferenceInvalid[referenceCode] } else { // Parse the number. let output = '' // Emit a warning when the parsed number should not be used. if (disallowed(referenceCode)) { warning(6 /* Disallowed (numeric) */, diff) } // Serialize the number. if (referenceCode > 0xffff) { referenceCode -= 0x10000 output += String.fromCharCode( (referenceCode >>> (10 & 0x3ff)) | 0xd800 ) referenceCode = 0xdc00 | (referenceCode & 0x3ff) } reference = output + String.fromCharCode(referenceCode) } } // Found it! // First eat the queued characters as normal text, then eat a reference. if (reference) { flush() previous = now() index = end - 1 column += end - start + 1 result.push(reference) const next = now() next.offset++ if (settings.reference) { settings.reference.call( settings.referenceContext || undefined, reference, {start: previous, end: next}, value.slice(start - 1, end) ) } previous = next } else { // If we could not find a reference, queue the checked characters (as // normal characters), and move the pointer to their end. // This is possible because we can be certain neither newlines nor // ampersands are included. characters = value.slice(start - 1, end) queue += characters column += characters.length index = end - 1 } } else { // Handle anything other than an ampersand, including newlines and EOF. if (character === 10 /* `\n` */) { line++ lines++ column = 0 } if (Number.isNaN(character)) { flush() } else { queue += String.fromCharCode(character) column++ } } } // Return the reduced nodes. return result.join('') // Get current position. function now() { return { line, column, offset: index + ((point ? point.offset : 0) || 0) } } /** * Handle the warning. * * @param {1|2|3|4|5|6|7} code * @param {number} offset */ function warning(code, offset) { /** @type {ReturnType} */ let position if (settings.warning) { position = now() position.column += offset position.offset += offset settings.warning.call( settings.warningContext || undefined, messages[code], position, code ) } } /** * Flush `queue` (normal text). * Macro invoked before each reference and at the end of `value`. * Does nothing when `queue` is empty. */ function flush() { if (queue) { result.push(queue) if (settings.text) { settings.text.call(settings.textContext || undefined, queue, { start: previous, end: now() }) } queue = '' } } } /** * Check if `character` is outside the permissible unicode range. * * @param {number} code * @returns {boolean} */ function prohibited(code) { return (code >= 0xd800 && code <= 0xdfff) || code > 0x10ffff } /** * Check if `character` is disallowed. * * @param {number} code * @returns {boolean} */ function disallowed(code) { return ( (code >= 0x0001 && code <= 0x0008) || code === 0x000b || (code >= 0x000d && code <= 0x001f) || (code >= 0x007f && code <= 0x009f) || (code >= 0xfdd0 && code <= 0xfdef) || (code & 0xffff) === 0xffff || (code & 0xffff) === 0xfffe ) } { "name": "parse-entities", "version": "4.0.2", "description": "Parse HTML character references", "license": "MIT", "keywords": [ "parse", "html", "character", "reference", "entity", "entities" ], "repository": "wooorm/parse-entities", "bugs": "https://github.com/wooorm/parse-entities/issues", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "main": "index.js", "types": "index.d.ts", "files": [ "lib/", "index.d.ts", "index.js" ], "dependencies": { "@types/unist": "^2.0.0", "character-entities-legacy": "^3.0.0", "character-reference-invalid": "^2.0.0", "decode-named-character-reference": "^1.0.0", "is-alphanumerical": "^2.0.0", "is-decimal": "^2.0.0", "is-hexadecimal": "^2.0.0" }, "devDependencies": { "@types/node": "^22.0.0", "c8": "^10.0.0", "prettier": "^3.0.0", "remark-cli": "^12.0.0", "remark-preset-wooorm": "^10.0.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.60.0" }, "scripts": { "prepack": "npm run build && npm run format", "build": "tsc --build --clean && tsc --build && type-coverage", "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix", "test-api": "node --conditions development test.js", "test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "prettier": { "tabWidth": 2, "useTabs": false, "singleQuote": true, "bracketSpacing": false, "semi": false, "trailingComma": "none" }, "xo": { "prettier": true, "rules": { "@typescript-eslint/consistent-type-definitions": "off", "@typescript-eslint/ban-types": "off", "complexity": "off", "max-depth": "off", "no-bitwise": "off", "unicorn/numeric-separators-style": "off", "unicorn/prefer-code-point": "off" } }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "strict": true, "ignoreCatch": true } } /** * @typedef {import('./lib/index.js').LightOptions} LightOptions * @typedef {import('./lib/index.js').Options} Options */ export * from './lib/index.js' /** * List of legacy (that don’t need a trailing `;`) named references which could, * depending on what follows them, turn into a different meaning * * @type {Array} */ export const dangerous = [ 'cent', 'copy', 'divide', 'gt', 'lt', 'not', 'para', 'times' ] /** * @typedef CoreOptions * @property {ReadonlyArray} [subset=[]] * Whether to only escape the given subset of characters. * @property {boolean} [escapeOnly=false] * Whether to only escape possibly dangerous characters. * Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``. * * @typedef FormatOptions * @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format * Format strategy. * * @typedef {CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions} CoreWithFormatOptions */ const defaultSubsetRegex = /["&'<>`]/g const surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g const controlCharactersRegex = // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g const regexEscapeRegex = /[|\\{}()[\]^$+*?.]/g /** @type {WeakMap, RegExp>} */ const subsetToRegexCache = new WeakMap() /** * Encode certain characters in `value`. * * @param {string} value * @param {CoreWithFormatOptions} options * @returns {string} */ export function core(value, options) { value = value.replace( options.subset ? charactersToExpressionCached(options.subset) : defaultSubsetRegex, basic ) if (options.subset || options.escapeOnly) { return value } return ( value // Surrogate pairs. .replace(surrogatePairsRegex, surrogate) // BMP control characters (C0 except for LF, CR, SP; DEL; and some more // non-ASCII ones). .replace(controlCharactersRegex, basic) ) /** * @param {string} pair * @param {number} index * @param {string} all */ function surrogate(pair, index, all) { return options.format( (pair.charCodeAt(0) - 0xd800) * 0x400 + pair.charCodeAt(1) - 0xdc00 + 0x10000, all.charCodeAt(index + 2), options ) } /** * @param {string} character * @param {number} index * @param {string} all */ function basic(character, index, all) { return options.format( character.charCodeAt(0), all.charCodeAt(index + 1), options ) } } /** * A wrapper function that caches the result of `charactersToExpression` with a WeakMap. * This can improve performance when tooling calls `charactersToExpression` repeatedly * with the same subset. * * @param {ReadonlyArray} subset * @returns {RegExp} */ function charactersToExpressionCached(subset) { let cached = subsetToRegexCache.get(subset) if (!cached) { cached = charactersToExpression(subset) subsetToRegexCache.set(subset, cached) } return cached } /** * @param {ReadonlyArray} subset * @returns {RegExp} */ function charactersToExpression(subset) { /** @type {Array} */ const groups = [] let index = -1 while (++index < subset.length) { groups.push(subset[index].replace(regexEscapeRegex, '\\$&')) } return new RegExp('(?:' + groups.join('|') + ')', 'g') } /** * @typedef {import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions} Options * @typedef {import('./core.js').CoreOptions} LightOptions */ import {core} from './core.js' import {formatSmart} from './util/format-smart.js' import {formatBasic} from './util/format-basic.js' /** * Encode special characters in `value`. * * @param {string} value * Value to encode. * @param {Options} [options] * Configuration. * @returns {string} * Encoded value. */ export function stringifyEntities(value, options) { return core(value, Object.assign({format: formatSmart}, options)) } /** * Encode special characters in `value` as hexadecimals. * * @param {string} value * Value to encode. * @param {LightOptions} [options] * Configuration. * @returns {string} * Encoded value. */ export function stringifyEntitiesLight(value, options) { return core(value, Object.assign({format: formatBasic}, options)) } /** * The smallest way to encode a character. * * @param {number} code * @returns {string} */ export function formatBasic(code) { return '&#x' + code.toString(16).toUpperCase() + ';' } /** * @typedef FormatSmartOptions * @property {boolean} [useNamedReferences=false] * Prefer named character references (`&`) where possible. * @property {boolean} [useShortestReferences=false] * Prefer the shortest possible reference, if that results in less bytes. * **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`. * @property {boolean} [omitOptionalSemicolons=false] * Whether to omit semicolons when possible. * **Note**: This creates what HTML calls “parse errors” but is otherwise still valid HTML — don’t use this except when building a minifier. * Omitting semicolons is possible for certain named and numeric references in some cases. * @property {boolean} [attribute=false] * Create character references which don’t fail in attributes. * **Note**: `attribute` only applies when operating dangerously with * `omitOptionalSemicolons: true`. */ import {toHexadecimal} from './to-hexadecimal.js' import {toDecimal} from './to-decimal.js' import {toNamed} from './to-named.js' /** * Configurable ways to encode a character yielding pretty or small results. * * @param {number} code * @param {number} next * @param {FormatSmartOptions} options * @returns {string} */ export function formatSmart(code, next, options) { let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons) /** @type {string|undefined} */ let named if (options.useNamedReferences || options.useShortestReferences) { named = toNamed( code, next, options.omitOptionalSemicolons, options.attribute ) } // Use the shortest numeric reference when requested. // A simple algorithm would use decimal for all code points under 100, as // those are shorter than hexadecimal: // // * `c` vs `c` (decimal shorter) // * `d` vs `d` (equal) // // However, because we take `next` into consideration when `omit` is used, // And it would be possible that decimals are shorter on bigger values as // well if `next` is hexadecimal but not decimal, we instead compare both. if ( (options.useShortestReferences || !named) && options.useShortestReferences ) { const decimal = toDecimal(code, next, options.omitOptionalSemicolons) if (decimal.length < numeric.length) { numeric = decimal } } return named && (!options.useShortestReferences || named.length < numeric.length) ? named : numeric } const decimalRegex = /\d/ /** * Configurable ways to encode characters as decimal references. * * @param {number} code * @param {number} next * @param {boolean|undefined} omit * @returns {string} */ export function toDecimal(code, next, omit) { const value = '&#' + String(code) return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ';' } const hexadecimalRegex = /[\dA-Fa-f]/ /** * Configurable ways to encode characters as hexadecimal references. * * @param {number} code * @param {number} next * @param {boolean|undefined} omit * @returns {string} */ export function toHexadecimal(code, next, omit) { const value = '&#x' + code.toString(16).toUpperCase() return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ';' } import {characterEntitiesLegacy} from 'character-entities-legacy' import {characterEntitiesHtml4} from 'character-entities-html4' import {dangerous} from '../constant/dangerous.js' const own = {}.hasOwnProperty /** * `characterEntitiesHtml4` but inverted. * * @type {Record} */ const characters = {} /** @type {string} */ let key for (key in characterEntitiesHtml4) { if (own.call(characterEntitiesHtml4, key)) { characters[characterEntitiesHtml4[key]] = key } } const notAlphanumericRegex = /[^\dA-Za-z]/ /** * Configurable ways to encode characters as named references. * * @param {number} code * @param {number} next * @param {boolean|undefined} omit * @param {boolean|undefined} attribute * @returns {string} */ export function toNamed(code, next, omit, attribute) { const character = String.fromCharCode(code) if (own.call(characters, character)) { const name = characters[character] const value = '&' + name if ( omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || (next && next !== 61 /* `=` */ && notAlphanumericRegex.test(String.fromCharCode(next)))) ) { return value } return value + ';' } return '' } { "name": "stringify-entities", "version": "4.0.4", "description": "Serialize (encode) HTML character references", "license": "MIT", "keywords": [ "stringify", "encode", "escape", "html", "character", "reference", "entity", "entities" ], "repository": "wooorm/stringify-entities", "bugs": "https://github.com/wooorm/stringify-entities/issues", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "main": "index.js", "types": "index.d.ts", "files": [ "lib/", "index.d.ts", "index.js" ], "dependencies": { "character-entities-html4": "^2.0.0", "character-entities-legacy": "^3.0.0" }, "devDependencies": { "@types/node": "^20.0.0", "c8": "^9.0.0", "character-entities": "^2.0.0", "prettier": "^3.0.0", "remark-cli": "^11.0.0", "remark-preset-wooorm": "^9.0.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.58.0" }, "scripts": { "prepack": "npm run build && npm run format", "generate": "node --conditions development build.js", "build": "tsc --build --clean && tsc --build && type-coverage", "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix", "test-api": "node --conditions development test.js", "test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api", "test": "npm run generate && npm run build && npm run format && npm run test-coverage" }, "prettier": { "tabWidth": 2, "useTabs": false, "singleQuote": true, "bracketSpacing": false, "semi": false, "trailingComma": "none" }, "xo": { "prettier": true, "rules": { "unicorn/prefer-code-point": "off", "unicorn/prefer-string-replace-all": "off", "unicorn/numeric-separators-style": "off" } }, "remarkConfig": { "plugins": [ "preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "strict": true, "ignoreCatch": true } } /** * @typedef {import('./lib/index.js').Check} Check * @typedef {import('./lib/index.js').Test} Test * @typedef {import('./lib/index.js').TestFunction} TestFunction */ export {is, convert} from './lib/index.js' /** * @import {Node, Parent} from 'unist' */ /** * @template Fn * @template Fallback * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate */ /** * @callback Check * Check that an arbitrary value is a node. * @param {unknown} this * The given context. * @param {unknown} [node] * Anything (typically a node). * @param {number | null | undefined} [index] * The node’s position in its parent. * @param {Parent | null | undefined} [parent] * The node’s parent. * @returns {boolean} * Whether this is a node and passes a test. * * @typedef {Record | Node} Props * Object to check for equivalence. * * Note: `Node` is included as it is common but is not indexable. * * @typedef {Array | ReadonlyArray | Props | TestFunction | string | null | undefined} Test * Check for an arbitrary node. * * @callback TestFunction * Check if a node passes a test. * @param {unknown} this * The given context. * @param {Node} node * A node. * @param {number | undefined} [index] * The node’s position in its parent. * @param {Parent | undefined} [parent] * The node’s parent. * @returns {boolean | undefined | void} * Whether this node passes the test. * * Note: `void` is included until TS sees no return as `undefined`. */ /** * Check if `node` is a `Node` and whether it passes the given test. * * @param {unknown} node * Thing to check, typically `Node`. * @param {Test} test * A check for a specific node. * @param {number | null | undefined} index * The node’s position in its parent. * @param {Parent | null | undefined} parent * The node’s parent. * @param {unknown} context * Context object (`this`) to pass to `test` functions. * @returns {boolean} * Whether `node` is a node and passes a test. */ export const is = // Note: overloads in JSDoc can’t yet use different `@template`s. /** * @type {( * (>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition[number]}) & * (>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition[number]}) & * ((node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) & * ((node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) & * ((node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate) & * ((node?: null | undefined) => false) & * ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) & * ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean) * )} */ ( /** * @param {unknown} [node] * @param {Test} [test] * @param {number | null | undefined} [index] * @param {Parent | null | undefined} [parent] * @param {unknown} [context] * @returns {boolean} */ // eslint-disable-next-line max-params function (node, test, index, parent, context) { const check = convert(test) if ( index !== undefined && index !== null && (typeof index !== 'number' || index < 0 || index === Number.POSITIVE_INFINITY) ) { throw new Error('Expected positive finite index') } if ( parent !== undefined && parent !== null && (!is(parent) || !parent.children) ) { throw new Error('Expected parent node') } if ( (parent === undefined || parent === null) !== (index === undefined || index === null) ) { throw new Error('Expected both parent and index') } return looksLikeANode(node) ? check.call(context, node, index, parent) : false } ) /** * Generate an assertion from a test. * * Useful if you’re going to test many nodes, for example when creating a * utility where something else passes a compatible test. * * The created function is a bit faster because it expects valid input only: * a `node`, `index`, and `parent`. * * @param {Test} test * * when nullish, checks if `node` is a `Node`. * * when `string`, works like passing `(node) => node.type === test`. * * when `function` checks if function passed the node is true. * * when `object`, checks that all keys in test are in node, and that they have (strictly) equal values. * * when `array`, checks if any one of the subtests pass. * @returns {Check} * An assertion. */ export const convert = // Note: overloads in JSDoc can’t yet use different `@template`s. /** * @type {( * ((test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) & * ((test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) & * ((test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate) & * ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) & * ((test?: Test) => Check) * )} */ ( /** * @param {Test} [test] * @returns {Check} */ function (test) { if (test === null || test === undefined) { return ok } if (typeof test === 'function') { return castFactory(test) } if (typeof test === 'object') { return Array.isArray(test) ? anyFactory(test) : // Cast because `ReadonlyArray` goes into the above but `isArray` // narrows to `Array`. propertiesFactory(/** @type {Props} */ (test)) } if (typeof test === 'string') { return typeFactory(test) } throw new Error('Expected function, string, or object as test') } ) /** * @param {Array} tests * @returns {Check} */ function anyFactory(tests) { /** @type {Array} */ const checks = [] let index = -1 while (++index < tests.length) { checks[index] = convert(tests[index]) } return castFactory(any) /** * @this {unknown} * @type {TestFunction} */ function any(...parameters) { let index = -1 while (++index < checks.length) { if (checks[index].apply(this, parameters)) return true } return false } } /** * Turn an object into a test for a node with a certain fields. * * @param {Props} check * @returns {Check} */ function propertiesFactory(check) { const checkAsRecord = /** @type {Record} */ (check) return castFactory(all) /** * @param {Node} node * @returns {boolean} */ function all(node) { const nodeAsRecord = /** @type {Record} */ ( /** @type {unknown} */ (node) ) /** @type {string} */ let key for (key in check) { if (nodeAsRecord[key] !== checkAsRecord[key]) return false } return true } } /** * Turn a string into a test for a node with a certain type. * * @param {string} check * @returns {Check} */ function typeFactory(check) { return castFactory(type) /** * @param {Node} node */ function type(node) { return node && node.type === check } } /** * Turn a custom test into a test for a node that passes that test. * * @param {TestFunction} testFunction * @returns {Check} */ function castFactory(testFunction) { return check /** * @this {unknown} * @type {Check} */ function check(value, index, parent) { return Boolean( looksLikeANode(value) && testFunction.call( this, value, typeof index === 'number' ? index : undefined, parent || undefined ) ) } } function ok() { return true } /** * @param {unknown} value * @returns {value is Node} */ function looksLikeANode(value) { return value !== null && typeof value === 'object' && 'type' in value } { "name": "unist-util-is", "version": "6.0.1", "description": "unist utility to check if a node passes a test", "license": "MIT", "keywords": [ "unist", "unist-util", "util", "utility", "tree", "node", "is", "equal", "check", "test", "type" ], "repository": "syntax-tree/unist-util-is", "bugs": "https://github.com/syntax-tree/unist-util-is/issues", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)", "Christian Murphy ", "Lucas Brandstaetter (https://github.com/Roang-zero1)" ], "sideEffects": false, "type": "module", "exports": "./index.js", "files": [ "lib/", "index.d.ts.map", "index.d.ts", "index.js" ], "dependencies": { "@types/unist": "^3.0.0" }, "devDependencies": { "@types/mdast": "^4.0.0", "@types/node": "^24.0.0", "c8": "^10.0.0", "prettier": "^3.0.0", "remark-cli": "^12.0.0", "remark-preset-wooorm": "^11.0.0", "tsd": "^0.33.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.58.0" }, "scripts": { "prepack": "npm run build && npm run format", "build": "tsc --build --clean && tsc --build && tsd && type-coverage", "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix", "test-api": "node --conditions development test/index.js", "test-coverage": "c8 --100 --reporter lcov npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "prettier": { "bracketSpacing": false, "semi": false, "singleQuote": true, "tabWidth": 2, "trailingComma": "none", "useTabs": false }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "#": "needed `any`s", "ignoreFiles": [ "lib/index.d.ts" ], "ignoreCatch": true, "strict": true }, "xo": { "overrides": [ { "files": [ "**/*.ts" ], "rules": { "@typescript-eslint/consistent-type-definitions": "off", "@typescript-eslint/no-unnecessary-type-arguments": "off", "@typescript-eslint/no-unsafe-argument": "off", "@typescript-eslint/no-unsafe-assignment": "off", "import/no-extraneous-dependencies": "off" } } ], "prettier": true } } export {stringifyPosition} from './lib/index.js' /** * @typedef {import('unist').Node} Node * @typedef {import('unist').Point} Point * @typedef {import('unist').Position} Position */ /** * @typedef NodeLike * @property {string} type * @property {PositionLike | null | undefined} [position] * * @typedef PointLike * @property {number | null | undefined} [line] * @property {number | null | undefined} [column] * @property {number | null | undefined} [offset] * * @typedef PositionLike * @property {PointLike | null | undefined} [start] * @property {PointLike | null | undefined} [end] */ /** * Serialize the positional info of a point, position (start and end points), * or node. * * @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value] * Node, position, or point. * @returns {string} * Pretty printed positional info of a node (`string`). * * In the format of a range `ls:cs-le:ce` (when given `node` or `position`) * or a point `l:c` (when given `point`), where `l` stands for line, `c` for * column, `s` for `start`, and `e` for end. * An empty string (`''`) is returned if the given value is neither `node`, * `position`, nor `point`. */ export function stringifyPosition(value) { // Nothing. if (!value || typeof value !== 'object') { return '' } // Node. if ('position' in value || 'type' in value) { return position(value.position) } // Position. if ('start' in value || 'end' in value) { return position(value) } // Point. if ('line' in value || 'column' in value) { return point(value) } // ? return '' } /** * @param {Point | PointLike | null | undefined} point * @returns {string} */ function point(point) { return index(point && point.line) + ':' + index(point && point.column) } /** * @param {Position | PositionLike | null | undefined} pos * @returns {string} */ function position(pos) { return point(pos && pos.start) + '-' + point(pos && pos.end) } /** * @param {number | null | undefined} value * @returns {number} */ function index(value) { return value && typeof value === 'number' ? value : 1 } { "name": "unist-util-stringify-position", "version": "4.0.0", "description": "unist utility to serialize a node, position, or point as a human readable location", "license": "MIT", "keywords": [ "unist", "unist-util", "util", "utility", "position", "location", "point", "node", "stringify", "tostring" ], "repository": "syntax-tree/unist-util-stringify-position", "bugs": "https://github.com/syntax-tree/unist-util-stringify-position/issues", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "exports": "./index.js", "files": [ "lib/", "index.d.ts", "index.js" ], "dependencies": { "@types/unist": "^3.0.0" }, "devDependencies": { "@types/mdast": "^4.0.0", "@types/node": "^20.0.0", "c8": "^8.0.0", "prettier": "^2.0.0", "remark-cli": "^11.0.0", "remark-preset-wooorm": "^9.0.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.54.0" }, "scripts": { "prepack": "npm run build && npm run format", "build": "tsc --build --clean && tsc --build && type-coverage", "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix", "test-api": "node --conditions development test.js", "test-coverage": "c8 --100 --reporter lcov npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "prettier": { "bracketSpacing": false, "semi": false, "singleQuote": true, "tabWidth": 2, "trailingComma": "none", "useTabs": false }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "ignoreCatch": true, "strict": true }, "xo": { "prettier": true } } // Note: types exported from `index.d.ts` export {CONTINUE, EXIT, SKIP, visitParents} from './lib/index.js' /** * @param {string} d * @returns {string} */ export function color(d) { return '\u001B[33m' + d + '\u001B[39m' } /** * @import {Node as UnistNode, Parent as UnistParent} from 'unist' */ /** * @typedef {Exclude | undefined} Test * Test from `unist-util-is`. * * Note: we have remove and add `undefined`, because otherwise when generating * automatic `.d.ts` files, TS tries to flatten paths from a local perspective, * which doesn’t work when publishing on npm. */ /** * @typedef {( * Fn extends (value: any) => value is infer Thing * ? Thing * : Fallback * )} Predicate * Get the value of a type guard `Fn`. * @template Fn * Value; typically function that is a type guard (such as `(x): x is Y`). * @template Fallback * Value to yield if `Fn` is not a type guard. */ /** * @typedef {( * Check extends null | undefined // No test. * ? Value * : Value extends {type: Check} // String (type) test. * ? Value * : Value extends Check // Partial test. * ? Value * : Check extends Function // Function test. * ? Predicate extends Value * ? Predicate * : never * : never // Some other test? * )} MatchesOne * Check whether a node matches a primitive check in the type system. * @template Value * Value; typically unist `Node`. * @template Check * Value; typically `unist-util-is`-compatible test, but not arrays. */ /** * @typedef {( * Check extends ReadonlyArray * ? MatchesOne * : Check extends Array * ? MatchesOne * : MatchesOne * )} Matches * Check whether a node matches a check in the type system. * @template Value * Value; typically unist `Node`. * @template Check * Value; typically `unist-util-is`-compatible test. */ /** * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint * Number; capped reasonably. */ /** * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment * Increment a number in the type system. * @template {Uint} [I=0] * Index. */ /** * @typedef {( * Node extends UnistParent * ? Node extends {children: Array} * ? Child extends Children ? Node : never * : never * : never * )} InternalParent * Collect nodes that can be parents of `Child`. * @template {UnistNode} Node * All node types in a tree. * @template {UnistNode} Child * Node to search for. */ /** * @typedef {InternalParent, Child>} Parent * Collect nodes in `Tree` that can be parents of `Child`. * @template {UnistNode} Tree * All node types in a tree. * @template {UnistNode} Child * Node to search for. */ /** * @typedef {( * Depth extends Max * ? never * : * | InternalParent * | InternalAncestor, Max, Increment> * )} InternalAncestor * Collect nodes in `Tree` that can be ancestors of `Child`. * @template {UnistNode} Node * All node types in a tree. * @template {UnistNode} Child * Node to search for. * @template {Uint} [Max=10] * Max; searches up to this depth. * @template {Uint} [Depth=0] * Current depth. */ /** * @typedef {InternalAncestor, Child>} Ancestor * Collect nodes in `Tree` that can be ancestors of `Child`. * @template {UnistNode} Tree * All node types in a tree. * @template {UnistNode} Child * Node to search for. */ /** * @typedef {( * Tree extends UnistParent * ? Depth extends Max * ? Tree * : Tree | InclusiveDescendant> * : Tree * )} InclusiveDescendant * Collect all (inclusive) descendants of `Tree`. * * > 👉 **Note**: for performance reasons, this seems to be the fastest way to * > recurse without actually running into an infinite loop, which the * > previous version did. * > * > Practically, a max of `2` is typically enough assuming a `Root` is * > passed, but it doesn’t improve performance. * > It gets higher with `List > ListItem > Table > TableRow > TableCell`. * > Using up to `10` doesn’t hurt or help either. * @template {UnistNode} Tree * Tree type. * @template {Uint} [Max=10] * Max; searches up to this depth. * @template {Uint} [Depth=0] * Current depth. */ /** * @typedef {'skip' | boolean} Action * Union of the action types. * * @typedef {number} Index * Move to the sibling at `index` next (after node itself is completely * traversed). * * Useful if mutating the tree, such as removing the node the visitor is * currently on, or any of its previous siblings. * Results less than 0 or greater than or equal to `children.length` stop * traversing the parent. * * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple * List with one or two values, the first an action, the second an index. * * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult * Any value that can be returned from a visitor. */ /** * @callback Visitor * Handle a node (matching `test`, if given). * * Visitors are free to transform `node`. * They can also transform the parent of node (the last of `ancestors`). * * Replacing `node` itself, if `SKIP` is not returned, still causes its * descendants to be walked (which is a bug). * * When adding or removing previous siblings of `node` (or next siblings, in * case of reverse), the `Visitor` should return a new `Index` to specify the * sibling to traverse after `node` is traversed. * Adding or removing next siblings of `node` (or previous siblings, in case * of reverse) is handled as expected without needing to return a new `Index`. * * Removing the children property of an ancestor still results in them being * traversed. * @param {Visited} node * Found node. * @param {Array} ancestors * Ancestors of `node`. * @returns {VisitorResult} * What to do next. * * An `Index` is treated as a tuple of `[CONTINUE, Index]`. * An `Action` is treated as a tuple of `[Action]`. * * Passing a tuple back only makes sense if the `Action` is `SKIP`. * When the `Action` is `EXIT`, that action can be returned. * When the `Action` is `CONTINUE`, `Index` can be returned. * @template {UnistNode} [Visited=UnistNode] * Visited node type. * @template {UnistParent} [VisitedParents=UnistParent] * Ancestor type. */ /** * @typedef {Visitor, Check>, Ancestor, Check>>>} BuildVisitor * Build a typed `Visitor` function from a tree and a test. * * It will infer which values are passed as `node` and which as `parents`. * @template {UnistNode} [Tree=UnistNode] * Tree type. * @template {Test} [Check=Test] * Test type. */ import {convert} from 'unist-util-is' import {color} from 'unist-util-visit-parents/do-not-use-color' /** @type {Readonly} */ const empty = [] /** * Continue traversing as normal. */ export const CONTINUE = true /** * Stop traversing immediately. */ export const EXIT = false /** * Do not traverse this node’s children. */ export const SKIP = 'skip' /** * Visit nodes, with ancestral information. * * This algorithm performs *depth-first* *tree traversal* in *preorder* * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**). * * You can choose for which nodes `visitor` is called by passing a `test`. * For complex tests, you should test yourself in `visitor`, as it will be * faster and will have improved type information. * * Walking the tree is an intensive task. * Make use of the return values of the visitor when possible. * Instead of walking a tree multiple times, walk it once, use `unist-util-is` * to check if a node matches, and then perform different operations. * * You can change the tree. * See `Visitor` for more info. * * @overload * @param {Tree} tree * @param {Check} check * @param {BuildVisitor} visitor * @param {boolean | null | undefined} [reverse] * @returns {undefined} * * @overload * @param {Tree} tree * @param {BuildVisitor} visitor * @param {boolean | null | undefined} [reverse] * @returns {undefined} * * @param {UnistNode} tree * Tree to traverse. * @param {Visitor | Test} test * `unist-util-is`-compatible test * @param {Visitor | boolean | null | undefined} [visitor] * Handle each node. * @param {boolean | null | undefined} [reverse] * Traverse in reverse preorder (NRL) instead of the default preorder (NLR). * @returns {undefined} * Nothing. * * @template {UnistNode} Tree * Node type. * @template {Test} Check * `unist-util-is`-compatible test. */ export function visitParents(tree, test, visitor, reverse) { /** @type {Test} */ let check if (typeof test === 'function' && typeof visitor !== 'function') { reverse = visitor // @ts-expect-error no visitor given, so `visitor` is test. visitor = test } else { // @ts-expect-error visitor given, so `test` isn’t a visitor. check = test } const is = convert(check) const step = reverse ? -1 : 1 factory(tree, undefined, [])() /** * @param {UnistNode} node * @param {number | undefined} index * @param {Array} parents */ function factory(node, index, parents) { const value = /** @type {Record} */ ( node && typeof node === 'object' ? node : {} ) if (typeof value.type === 'string') { const name = // `hast` typeof value.tagName === 'string' ? value.tagName : // `xast` typeof value.name === 'string' ? value.name : undefined Object.defineProperty(visit, 'name', { value: 'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')' }) } return visit function visit() { /** @type {Readonly} */ let result = empty /** @type {Readonly} */ let subresult /** @type {number} */ let offset /** @type {Array} */ let grandparents if (!test || is(node, index, parents[parents.length - 1] || undefined)) { // @ts-expect-error: `visitor` is now a visitor. result = toResult(visitor(node, parents)) if (result[0] === EXIT) { return result } } if ('children' in node && node.children) { const nodeAsParent = /** @type {UnistParent} */ (node) if (nodeAsParent.children && result[0] !== SKIP) { offset = (reverse ? nodeAsParent.children.length : -1) + step grandparents = parents.concat(nodeAsParent) while (offset > -1 && offset < nodeAsParent.children.length) { const child = nodeAsParent.children[offset] subresult = factory(child, offset, grandparents)() if (subresult[0] === EXIT) { return subresult } offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step } } } return result } } } /** * Turn a return value into a clean result. * * @param {VisitorResult} value * Valid return values from visitors. * @returns {Readonly} * Clean result. */ function toResult(value) { if (Array.isArray(value)) { return value } if (typeof value === 'number') { return [CONTINUE, value] } return value === null || value === undefined ? empty : [value] } { "name": "unist-util-visit-parents", "version": "6.0.2", "description": "unist utility to recursively walk over nodes, with ancestral information", "license": "MIT", "keywords": [ "unist", "unist-util", "util", "utility", "tree", "ast", "visit", "traverse", "walk", "check", "parent", "parents" ], "repository": "syntax-tree/unist-util-visit-parents", "bugs": "https://github.com/syntax-tree/unist-util-visit-parents/issues", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "exports": { ".": "./index.js", "./do-not-use-color": { "node": "./lib/color.node.js", "default": "./lib/color.js" } }, "types": "index.d.ts", "files": [ "lib/", "index.d.ts.map", "index.d.ts", "index.js" ], "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" }, "devDependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@types/node": "^24.0.0", "@types/xast": "^2.0.0", "c8": "^10.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-gfm": "^3.0.0", "micromark-extension-gfm": "^3.0.0", "prettier": "^3.0.0", "remark-cli": "^12.0.0", "remark-preset-wooorm": "^10.0.0", "strip-ansi": "^7.0.0", "tsd": "^0.33.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^0.58.0" }, "scripts": { "prepack": "npm run build && npm run format", "build": "tsc --build --clean && tsc --build && tsd && type-coverage", "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix", "test-api": "node --conditions development test.js", "test-coverage": "c8 --100 --reporter lcov npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "prettier": { "bracketSpacing": false, "semi": false, "singleQuote": true, "tabWidth": 2, "trailingComma": "none", "useTabs": false }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "#": "needed `any`s", "ignoreFiles": [ "lib/index.d.ts" ], "ignoreCatch": true, "strict": true }, "xo": { "prettier": true, "rules": { "unicorn/prefer-at": "off", "unicorn/prefer-string-replace-all": "off" } } } // Note: types exported from `index.d.ts` export {CONTINUE, EXIT, SKIP, visit} from './lib/index.js' /** * @import {Node as UnistNode, Parent as UnistParent} from 'unist' * @import {VisitorResult} from 'unist-util-visit-parents' */ /** * @typedef {Exclude | undefined} Test * Test from `unist-util-is`. * * Note: we have remove and add `undefined`, because otherwise when generating * automatic `.d.ts` files, TS tries to flatten paths from a local perspective, * which doesn’t work when publishing on npm. */ // To do: use types from `unist-util-visit-parents` when it’s released. /** * @typedef {( * Fn extends (value: any) => value is infer Thing * ? Thing * : Fallback * )} Predicate * Get the value of a type guard `Fn`. * @template Fn * Value; typically function that is a type guard (such as `(x): x is Y`). * @template Fallback * Value to yield if `Fn` is not a type guard. */ /** * @typedef {( * Check extends null | undefined // No test. * ? Value * : Value extends {type: Check} // String (type) test. * ? Value * : Value extends Check // Partial test. * ? Value * : Check extends Function // Function test. * ? Predicate extends Value * ? Predicate * : never * : never // Some other test? * )} MatchesOne * Check whether a node matches a primitive check in the type system. * @template Value * Value; typically unist `Node`. * @template Check * Value; typically `unist-util-is`-compatible test, but not arrays. */ /** * @typedef {( * Check extends ReadonlyArray * ? MatchesOne * : MatchesOne * )} Matches * Check whether a node matches a check in the type system. * @template Value * Value; typically unist `Node`. * @template Check * Value; typically `unist-util-is`-compatible test. */ /** * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint * Number; capped reasonably. */ /** * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment * Increment a number in the type system. * @template {Uint} [I=0] * Index. */ /** * @typedef {( * Node extends UnistParent * ? Node extends {children: Array} * ? Child extends Children ? Node : never * : never * : never * )} InternalParent * Collect nodes that can be parents of `Child`. * @template {UnistNode} Node * All node types in a tree. * @template {UnistNode} Child * Node to search for. */ /** * @typedef {InternalParent, Child>} Parent * Collect nodes in `Tree` that can be parents of `Child`. * @template {UnistNode} Tree * All node types in a tree. * @template {UnistNode} Child * Node to search for. */ /** * @typedef {( * Depth extends Max * ? never * : * | InternalParent * | InternalAncestor, Max, Increment> * )} InternalAncestor * Collect nodes in `Tree` that can be ancestors of `Child`. * @template {UnistNode} Node * All node types in a tree. * @template {UnistNode} Child * Node to search for. * @template {Uint} [Max=10] * Max; searches up to this depth. * @template {Uint} [Depth=0] * Current depth. */ /** * @typedef {( * Tree extends UnistParent * ? Depth extends Max * ? Tree * : Tree | InclusiveDescendant> * : Tree * )} InclusiveDescendant * Collect all (inclusive) descendants of `Tree`. * * > 👉 **Note**: for performance reasons, this seems to be the fastest way to * > recurse without actually running into an infinite loop, which the * > previous version did. * > * > Practically, a max of `2` is typically enough assuming a `Root` is * > passed, but it doesn’t improve performance. * > It gets higher with `List > ListItem > Table > TableRow > TableCell`. * > Using up to `10` doesn’t hurt or help either. * @template {UnistNode} Tree * Tree type. * @template {Uint} [Max=10] * Max; searches up to this depth. * @template {Uint} [Depth=0] * Current depth. */ /** * @callback Visitor * Handle a node (matching `test`, if given). * * Visitors are free to transform `node`. * They can also transform `parent`. * * Replacing `node` itself, if `SKIP` is not returned, still causes its * descendants to be walked (which is a bug). * * When adding or removing previous siblings of `node` (or next siblings, in * case of reverse), the `Visitor` should return a new `Index` to specify the * sibling to traverse after `node` is traversed. * Adding or removing next siblings of `node` (or previous siblings, in case * of reverse) is handled as expected without needing to return a new `Index`. * * Removing the children property of `parent` still results in them being * traversed. * @param {Visited} node * Found node. * @param {Visited extends UnistNode ? number | undefined : never} index * Index of `node` in `parent`. * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent * Parent of `node`. * @returns {VisitorResult} * What to do next. * * An `Index` is treated as a tuple of `[CONTINUE, Index]`. * An `Action` is treated as a tuple of `[Action]`. * * Passing a tuple back only makes sense if the `Action` is `SKIP`. * When the `Action` is `EXIT`, that action can be returned. * When the `Action` is `CONTINUE`, `Index` can be returned. * @template {UnistNode} [Visited=UnistNode] * Visited node type. * @template {UnistParent} [Ancestor=UnistParent] * Ancestor type. */ /** * @typedef {Visitor>} BuildVisitorFromMatch * Build a typed `Visitor` function from a node and all possible parents. * * It will infer which values are passed as `node` and which as `parent`. * @template {UnistNode} Visited * Node type. * @template {UnistParent} Ancestor * Parent type. */ /** * @typedef {( * BuildVisitorFromMatch< * Matches, * Extract * > * )} BuildVisitorFromDescendants * Build a typed `Visitor` function from a list of descendants and a test. * * It will infer which values are passed as `node` and which as `parent`. * @template {UnistNode} Descendant * Node type. * @template {Test} Check * Test type. */ /** * @typedef {( * BuildVisitorFromDescendants< * InclusiveDescendant, * Check * > * )} BuildVisitor * Build a typed `Visitor` function from a tree and a test. * * It will infer which values are passed as `node` and which as `parent`. * @template {UnistNode} [Tree=UnistNode] * Node type. * @template {Test} [Check=Test] * Test type. */ import {visitParents} from 'unist-util-visit-parents' export {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents' /** * Visit nodes. * * This algorithm performs *depth-first* *tree traversal* in *preorder* * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**). * * You can choose for which nodes `visitor` is called by passing a `test`. * For complex tests, you should test yourself in `visitor`, as it will be * faster and will have improved type information. * * Walking the tree is an intensive task. * Make use of the return values of the visitor when possible. * Instead of walking a tree multiple times, walk it once, use `unist-util-is` * to check if a node matches, and then perform different operations. * * You can change the tree. * See `Visitor` for more info. * * @overload * @param {Tree} tree * @param {Check} check * @param {BuildVisitor} visitor * @param {boolean | null | undefined} [reverse] * @returns {undefined} * * @overload * @param {Tree} tree * @param {BuildVisitor} visitor * @param {boolean | null | undefined} [reverse] * @returns {undefined} * * @param {UnistNode} tree * Tree to traverse. * @param {Visitor | Test} testOrVisitor * `unist-util-is`-compatible test (optional, omit to pass a visitor). * @param {Visitor | boolean | null | undefined} [visitorOrReverse] * Handle each node (when test is omitted, pass `reverse`). * @param {boolean | null | undefined} [maybeReverse=false] * Traverse in reverse preorder (NRL) instead of the default preorder (NLR). * @returns {undefined} * Nothing. * * @template {UnistNode} Tree * Node type. * @template {Test} Check * `unist-util-is`-compatible test. */ export function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) { /** @type {boolean | null | undefined} */ let reverse /** @type {Test} */ let test /** @type {Visitor} */ let visitor if ( typeof testOrVisitor === 'function' && typeof visitorOrReverse !== 'function' ) { test = undefined visitor = testOrVisitor reverse = visitorOrReverse } else { // @ts-expect-error: assume the overload with test was given. test = testOrVisitor // @ts-expect-error: assume the overload with test was given. visitor = visitorOrReverse reverse = maybeReverse } visitParents(tree, test, overload, reverse) /** * @param {UnistNode} node * @param {Array} parents */ function overload(node, parents) { const parent = parents[parents.length - 1] const index = parent ? parent.children.indexOf(node) : undefined return visitor(node, index, parent) } } { "name": "unist-util-visit", "version": "5.1.0", "description": "unist utility to visit nodes", "license": "MIT", "keywords": [ "unist", "unist-util", "util", "utility", "remark", "retext", "rehype", "mdast", "hast", "xast", "nlcst", "natural", "language", "markdown", "html", "xml", "tree", "ast", "node", "visit", "walk" ], "repository": "syntax-tree/unist-util-visit", "bugs": "https://github.com/syntax-tree/unist-util-visit/issues", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)", "Eugene Sharygin ", "Richard Gibson " ], "sideEffects": false, "type": "module", "exports": "./index.js", "files": [ "lib/", "index.d.ts.map", "index.d.ts", "index.js" ], "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" }, "devDependencies": { "@types/mdast": "^4.0.0", "@types/node": "^25.0.0", "c8": "^10.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-gfm": "^3.0.0", "micromark-extension-gfm": "^3.0.0", "prettier": "^3.0.0", "remark-cli": "^12.0.0", "remark-preset-wooorm": "^11.0.0", "tsd": "^0.33.0", "type-coverage": "^2.0.0", "typescript": "^5.0.0", "xo": "^1.0.0" }, "scripts": { "prepack": "npm run build && npm run format", "build": "tsc --build --clean && tsc --build && tsd && type-coverage", "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix", "test-api": "node --conditions development test.js", "test-coverage": "c8 --100 --reporter lcov npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "prettier": { "bracketSpacing": false, "semi": false, "singleQuote": true, "tabWidth": 2, "trailingComma": "none", "useTabs": false }, "remarkConfig": { "plugins": [ "remark-preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "#": "needed `any`s", "ignoreFiles": [ "lib/index.d.ts" ], "ignoreCatch": true, "strict": true }, "xo": { "space": true, "prettier": true, "rules": { "unicorn/prefer-at": "off" } } } /** * @callback Handler * Handle a value, with a certain ID field set to a certain value. * The ID field is passed to `zwitch`, and it’s value is this function’s * place on the `handlers` record. * @param {...any} parameters * Arbitrary parameters passed to the zwitch. * The first will be an object with a certain ID field set to a certain value. * @returns {any} * Anything! */ /** * @callback UnknownHandler * Handle values that do have a certain ID field, but it’s set to a value * that is not listed in the `handlers` record. * @param {unknown} value * An object with a certain ID field set to an unknown value. * @param {...any} rest * Arbitrary parameters passed to the zwitch. * @returns {any} * Anything! */ /** * @callback InvalidHandler * Handle values that do not have a certain ID field. * @param {unknown} value * Any unknown value. * @param {...any} rest * Arbitrary parameters passed to the zwitch. * @returns {void|null|undefined|never} * This should crash or return nothing. */ /** * @template {InvalidHandler} [Invalid=InvalidHandler] * @template {UnknownHandler} [Unknown=UnknownHandler] * @template {Record} [Handlers=Record] * @typedef Options * Configuration (required). * @property {Invalid} [invalid] * Handler to use for invalid values. * @property {Unknown} [unknown] * Handler to use for unknown values. * @property {Handlers} [handlers] * Handlers to use. */ const own = {}.hasOwnProperty /** * Handle values based on a field. * * @template {InvalidHandler} [Invalid=InvalidHandler] * @template {UnknownHandler} [Unknown=UnknownHandler] * @template {Record} [Handlers=Record] * @param {string} key * Field to switch on. * @param {Options} [options] * Configuration (required). * @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters): ReturnType, (...parameters: Parameters): ReturnType}} */ export function zwitch(key, options) { const settings = options || {} /** * Handle one value. * * Based on the bound `key`, a respective handler will be called. * If `value` is not an object, or doesn’t have a `key` property, the special * “invalid” handler will be called. * If `value` has an unknown `key`, the special “unknown” handler will be * called. * * All arguments, and the context object, are passed through to the handler, * and it’s result is returned. * * @this {unknown} * Any context object. * @param {unknown} [value] * Any value. * @param {...unknown} parameters * Arbitrary parameters passed to the zwitch. * @property {Handler} invalid * Handle for values that do not have a certain ID field. * @property {Handler} unknown * Handle values that do have a certain ID field, but it’s set to a value * that is not listed in the `handlers` record. * @property {Handlers} handlers * Record of handlers. * @returns {unknown} * Anything. */ function one(value, ...parameters) { /** @type {Handler|undefined} */ let fn = one.invalid const handlers = one.handlers if (value && own.call(value, key)) { // @ts-expect-error Indexable. const id = String(value[key]) // @ts-expect-error Indexable. fn = own.call(handlers, id) ? handlers[id] : one.unknown } if (fn) { return fn.call(this, value, ...parameters) } } one.handlers = settings.handlers || {} one.invalid = settings.invalid one.unknown = settings.unknown // @ts-expect-error: matches! return one } { "name": "zwitch", "version": "2.0.4", "description": "Handle values based on a property", "license": "MIT", "keywords": [ "handle", "switch", "property" ], "repository": "wooorm/zwitch", "bugs": "https://github.com/wooorm/zwitch/issues", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" }, "author": "Titus Wormer (https://wooorm.com)", "contributors": [ "Titus Wormer (https://wooorm.com)" ], "sideEffects": false, "type": "module", "main": "index.js", "types": "index.d.ts", "files": [ "index.d.ts", "index.js" ], "devDependencies": { "@types/node": "^18.0.0", "c8": "^7.0.0", "prettier": "^2.0.0", "remark-cli": "^11.0.0", "remark-preset-wooorm": "^9.0.0", "tsd": "^0.24.0", "type-coverage": "^2.0.0", "typescript": "^4.0.0", "xo": "^0.52.0" }, "scripts": { "prepack": "npm run build && npm run format", "build": "tsc --build --clean && tsc --build && tsd && type-coverage", "format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix", "test-api": "node --conditions development test.js", "test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api", "test": "npm run build && npm run format && npm run test-coverage" }, "prettier": { "tabWidth": 2, "useTabs": false, "singleQuote": true, "bracketSpacing": false, "semi": false, "trailingComma": "none" }, "xo": { "prettier": true }, "remarkConfig": { "plugins": [ "preset-wooorm" ] }, "typeCoverage": { "atLeast": 100, "detail": true, "strict": true, "ignoreFiles": [ "index.d.ts" ] } } { "name": "favela-markdown", "version": "0.2.0", "description": "The P2P-native markdown record layer for favela. A post is a markdown document; atproto and ActivityPub are projections derived from it on read.", "type": "module", "license": "MIT", "dependencies": { "mdast-util-directive": "^3.1.0", "mdast-util-from-markdown": "^2.0.3", "mdast-util-gfm-footnote": "^2.1.0", "mdast-util-gfm-strikethrough": "^2.0.0", "mdast-util-gfm-table": "^2.0.0", "micromark-extension-directive": "^4.0.0", "micromark-extension-gfm-footnote": "^2.1.0", "micromark-extension-gfm-strikethrough": "^2.1.0", "micromark-extension-gfm-table": "^2.1.1", "bare-fs": "^4.8.1", "bare-path": "^3.1.2", "bare-os": "^3.9.3" }, "scripts": { "test": "brittle-bare test/*.test.js" }, "bin": { "favela-markdown": "bin/favela-markdown.js" }, "imports": { "#node:fs": { "bare": "bare-fs", "default": "fs" }, "#node:path": { "bare": "bare-path", "default": "path" }, "#node:os": { "bare": "bare-os", "default": "os" } } } const { EventEmitter } = require('events-universal') const FIFO = require('fast-fifo') const TextDecoder = require('text-decoder') const StreamError = require('./lib/errors.js') // if we do a future major, expect queue microtask to be there always, for now a bit defensive const qmt = typeof queueMicrotask === 'undefined' ? (fn) => global.process.nextTick(fn) : queueMicrotask // 29 bits used total (4 from shared, 14 from read, and 11 from write) const MAX = (1 << 29) - 1 // Shared state const OPENING = 0b0001 const PREDESTROYING = 0b0010 const DESTROYING = 0b0100 const DESTROYED = 0b1000 const NOT_OPENING = MAX ^ OPENING const NOT_PREDESTROYING = MAX ^ PREDESTROYING // Read state (4 bit offset from shared state) const READ_ACTIVE = 0b00000000000001 << 4 const READ_UPDATING = 0b00000000000010 << 4 const READ_PRIMARY = 0b00000000000100 << 4 const READ_QUEUED = 0b00000000001000 << 4 const READ_RESUMED = 0b00000000010000 << 4 const READ_PIPE_DRAINED = 0b00000000100000 << 4 const READ_ENDING = 0b00000001000000 << 4 const READ_EMIT_DATA = 0b00000010000000 << 4 const READ_EMIT_READABLE = 0b00000100000000 << 4 const READ_EMITTED_READABLE = 0b00001000000000 << 4 const READ_DONE = 0b00010000000000 << 4 const READ_NEXT_TICK = 0b00100000000000 << 4 const READ_NEEDS_PUSH = 0b01000000000000 << 4 const READ_READ_AHEAD = 0b10000000000000 << 4 // Combined read state const READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED const READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH const READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE const READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED const READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD const READ_NOT_ACTIVE = MAX ^ READ_ACTIVE const READ_NON_PRIMARY = MAX ^ READ_PRIMARY const READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH) const READ_PUSHED = MAX ^ READ_NEEDS_PUSH const READ_PAUSED = MAX ^ READ_RESUMED const READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE) const READ_NOT_ENDING = MAX ^ READ_ENDING const READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING const READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK const READ_NOT_UPDATING = MAX ^ READ_UPDATING const READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD const READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD // Write state (18 bit offset, 4 bit offset from shared state and 14 from read state) const WRITE_ACTIVE = 0b00000000001 << 18 const WRITE_UPDATING = 0b00000000010 << 18 const WRITE_PRIMARY = 0b00000000100 << 18 const WRITE_QUEUED = 0b00000001000 << 18 const WRITE_UNDRAINED = 0b00000010000 << 18 const WRITE_DONE = 0b00000100000 << 18 const WRITE_EMIT_DRAIN = 0b00001000000 << 18 const WRITE_NEXT_TICK = 0b00010000000 << 18 const WRITE_WRITING = 0b00100000000 << 18 const WRITE_FINISHING = 0b01000000000 << 18 const WRITE_CORKED = 0b10000000000 << 18 const WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING) const WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY const WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING) const WRITE_DRAINED = MAX ^ WRITE_UNDRAINED const WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED const WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK const WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING const WRITE_NOT_CORKED = MAX ^ WRITE_CORKED // Combined shared state const ACTIVE = READ_ACTIVE | WRITE_ACTIVE const NOT_ACTIVE = MAX ^ ACTIVE const DONE = READ_DONE | WRITE_DONE const DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING const OPEN_STATUS = DESTROY_STATUS | OPENING const AUTO_DESTROY = DESTROY_STATUS | DONE const NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY const ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK const TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE const IS_OPENING = OPEN_STATUS | TICKING // Combined shared state and read state const READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE const READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED const READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED const READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE const SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD const READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE const READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY const READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING // Combined write state const WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE const WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED const WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE const WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE const WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED const WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE const WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING const WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE const WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE const WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY const WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS const asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator') class WritableState { constructor( stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {} ) { this.stream = stream this.queue = new FIFO() this.highWaterMark = highWaterMark this.buffered = 0 this.error = null this.pipeline = null this.drains = null // if we add more seldomly used helpers we might them into a subobject so its a single ptr this.byteLength = byteLengthWritable || byteLength || defaultByteLength this.map = mapWritable || map this.afterWrite = afterWrite.bind(this) this.afterUpdateNextTick = updateWriteNT.bind(this) } get ending() { return (this.stream._duplexState & WRITE_FINISHING) !== 0 } get ended() { return (this.stream._duplexState & WRITE_DONE) !== 0 } push(data) { if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false if (this.map !== null) data = this.map(data) this.buffered += this.byteLength(data) this.queue.push(data) if (this.buffered < this.highWaterMark) { this.stream._duplexState |= WRITE_QUEUED return true } this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED return false } shift() { const data = this.queue.shift() this.buffered -= this.byteLength(data) if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED return data } end(data) { if (typeof data === 'function') { this.stream.once('finish', data) } else if (data !== undefined && data !== null) { this.push(data) } this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY } autoBatch(data, cb) { const buffer = [] const stream = this.stream buffer.push(data) while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) { buffer.push(stream._writableState.shift()) } if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null) stream._writev(buffer, cb) } update() { const stream = this.stream stream._duplexState |= WRITE_UPDATING do { while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) { const data = this.shift() stream._duplexState |= WRITE_ACTIVE_AND_WRITING stream._write(data, this.afterWrite) } if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary() } while (this.continueUpdate() === true) stream._duplexState &= WRITE_NOT_UPDATING } updateNonPrimary() { const stream = this.stream if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) { stream._duplexState = stream._duplexState | WRITE_ACTIVE stream._final(afterFinal.bind(this)) return } if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { stream._duplexState |= ACTIVE stream._destroy(afterDestroy.bind(this)) } return } if ((stream._duplexState & IS_OPENING) === OPENING) { stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING stream._open(afterOpen.bind(this)) } } continueUpdate() { if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false this.stream._duplexState &= WRITE_NOT_NEXT_TICK return true } updateCallback() { if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) { this.update() } else { this.updateNextTick() } } updateNextTick() { if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return this.stream._duplexState |= WRITE_NEXT_TICK if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick) } } class ReadableState { constructor( stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {} ) { this.stream = stream this.queue = new FIFO() this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark this.buffered = 0 this.readAhead = highWaterMark > 0 this.error = null this.pipeline = null this.byteLength = byteLengthReadable || byteLength || defaultByteLength this.map = mapReadable || map this.pipeTo = null this.afterRead = afterRead.bind(this) this.afterUpdateNextTick = updateReadNT.bind(this) } get ending() { return (this.stream._duplexState & READ_ENDING) !== 0 } get ended() { return (this.stream._duplexState & READ_DONE) !== 0 } pipe(pipeTo, cb) { if (this.pipeTo !== null) throw StreamError.BAD_ARGUMENT('Can only pipe to one destination') if (typeof cb !== 'function') cb = null this.stream._duplexState |= READ_PIPE_DRAINED this.pipeTo = pipeTo this.pipeline = new Pipeline(this.stream, pipeTo, cb) if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes if (isStreamx(pipeTo)) { pipeTo._writableState.pipeline = this.pipeline if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself } else { const onerror = this.pipeline.done.bind(this.pipeline, pipeTo) const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool arg pipeTo.on('error', onerror) pipeTo.on('close', onclose) pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) } pipeTo.on('drain', afterDrain.bind(this)) this.stream.emit('piping', pipeTo) pipeTo.emit('pipe', this.stream) } push(data) { const stream = this.stream if (data === null) { this.highWaterMark = 0 stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED return false } if (this.map !== null) { data = this.map(data) if (data === null) { stream._duplexState &= READ_PUSHED return this.buffered < this.highWaterMark } } this.buffered += this.byteLength(data) this.queue.push(data) stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED return this.buffered < this.highWaterMark } shift() { const data = this.queue.shift() this.buffered -= this.byteLength(data) if (this.buffered === 0) { this.stream._duplexState &= READ_NOT_QUEUED } return data } unshift(data) { const pending = [this.map !== null ? this.map(data) : data] while (this.buffered > 0) pending.push(this.shift()) for (let i = 0; i < pending.length - 1; i++) { const data = pending[i] this.buffered += this.byteLength(data) this.queue.push(data) } this.push(pending[pending.length - 1]) } read() { const stream = this.stream if ((stream._duplexState & READ_STATUS) === READ_QUEUED) { const data = this.shift() if (this.pipeTo !== null && this.pipeTo.write(data) === false) { stream._duplexState &= READ_PIPE_NOT_DRAINED } if ((stream._duplexState & READ_EMIT_DATA) !== 0) { stream.emit('data', data) } return data } if (this.readAhead === false) { stream._duplexState |= READ_READ_AHEAD this.updateNextTick() } return null } drain() { const stream = this.stream while ( (stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0 ) { const data = this.shift() if (this.pipeTo !== null && this.pipeTo.write(data) === false) { stream._duplexState &= READ_PIPE_NOT_DRAINED } if ((stream._duplexState & READ_EMIT_DATA) !== 0) { stream.emit('data', data) } } } update() { const stream = this.stream stream._duplexState |= READ_UPDATING do { this.drain() while ( this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD ) { stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH stream._read(this.afterRead) this.drain() } if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) { stream._duplexState |= READ_EMITTED_READABLE stream.emit('readable') } if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) { this.updateNonPrimary() } } while (this.continueUpdate() === true) stream._duplexState &= READ_NOT_UPDATING } updateNonPrimary() { const stream = this.stream if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) { stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING stream.emit('end') if ((stream._duplexState & AUTO_DESTROY) === DONE) { stream._duplexState |= DESTROYING } if (this.pipeTo !== null) { this.pipeTo.end() } } if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { stream._duplexState |= ACTIVE stream._destroy(afterDestroy.bind(this)) } return } if ((stream._duplexState & IS_OPENING) === OPENING) { stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING stream._open(afterOpen.bind(this)) } } continueUpdate() { if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false this.stream._duplexState &= READ_NOT_NEXT_TICK return true } updateCallback() { if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) { this.update() } else { this.updateNextTick() } } updateNextTickIfOpen() { if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return this.stream._duplexState |= READ_NEXT_TICK if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick) } updateNextTick() { if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return this.stream._duplexState |= READ_NEXT_TICK if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick) } } class TransformState { constructor(stream) { this.data = null this.afterTransform = afterTransform.bind(stream) this.afterFinal = null } } class Pipeline { constructor(src, dst, cb) { this.from = src this.to = dst this.afterPipe = cb this.error = null this.pipeToFinished = false } finished() { this.pipeToFinished = true } done(stream, err) { if (err) this.error = err if (stream === this.to) { this.to = null if (this.from !== null) { if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) { this.from.destroy(this.error || StreamError.PREMATURE_CLOSE('Writable stream closed')) } return } } if (stream === this.from) { this.from = null if (this.to !== null) { if ((stream._duplexState & READ_DONE) === 0) { this.to.destroy(this.error || StreamError.PREMATURE_CLOSE('Readable stream closed')) } return } } if (this.afterPipe !== null) this.afterPipe(this.error) this.to = this.from = this.afterPipe = null } } function afterDrain() { this.stream._duplexState |= READ_PIPE_DRAINED this.updateCallback() } function afterFinal(err) { const stream = this.stream if (err) stream.destroy(err) if ((stream._duplexState & DESTROY_STATUS) === 0) { stream._duplexState |= WRITE_DONE stream.emit('finish') } if ((stream._duplexState & AUTO_DESTROY) === DONE) { stream._duplexState |= DESTROYING } stream._duplexState &= WRITE_NOT_FINISHING // no need to wait the extra tick here, so we short circuit that if ((stream._duplexState & WRITE_UPDATING) === 0) { this.update() } else { this.updateNextTick() } } function afterDestroy(err) { const stream = this.stream if (!err && !StreamError.isStreamDestroyed(this.error)) err = this.error if (err) stream.emit('error', err) stream._duplexState |= DESTROYED stream.emit('close') const rs = stream._readableState const ws = stream._writableState if (rs !== null && rs.pipeline !== null) { rs.pipeline.done(stream, err) } if (ws !== null) { while (ws.drains !== null && ws.drains.length > 0) { ws.drains.shift().resolve(false) } if (ws.pipeline !== null) { ws.pipeline.done(stream, err) } } } function afterWrite(err) { const stream = this.stream if (err) stream.destroy(err) stream._duplexState &= WRITE_NOT_ACTIVE if (this.drains !== null) tickDrains(this.drains) if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) { stream._duplexState &= WRITE_DRAINED if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) { stream.emit('drain') } } this.updateCallback() } function afterRead(err) { if (err) this.stream.destroy(err) this.stream._duplexState &= READ_NOT_ACTIVE if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) { this.stream._duplexState &= READ_NO_READ_AHEAD } this.updateCallback() } function updateReadNT() { if ((this.stream._duplexState & READ_UPDATING) === 0) { this.stream._duplexState &= READ_NOT_NEXT_TICK this.update() } } function updateWriteNT() { if ((this.stream._duplexState & WRITE_UPDATING) === 0) { this.stream._duplexState &= WRITE_NOT_NEXT_TICK this.update() } } function tickDrains(drains) { for (let i = 0; i < drains.length; i++) { // drains.writes are monotonic, so if one is 0 its always the first one if (--drains[i].writes === 0) { drains.shift().resolve(true) i-- } } } function afterOpen(err) { const stream = this.stream if (err) stream.destroy(err) if ((stream._duplexState & DESTROYING) === 0) { if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) { stream._duplexState |= READ_PRIMARY } if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) { stream._duplexState |= WRITE_PRIMARY } stream.emit('open') } stream._duplexState &= NOT_ACTIVE if (stream._writableState !== null) { stream._writableState.updateCallback() } if (stream._readableState !== null) { stream._readableState.updateCallback() } } function afterTransform(err, data) { if (data !== undefined && data !== null) this.push(data) this._writableState.afterWrite(err) } function newListener(name) { if (this._readableState !== null) { if (name === 'data') { this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD this._readableState.updateNextTick() } if (name === 'readable') { this._duplexState |= READ_EMIT_READABLE this._readableState.updateNextTick() } } if (this._writableState !== null) { if (name === 'drain') { this._duplexState |= WRITE_EMIT_DRAIN this._writableState.updateNextTick() } } } class Stream extends EventEmitter { constructor(opts) { super() this._duplexState = 0 this._readableState = null this._writableState = null if (opts) { if (opts.open) this._open = opts.open if (opts.destroy) this._destroy = opts.destroy if (opts.predestroy) this._predestroy = opts.predestroy if (opts.signal) opts.signal.addEventListener('abort', abort.bind(this)) } this.on('newListener', newListener) } _open(cb) { cb(null) } _destroy(cb) { cb(null) } _predestroy() { // does nothing } get readable() { return this._readableState !== null ? true : undefined } get writable() { return this._writableState !== null ? true : undefined } get destroyed() { return (this._duplexState & DESTROYED) !== 0 } get destroying() { return (this._duplexState & DESTROY_STATUS) !== 0 } destroy(err) { if ((this._duplexState & DESTROY_STATUS) === 0) { if (!err) err = StreamError.STREAM_DESTROYED() this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY if (this._readableState !== null) { this._readableState.highWaterMark = 0 this._readableState.error = err } if (this._writableState !== null) { this._writableState.highWaterMark = 0 this._writableState.error = err } this._duplexState |= PREDESTROYING this._predestroy() this._duplexState &= NOT_PREDESTROYING if (this._readableState !== null) { this._readableState.updateNextTick() } if (this._writableState !== null) { this._writableState.updateNextTick() } } } } class Readable extends Stream { constructor(opts) { super(opts) this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD this._readableState = new ReadableState(this, opts) if (opts) { if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD if (opts.read) this._read = opts.read if (opts.eagerOpen) this._readableState.updateNextTick() if (opts.encoding) this.setEncoding(opts.encoding) } } static deferred(fn, opts) { const out = new PassThrough(opts) fn() .then((src) => { if (src === null) return out.end() if (out.destroying) return pipeline(src, out, noop) }) .catch((err) => out.destroy(err)) return out } setEncoding(encoding) { const dec = new TextDecoder(encoding) const map = this._readableState.map || echo this._readableState.map = mapOrSkip return this function mapOrSkip(data) { const next = dec.push(data) return next === '' && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next) } } _read(cb) { cb(null) } pipe(dest, cb) { this._readableState.updateNextTick() this._readableState.pipe(dest, cb) return dest } read() { this._readableState.updateNextTick() return this._readableState.read() } push(data) { this._readableState.updateNextTickIfOpen() return this._readableState.push(data) } unshift(data) { this._readableState.updateNextTickIfOpen() return this._readableState.unshift(data) } resume() { this._duplexState |= READ_RESUMED_READ_AHEAD this._readableState.updateNextTick() return this } pause() { this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED return this } static _fromAsyncIterator(ite, opts) { let destroy const rs = new Readable({ ...opts, read(cb) { ite.next().then(push).then(cb.bind(null, null)).catch(cb) }, predestroy() { destroy = ite.return() }, destroy(cb) { if (!destroy) return cb(null) destroy.then(cb.bind(null, null)).catch(cb) } }) return rs function push(data) { if (data.done) rs.push(null) else rs.push(data.value) } } static from(data, opts) { if (isReadStreamx(data)) return data if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts) if (!Array.isArray(data)) data = data === undefined ? [] : [data] let i = 0 return new Readable({ ...opts, read(cb) { this.push(i === data.length ? null : data[i++]) cb(null) } }) } static isBackpressured(rs) { return ( (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark ) } static isPaused(rs) { return (rs._duplexState & READ_RESUMED) === 0 } [asyncIterator]() { const stream = this let error = null let promiseResolve = null let promiseReject = null this.on('error', (err) => { error = err }) this.on('readable', onreadable) this.on('close', onclose) return { [asyncIterator]() { return this }, next() { return new Promise(function (resolve, reject) { promiseResolve = resolve promiseReject = reject const data = stream.read() if (data !== null) ondata(data) else if ((stream._duplexState & DESTROYED) !== 0) ondata(null) }) }, return() { return destroy(null) }, throw(err) { return destroy(err) } } function onreadable() { if (promiseResolve !== null) ondata(stream.read()) } function onclose() { if (promiseResolve !== null) ondata(null) } function ondata(data) { if (promiseReject === null) return if (error) { promiseReject(error) } else if (data === null && (stream._duplexState & READ_DONE) === 0) { promiseReject(StreamError.STREAM_DESTROYED()) } else { promiseResolve({ value: data, done: data === null }) } promiseReject = promiseResolve = null } function destroy(err) { stream.destroy(err) return new Promise((resolve, reject) => { if (stream._duplexState & DESTROYED) return resolve({ value: undefined, done: true }) stream.once('close', function () { if (err) reject(err) else resolve({ value: undefined, done: true }) }) }) } } } class Writable extends Stream { constructor(opts) { super(opts) this._duplexState |= OPENING | READ_DONE this._writableState = new WritableState(this, opts) if (opts) { if (opts.writev) this._writev = opts.writev if (opts.write) this._write = opts.write if (opts.final) this._final = opts.final if (opts.eagerOpen) this._writableState.updateNextTick() } } cork() { this._duplexState |= WRITE_CORKED } uncork() { this._duplexState &= WRITE_NOT_CORKED this._writableState.updateNextTick() } _writev(batch, cb) { cb(null) } _write(data, cb) { this._writableState.autoBatch(data, cb) } _final(cb) { cb(null) } static isBackpressured(ws) { return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0 } static drained(ws) { if (ws.destroyed) return Promise.resolve(false) const state = ws._writableState const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0) if (writes === 0) return Promise.resolve(true) if (state.drains === null) state.drains = [] return new Promise((resolve) => { state.drains.push({ writes, resolve }) }) } write(data) { this._writableState.updateNextTick() return this._writableState.push(data) } end(data) { this._writableState.updateNextTick() this._writableState.end(data) return this } } class Duplex extends Readable { // and Writable constructor(opts) { super(opts) this._duplexState = OPENING | (this._duplexState & READ_READ_AHEAD) this._writableState = new WritableState(this, opts) if (opts) { if (opts.writev) this._writev = opts.writev if (opts.write) this._write = opts.write if (opts.final) this._final = opts.final } } cork() { this._duplexState |= WRITE_CORKED } uncork() { this._duplexState &= WRITE_NOT_CORKED this._writableState.updateNextTick() } _writev(batch, cb) { cb(null) } _write(data, cb) { this._writableState.autoBatch(data, cb) } _final(cb) { cb(null) } write(data) { this._writableState.updateNextTick() return this._writableState.push(data) } end(data) { this._writableState.updateNextTick() this._writableState.end(data) return this } } class Transform extends Duplex { constructor(opts) { super(opts) this._transformState = new TransformState(this) if (opts) { if (opts.transform) this._transform = opts.transform if (opts.flush) this._flush = opts.flush } } _write(data, cb) { if (this._readableState.buffered >= this._readableState.highWaterMark) { this._transformState.data = data } else { this._transform(data, this._transformState.afterTransform) } } _read(cb) { if (this._transformState.data !== null) { const data = this._transformState.data this._transformState.data = null cb(null) this._transform(data, this._transformState.afterTransform) } else { cb(null) } } destroy(err) { super.destroy(err) if (this._transformState.data !== null) { this._transformState.data = null this._transformState.afterTransform() } } _transform(data, cb) { cb(null, data) } _flush(cb) { cb(null) } _final(cb) { this._transformState.afterFinal = cb this._flush(transformAfterFlush.bind(this)) } } class PassThrough extends Transform {} function transformAfterFlush(err, data) { const cb = this._transformState.afterFinal if (err) return cb(err) if (data !== null && data !== undefined) this.push(data) this.push(null) cb(null) } function pipelinePromise(...streams) { return new Promise((resolve, reject) => { return pipeline(...streams, (err) => { if (err) return reject(err) resolve() }) }) } function pipeline(stream, ...streams) { const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams] const done = all.length && typeof all[all.length - 1] === 'function' ? all.pop() : null if (all.length < 2) throw StreamError.BAD_ARGUMENT('Pipeline requires at least 2 streams') let src = all[0] let dest = null let error = null for (let i = 1; i < all.length; i++) { dest = all[i] if (isStreamx(src)) { src.pipe(dest, onerror) } else { errorHandle(src, true, i > 1, onerror) src.pipe(dest) } src = dest } if (done) { let fin = false const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy) dest.on('error', (err) => { if (error === null) error = err }) dest.on('finish', () => { fin = true if (!autoDestroy) done(error) }) if (autoDestroy) { dest.on('close', () => done(error || (fin ? null : StreamError.PREMATURE_CLOSE()))) } } return dest function errorHandle(s, rd, wr, onerror) { s.on('error', onerror) s.on('close', onclose) function onclose() { if (rd && s._readableState && !s._readableState.ended) { return onerror(StreamError.PREMATURE_CLOSE()) } if (wr && s._writableState && !s._writableState.ended) { return onerror(StreamError.PREMATURE_CLOSE()) } } } function onerror(err) { if (!err || error) return error = err for (const s of all) { s.destroy(err) } } } function echo(s) { return s } function isStream(stream) { return !!stream._readableState || !!stream._writableState } function isStreamx(stream) { return typeof stream._duplexState === 'number' && isStream(stream) } function isEnding(stream) { return !!stream._readableState && stream._readableState.ending } function isEnded(stream) { return !!stream._readableState && stream._readableState.ended } function isFinishing(stream) { return !!stream._writableState && stream._writableState.ending } function isFinished(stream) { return !!stream._writableState && stream._writableState.ended } function getStreamError(stream, opts = {}) { const err = (stream._readableState && stream._readableState.error) || (stream._writableState && stream._writableState.error) // avoid implicit errors by default return !opts.all && StreamError.isStreamDestroyed(err) ? null : err } function isReadStreamx(stream) { return isStreamx(stream) && stream.readable } function isDisturbed(stream) { return ( (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0 ) } function isTypedArray(data) { return typeof data === 'object' && data !== null && typeof data.byteLength === 'number' } function defaultByteLength(data) { return isTypedArray(data) ? data.byteLength : 1024 } function noop() {} function abort() { this.destroy(StreamError.ABORTED()) } function isWritev(s) { return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev } module.exports = { pipeline, pipelinePromise, isStream, isStreamx, isEnding, isEnded, isFinishing, isFinished, isDisturbed, getStreamError, Stream, Writable, Readable, Duplex, Transform, // Export PassThrough for compatibility with Node.js core's stream module PassThrough } module.exports = class StreamError extends Error { constructor(msg, code, fn = StreamError) { super(msg) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } static isStreamDestroyed(err) { return err && err.code === 'STREAM_DESTROYED' } static isPrematureClose(err) { return err && err.code === 'PREMATURE_CLOSE' } static isAborted(err) { return err && err.code === 'ABORTED' } static isBadArgument(err) { return err && err.code === 'BAD_ARGUMENT' } get name() { return 'StreamError' } static STREAM_DESTROYED() { return new StreamError('Stream was destroyed', 'STREAM_DESTROYED', StreamError.STREAM_DESTROYED) } static PREMATURE_CLOSE(msg = 'Premature close') { return new StreamError(msg, 'PREMATURE_CLOSE', StreamError.PREMATURE_CLOSE) } static ABORTED() { return new StreamError('Stream aborted', 'ABORTED', StreamError.ABORTED) } static BAD_ARGUMENT(msg = 'Bad argument') { return new StreamError(msg, 'BAD_ARGUMENT', StreamError.BAD_ARGUMENT) } } { "name": "streamx", "version": "2.28.1", "description": "An iteration of the Node.js core streams with a series of improvements", "main": "index.js", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors" } }, "dependencies": { "events-universal": "^1.0.0", "fast-fifo": "^1.3.2", "text-decoder": "^1.1.0" }, "devDependencies": { "b4a": "^1.6.6", "brittle": "^3.1.1", "end-of-stream": "^1.4.4", "lunte": "^1.8.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "files": [ "index.js", "index.d.ts", "runtime.d.ts", "lib" ], "scripts": { "format": "prettier . --write", "test": "brittle test/all.js && brittle-bare test/all.js", "lint": "prettier . --check && lunte" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/streamx.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/streamx/issues" }, "homepage": "https://github.com/mafintosh/streamx" } const { Readable } = require('streamx') module.exports = function (s, forks = 2) { const streams = new Array(forks) const status = new Array(forks).fill(true) let ended = false for (let i = 0; i < forks; i++) { streams[i] = new Readable({ read (cb) { const check = !status[i] status[i] = true if (check && allReadable()) s.resume() cb(null) } }) } s.on('end', function () { ended = true for (const stream of streams) stream.push(null) }) s.on('error', function (err) { for (const stream of streams) stream.destroy(err) }) s.on('close', function () { if (ended) return for (const stream of streams) stream.destroy() }) s.on('data', function (data) { let needsPause = false for (let i = 0; i < streams.length; i++) { if (!(status[i] = streams[i].push(data))) { needsPause = true } } if (needsPause) s.pause() }) return streams function allReadable () { for (let j = 0; j < status.length; j++) { if (!status[j]) return false } return true } } { "name": "teex", "version": "1.0.1", "description": "Turn a readable stream into multiple readable streamx streams", "main": "index.js", "dependencies": { "streamx": "^2.12.5" }, "devDependencies": { "standard": "^14.3.4", "tape": "^5.0.1" }, "scripts": { "test": "standard && tape test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/teex.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/teex/issues" }, "homepage": "https://github.com/mafintosh/teex" } const PassThroughDecoder = require('./lib/pass-through-decoder') const UTF8Decoder = require('./lib/utf8-decoder') module.exports = class TextDecoder { constructor(encoding = 'utf8') { this.encoding = normalizeEncoding(encoding) switch (this.encoding) { case 'utf8': this.decoder = new UTF8Decoder() break case 'utf16le': case 'base64': throw new Error('Unsupported encoding: ' + this.encoding) default: this.decoder = new PassThroughDecoder(this.encoding) } } get remaining() { return this.decoder.remaining } push(data) { if (typeof data === 'string') return data return this.decoder.decode(data) } // For Node.js compatibility write(data) { return this.push(data) } end(data) { let result = '' if (data) result = this.push(data) result += this.decoder.flush() return result } } function normalizeEncoding(encoding) { encoding = encoding.toLowerCase() switch (encoding) { case 'utf8': case 'utf-8': return 'utf8' case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return 'utf16le' case 'latin1': case 'binary': return 'latin1' case 'base64': case 'ascii': case 'hex': return encoding default: throw new Error('Unknown encoding: ' + encoding) } } const b4a = require('b4a') module.exports = class PassThroughDecoder { constructor(encoding) { this.encoding = encoding } get remaining() { return 0 } decode(data) { return b4a.toString(data, this.encoding) } flush() { return '' } } const b4a = require('b4a') /** * https://encoding.spec.whatwg.org/#utf-8-decoder */ module.exports = class UTF8Decoder { constructor() { this._reset() } get remaining() { return this.bytesSeen } decode(data) { if (data.byteLength === 0) return '' if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) { this.bytesSeen = trailingBytesSeen(data) return b4a.toString(data, 'utf8') } let result = '' let start = 0 if (this.bytesNeeded > 0) { while (start < data.byteLength) { const byte = data[start] if (byte < this.lowerBoundary || byte > this.upperBoundary) { result += '\ufffd' this._reset() break } this.lowerBoundary = 0x80 this.upperBoundary = 0xbf this.codePoint = (this.codePoint << 6) | (byte & 0x3f) this.bytesSeen++ start++ if (this.bytesSeen === this.bytesNeeded) { result += String.fromCodePoint(this.codePoint) this._reset() break } } if (this.bytesNeeded > 0) return result } const trailing = trailingIncomplete(data, start) const end = data.byteLength - trailing if (end > start) result += b4a.toString(data, 'utf8', start, end) for (let i = end; i < data.byteLength; i++) { const byte = data[i] if (this.bytesNeeded === 0) { if (byte <= 0x7f) { this.bytesSeen = 0 result += String.fromCharCode(byte) } else if (byte >= 0xc2 && byte <= 0xdf) { this.bytesNeeded = 2 this.bytesSeen = 1 this.codePoint = byte & 0x1f } else if (byte >= 0xe0 && byte <= 0xef) { if (byte === 0xe0) this.lowerBoundary = 0xa0 else if (byte === 0xed) this.upperBoundary = 0x9f this.bytesNeeded = 3 this.bytesSeen = 1 this.codePoint = byte & 0xf } else if (byte >= 0xf0 && byte <= 0xf4) { if (byte === 0xf0) this.lowerBoundary = 0x90 else if (byte === 0xf4) this.upperBoundary = 0x8f this.bytesNeeded = 4 this.bytesSeen = 1 this.codePoint = byte & 0x7 } else { this.bytesSeen = 1 result += '\ufffd' } continue } if (byte < this.lowerBoundary || byte > this.upperBoundary) { result += '\ufffd' i-- this._reset() continue } this.lowerBoundary = 0x80 this.upperBoundary = 0xbf this.codePoint = (this.codePoint << 6) | (byte & 0x3f) this.bytesSeen++ if (this.bytesSeen === this.bytesNeeded) { result += String.fromCodePoint(this.codePoint) this._reset() } } return result } flush() { const result = this.bytesNeeded > 0 ? '\ufffd' : '' this._reset() return result } _reset() { this.codePoint = 0 this.bytesNeeded = 0 this.bytesSeen = 0 this.lowerBoundary = 0x80 this.upperBoundary = 0xbf } } function trailingIncomplete(data, start) { const len = data.byteLength if (len <= start) return 0 const limit = Math.max(start, len - 4) let i = len - 1 while (i > limit && (data[i] & 0xc0) === 0x80) i-- if (i < start) return 0 const byte = data[i] let needed if (byte <= 0x7f) return 0 if (byte >= 0xc2 && byte <= 0xdf) needed = 2 else if (byte >= 0xe0 && byte <= 0xef) needed = 3 else if (byte >= 0xf0 && byte <= 0xf4) needed = 4 else return 0 const available = len - i return available < needed ? available : 0 } function trailingBytesSeen(data) { const len = data.byteLength if (len === 0) return 0 const last = data[len - 1] if (last <= 0x7f) return 0 if ((last & 0xc0) !== 0x80) return 1 const limit = Math.max(0, len - 4) let i = len - 2 while (i >= limit && (data[i] & 0xc0) === 0x80) i-- if (i < 0) return 1 const first = data[i] let needed if (first >= 0xc2 && first <= 0xdf) needed = 2 else if (first >= 0xe0 && first <= 0xef) needed = 3 else if (first >= 0xf0 && first <= 0xf4) needed = 4 else return 1 if (len - i !== needed) return 1 if (needed >= 3) { const second = data[i + 1] if (first === 0xe0 && second < 0xa0) return 1 if (first === 0xed && second > 0x9f) return 1 if (first === 0xf0 && second < 0x90) return 1 if (first === 0xf4 && second > 0x8f) return 1 } return 0 } { "name": "text-decoder", "version": "1.2.7", "description": "Streaming text decoder that preserves multibyte Unicode characters", "exports": { "./package": "./package.json", ".": "./index.js" }, "files": [ "index.js", "lib" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/text-decoder.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/text-decoder/issues" }, "homepage": "https://github.com/holepunchto/text-decoder#readme", "dependencies": { "b4a": "^1.6.4" }, "devDependencies": { "brittle": "^3.3.2", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" } } { "name": "favela-surface", "version": "0.0.59", "description": "The favela renderer \u2014 server-side HTML over the daemon's socket. No storage, no keys, no swarm.", "type": "module", "main": "index.js", "bin": { "favela-surface": "index.js" }, "scripts": { "test": "brittle-bare test/*.test.js" }, "imports": { "#node:net": { "bare": "bare-net", "default": "net" }, "#node:os": { "bare": "bare-os", "default": "os" }, "#node:path": { "bare": "bare-path", "default": "path" }, "#node:process": { "bare": "bare-process", "default": "process" }, "#node:fs": { "bare": "bare-fs", "default": "fs" } }, "dependencies": { "favela-markdown": "file:../favela-markdown", "bare-http1": "^4.0.7", "bare-net": "^2.3.3", "bare-os": "^3.9.3", "bare-path": "^3.1.2", "bare-process": "^4.5.1", "bare-fs": "^4.8.1", "bare-crypto": "^1.11.1" }, "devDependencies": { "brittle": "^4.0.2" }, "pgh": { "bin": "favela-surface", "entrypoint": "index.js", "type": "daemon", "runtime": "bare", "upgrade": "pgh://1dd36bdfa9cb7f7d84adbd07f017e7200f7f90a3a546cd0761fac2a1f8a13e86/favela-surface", "autostart": false, "depends": [ "pgh-sidecar" ], "defaults": { "env": { "FAVELA_SURFACE_PORT": "4042", "FAVELA_SOCK": "${HOME}/.config/favela-peer/favela.sock" } }, "service": { "requiresNetwork": false } } } /** * Tree — content-addressable directory hashing for hyper-overlay * * A tree is a canonical serialization of a directory's immediate entries. * Each entry is one of: file, subdirectory, symlink. The tree's identity * is blake2b-256 of its canonical bytes. * * Format (P.10 Phase 0.5a): * * tree := "pgh-tree-1\n" || * varint(n_entries) || * entry[0] || ... || entry[n-1] * * entry := u8(kind) || // 0=file, 1=dir, 2=symlink * u8(exec) || // 0 or 1; always 0 for dir/symlink * varint(name_len) || name || // UTF-8 NFC, no NUL, no "/" * 32_bytes(child_hash) * * tree_hash := blake2b-256(tree_bytes) * * Identity fields (in the hash): kind, exec-bit, name, child_hash. * Explicitly excluded: mtime, size, uid/gid, full mode. * * Entries MUST be sorted byte-wise by name (after NFC normalization). * Encoders emit sorted; decoders reject unsorted trees. * * Symlinks: child_hash = blake2b-256 of the target path bytes (not followed). * Empty directories: zero-entry tree, valid, deterministic. */ import fs from '#fs' import path from '#path' import crypto from 'hypercore-crypto' import c from 'compact-encoding' // ── Constants ───────────────────────────────────────────────── export const MAGIC = Buffer.from('pgh-tree-1\n', 'utf8') export const KIND_FILE = 0 export const KIND_DIR = 1 export const KIND_SYMLINK = 2 // Windows reserved device names (case-insensitive, with or without extension) const WINDOWS_RESERVED = new Set([ 'CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9' ]) // Chars forbidden in filenames on Windows (beyond format-layer rules) // eslint-disable-next-line no-control-regex const WINDOWS_FORBIDDEN = /[\\:*?"<>|\x00-\x1f]/ // Default skip list for walkTree — minimal, just obvious platform cruft. // Consumers that want more (e.g. .git for pgh publish) pass their own. export const DEFAULT_SKIP = new Set(['.DS_Store', 'Thumbs.db']) // ── Name validation (format layer) ──────────────────────────── /** * Normalize a filename for hashing and validate format-layer rules. * Throws on unrepresentable names. Returns the canonical form. * * @param {string} name - single path component (no "/") * @returns {string} NFC-normalized name */ export function normalizeName (name) { if (typeof name !== 'string') { throw new Error('tree entry name must be string, got ' + typeof name) } if (name.length === 0) { throw new Error('tree entry name cannot be empty') } if (name === '.' || name === '..') { throw new Error('tree entry name cannot be "." or ".."') } if (name.indexOf('/') !== -1) { throw new Error('tree entry name cannot contain "/": ' + JSON.stringify(name)) } if (name.indexOf('\x00') !== -1) { throw new Error('tree entry name cannot contain NUL: ' + JSON.stringify(name)) } const normalized = name.normalize('NFC') // Verify the normalized form is valid UTF-8 that round-trips through // Buffer (catches lone surrogates and other malformed sequences). const asBytes = Buffer.from(normalized, 'utf8') if (asBytes.toString('utf8') !== normalized) { throw new Error('tree entry name is not valid UTF-8: ' + JSON.stringify(name)) } return normalized } // ── Consumer-policy layer ───────────────────────────────────── /** * Check a name against Windows compatibility rules. * Does NOT throw — returns a reason string (or null if the name is OK). * Used by pgh publish for strict cross-platform validation. * * @param {string} name * @returns {string|null} reason if incompatible, null if OK */ export function windowsIncompatibleReason (name) { if (WINDOWS_FORBIDDEN.test(name)) { return 'contains Windows-forbidden character (\\:*?"<>| or control code)' } const trimmed = name.replace(/\.+$/, '').replace(/ +$/, '') if (trimmed !== name) { return 'trailing "." or space (Windows strips these silently)' } // Reserved device names apply with any extension: AUX.log, PRN.txt etc. const base = name.split('.')[0].toUpperCase() if (WINDOWS_RESERVED.has(base)) { return `"${base}" is a reserved Windows device name (even with extension)` } return null } // ── Canonical encoding ──────────────────────────────────────── /** * Encode a single entry to its canonical byte representation. * * @param {object} state - compact-encoding state * @param {{kind: number, exec: number, name: string, childHash: Buffer|string}} e */ function encodeEntry (state, e) { if (e.kind !== KIND_FILE && e.kind !== KIND_DIR && e.kind !== KIND_SYMLINK) { throw new Error('invalid entry kind: ' + e.kind) } if (e.exec !== 0 && e.exec !== 1) { throw new Error('entry exec must be 0 or 1') } if (e.kind !== KIND_FILE && e.exec !== 0) { throw new Error('non-file entry must have exec=0') } const hash = toBuffer32(e.childHash) c.uint8.encode(state, e.kind) c.uint8.encode(state, e.exec) c.string.encode(state, e.name) // compact-encoding: varint len + utf8 bytes state.buffer.set(hash, state.start) state.start += 32 } function preencodeEntry (state, e) { c.uint8.preencode(state, e.kind) c.uint8.preencode(state, e.exec) c.string.preencode(state, e.name) state.end += 32 } /** * Serialize a list of entries to canonical tree bytes. * Entries are sorted + normalized as a side-effect of the call. * * @param {Array<{kind: number, exec: number, name: string, childHash: Buffer|string}>} entries * @returns {Buffer} */ export function encodeTree (entries) { const normalized = entries.map(e => ({ kind: e.kind, exec: e.exec || 0, name: normalizeName(e.name), childHash: e.childHash })) normalized.sort(compareEntries) // Sanity: no duplicate names after normalization for (let i = 1; i < normalized.length; i++) { if (normalized[i].name === normalized[i - 1].name) { throw new Error('duplicate entry name after NFC normalization: ' + normalized[i].name) } } const state = { start: 0, end: 0, buffer: null } state.end += MAGIC.length c.uint.preencode(state, normalized.length) for (const e of normalized) preencodeEntry(state, e) state.buffer = Buffer.alloc(state.end) state.buffer.set(MAGIC, state.start) state.start += MAGIC.length c.uint.encode(state, normalized.length) for (const e of normalized) encodeEntry(state, e) return state.buffer } /** * Byte-wise comparator for entry names (after NFC normalization). */ function compareEntries (a, b) { const ab = Buffer.from(a.name, 'utf8') const bb = Buffer.from(b.name, 'utf8') return Buffer.compare(ab, bb) } /** * Decode canonical tree bytes back to an entries list. * Rejects unsorted or malformed trees. * * @param {Buffer} buf * @returns {Array<{kind: number, exec: number, name: string, childHash: string}>} */ export function decodeTree (buf) { if (!Buffer.isBuffer(buf)) throw new Error('decodeTree expects a Buffer') if (buf.length < MAGIC.length) throw new Error('tree too short') if (buf.compare(MAGIC, 0, MAGIC.length, 0, MAGIC.length) !== 0) { throw new Error('tree magic mismatch (expected "pgh-tree-1")') } const state = { start: MAGIC.length, end: buf.length, buffer: buf } const count = c.uint.decode(state) const entries = [] let prevName = null for (let i = 0; i < count; i++) { const kind = c.uint8.decode(state) const exec = c.uint8.decode(state) const name = c.string.decode(state) if (state.start + 32 > state.end) throw new Error('truncated tree: missing hash bytes') const childHash = buf.subarray(state.start, state.start + 32).toString('hex') state.start += 32 // Validate format rules on read — reject invalid trees rather than silently accept const normalized = normalizeName(name) if (normalized !== name) { throw new Error('tree entry name not NFC-normalized: ' + JSON.stringify(name)) } if (kind !== KIND_FILE && exec !== 0) { throw new Error('non-file entry with exec=1 is invalid') } if (prevName !== null) { const cmp = Buffer.compare(Buffer.from(prevName, 'utf8'), Buffer.from(name, 'utf8')) if (cmp === 0) throw new Error('tree has duplicate entry: ' + name) if (cmp > 0) throw new Error('tree entries not sorted: ' + prevName + ' before ' + name) } prevName = name entries.push({ kind, exec, name, childHash }) } if (state.start !== state.end) throw new Error('tree has trailing bytes after entries') return entries } /** * Compute the tree hash of an entries list. * * @param {Array<{kind: number, exec: number, name: string, childHash: Buffer|string}>} entries * @returns {string} hex-encoded blake2b-256 */ export function computeTreeHash (entries) { const buf = encodeTree(entries) return crypto.data(buf).toString('hex') } // ── Helpers ─────────────────────────────────────────────────── function toBuffer32 (hashOrBuf) { if (Buffer.isBuffer(hashOrBuf)) { if (hashOrBuf.length !== 32) throw new Error('childHash buffer must be 32 bytes') return hashOrBuf } if (typeof hashOrBuf !== 'string') { throw new Error('childHash must be Buffer or hex string') } if (hashOrBuf.length !== 64) throw new Error('childHash hex string must be 64 chars') return Buffer.from(hashOrBuf, 'hex') } // ── Filesystem walk ─────────────────────────────────────────── /** * Walk a directory recursively, producing tree hashes bottom-up. * * Returns a nested object keyed by path, where each entry has: * { hash: hex, entries: [{kind, exec, name, childHash, size?}] } * * File entries carry their content hash as childHash (blake2b of bytes). * Dir entries carry the subtree hash. * Symlink entries carry blake2b of the link target bytes. * * @param {string} rootDir - absolute path to scan * @param {object} [opts] * @param {Set} [opts.skip] - basenames to skip (default: DEFAULT_SKIP) * @param {(relPath: string, baseName: string) => boolean} [opts.matcher] * Optional gitignore-style matcher. Returns true to EXCLUDE an entry. * Receives the path relative to rootDir plus the basename. Applies to * all kinds (file/dir/symlink). Used by `pgh publish` for publishIgnore. * @returns {Map} * map keyed by relative path ('' = root); root tree is at key '' */ export function walkTree (rootDir, opts = {}) { const skip = opts.skip || DEFAULT_SKIP const matcher = opts.matcher || null const trees = new Map() function visit (relPath) { const absPath = relPath === '' ? rootDir : path.join(rootDir, relPath) const raw = fs.readdirSync(absPath) const entries = [] let totalSize = 0 for (const name of raw) { if (skip.has(name)) continue const entryAbs = path.join(absPath, name) const entryRel = relPath === '' ? name : relPath + '/' + name if (matcher && matcher(entryRel, name)) continue let stat try { stat = fs.lstatSync(entryAbs) } catch { continue } if (stat.isSymbolicLink()) { const target = fs.readlinkSync(entryAbs) const targetBytes = Buffer.from(target, 'utf8') const childHash = crypto.data(targetBytes).toString('hex') entries.push({ kind: KIND_SYMLINK, exec: 0, name: normalizeName(name), childHash, size: targetBytes.length, linkTarget: target }) totalSize += targetBytes.length } else if (stat.isDirectory()) { visit(entryRel) const sub = trees.get(entryRel) if (!sub) continue entries.push({ kind: KIND_DIR, exec: 0, name: normalizeName(name), childHash: sub.hash, size: sub.size }) totalSize += sub.size } else if (stat.isFile()) { const content = fs.readFileSync(entryAbs) const childHash = crypto.data(content).toString('hex') // Executable bit from stat.mode — works on POSIX; Windows always 0 const exec = (stat.mode & 0o100) ? 1 : 0 entries.push({ kind: KIND_FILE, exec, name: normalizeName(name), childHash, size: stat.size }) totalSize += stat.size } // device files, sockets, fifos: silently skipped (unrepresentable) } entries.sort(compareEntries) const hash = computeTreeHash(entries) trees.set(relPath, { hash, entries, size: totalSize }) } visit('') return trees } // ── Publish-time validation (consumer policy) ───────────────── /** * Scan entries (recursively via walkTree output) for cross-platform-hostile * names. Returns an array of {path, name, reason} for every problem found. * Does NOT throw — caller decides how to present. * * @param {Map} trees - from walkTree * @returns {Array<{path: string, name: string, reason: string}>} */ export function validateForPublish (trees) { const problems = [] for (const [relPath, tree] of trees) { for (const e of tree.entries) { const reason = windowsIncompatibleReason(e.name) if (reason) { problems.push({ path: relPath ? relPath + '/' + e.name : e.name, name: e.name, reason }) } } } return problems } function isBuffer(value) { return Buffer.isBuffer(value) || value instanceof Uint8Array } function isEncoding(encoding) { return Buffer.isEncoding(encoding) } function alloc(size, fill, encoding) { return Buffer.alloc(size, fill, encoding) } function allocUnsafe(size) { return Buffer.allocUnsafe(size) } function allocUnsafeSlow(size) { return Buffer.allocUnsafeSlow(size) } function byteLength(string, encoding) { return Buffer.byteLength(string, encoding) } function compare(a, b) { return Buffer.compare(a, b) } function concat(buffers, totalLength) { return Buffer.concat(buffers, totalLength) } function copy(source, target, targetStart, start, end) { return toBuffer(source).copy(target, targetStart, start, end) } function equals(a, b) { return toBuffer(a).equals(b) } function fill(buffer, value, offset, end, encoding) { return toBuffer(buffer).fill(value, offset, end, encoding) } function from(value, encodingOrOffset, length) { return Buffer.from(value, encodingOrOffset, length) } function includes(buffer, value, byteOffset, encoding) { return toBuffer(buffer).includes(value, byteOffset, encoding) } function indexOf(buffer, value, byfeOffset, encoding) { return toBuffer(buffer).indexOf(value, byfeOffset, encoding) } function lastIndexOf(buffer, value, byteOffset, encoding) { return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding) } function swap16(buffer) { return toBuffer(buffer).swap16() } function swap32(buffer) { return toBuffer(buffer).swap32() } function swap64(buffer) { return toBuffer(buffer).swap64() } function toBuffer(buffer) { if (Buffer.isBuffer(buffer)) return buffer return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength) } function toString(buffer, encoding, start, end) { return toBuffer(buffer).toString(encoding, start, end) } function write(buffer, string, offset, length, encoding) { return toBuffer(buffer).write(string, offset, length, encoding) } function readDoubleBE(buffer, offset) { return toBuffer(buffer).readDoubleBE(offset) } function readDoubleLE(buffer, offset) { return toBuffer(buffer).readDoubleLE(offset) } function readFloatBE(buffer, offset) { return toBuffer(buffer).readFloatBE(offset) } function readFloatLE(buffer, offset) { return toBuffer(buffer).readFloatLE(offset) } function readInt32BE(buffer, offset) { return toBuffer(buffer).readInt32BE(offset) } function readInt32LE(buffer, offset) { return toBuffer(buffer).readInt32LE(offset) } function readUInt32BE(buffer, offset) { return toBuffer(buffer).readUInt32BE(offset) } function readUInt32LE(buffer, offset) { return toBuffer(buffer).readUInt32LE(offset) } function writeDoubleBE(buffer, value, offset) { return toBuffer(buffer).writeDoubleBE(value, offset) } function writeDoubleLE(buffer, value, offset) { return toBuffer(buffer).writeDoubleLE(value, offset) } function writeFloatBE(buffer, value, offset) { return toBuffer(buffer).writeFloatBE(value, offset) } function writeFloatLE(buffer, value, offset) { return toBuffer(buffer).writeFloatLE(value, offset) } function writeInt32BE(buffer, value, offset) { return toBuffer(buffer).writeInt32BE(value, offset) } function writeInt32LE(buffer, value, offset) { return toBuffer(buffer).writeInt32LE(value, offset) } function writeUInt32BE(buffer, value, offset) { return toBuffer(buffer).writeUInt32BE(value, offset) } function writeUInt32LE(buffer, value, offset) { return toBuffer(buffer).writeUInt32LE(value, offset) } module.exports = { isBuffer, isEncoding, alloc, allocUnsafe, allocUnsafeSlow, byteLength, compare, concat, copy, equals, fill, from, includes, indexOf, lastIndexOf, swap16, swap32, swap64, toBuffer, toString, write, readDoubleBE, readDoubleLE, readFloatBE, readFloatLE, readInt32BE, readInt32LE, readUInt32BE, readUInt32LE, writeDoubleBE, writeDoubleLE, writeFloatBE, writeFloatLE, writeInt32BE, writeInt32LE, writeUInt32BE, writeUInt32LE } { "name": "b4a", "version": "1.8.1", "description": "Bridging the gap between buffers and typed arrays", "exports": { "./package": "./package.json", ".": { "react-native": "./react-native.js", "browser": "./browser.js", "default": "./index.js" } }, "files": [ "browser.js", "index.js", "react-native.js", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.mjs", "test:node": "brittle-node --coverage test.mjs" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/b4a.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/b4a/issues" }, "homepage": "https://github.com/holepunchto/b4a#readme", "devDependencies": { "brittle": "^3.5.2", "lunte": "^1.7.0", "nanobench": "^3.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "react-native-b4a": "*" }, "peerDependenciesMeta": { "react-native-b4a": { "optional": true } } } const ESC = '\x1b' const CSI = ESC + '[' const SGR = (n) => CSI + n + 'm' exports.constants = { ESC, CSI, SGR } // https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_(Control_Sequence_Introducer)_sequences exports.cursorHide = CSI + '?25l' exports.cursorShow = CSI + '?25h' exports.cursorUp = function cursorUp(n = 1) { return CSI + n + 'A' } exports.cursorDown = function cursorDown(n = 1) { return CSI + n + 'B' } exports.cursorForward = function cursorForward(n = 1) { return CSI + n + 'C' } exports.cursorBack = function cursorBack(n = 1) { return CSI + n + 'D' } exports.cursorNextLine = function cursorNextLine(n = 1) { return CSI + n + 'E' } exports.cursorPreviousLine = function cursorPreviousLine(n = 1) { return CSI + n + 'F' } exports.cursorPosition = function cursorPosition(column, row = 0) { if (row === 0) return CSI + (column + 1) + 'G' return CSI + (row + 1) + ';' + (column + 1) + 'H' } exports.eraseDisplayEnd = CSI + 'J' exports.eraseDisplayStart = CSI + '1J' exports.eraseDisplay = CSI + '2J' exports.eraseLineEnd = CSI + 'K' exports.eraseLineStart = CSI + '1K' exports.eraseLine = CSI + '2K' exports.scrollUp = function scrollUp(n = 1) { return CSI + n + 'S' } exports.scrollDown = function scrollDown(n = 1) { return CSI + n + 'T' } // https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters exports.modifierReset = SGR(0) exports.modifierBold = SGR(1) exports.modifierDim = SGR(2) exports.modifierItalic = SGR(3) exports.modifierUnderline = SGR(4) exports.modifierNormal = SGR(22) exports.modifierNotItalic = SGR(23) exports.modifierNotUnderline = SGR(24) // https://en.wikipedia.org/wiki/ANSI_escape_code#Colors exports.colorBlack = SGR(30) exports.colorRed = SGR(31) exports.colorGreen = SGR(32) exports.colorYellow = SGR(33) exports.colorBlue = SGR(34) exports.colorMagenta = SGR(35) exports.colorCyan = SGR(36) exports.colorWhite = SGR(37) exports.colorDefault = SGR(39) exports.colorBrightBlack = SGR(90) exports.colorBrightRed = SGR(91) exports.colorBrightGreen = SGR(92) exports.colorBrightYellow = SGR(93) exports.colorBrightBlue = SGR(94) exports.colorBrightMagenta = SGR(95) exports.colorBrightCyan = SGR(96) exports.colorBrightWhite = SGR(97) { "name": "bare-ansi-escapes", "version": "2.2.3", "description": "Parse and produce ANSI escape sequences", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./key-decoder": { "types": "./key-decoder.d.ts", "default": "./key-decoder.js" } }, "files": [ "index.js", "index.d.ts", "key-decoder.js", "key-decoder.d.ts" ], "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-ansi-escapes.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-ansi-escapes/issues" }, "homepage": "https://github.com/holepunchto/bare-ansi-escapes#readme", "dependencies": { "bare-stream": "^2.6.5" }, "devDependencies": { "bare-buffer": "^3.0.2", "brittle": "^3.3.2", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" }, "peerDependencies": { "bare-buffer": "*" }, "peerDependenciesMeta": { "bare-buffer": { "optional": true } } } const inspect = require('bare-inspect') class AssertionError extends Error { constructor(opts = {}) { let { message = null, actual, expected, operator } = opts if (message === null) { message = `${inspect(actual)} ${operator} ${inspect(expected)}` } super(message) this.actual = actual this.expected = expected this.operator = operator } get name() { return 'AssertionError' } get code() { 'ASSERTION' } } function assertFail(opts, fn) { if (opts.message instanceof Error) throw opts.message const err = new AssertionError(opts) if (Error.captureStackTrace) Error.captureStackTrace(err, fn) throw err } module.exports = exports = function assert(actual, message) { if (actual) return assertFail({ message, actual, expected: true, operator: '==' }, assert) } exports.AssertionError = AssertionError exports.fail = function fail(message) { if (message === undefined) message = 'Failed' assertFail({ message, operator: 'fail' }, fail) } exports.ok = function ok(actual, message) { if (actual) return assertFail({ message, actual, expected: true, operator: '==' }, ok) } exports.notOk = function ok(actual, message) { if (!actual) return assertFail({ message, actual, expected: false, operator: '==' }, ok) } exports.equal = function equal(actual, expected, message) { if (actual == expected || (actual !== actual && expected !== expected)) { return } assertFail({ message, actual, expected, operator: '==' }, equal) } exports.notEqual = function notEqual(actual, expected, message) { if (actual != expected && (actual === actual || expected === expected)) { return } assertFail({ message, actual, expected, operator: '!=' }, notEqual) } exports.strictEqual = function strictEqual(actual, expected, message) { if (Object.is(actual, expected)) return assertFail( { message, actual, expected, operator: 'strictEqual' }, strictEqual ) } exports.notStrictEqual = function notStrictEqual(actual, expected, message) { if (!Object.is(actual, expected)) return assertFail( { message, actual, expected, operator: 'notStrictEqual' }, notStrictEqual ) } { "name": "bare-assert", "version": "1.2.0", "description": "Assertion library for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts" ], "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-assert.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-assert/issues" }, "homepage": "https://github.com/holepunchto/bare-assert#readme", "dependencies": { "bare-inspect": "^3.1.2" }, "devDependencies": { "brittle": "^3.1.1", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" } } const errors = require('./lib/errors') class EventListener { constructor() { this.list = [] this.count = 0 } append(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.push([fn, once]) } prepend(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.unshift([fn, once]) } remove(ctx, name, fn) { for (let i = 0, n = this.list.length; i < n; i++) { const l = this.list[i] if (l[0] === fn) { this.list.splice(i, 1) if (this.count === 1) delete ctx._events[name] ctx.emit('removeListener', name, fn) // Emit AFTER removing this.count-- return } } } removeAll(ctx, name) { const list = [...this.list] this.list = [] if (this.count === list.length) delete ctx._events[name] for (let i = list.length - 1; i >= 0; i--) { ctx.emit('removeListener', name, list[i][0]) // Emit AFTER removing } this.count -= list.length } emit(ctx, name, ...args) { const list = [...this.list] for (let i = 0, n = list.length; i < n; i++) { const l = list[i] if (l[1] === true) this.remove(ctx, name, l[0]) Reflect.apply(l[0], ctx, args) } return list.length > 0 } } function appendListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.append(ctx, name, fn, once) return ctx } function prependListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.prepend(ctx, name, fn, once) return ctx } function removeListener(ctx, name, fn) { if (ctx._events === undefined) return ctx const e = ctx._events[name] if (e !== undefined) e.remove(ctx, name, fn) return ctx } function throwUnhandledError(...args) { let err if (args.length > 0) err = args[0] if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err) if (Error.captureStackTrace) { Error.captureStackTrace(err, exports.prototype.emit) } queueMicrotask(() => { throw err }) } module.exports = exports = class EventEmitter { constructor() { this._events = Object.create(null) } addListener(name, fn) { return appendListener(this, name, fn, false) } addOnceListener(name, fn) { return appendListener(this, name, fn, true) } prependListener(name, fn) { return prependListener(this, name, fn, false) } prependOnceListener(name, fn) { return prependListener(this, name, fn, true) } removeListener(name, fn) { return removeListener(this, name, fn) } on(name, fn) { return appendListener(this, name, fn, false) } once(name, fn) { return appendListener(this, name, fn, true) } off(name, fn) { return removeListener(this, name, fn) } emit(name, ...args) { if (name === 'error' && this._events !== undefined && this._events.error === undefined) { throwUnhandledError(...args) } if (this._events === undefined) return false const e = this._events[name] return e === undefined ? false : e.emit(this, name, ...args) } listeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : [...e.list] } rawListeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : e.list.map((l) => l[0]) } eventNames() { if (this._events === undefined) return [] return Reflect.ownKeys(this._events) } listenerCount(name) { if (this._events === undefined) return 0 const e = this._events[name] return e === undefined ? 0 : e.list.length } getMaxListeners() { return EventEmitter.defaultMaxListeners } setMaxListeners(n) {} removeAllListeners(name) { if (arguments.length === 0) { for (const key of Reflect.ownKeys(this._events)) { if (key === 'removeListener') continue this.removeAllListeners(key) } this.removeAllListeners('removeListener') } else { const e = this._events[name] if (e !== undefined) e.removeAll(this, name) } return this } } exports.EventEmitter = exports exports.errors = errors exports.defaultMaxListeners = 10 exports.on = function on(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { throw errors.OPERATION_ABORTED(signal.reason) } let error = null let done = false const events = [] const promises = [] if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.on(name, onevent) return { next() { if (events.length) { return Promise.resolve({ value: events.shift(), done: false }) } if (error) { const err = error error = null return Promise.reject(err) } if (done) return onclose() return new Promise((resolve, reject) => promises.push({ resolve, reject })) }, return() { return onclose() }, throw(err) { return onerror(err) }, [Symbol.asyncIterator]() { return this } } function onevent(...args) { if (promises.length) { promises.shift().resolve({ value: args, done: false }) } else { events.push(args) } } function onerror(err) { emitter.off(name, onevent).off('error', onerror) if (promises.length) { promises.shift().reject(err) } else { error = err } return Promise.resolve({ done: true }) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } function onclose() { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) done = true if (promises.length) promises.shift().resolve({ done: true }) return Promise.resolve({ done: true }) } } exports.once = function once(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { return Promise.reject(errors.OPERATION_ABORTED(signal.reason)) } return new Promise((resolve, reject) => { if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.once(name, onevent) function onevent(...args) { if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) resolve(args) } function onerror(err) { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) reject(err) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } }) } exports.forward = function forward(from, to, names, opts = {}) { if (typeof names === 'string') names = [names] const { emit = to.emit.bind(to) } = opts const listeners = names.map( (name) => function onevent(...args) { emit(name, ...args) } ) to.on('newListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.on(name, listeners[i]) } }).on('removeListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.off(name, listeners[i]) } }) } exports.listenerCount = function listenerCount(emitter, name) { return emitter.listenerCount(name) } exports.getMaxListeners = function getMaxListeners(emitter) { if (typeof emitter.getMaxListeners === 'function') { return emitter.getMaxListeners() } return exports.defaultMaxListeners } exports.setMaxListeners = function setMaxListeners(n, ...emitters) { if (emitters.length === 0) exports.defaultMaxListeners = n else { for (const emitter of emitters) { if (typeof emitter.setMaxListeners === 'function') { emitter.setMaxListeners(n) } } } } module.exports = class EventEmitterError extends Error { constructor(msg, code, fn = EventEmitterError, opts) { super(`${code}: ${msg}`, opts) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'EventEmitterError' } static OPERATION_ABORTED(cause, msg = 'Operation aborted') { return new EventEmitterError(msg, 'OPERATION_ABORTED', EventEmitterError.OPERATION_ABORTED, { cause }) } static UNHANDLED_ERROR(cause, msg = 'Unhandled error') { return new EventEmitterError(msg, 'UNHANDLED_ERROR', EventEmitterError.UNHANDLED_ERROR, { cause }) } } { "name": "bare-events", "version": "2.9.1", "description": "Event emitters for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" }, "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./errors": "./lib/errors.js" }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "web.js", "web.d.ts", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.js", "test:node": "brittle-node --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-events.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-events/issues" }, "homepage": "https://github.com/holepunchto/bare-events#readme", "devDependencies": { "bare-abort-controller": "^1.0.0", "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0", "uncaughts": "^1.1.1" }, "peerDependencies": { "bare-abort-controller": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true } } } module.exports = require.addon() const FIFO = require('fast-fifo') const EventEmitter = require('bare-events') const path = require('bare-path') const { isURL, fileURLToPath } = require('bare-url') const { Readable, Writable } = require('bare-stream') const binding = require('./binding') const constants = require('./lib/constants') const FileError = require('./lib/errors') const isWindows = Bare.platform === 'win32' exports.constants = constants class FileRequest { static borrow() { if (this._free.length > 0) return this._free.pop() return new FileRequest() } static return(req) { if (this._free.length < 32) this._free.push(req.reset()) else req.destroy() } constructor() { this._reset() this._handle = binding.requestInit(this, this._onresult) } get handle() { return this._handle } retain(value) { this._retain = value // Tie the lifetime of `value` to the lifetime of `this` } reset() { if (this._handle === null) return this binding.requestReset(this._handle) this._reset() return this } destroy() { if (this._handle === null) return this binding.requestDestroy(this._handle) this._reset() this._handle = null return this } then(resolve, reject) { return this._promise.then(resolve, reject) } return() { if (this._handle === null) return this FileRequest.return(this) return this } _reset() { this._promise = new Promise((resolve, reject) => { this._resolve = resolve this._reject = reject }) this._retain = null } _onresult(err, status) { if (err) this._reject(err) else this._resolve(status) } } FileRequest._free = [] function ok(result, cb) { if (typeof result === 'function') { cb = result result = undefined } if (cb) cb(null, result) else return result } function fail(err, cb) { if (cb) cb(err) else throw err } function done(err, result, cb) { if (typeof result === 'function') { cb = result result = undefined } if (err) fail(err, cb) else return ok(result, cb) } async function open(filepath, flags = 'r', mode = 0o666, cb) { if (typeof flags === 'function') { cb = flags flags = 'r' mode = 0o666 } else if (typeof mode === 'function') { cb = mode mode = 0o666 } if (typeof flags === 'string') flags = toFlags(flags) if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let fd let err = null try { binding.open(req.handle, filepath, flags, mode) fd = await req } catch (e) { err = new FileError(e.message, { operation: 'open', code: e.code, path: filepath }) } finally { req.return() } return done(err, fd, cb) } function openSync(filepath, flags = 'r', mode = 0o666) { if (typeof flags === 'string') flags = toFlags(flags) if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { return binding.openSync(req.handle, filepath, flags, mode) } catch (e) { throw new FileError(e.message, { operation: 'open', code: e.code, path: filepath }) } finally { req.return() } } async function close(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.close(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'close', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function closeSync(fd) { const req = FileRequest.borrow() try { binding.closeSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'close', code: e.code, fd }) } finally { req.return() } } async function access(filepath, mode = constants.F_OK, cb) { if (typeof mode === 'function') { cb = mode mode = constants.F_OK } filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.access(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'access', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function accessSync(filepath, mode = constants.F_OK) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.accessSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'access', code: e.code, path: filepath }) } finally { req.return() } } async function exists(filepath, cb) { let ok = true try { await access(filepath) } catch { ok = false } return done(null, ok, cb) } function existsSync(filepath) { try { accessSync(filepath) } catch { return false } return true } async function read(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1, cb) { if (typeof offset === 'function') { cb = offset offset = 0 len = buffer.byteLength pos = -1 } else if (typeof len === 'function') { cb = len len = buffer.byteLength - offset pos = -1 } else if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.read(req.handle, fd, buffer, offset, len, pos) req.retain(buffer) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'read', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function readSync(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1) { const req = FileRequest.borrow() try { return binding.readSync(req.handle, fd, buffer, offset, len, pos) } catch (e) { throw new FileError(e.message, { operation: 'read', code: e.code, fd }) } finally { req.return() } } async function readv(fd, buffers, pos = -1, cb) { if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.readv(req.handle, fd, buffers, pos) req.retain(buffers) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'readv', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function readvSync(fd, buffers, pos = -1) { if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.readvSync(req.handle, fd, buffers, pos) } catch (e) { throw new FileError(e.message, { operation: 'readv', code: e.code, fd }) } finally { req.return() } } async function write(fd, data, offset, len, pos = -1, cb) { if (typeof data === 'string') { let encoding = len cb = pos pos = offset if (typeof pos === 'function') { cb = pos pos = -1 encoding = 'utf8' } else if (typeof encoding === 'function') { cb = encoding encoding = 'utf8' } if (typeof pos === 'string') { encoding = pos pos = -1 } data = Buffer.from(data, encoding) offset = 0 len = data.byteLength } else if (typeof offset === 'function') { cb = offset offset = 0 len = data.byteLength pos = -1 } else if (typeof len === 'function') { cb = len len = data.byteLength - offset pos = -1 } else if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof offset !== 'number') offset = 0 if (typeof len !== 'number') len = data.byteLength - offset if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.write(req.handle, fd, data, offset, len, pos) req.retain(data) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'write', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function writeSync(fd, data, offset, len, pos = -1) { if (typeof data === 'string') { let encoding = len pos = offset if (typeof pos === 'string') { encoding = pos pos = -1 } data = Buffer.from(data, encoding) offset = 0 len = data.byteLength } if (typeof offset !== 'number') offset = 0 if (typeof len !== 'number') len = data.byteLength - offset if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.writeSync(req.handle, fd, data, offset, len, pos) } catch (e) { throw new FileError(e.message, { operation: 'write', code: e.code, fd }) } finally { req.return() } } async function writev(fd, buffers, pos = -1, cb) { if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.writev(req.handle, fd, buffers, pos) req.retain(buffers) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'writev', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function writevSync(fd, buffers, pos = -1) { if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.writevSync(req.handle, fd, buffers, pos) } catch (e) { throw new FileError(e.message, { operation: 'writev', code: e.code, fd }) } finally { req.return() } } async function stat(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.stat(req.handle, filepath) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'stat', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function statSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.statSync(req.handle, filepath) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'stat', code: e.code, path: filepath }) } finally { req.return() } } async function lstat(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.lstat(req.handle, filepath) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'lstat', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function lstatSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lstatSync(req.handle, filepath) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'lstat', code: e.code, path: filepath }) } finally { req.return() } } async function fstat(fd, cb) { const req = FileRequest.borrow() let st let err = null try { binding.fstat(req.handle, fd) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'fstat', code: e.code, fd }) } finally { req.return() } return done(err, st, cb) } function fstatSync(fd) { const req = FileRequest.borrow() try { binding.fstatSync(req.handle, fd) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'fstat', code: e.code, fd }) } finally { req.return() } } async function statfs(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.statfs(req.handle, filepath) await req st = new StatFs(...binding.requestResultStatfs(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'statfs', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function statfsSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.statfsSync(req.handle, filepath) return new StatFs(...binding.requestResultStatfs(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'statfs', code: e.code, path: filepath }) } finally { req.return() } } async function ftruncate(fd, len = 0, cb) { if (typeof len === 'function') { cb = len len = 0 } if (typeof len !== 'number') len = 0 const req = FileRequest.borrow() let err = null try { binding.ftruncate(req.handle, fd, len) await req } catch (e) { err = new FileError(e.message, { operation: 'ftruncate', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function ftruncateSync(fd, len = 0) { if (typeof len !== 'number') len = 0 const req = FileRequest.borrow() try { binding.ftruncateSync(req.handle, fd, len) } catch (e) { throw new FileError(e.message, { operation: 'ftruncate', code: e.code, fd }) } finally { req.return() } } async function truncate(filepath, len, cb) { let fd = -1 let err try { fd = await open(filepath, 'r+') await ftruncate(fd, len) } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, cb) } function truncateSync(filepath, len) { let fd = -1 let err try { fd = openSync(filepath, 'r+') ftruncateSync(fd, len) } catch (e) { err = e } finally { if (fd !== -1) closeSync(fd) } } async function chmod(filepath, mode, cb) { if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.chmod(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'chmod', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function chmodSync(filepath, mode) { if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.chmodSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'chmod', code: e.code, path: filepath }) } finally { req.return() } } async function fchmod(fd, mode, cb) { if (typeof mode === 'string') mode = toMode(mode) const req = FileRequest.borrow() let err = null try { binding.fchmod(req.handle, fd, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'fchmod', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fchmodSync(fd, mode) { if (typeof mode === 'string') mode = toMode(mode) const req = FileRequest.borrow() try { binding.fchmodSync(req.handle, fd, mode) } catch (e) { throw new FileError(e.message, { operation: 'fchmod', code: e.code, fd }) } finally { req.return() } } async function chown(filepath, uid, gid, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.chown(req.handle, filepath, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'chown', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function chownSync(filepath, uid, gid) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.chownSync(req.handle, filepath, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'chownSync', code: e.code, path: filepath }) } finally { req.return() } } async function lchown(filepath, uid, gid, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.lchown(req.handle, filepath, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'lchown', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function lchownSync(filepath, uid, gid) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lchownSync(req.handle, filepath, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'lchownSync', code: e.code, path: filepath }) } finally { req.return() } } async function fchown(fd, uid, gid, cb) { const req = FileRequest.borrow() let err = null try { binding.fchown(req.handle, fd, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'fchown', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fchownSync(fd, uid, gid) { const req = FileRequest.borrow() try { binding.fchownSync(req.handle, fd, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'fchownSync', code: e.code, fd }) } finally { req.return() } } async function utimes(filepath, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.utimes(req.handle, filepath, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'utimes', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function utimesSync(filepath, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.utimesSync(req.handle, filepath, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'utimes', code: e.code, path: filepath }) } finally { req.return() } } async function lutimes(filepath, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.lutimes(req.handle, filepath, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'lutimes', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function lutimesSync(filepath, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lutimesSync(req.handle, filepath, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'lutimes', code: e.code, path: filepath }) } finally { req.return() } } async function futimes(fd, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 const req = FileRequest.borrow() let err = null try { binding.futimes(req.handle, fd, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'futimes', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function futimesSync(fd, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 const req = FileRequest.borrow() try { binding.futimesSync(req.handle, fd, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'futimesSync', code: e.code, fd }) } finally { req.return() } } async function link(src, dst, cb) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.link(req.handle, src, dst) await req } catch (e) { err = new FileError(e.message, { operation: 'link', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function linkSync(src, dst) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.linkSync(req.handle, src, dst) } catch (e) { throw new FileError(e.message, { operation: 'linkSync', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function mkdir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = { mode: 0o777 } } if (typeof opts === 'number') opts = { mode: opts } else if (!opts) opts = {} const mode = typeof opts.mode === 'number' ? opts.mode : 0o777 filepath = toNamespacedPath(filepath) if (opts.recursive) { let err = null try { try { await mkdir(filepath, { mode }) } catch (err) { if (err.code !== 'ENOENT') { if (!(await stat(filepath)).isDirectory()) throw err } else { while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1) const i = filepath.lastIndexOf(path.sep) if (i <= 0) throw err await mkdir(filepath.slice(0, i), { mode, recursive: true }) try { await mkdir(filepath, { mode }) } catch (err) { if (!(await stat(filepath)).isDirectory()) throw err } } } } catch (e) { err = e } return done(err, cb) } const req = FileRequest.borrow() let err = null try { binding.mkdir(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'mkdir', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function mkdirSync(filepath, opts) { if (typeof opts === 'number') opts = { mode: opts } else if (!opts) opts = {} const mode = typeof opts.mode === 'number' ? opts.mode : 0o777 filepath = toNamespacedPath(filepath) if (opts.recursive) { try { mkdirSync(filepath, { mode }) } catch (err) { if (err.code !== 'ENOENT') { if (!statSync(filepath).isDirectory()) throw err } else { while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1) const i = filepath.lastIndexOf(path.sep) if (i <= 0) throw err mkdirSync(filepath.slice(0, i), { mode, recursive: true }) try { mkdirSync(filepath, { mode }) } catch (err) { if (!statSync(filepath).isDirectory()) throw err } } } return } const req = FileRequest.borrow() try { binding.mkdirSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'mkdir', code: e.code, path: filepath }) } finally { req.return() } } async function mkdtemp(prefix, cb) { prefix = toNamespacedPath(prefix) const req = FileRequest.borrow() let res let err = null try { binding.mkdtemp(req.handle, prefix + 'XXXXXX') await req res = binding.requestResultPath(req.handle) } catch (e) { err = new FileError(e.message, { operation: 'mkdtemp', code: e.code, path: prefix }) } finally { req.return() } return done(err, res, cb) } function mkdtempSync(prefix) { prefix = toNamespacedPath(prefix) const req = FileRequest.borrow() try { binding.mkdtempSync(req.handle, prefix + 'XXXXXX') return binding.requestResultPath(req.handle) } catch (e) { throw new FileError(e.message, { operation: 'mkdtempSync', code: e.code, path: prefix }) } finally { req.return() } } async function rmdir(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.rmdir(req.handle, filepath) await req } catch (e) { err = new FileError(e.message, { operation: 'rmdir', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function rmdirSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.rmdirSync(req.handle, filepath) } catch (e) { throw new FileError(e.message, { operation: 'rmdir', code: e.code, path: filepath }) } finally { req.return() } } async function rm(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} filepath = toNamespacedPath(filepath) let err = null try { const st = await lstat(filepath) if (st.isDirectory()) { if (opts.recursive) { try { await rmdir(filepath) } catch (err) { if (err.code !== 'ENOTEMPTY') throw err const files = await readdir(filepath) for (const file of files) { await rm(filepath + path.sep + file, opts) } await rmdir(filepath) } } else { throw new FileError('is a directory', { operation: 'rm', code: 'EISDIR', path: filepath }) } } else { await unlink(filepath) } } catch (e) { if (e.code !== 'ENOENT' || !opts.force) err = e } return done(err, cb) } function rmSync(filepath, opts) { if (!opts) opts = {} filepath = toNamespacedPath(filepath) try { const st = lstatSync(filepath) if (st.isDirectory()) { if (opts.recursive) { try { rmdirSync(filepath) } catch (err) { if (err.code !== 'ENOTEMPTY') throw err const files = readdirSync(filepath) for (const file of files) { rmSync(filepath + path.sep + file, opts) } rmdirSync(filepath) } } else { throw new FileError('is a directory', { operation: 'rm', code: 'EISDIR', path: filepath }) } } else { unlinkSync(filepath) } } catch (err) { if (err.code !== 'ENOENT' || !opts.force) throw err } } async function unlink(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.unlink(req.handle, filepath) await req } catch (e) { err = new FileError(e.message, { operation: 'unlink', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function unlinkSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.unlinkSync(req.handle, filepath) } catch (e) { throw new FileError(e.message, { operation: 'unlink', code: e.code, path: filepath }) } finally { req.return() } } async function rename(src, dst, cb) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.rename(req.handle, src, dst) await req } catch (e) { err = new FileError(e.message, { operation: 'rename', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function renameSync(src, dst) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.renameSync(req.handle, src, dst) } catch (e) { throw new FileError(e.message, { operation: 'rename', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function copyFile(src, dst, mode = 0, cb) { if (typeof mode === 'function') { cb = mode mode = 0 } src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.copyfile(req.handle, src, dst, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'copyfile', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function copyFileSync(src, dst, mode = 0) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.copyfileSync(req.handle, src, dst, mode) } catch (e) { throw new FileError(e.message, { operation: 'copyfile', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function cp(src, dst, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} src = toNamespacedPath(src) dst = toNamespacedPath(dst) let err = null try { const st = await lstat(src) if (st.isDirectory()) { if (opts.recursive !== true) { throw new FileError('is a directory', { operation: 'cp', code: 'EISDIR', path: src }) } try { await lstat(dst) } catch (e) { if (e.code !== 'ENOENT') throw e await mkdir(dst, { mode: st.mode, recursive: true }) } const dir = await opendir(src) for await (const { name } of dir) { await cp(path.join(src, name), path.join(dst, name), opts) } } else if (st.isFile()) { await copyFile(src, dst) await chmod(dst, st.mode) } } catch (e) { err = e } return done(err, cb) } function cpSync(src, dst, opts = {}) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const st = lstatSync(src) if (st.isDirectory()) { if (opts.recursive !== true) { throw new FileError('is a directory', { operation: 'cp', code: 'EISDIR', path: src }) } try { lstatSync(dst) } catch (e) { if (e.code !== 'ENOENT') throw e mkdirSync(dst, { mode: st.mode, recursive: true }) } const dir = opendirSync(src) for (const { name } of dir) { cpSync(path.join(src, name), path.join(dst, name), opts) } } else if (st.isFile()) { copyFileSync(src, dst) chmodSync(dst, st.mode) } } async function realpath(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let res let err = null try { binding.realpath(req.handle, filepath) await req res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) } catch (e) { err = new FileError(e.message, { operation: 'realpath', code: e.code, path: filepath }) } finally { req.return() } return done(err, res, cb) } function realpathSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.realpathSync(req.handle, filepath) let res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) return res } catch (e) { throw new FileError(e.message, { operation: 'realpath', code: e.code, path: filepath }) } finally { req.return() } } async function readlink(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let res let err = null try { binding.readlink(req.handle, filepath) await req res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) } catch (e) { err = new FileError(e.message, { operation: 'readlink', code: e.code, path: filepath }) } finally { req.return() } return done(err, res, cb) } function readlinkSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.readlinkSync(req.handle, filepath) let res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) return res } catch (e) { throw new FileError(e.message, { operation: 'readlink', code: e.code, path: filepath }) } finally { req.return() } } async function fsync(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.fsync(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'fsync', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fsyncSync(fd) { const req = FileRequest.borrow() try { binding.fsyncSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'fsyncSync', code: e.code, fd }) } finally { req.return() } } async function fdatasync(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.fdatasync(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'fdatasync', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fdatasyncSync(fd) { const req = FileRequest.borrow() try { binding.fdatasyncSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'fdatasyncSync', code: e.code, fd }) } finally { req.return() } } function normalizeSymlinkTarget(target, type, filepath) { if (isWindows) { if (type === constants.UV_FS_SYMLINK_JUNCTION) target = path.resolve(filepath, '..', target) if (path.isAbsolute(target)) return path.toNamespacedPath(target) return target.replace(/\//g, path.sep) } return target } async function symlink(target, filepath, type, cb) { if (typeof type === 'function') { cb = type type = null } filepath = toNamespacedPath(filepath) if (typeof type === 'string') { switch (type) { case 'dir': type = constants.UV_FS_SYMLINK_DIR break case 'junction': type = constants.UV_FS_SYMLINK_JUNCTION break case 'file': default: type = 0 break } } else if (typeof type !== 'number') { if (isWindows) { target = path.resolve(filepath, '..', target) try { type = (await stat(target)).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION } catch { type = 0 } } else { type = 0 } } target = normalizeSymlinkTarget(target, type, filepath) const req = FileRequest.borrow() let err = null try { binding.symlink(req.handle, target, filepath, type) await req } catch (e) { err = new FileError(e.message, { operation: 'symlink', code: e.code, path: target, destination: filepath }) } finally { req.return() } return done(err, cb) } function symlinkSync(target, filepath, type) { filepath = toNamespacedPath(filepath) if (typeof type === 'string') { switch (type) { case 'dir': type = constants.UV_FS_SYMLINK_DIR break case 'junction': type = constants.UV_FS_SYMLINK_JUNCTION break case 'file': default: type = 0 break } } else if (typeof type !== 'number') { if (isWindows) { target = path.resolve(filepath, '..', target) try { type = statSync(target).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION } catch { type = 0 } } else { type = 0 } } target = normalizeSymlinkTarget(target, type, filepath) const req = FileRequest.borrow() try { binding.symlinkSync(req.handle, target, filepath, type) } catch (e) { throw new FileError(e.message, { operation: 'symlink', code: e.code, path: target, destination: filepath }) } finally { req.return() } } async function opendir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let dir let err = null try { binding.opendir(req.handle, filepath) await req dir = new Dir(filepath, binding.requestResultDir(req.handle), opts) } catch (e) { err = new FileError(e.message, { operation: 'opendir', code: e.code, path: filepath }) } finally { req.return() } return done(err, dir, cb) } function opendirSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.opendirSync(req.handle, filepath) return new Dir(filepath, binding.requestResultDir(req.handle), opts) } catch (e) { throw new FileError(e.message, { operation: 'opendir', code: e.code, path: filepath }) } finally { req.return() } } async function readdir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { withFileTypes = false, recursive = false } = opts filepath = toNamespacedPath(filepath) const queue = [filepath] let result = [] let err = null try { while (queue.length !== 0) { const dir = await opendir(queue.pop()) for await (const entry of dir) { const entryPath = path.join(entry.parentPath, entry.name) if (withFileTypes) { result.push(entry) } else { result.push(path.relative(filepath, entryPath)) } if (recursive && entry.isDirectory()) queue.push(entryPath) } } } catch (e) { result = [] err = e } return done(err, result, cb) } function readdirSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { withFileTypes = false, recursive = false } = opts filepath = toNamespacedPath(filepath) const queue = [filepath] const result = [] while (queue.length !== 0) { const dir = opendirSync(queue.pop(), opts) for (const entry of dir) { const entryPath = path.join(entry.parentPath, entry.name) if (withFileTypes) { result.push(entry) } else { result.push(path.relative(filepath, entryPath)) } if (recursive && entry.isDirectory()) queue.push(entryPath) } } return result } async function readFile(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'buffer' } = opts let fd = -1 let buffer = null let err = null try { fd = await open(filepath, opts.flag || 'r') const st = await fstat(fd) let len = 0 if (st.size === 0) { const buffers = [] while (true) { buffer = Buffer.allocUnsafe(8192) const r = await read(fd, buffer) len += r if (r === 0) break buffers.push(buffer.subarray(0, r)) } buffer = Buffer.concat(buffers) } else { buffer = Buffer.allocUnsafe(st.size) while (true) { const r = await read(fd, len ? buffer.subarray(len) : buffer) len += r if (r === 0 || len === buffer.byteLength) break } if (len !== buffer.byteLength) buffer = buffer.subarray(0, len) } if (encoding !== 'buffer') buffer = buffer.toString(encoding) } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, buffer, cb) } function readFileSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'buffer' } = opts let fd = -1 try { fd = openSync(filepath, opts.flag || 'r') const st = fstatSync(fd) let buffer let len = 0 if (st.size === 0) { const buffers = [] while (true) { buffer = Buffer.allocUnsafe(8192) const r = readSync(fd, buffer) len += r if (r === 0) break buffers.push(buffer.subarray(0, r)) } buffer = Buffer.concat(buffers) } else { buffer = Buffer.allocUnsafe(st.size) while (true) { const r = readSync(fd, len ? buffer.subarray(len) : buffer) len += r if (r === 0 || len === buffer.byteLength) break } if (len !== buffer.byteLength) buffer = buffer.subarray(0, len) } if (encoding !== 'buffer') buffer = buffer.toString(encoding) return buffer } finally { if (fd !== -1) closeSync(fd) } } async function writeFile(filepath, data, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (typeof data === 'string') data = Buffer.from(data, opts.encoding) let fd = -1 let len = 0 let err = null try { fd = await open(filepath, opts.flag || 'w', opts.mode || 0o666) while (true) { len += await write(fd, len ? data.subarray(len) : data) if (len === data.byteLength) break } } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, len, cb) } function writeFileSync(filepath, data, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (typeof data === 'string') data = Buffer.from(data, opts.encoding) let fd = -1 try { fd = openSync(filepath, opts.flag || 'w', opts.mode || 0o666) let len = 0 while (true) { len += writeSync(fd, len ? data.subarray(len) : data) if (len === data.byteLength) break } } finally { if (fd !== -1) closeSync(fd) } } function appendFile(filepath, data, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (!opts.flag) opts = { ...opts, flag: 'a' } return writeFile(filepath, data, opts, cb) } function appendFileSync(filepath, data, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (!opts.flag) opts = { ...opts, flag: 'a' } return writeFileSync(filepath, data, opts) } function watch(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) return new Watcher(filepath, opts, cb) } class Stats { constructor( dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs ) { this.dev = dev this.mode = mode this.nlink = nlink this.uid = uid this.gid = gid this.rdev = rdev this.blksize = blksize this.ino = ino this.size = size this.blocks = blocks this.atimeMs = atimeMs this.mtimeMs = mtimeMs this.ctimeMs = ctimeMs this.birthtimeMs = birthtimeMs this.atime = new Date(atimeMs) this.mtime = new Date(mtimeMs) this.ctime = new Date(ctimeMs) this.birthtime = new Date(birthtimeMs) } isDirectory() { return (this.mode & constants.S_IFMT) === constants.S_IFDIR } isFile() { return (this.mode & constants.S_IFMT) === constants.S_IFREG } isBlockDevice() { return (this.mode & constants.S_IFMT) === constants.S_IFBLK } isCharacterDevice() { return (this.mode & constants.S_IFMT) === constants.S_IFCHR } isFIFO() { return (this.mode & constants.S_IFMT) === constants.S_IFIFO } isSymbolicLink() { return (this.mode & constants.S_IFMT) === constants.S_IFLNK } isSocket() { return (this.mode & constants.S_IFMT) === constants.S_IFSOCK } } class StatFs { constructor(type, bsize, blocks, bfree, bavail, files, ffree) { this.type = type this.bsize = bsize this.blocks = blocks this.bfree = bfree this.bavail = bavail this.files = files this.ffree = ffree } } class Dir { constructor(path, handle, opts = {}) { const { encoding = 'utf8', bufferSize = 32 } = opts this.path = path this._encoding = encoding this._capacity = bufferSize this._buffer = new FIFO() this._ended = false this._handle = handle } async read(cb) { if (this._buffer.length) return ok(this._buffer.shift(), cb) if (this._ended) return ok(null, cb) const req = FileRequest.borrow() let entries let err = null try { req.retain(binding.readdir(req.handle, this._handle, this._capacity)) await req entries = binding.requestResultDirents(req.handle) } catch (e) { err = new FileError(e.message, { operation: 'readdir', code: e.code, path: this.path }) } finally { req.return() } if (err) return fail(err, cb) if (entries.length === 0) { this._ended = true return ok(null, cb) } for (const entry of entries) { let name = Buffer.from(entry.name) if (this._encoding !== 'buffer') name = name.toString(this._encoding) this._buffer.push(new Dirent(this.path, name, entry.type)) } return ok(this._buffer.shift(), cb) } readSync() { if (this._buffer.length) return this._buffer.shift() if (this._ended) return null const req = FileRequest.borrow() let entries try { req.retain(binding.readdirSync(req.handle, this._handle, this._capacity)) entries = binding.requestResultDirents(req.handle) } catch (e) { throw new FileError(e.message, { operation: 'readdir', code: e.code, path: this.path }) } finally { req.return() } if (entries.length === 0) { this._ended = true return null } for (const entry of entries) { let name = Buffer.from(entry.name) if (this._encoding !== 'buffer') name = name.toString(this._encoding) this._buffer.push(new Dirent(this.path, name, entry.type)) } return this._buffer.shift() } async close(cb) { const req = FileRequest.borrow() let err = null try { binding.closedir(req.handle, this._handle) await req } catch (e) { err = new FileError(e.message, { operation: 'closedir', code: e.code, path: this.path }) } finally { req.return() } this._handle = null return done(err, cb) } closeSync() { const req = FileRequest.borrow() try { binding.closedirSync(req.handle, this._handle) } catch (e) { throw new FileError(e.message, { operation: 'closedir', code: e.code, path: this.path }) } finally { req.return() } this._handle = null } [Symbol.dispose]() { this.closeSync() } async [Symbol.asyncDispose]() { await this.close() } *[Symbol.iterator]() { while (true) { const entry = this.readSync() if (entry === null) break yield entry } this.closeSync() } async *[Symbol.asyncIterator]() { while (true) { const entry = await this.read() if (entry === null) break yield entry } await this.close() } } class Dirent { constructor(parentPath, name, type) { this.parentPath = parentPath this.name = name this.type = type } isFile() { return this.type === constants.UV_DIRENT_FILE } isDirectory() { return this.type === constants.UV_DIRENT_DIR } isSymbolicLink() { return this.type === constants.UV_DIRENT_LINK } isFIFO() { return this.type === constants.UV_DIRENT_FIFO } isSocket() { return this.type === constants.UV_DIRENT_SOCKET } isCharacterDevice() { return this.type === constants.UV_DIRENT_CHAR } isBlockDevice() { return this.type === constants.UV_DIRENT_BLOCK } } class FileReadStream extends Readable { constructor(path, opts = {}) { const { eagerOpen = true } = opts super({ eagerOpen, ...opts }) this.path = path this.fd = typeof opts.fd === 'number' ? opts.fd : -1 this.flags = opts.flags || 'r' this.mode = opts.mode || 0o666 this._offset = opts.start || 0 this._missing = 0 if (opts.length) { this._missing = opts.length } else if (typeof opts.end === 'number') { this._missing = opts.end - this._offset + 1 } else { this._missing = -1 } } async _open(cb) { let err if (this.fd === -1) { err = null try { this.fd = await open(this.path, this.flags, this.mode) } catch (e) { err = e } if (err) return cb(err) } let st err = null try { st = await fstat(this.fd) } catch (e) { err = e } if (err) return cb(err) if (this._missing === -1) this._missing = st.size if (st.size < this._offset) { this._offset = st.size this._missing = 0 } else if (st.size < this._offset + this._missing) { this._missing = st.size - this._offset } cb(null) } async _read(size) { if (this._missing <= 0) return this.push(null) const data = Buffer.allocUnsafe(Math.min(this._missing, size)) let len let err = null try { len = await read(this.fd, data, 0, data.byteLength, this._offset) } catch (e) { err = e } if (err) return this.destroy(err) if (len === 0) return this.push(null) if (this._missing < len) len = this._missing this._missing -= len this._offset += len this.push(data.subarray(0, len)) } async _destroy(err, cb) { if (this.fd === -1) return cb(err) try { await close(this.fd) } catch (e) { err = err || e } cb(err) } } class FileWriteStream extends Writable { constructor(path, opts = {}) { const { eagerOpen = true } = opts super({ eagerOpen, ...opts }) this.path = path this.fd = typeof opts.fd === 'number' ? opts.fd : -1 this.flags = opts.flags || 'w' this.mode = opts.mode || 0o666 } async _open(cb) { if (this.fd !== -1) return cb(null) let err = null try { this.fd = await open(this.path, this.flags, this.mode) } catch (e) { err = e } cb(err) } async _writev(batch, cb) { let err = null try { await writev( this.fd, batch.map(({ chunk }) => chunk) ) } catch (e) { err = e } cb(err) } async _destroy(err, cb) { if (this.fd === -1) return cb(err) try { await close(this.fd) } catch (e) { err = err || e } cb(err) } } class Watcher extends EventEmitter { constructor(path, opts, onchange) { if (typeof opts === 'function') { onchange = opts opts = {} } if (!opts) opts = {} const { persistent = true, recursive = false, encoding = 'utf8' } = opts super() this._closed = false this._encoding = encoding this._handle = binding.watcherInit(path, recursive, this, this._onevent, this._onclose) if (!persistent) this.unref() if (onchange) this.on('change', onchange) } close() { if (this._closed) return this._closed = true binding.watcherClose(this._handle) } ref() { if (this._handle) binding.watcherRef(this._handle) return this } unref() { if (this._handle) binding.watcherUnref(this._handle) return this } [Symbol.asyncIterator]() { const buffer = [] let done = false let error = null let next = null this.on('change', (eventType, filename) => { if (next) { next.resolve({ done: false, value: { eventType, filename } }) next = null } else { buffer.push({ eventType, filename }) } }) .on('error', (err) => { done = true error = err if (next) { next.reject(error) next = null } }) .on('close', () => { done = true if (next) { next.resolve({ done }) next = null } }) return { next: () => new Promise((resolve, reject) => { if (error) return reject(error) if (buffer.length) return resolve({ done: false, value: buffer.shift() }) if (done) return resolve({ done }) next = { resolve, reject } }) } } _onevent(err, events, filename) { if (err) { this.close() this.emit('error', err) } else { const path = this._encoding === 'buffer' ? Buffer.from(filename) : Buffer.from(filename).toString(this._encoding) if (events & binding.UV_RENAME) { this.emit('change', 'rename', path) } if (events & binding.UV_CHANGE) { this.emit('change', 'change', path) } } } _onclose() { this._handle = null this.emit('close') } } exports.access = access exports.appendFile = appendFile exports.chmod = chmod exports.chown = chown exports.close = close exports.copyFile = copyFile exports.cp = cp exports.exists = exists exports.fchmod = fchmod exports.fchown = fchown exports.fdatasync = fdatasync exports.fstat = fstat exports.fsync = fsync exports.ftruncate = ftruncate exports.futimes = futimes exports.lchown = lchown exports.lutimes = lutimes exports.link = link exports.lstat = lstat exports.mkdir = mkdir exports.mkdtemp = mkdtemp exports.open = open exports.opendir = opendir exports.read = read exports.readFile = readFile exports.readdir = readdir exports.readlink = readlink exports.readv = readv exports.realpath = realpath exports.rename = rename exports.rm = rm exports.rmdir = rmdir exports.stat = stat exports.statfs = statfs exports.symlink = symlink exports.truncate = truncate exports.unlink = unlink exports.utimes = utimes exports.watch = watch exports.write = write exports.writeFile = writeFile exports.writev = writev exports.accessSync = accessSync exports.appendFileSync = appendFileSync exports.chmodSync = chmodSync exports.chownSync = chownSync exports.closeSync = closeSync exports.copyFileSync = copyFileSync exports.cpSync = cpSync exports.existsSync = existsSync exports.fchmodSync = fchmodSync exports.fchownSync = fchownSync exports.fdatasyncSync = fdatasyncSync exports.fstatSync = fstatSync exports.fsyncSync = fsyncSync exports.ftruncateSync = ftruncateSync exports.futimesSync = futimesSync exports.lchownSync = lchownSync exports.lutimesSync = lutimesSync exports.linkSync = linkSync exports.lstatSync = lstatSync exports.mkdirSync = mkdirSync exports.mkdtempSync = mkdtempSync exports.openSync = openSync exports.opendirSync = opendirSync exports.readFileSync = readFileSync exports.readSync = readSync exports.readdirSync = readdirSync exports.readlinkSync = readlinkSync exports.readvSync = readvSync exports.realpathSync = realpathSync exports.renameSync = renameSync exports.rmSync = rmSync exports.rmdirSync = rmdirSync exports.statSync = statSync exports.statfsSync = statfsSync exports.symlinkSync = symlinkSync exports.truncateSync = truncateSync exports.unlinkSync = unlinkSync exports.utimesSync = utimesSync exports.writeFileSync = writeFileSync exports.writeSync = writeSync exports.writevSync = writevSync exports.promises = require('./promises') exports.Stats = Stats exports.StatFs = StatFs exports.Dir = Dir exports.Dirent = Dirent exports.Watcher = Watcher exports.ReadStream = FileReadStream exports.createReadStream = function createReadStream(path, opts) { return new FileReadStream(path, opts) } exports.WriteStream = FileWriteStream exports.createWriteStream = function createWriteStream(path, opts) { return new FileWriteStream(path, opts) } function toNamespacedPath(filepath) { if (typeof filepath !== 'string') { if (isURL(filepath)) filepath = fileURLToPath(filepath) else filepath = filepath.toString() } return path.toNamespacedPath(filepath) } function toFlags(flags) { switch (flags) { case 'r': return constants.O_RDONLY case 'rs': // Fall through. case 'sr': return constants.O_RDONLY | constants.O_SYNC case 'r+': return constants.O_RDWR case 'rs+': // Fall through. case 'sr+': return constants.O_RDWR | constants.O_SYNC case 'w': return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY case 'wx': // Fall through. case 'xw': return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL case 'w+': return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR case 'wx+': // Fall through. case 'xw+': return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL case 'a': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY case 'ax': // Fall through. case 'xa': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL case 'as': // Fall through. case 'sa': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_SYNC case 'a+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR case 'ax+': // Fall through. case 'xa+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL case 'as+': // Fall through. case 'sa+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_SYNC default: return 0 } } function toMode(mode) { return parseInt(mode, 8) } const binding = require('../binding') module.exports = { O_RDWR: binding.O_RDWR, O_RDONLY: binding.O_RDONLY, O_WRONLY: binding.O_WRONLY, O_CREAT: binding.O_CREAT, O_TRUNC: binding.O_TRUNC, O_APPEND: binding.O_APPEND, F_OK: binding.F_OK || 0, R_OK: binding.R_OK || 0, W_OK: binding.W_OK || 0, X_OK: binding.X_OK || 0, S_IFMT: binding.S_IFMT, S_IFREG: binding.S_IFREG, S_IFDIR: binding.S_IFDIR, S_IFCHR: binding.S_IFCHR, S_IFLNK: binding.S_IFLNK, S_IFBLK: binding.S_IFBLK || 0, S_IFIFO: binding.S_IFIFO || 0, S_IFSOCK: binding.S_IFSOCK || 0, S_IRUSR: binding.S_IRUSR || 0, S_IWUSR: binding.S_IWUSR || 0, S_IXUSR: binding.S_IXUSR || 0, S_IRGRP: binding.S_IRGRP || 0, S_IWGRP: binding.S_IWGRP || 0, S_IXGRP: binding.S_IXGRP || 0, S_IROTH: binding.S_IROTH || 0, S_IWOTH: binding.S_IWOTH || 0, S_IXOTH: binding.S_IXOTH || 0, UV_DIRENT_UNKNOWN: binding.UV_DIRENT_UNKNOWN, UV_DIRENT_FILE: binding.UV_DIRENT_FILE, UV_DIRENT_DIR: binding.UV_DIRENT_DIR, UV_DIRENT_LINK: binding.UV_DIRENT_LINK, UV_DIRENT_FIFO: binding.UV_DIRENT_FIFO, UV_DIRENT_SOCKET: binding.UV_DIRENT_SOCKET, UV_DIRENT_CHAR: binding.UV_DIRENT_CHAR, UV_DIRENT_BLOCK: binding.UV_DIRENT_BLOCK, COPYFILE_EXCL: binding.UV_FS_COPYFILE_EXCL, COPYFILE_FICLONE: binding.UV_FS_COPYFILE_FICLONE, COPYFILE_FICLONE_FORCE: binding.UV_FS_COPYFILE_FICLONE_FORCE, UV_FS_SYMLINK_DIR: binding.UV_FS_SYMLINK_DIR, UV_FS_SYMLINK_JUNCTION: binding.UV_FS_SYMLINK_JUNCTION } const os = require('bare-os') module.exports = class FileError extends Error { constructor(msg, opts = {}) { const { code, operation = null, path = null, destination = null, fd = -1 } = opts if (operation !== null) msg += describe(operation, opts) super(`${code}: ${msg}`) this.code = code if (operation !== null) this.operation = operation if (path !== null) this.path = path if (destination !== null) this.destination = destination if (fd !== -1) this.fd = fd } get name() { return 'FileError' } // For Node.js compatibility get errno() { return os.constants.errnos[this.code] } // For Node.js compatibility get syscall() { return this.operation } // For Node.js compatibility get dest() { return this.destination } } function describe(operation, opts) { const { path = null, destination = null, fd = -1 } = opts let result = `, ${operation}` if (path !== null) { result += ` ${JSON.stringify(path)}` if (destination !== null) { result += ` -> ${JSON.stringify(destination)}` } } else if (fd !== -1) { result += ` ${fd}` } return result } { "name": "bare-fs", "version": "4.7.2", "description": "Native file system operations for Bare", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./promises": { "types": "./promises.d.ts", "default": "./promises.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" } }, "files": [ "index.js", "index.d.ts", "promises.js", "promises.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-fs.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-fs/issues" }, "homepage": "https://github.com/holepunchto/bare-fs#readme", "engines": { "bare": ">=1.16.0" }, "dependencies": { "bare-events": "^2.5.4", "bare-path": "^3.0.0", "bare-stream": "^2.6.4", "bare-url": "^2.2.2", "fast-fifo": "^1.3.2" }, "devDependencies": { "bare-buffer": "^3.0.2", "bare-crypto": "^1.11.2", "brittle": "^3.1.1", "cmake-bare": "^1.1.7", "lunte": "^1.6.0", "prettier": "^3.4.1", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "bare-buffer": "*" }, "peerDependenciesMeta": { "bare-buffer": { "optional": true } } } const EventEmitter = require('bare-events') const fs = require('.') class FileHandle extends EventEmitter { constructor(fd) { super() this.fd = fd } async close() { await fs.close(this.fd) this.fd = -1 this.emit('close') } async read(buffer, ...args) { return { bytesRead: await fs.read(this.fd, buffer, ...args), buffer } } async readv(buffers, ...args) { return { bytesRead: await fs.readv(this.fd, buffers, ...args), buffers } } async write(buffer, ...args) { return { bytesWritten: await fs.write(this.fd, buffer, ...args), buffer } } async writev(buffers, ...args) { return { bytesWritten: await fs.writev(this.fd, buffers, ...args), buffers } } async stat() { return fs.fstat(this.fd) } async chmod(mode) { await fs.fchmod(this.fd, mode) } async chown(uid, gid) { await fs.fchown(this.fd, uid, gid) } async datasync() { return fs.fdatasync(this.fd) } async sync() { return fs.fsync(this.fd) } async truncate(len) { await fs.ftruncate(this.fd, len) } async utimes(atime, mtime) { await fs.futimes(this.fd, atime, mtime) } createReadStream(opts) { return fs.createReadStream(null, { ...opts, fd: this.fd }) } createWriteStream(opts) { return fs.createWriteStream(null, { ...opts, fd: this.fd }) } async [Symbol.asyncDispose]() { await this.close() } } exports.open = async function open(filepath, flags, mode) { return new FileHandle(await fs.open(filepath, flags, mode)) } exports.access = fs.access exports.appendFile = fs.appendFile exports.chmod = fs.chmod exports.chown = fs.chown exports.constants = fs.constants exports.copyFile = fs.copyFile exports.cp = fs.cp exports.lchown = fs.lchown exports.lutimes = fs.lutimes exports.link = fs.link exports.lstat = fs.lstat exports.mkdir = fs.mkdir exports.mkdtemp = fs.mkdtemp exports.opendir = fs.opendir exports.readFile = fs.readFile exports.readdir = fs.readdir exports.readlink = fs.readlink exports.realpath = fs.realpath exports.rename = fs.rename exports.rm = fs.rm exports.rmdir = fs.rmdir exports.stat = fs.stat exports.statfs = fs.statfs exports.truncate = fs.truncate exports.symlink = fs.symlink exports.unlink = fs.unlink exports.utimes = fs.utimes exports.watch = fs.watch exports.writeFile = fs.writeFile module.exports = require.addon() const ansiEscapes = require('bare-ansi-escapes') const getType = require('bare-type') const binding = require('./binding') const PLAIN_KEY = /^[a-zA-Z_][a-zA-Z_0-9]*$/ const defaultDepth = 2 const defaultBreakLength = 80 const defaultMaxArrayLength = 40 module.exports = exports = function inspect(value, opts = {}) { const { colors = false, depth = defaultDepth, breakLength = defaultBreakLength, stylize = defaultStylize(colors) } = opts const references = new InspectRefMap() const tree = inspectValue(value, 0, { colors, depth, breakLength, stylize, references }) return tree.toString() } exports.styles = { bigint: ansiEscapes.colorYellow, boolean: ansiEscapes.colorYellow, date: ansiEscapes.colorMagenta, module: ansiEscapes.modifierUnderline, name: ansiEscapes.modifierReset, null: ansiEscapes.modifierBold, number: ansiEscapes.colorYellow, regexp: ansiEscapes.colorRed, special: ansiEscapes.colorCyan, string: ansiEscapes.colorGreen, symbol: ansiEscapes.colorGreen, undefined: ansiEscapes.colorBrightBlack } const styles = exports.styles function defaultStylize(colors) { return function stylize(value, style) { const color = colors && styles[style] if (color) return color + value + ansiEscapes.modifierReset return value } } class InspectRefMap { constructor() { this.refs = new WeakMap() this.ids = new WeakMap() this.nextId = 1 } has(object) { return this.refs.has(object) } get(object) { return this.refs.get(object) || null } set(object, ref) { this.refs.set(object, ref) } id(object) { let id = this.ids.get(object) if (id) return id id = this.nextId++ this.ids.set(object, id) return id } } class InspectNode { constructor(depth, length, opts) { const { breakLength = defaultBreakLength, breakAlways = false } = opts this.depth = depth this.length = length this.breakLength = breakLength this.breakAlways = breakAlways } pad(n, string) { return string.padStart(n, ' ') } indent(n, string) { return ' '.repeat(n) + string } } class InspectRef extends InspectNode { constructor(depth, opts) { super(depth, '[circular *]'.length, opts) this.refs = opts.references this.count = 0 this.circular = false this.color = opts.colors && styles.special } get id() { return this.refs.id(this) } increment() { return ++this.count } decrement() { return --this.count } toString(opts = {}) { const { offset = 0, pad = 0, indent = 0 } = opts let value = this.pad(pad, '[circular *' + this.id + ']') if (this.color) value = this.color + value + ansiEscapes.modifierReset return offset ? value : this.indent(indent, value) } } class InspectLeaf extends InspectNode { constructor(value, color, depth, opts) { const length = value.length if (value.includes('\n')) { value = value.replaceAll('\n', '\n' + ' '.repeat(depth)) opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.value = value this.color = opts.colors && color } toString(opts = {}) { const { offset = 0, pad = 0, indent = 0 } = opts let value = this.pad(pad, this.value) if (this.color) value = this.color + value + ansiEscapes.modifierReset return offset ? value : this.indent(indent, value) } } class InspectPair extends InspectNode { constructor(delim, left, right, depth, opts) { const length = left.length + delim.length + right.length if (left.breakAlways || right.breakAlways) { opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.delim = delim this.left = left this.right = right } toString(opts = {}) { const { indent = 0 } = opts return this.indent( indent, this.left + this.delim + this.right.toString({ indent, offset: this.left.length + this.delim.length }) ) } } class InspectSuspension extends InspectNode { constructor(overflow, depth, opts) { const label = `... ${overflow} more` super(depth, label.length, opts) this.label = label } toString(opts = {}) { const { indent = 0 } = opts return this.indent(indent, this.label) } } class InspectSequence extends InspectNode { constructor(header, footer, delim, values, ref, depth, opts) { const { tabulate = false } = opts const length = (ref.circular ? ''.length + 1 : 0) + header.length + values.reduce( (length, value, i) => length + value.length + (i === 0 ? 0 : delim.length), 0 ) + footer.length if (values.some((value) => value.breakAlways)) { opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.header = header this.footer = footer this.delim = delim this.values = values this.ref = ref this.tabulate = tabulate } toString(opts = {}) { const { offset = 0, indent = 0 } = opts const split = this.breakAlways || (this.values.length && (offset + this.length > this.breakLength || indent * 2 + this.length > this.breakLength)) let header = this.header if (this.ref.circular) { header = ' ' + header } if (this.values.length === 0) { header = header.trimEnd() } if (offset === 0) { header = this.indent(indent, header) } if (split) { header = header.trimEnd() + '\n' } let string = header let columns = 1 let pad = 0 if (this.tabulate) { const widest = this.values.reduce( (length, value) => value.breakAlways ? length : Math.max(length, value.length), 0 ) if (widest) { columns = Math.max( columns, Math.floor( (this.breakLength - indent * 2) / (widest + this.delim.length) ) ) if (columns > 1) pad = widest } } for (let i = 0, n = this.values.length, offset = 0; i < n; i++) { const value = this.values[i] if (split) { let part if (i % columns === 0 || value.breakAlways) { part = value.toString({ indent: indent + 1, pad }) } else { part = value.toString({ pad }) } string += part if (i < n - 1) { if (i % columns === columns - 1 || this.values[i + 1].breakAlways) { string += this.delim.trimEnd() + '\n' } else { string += this.delim } } } else { if (i > 0) string += this.delim string += value.toString({ offset }) offset += value.length } } let footer = this.footer if (this.values.length === 0) { footer = footer.trimStart() } if (split) { string += '\n' + this.indent(indent, footer.trimStart()) } else { string += footer } return string } } function inspectValue(value, depth, opts) { const type = getType(value) if (type.isUndefined()) return inspectUndefined(depth, opts) if (type.isNull()) return inspectNull(depth, opts) if (type.isBoolean()) return inspectBoolean(value, depth, opts) if (type.isNumber()) return inspectNumber(value, depth, opts) if (type.isBigInt()) return inspectBigInt(value, depth, opts) if (type.isString()) return inspectString(value, depth, opts) if (type.isSymbol()) return inspectSymbol(value, depth, opts) if (type.isObject()) return inspectObject(type, value, depth, opts) if (type.isFunction()) return inspectFunction(type, value, depth, opts) if (type.isExternal()) return inspectExternal(value, opts, opts) } function inspectUndefined(depth, opts) { return new InspectLeaf('undefined', styles.undefined, depth, opts) } function inspectNull(depth, opts) { return new InspectLeaf('null', styles.null, depth, opts) } function inspectBoolean(value, depth, opts) { return new InspectLeaf(value.toString(), styles.boolean, depth, opts) } function inspectNumber(value, depth, opts) { let string if (Object.is(value, -0)) { string = '-0' } else { string = value.toString(10) } return new InspectLeaf(string, styles.number, depth, opts) } function inspectBigInt(value, depth, opts) { return new InspectLeaf(value.toString(10) + 'n', styles.bigint, depth, opts) } const STRING_ESCAPES = /[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f'\\\ud800-\udfff]/g function inspectString(value, depth, opts) { // https://tc39.es/ecma262/multipage/structured-data.html#sec-quotejsonstring const string = value.replace(STRING_ESCAPES, (match) => { if (match.length === 2) return match switch (match) { case "'": return "\\'" case '\\': return '\\\\' case '\b': return '\\b' case '\t': return '\\t' case '\n': return '\\n' case '\f': return '\\f' case '\r': return '\\r' default: return '\\u' + match.charCodeAt(0).toString(16).padStart(4, '0') } }) return new InspectLeaf("'" + string + "'", styles.string, depth, opts) } function inspectSymbol(value, depth, opts) { return new InspectLeaf(value.toString(), styles.symbol, depth, opts) } function inspectKey(value, depth, opts) { if (PLAIN_KEY.test(value)) { return new InspectLeaf(value, null, depth, opts) } else { return inspectValue(value, depth, opts) } } function inspectObject(type, object, depth, opts) { const refs = opts.references let ref = refs.get(object) if (ref === null) { ref = new InspectRef(depth, opts) refs.set(object, ref) } else if (ref.count) { ref.circular = true return ref } const maxDepth = typeof opts.depth === 'number' ? opts.depth : Infinity if (maxDepth < depth) { const constructor = object.constructor return new InspectLeaf( '[' + (constructor && constructor.name ? constructor.name : 'Object') + ']', styles.special, depth, opts ) } const inspect = object[Symbol.for('bare.inspect')] || object[Symbol.for('nodejs.util.inspect.custom')] if (typeof inspect === 'function') { const value = inspect.call( object, typeof opts.depth === 'number' ? opts.depth - depth : null, { colors: opts.colors, breakLength: opts.breakLength, stylize: opts.stylize }, exports ) if (typeof value === 'object' && value !== null) { refs.set(value, ref) } if (typeof value !== 'string') { return inspectValue(value, depth, opts) } return new InspectLeaf(value, null, depth, opts) } if (type.isArray()) return inspectArray(object, ref, depth, opts) if (type.isDate()) return inspectDate(object, ref, depth, opts) if (type.isRegExp()) return inspectRegExp(object, ref, depth, opts) if (type.isError()) return inspectError(object, ref, depth, opts) if (type.isPromise()) return inspectPromise(object, ref, depth, opts) if (type.isMap()) return inspectMap(object, ref, depth, opts) if (type.isSet()) return inspectSet(object, ref, depth, opts) if (type.isWeakMap()) return inspectWeakMap(object, ref, depth, opts) if (type.isWeakSet()) return inspectWeakSet(object, ref, depth, opts) if (type.isWeakRef()) return inspectWeakRef(object, ref, depth, opts) if (type.isArrayBuffer()) return inspectArrayBuffer(object, ref, depth, opts) if (type.isSharedArrayBuffer()) return inspectSharedArrayBuffer(object, ref, depth, opts) if (type.isTypedArray()) return inspectTypedArray(object, ref, depth, opts) if (type.isDataView()) return inspectDataView(object, ref, depth, opts) ref.increment() const values = [] for (const key in object) { if (key === 'constructor') continue values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(object[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() let header = '{ ' const tag = object[Symbol.toStringTag] if (tag) header = '[' + tag + '] ' + header if (object.constructor) { const name = object.constructor.name if (name && name !== 'Object') { header = object.constructor.name + ' ' + header } } return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectArray(array, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxArrayLength, 0) for (let i = 0, n = array.length; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(array.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(array[i], depth + 1, opts)) } for (const key of binding.getOwnNonIndexPropertyNames(array)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(array[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() let header = '[ ' if (array.constructor.name !== 'Array') { header = array.constructor.name + '(' + array.length + ') ' + header } return new InspectSequence(header, ' ]', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectDate(date, ref, depth, opts) { return new InspectLeaf(date.toISOString(), styles.date, depth, opts) } function inspectRegExp(regExp, ref, depth, opts) { return new InspectLeaf(regExp.toString(), styles.regexp, depth, opts) } function inspectError(error, ref, depth, opts) { let header if ('stack' in error) { header = error.stack if (depth > 0) { header = header.replaceAll('\n', '\n' + ' '.repeat(depth)) } } else { header = error.toString() } const builtins = ['cause'] if (error.name === 'AggregateError') { builtins.push('errors') } else if (error.name === 'SuppressedError') { builtins.push('error', 'suppressed') } const values = [] for (const key of builtins) { if (key in error === false) continue values.push( new InspectPair( ': ', new InspectLeaf('[' + key + ']', null, depth + 1, opts), inspectValue(error[key], depth + 1, opts), depth + 1, opts ) ) } for (const key in error) { if (key === 'constructor' || builtins.includes(key)) continue values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(error[key], depth + 1, opts), depth + 1, opts ) ) } if (values.length === 0) return new InspectLeaf(header, null, depth, opts) return new InspectSequence( header + ' {', ' }', ', ', values, ref, depth, opts ) } function inspectPromise(promise, ref, depth, opts) { ref.increment() const state = binding.getPromiseState(promise) const values = [] switch (state) { case 0: // Pending values.push(new InspectLeaf('', styles.special, depth, opts)) break case 1: // Fulfilled values.push(inspectValue(binding.getPromiseResult(promise), depth, opts)) break case 2: // Rejected values.push( new InspectLeaf('', styles.special, depth, opts), inspectValue(binding.getPromiseResult(promise), depth, opts) ) } ref.decrement() const header = promise.constructor.name + ' { ' return new InspectSequence(header, ' }', ' ', values, ref, depth, opts) } function inspectMap(map, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxMapLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = maxMapLength for (const entry of map) { if (remaining-- === 0) { values.push( new InspectSuspension(map.size - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push( new InspectPair( ' => ', inspectValue(entry[0], depth + 1, opts), inspectValue(entry[1], depth + 1, opts), depth + 1, opts ) ) } for (const key in map) { if (key === 'constructor') continue const value = inspectValue(map[key], depth + 1, opts) values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), value, depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = map.constructor.name + '(' + map.size + ') { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectSet(set, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxSetLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = maxSetLength for (const entry of set) { if (remaining-- === 0) { values.push( new InspectSuspension(set.size - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(entry, depth + 1, opts)) } for (const key in set) { if (key === 'constructor') continue const value = inspectValue(set[key], depth + 1, opts) values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), value, depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = set.constructor.name + '(' + set.size + ') { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectWeakMap(weakMap, ref, depth, opts) { const header = weakMap.constructor.name + ' { ' return new InspectSequence( header, ' }', ' ', [new InspectLeaf('', styles.special, depth + 1, opts)], ref, depth, opts ) } function inspectWeakSet(weakSet, ref, depth, opts) { const header = weakSet.constructor.name + ' { ' return new InspectSequence( header, ' }', ' ', [new InspectLeaf('', styles.special, depth + 1, opts)], ref, depth, opts ) } function inspectWeakRef(weakRef, ref, depth, opts) { const target = weakRef.deref() let value if (target === undefined) { value = new InspectLeaf('', styles.special, depth + 1, opts) } else { value = inspectValue(target, depth + 1, opts) } const header = weakRef.constructor.name + ' { ' return new InspectSequence(header, ' }', ' ', [value], ref, depth, opts) } function inspectArrayBuffer(arrayBuffer, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(arrayBuffer[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = arrayBuffer.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectSharedArrayBuffer(sharedArrayBuffer, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(sharedArrayBuffer[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = sharedArrayBuffer.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectTypedArray(typedArray, ref, depth, opts) { if (Buffer.isBuffer(typedArray)) { return inspectBuffer(typedArray, ref, depth, opts) } const { maxArrayLength = defaultMaxArrayLength, maxTypedArrayLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxTypedArrayLength, 0) for (let i = 0, n = typedArray.length; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(typedArray.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(typedArray[i], depth + 1, opts)) } for (const key of binding.getOwnNonIndexPropertyNames(typedArray)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(typedArray[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = typedArray.constructor.name + '(' + typedArray.length + ') [ ' return new InspectSequence(header, ' ]', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectBuffer(buffer, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxBufferLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxBufferLength, 0) for (let i = 0, n = buffer.byteLength; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(buffer.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push( new InspectLeaf( buffer[i].toString(16).padStart(2, '0'), null, depth + 1, opts ) ) } for (const key of binding.getOwnNonIndexPropertyNames(buffer)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(buffer[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() return new InspectSequence('', ' ', values, ref, depth, { ...opts, tabulate: true }) } function inspectDataView(dataView, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength', 'byteOffset', 'buffer']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(dataView[key], depth + 1, opts), depth + 1, opts ) ) } for (const key of binding.getOwnNonIndexPropertyNames(dataView)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(dataView[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = dataView.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectFunction(type, fn, depth, opts) { if (fn.toString().startsWith('class')) return inspectClass(fn, depth, opts) let tag = 'function' if (type.isGeneratorFunction()) tag = 'generator ' + tag if (type.isAsyncFunction()) tag = 'async ' + tag return new InspectLeaf( '[' + tag + ' ' + (fn.name ? fn.name : '(anonymous)') + ']', styles.special, depth, opts ) } function inspectClass(ctor, depth, opts) { return new InspectLeaf( '[class ' + (ctor.name ? ctor.name : '(anonymous)') + ']', styles.special, depth, opts ) } function inspectExternal(external, depth, opts) { return new InspectLeaf( '[external 0x' + binding.getExternal(external).toString(16) + ']', styles.special, depth, opts ) } { "name": "bare-inspect", "version": "3.1.4", "description": "Inspect objects as strings for debugging", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-inspect.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-inspect/issues" }, "homepage": "https://github.com/holepunchto/bare-inspect#readme", "engines": { "bare": ">=1.18.0" }, "dependencies": { "bare-ansi-escapes": "^2.1.0", "bare-type": "^1.0.0" }, "devDependencies": { "brittle": "^3.3.2", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const binding = require('./binding') const errors = require('./lib/errors') const constants = require('./lib/constants') exports.constants = constants exports.errors = errors exports.EOL = binding.platform === 'win32' ? '\r\n' : '\n' exports.devNull = binding.platform === 'win32' ? '\\\\.\\nul' : '/dev/null' exports.platform = function platform() { return binding.platform } exports.arch = function arch() { return binding.arch } exports.type = binding.type exports.version = binding.version exports.release = binding.release exports.machine = binding.machine exports.execPath = binding.execPath exports.pid = binding.pid exports.ppid = binding.ppid exports.cwd = binding.cwd exports.chdir = binding.chdir exports.tmpdir = binding.tmpdir exports.homedir = binding.homedir exports.hostname = binding.hostname exports.userInfo = binding.userInfo exports.groupInfo = binding.groupInfo exports.networkInterfaces = function networkInterfaces() { const result = {} for (const entry of binding.networkInterfaces()) { const { name, ...properties } = entry if (result[name]) result[name].push(properties) else result[name] = [properties] } return result } exports.kill = function kill(pid, signal = constants.signals.SIGTERM) { if (typeof signal === 'string') { if (signal in constants.signals === false) { throw errors.UNKNOWN_SIGNAL('Unknown signal: ' + signal) } signal = constants.signals[signal] } binding.kill(pid, signal) } exports.endianness = function endianness() { return binding.isLittleEndian ? 'LE' : 'BE' } exports.availableParallelism = binding.availableParallelism exports.cpuUsage = function cpuUsage(previous) { const current = binding.cpuUsage() if (previous) { return { user: current.user - previous.user, system: current.system - previous.system } } return current } exports.threadCpuUsage = function threadCpuUsage(previous) { const current = binding.threadCpuUsage() if (previous) { return { user: current.user - previous.user, system: current.system - previous.system } } return current } exports.resourceUsage = binding.resourceUsage exports.memoryUsage = binding.memoryUsage exports.freemem = binding.freemem exports.totalmem = binding.totalmem exports.availableMemory = binding.availableMemory exports.constrainedMemory = binding.constrainedMemory exports.uptime = binding.uptime exports.loadavg = binding.loadavg exports.cpus = binding.cpus exports.getProcessTitle = binding.getProcessTitle exports.setProcessTitle = function setProcessTitle(title) { if (typeof title !== 'string') title = title.toString() if (title.length >= 256) { throw errors.TITLE_OVERFLOW('Process title is too long') } binding.setProcessTitle(title) } exports.getPriority = function getPriority(pid = 0) { return binding.getPriority(pid) } exports.setPriority = function setPriority(pid, priority) { if (priority === undefined) { priority = pid pid = 0 } binding.setPriority(pid, priority) } exports.getEnvKeys = binding.getEnvKeys exports.getEnv = binding.getEnv exports.hasEnv = binding.hasEnv exports.setEnv = binding.setEnv exports.unsetEnv = binding.unsetEnv const binding = require('../binding') module.exports = { signals: binding.signals, errnos: binding.errnos, priority: binding.priority } module.exports = class OSError extends Error { constructor(msg, fn = OSError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'OSError' } static UNKNOWN_SIGNAL(msg) { return new OSError(msg, OSError.UNKNOWN_SIGNAL) } static TITLE_OVERFLOW(msg) { return new OSError(msg, OSError.TITLE_OVERFLOW) } } { "name": "bare-os", "version": "3.9.1", "description": "Operating system utilities for Bare", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" }, "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors.js" } }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-os.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-os/issues" }, "homepage": "https://github.com/holepunchto/bare-os#readme", "engines": { "bare": ">=1.14.0" }, "devDependencies": { "brittle": "^3.1.1", "cmake-bare": "^1.1.6", "lunte": "^1.6.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0" } } // This export SHOULD NOT be shortened in any way as having the full // `module.exports = require(...)` statement is crucial for synthesizing // ESM exports. if (Bare.platform === 'win32') { module.exports = require('./lib/win32') } else { module.exports = require('./lib/posix') } module.exports = { CHAR_UPPERCASE_A: 0x41, CHAR_LOWERCASE_A: 0x61, CHAR_UPPERCASE_Z: 0x5a, CHAR_LOWERCASE_Z: 0x7a, CHAR_DOT: 0x2e, CHAR_FORWARD_SLASH: 0x2f, CHAR_BACKWARD_SLASH: 0x5c, CHAR_COLON: 0x3a, CHAR_QUESTION_MARK: 0x3f } const os = require('bare-os') const { normalizeString } = require('./shared') const { CHAR_DOT, CHAR_FORWARD_SLASH } = require('./constants') function isPosixPathSeparator(code) { return code === CHAR_FORWARD_SLASH } exports.win32 = require('./win32') exports.posix = exports exports.sep = '/' exports.delimiter = ':' exports.resolve = function resolve(...args) { let resolvedPath = '' let resolvedAbsolute = false for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) { const path = i >= 0 ? args[i] : os.cwd() if (path.length === 0) { continue } resolvedPath = `${path}/${resolvedPath}` resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH } resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator) if (resolvedAbsolute) { return `/${resolvedPath}` } return resolvedPath.length > 0 ? resolvedPath : '.' } exports.normalize = function normalize(path) { if (path.length === 0) return '.' const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator) if (path.length === 0) { if (isAbsolute) return '/' return trailingSeparator ? './' : '.' } if (trailingSeparator) path += '/' return isAbsolute ? `/${path}` : path } exports.isAbsolute = function isAbsolute(path) { return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH } exports.join = function join(...args) { if (args.length === 0) return '.' let joined for (let i = 0; i < args.length; ++i) { const arg = args[i] if (arg.length > 0) { if (joined === undefined) joined = arg else joined += `/${arg}` } } if (joined === undefined) return '.' return exports.normalize(joined) } exports.relative = function relative(from, to) { if (from === to) return '' from = exports.resolve(from) to = exports.resolve(to) if (from === to) return '' const fromStart = 1 const fromEnd = from.length const fromLen = fromEnd - fromStart const toStart = 1 const toLen = to.length - toStart const length = fromLen < toLen ? fromLen : toLen let lastCommonSep = -1 let i = 0 for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i) if (fromCode !== to.charCodeAt(toStart + i)) { break } else if (fromCode === CHAR_FORWARD_SLASH) { lastCommonSep = i } } if (i === length) { if (toLen > length) { if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) { return to.substring(toStart + i + 1) } if (i === 0) { return to.substring(toStart + i) } } else if (fromLen > length) { if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) { lastCommonSep = i } else if (i === 0) { lastCommonSep = 0 } } } let out = '' for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { out += out.length === 0 ? '..' : '/..' } } return `${out}${to.substring(toStart + lastCommonSep)}` } exports.toNamespacedPath = function toNamespacedPath(path) { return path } exports.dirname = function dirname(path) { if (path.length === 0) return '.' const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH let end = -1 let matchedSlash = true for (let i = path.length - 1; i >= 1; --i) { if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { if (!matchedSlash) { end = i break } } else { matchedSlash = false } } if (end === -1) return hasRoot ? '/' : '.' if (hasRoot && end === 1) return '//' return path.substring(0, end) } exports.basename = function basename(path, suffix) { let start = 0 let end = -1 let matchedSlash = true if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) { return '' } let extIdx = suffix.length - 1 let firstNonSlashEnd = -1 for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i) if (code === CHAR_FORWARD_SLASH) { if (!matchedSlash) { start = i + 1 break } } else { if (firstNonSlashEnd === -1) { matchedSlash = false firstNonSlashEnd = i + 1 } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) { end = i } } else { extIdx = -1 end = firstNonSlashEnd } } } } if (start === end) end = firstNonSlashEnd else if (end === -1) end = path.length return path.substring(start, end) } for (let i = path.length - 1; i >= 0; --i) { if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { if (!matchedSlash) { start = i + 1 break } } else if (end === -1) { matchedSlash = false end = i + 1 } } if (end === -1) return '' return path.substring(start, end) } exports.extname = function extname(path) { let startDot = -1 let startPart = 0 let end = -1 let matchedSlash = true let preDotState = 0 for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i) if (code === CHAR_FORWARD_SLASH) { if (!matchedSlash) { startPart = i + 1 break } continue } if (end === -1) { matchedSlash = false end = i + 1 } if (code === CHAR_DOT) { if (startDot === -1) startDot = i else if (preDotState !== 1) preDotState = 1 } else if (startDot !== -1) { preDotState = -1 } } if ( startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return '' } return path.substring(startDot, end) } const { CHAR_DOT, CHAR_FORWARD_SLASH } = require('./constants') exports.normalizeString = function normalizeString( path, allowAboveRoot, separator, isPathSeparator ) { let res = '' let lastSegmentLength = 0 let lastSlash = -1 let dots = 0 let code = 0 for (let i = 0; i <= path.length; ++i) { if (i < path.length) { code = path.charCodeAt(i) } else if (isPathSeparator(code)) { break } else { code = CHAR_FORWARD_SLASH } if (isPathSeparator(code)) { if (lastSlash === i - 1 || dots === 1); else if (dots === 2) { if ( res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT ) { if (res.length > 2) { const lastSlashIndex = res.lastIndexOf(separator) if (lastSlashIndex === -1) { res = '' lastSegmentLength = 0 } else { res = res.substring(0, lastSlashIndex) lastSegmentLength = res.length - 1 - res.lastIndexOf(separator) } lastSlash = i dots = 0 continue } else if (res.length !== 0) { res = '' lastSegmentLength = 0 lastSlash = i dots = 0 continue } } if (allowAboveRoot) { res += res.length > 0 ? `${separator}..` : '..' lastSegmentLength = 2 } } else { if (res.length > 0) { res += `${separator}${path.substring(lastSlash + 1, i)}` } else { res = path.substring(lastSlash + 1, i) } lastSegmentLength = i - lastSlash - 1 } lastSlash = i dots = 0 } else if (code === CHAR_DOT && dots !== -1) { ++dots } else { dots = -1 } } return res } const os = require('bare-os') const { normalizeString } = require('./shared') const { CHAR_UPPERCASE_A, CHAR_LOWERCASE_A, CHAR_UPPERCASE_Z, CHAR_LOWERCASE_Z, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_QUESTION_MARK } = require('./constants') function isWindowsPathSeparator(code) { return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH } function isWindowsDeviceRoot(code) { return ( (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) || (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ) } exports.posix = require('./posix') exports.win32 = exports exports.sep = '\\' exports.delimiter = ';' exports.resolve = function resolve(...args) { let resolvedDevice = '' let resolvedTail = '' let resolvedAbsolute = false for (let i = args.length - 1; i >= -1; i--) { let path if (i >= 0) { path = args[i] if (path.length === 0) continue } else if (resolvedDevice.length === 0) { path = os.cwd() } else { path = os.getEnv(`=${resolvedDevice}`) || os.cwd() if ( path === undefined || (path.substring(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH) ) { path = `${resolvedDevice}\\` } } const len = path.length let rootEnd = 0 let device = '' let isAbsolute = false const code = path.charCodeAt(0) if (len === 1) { if (isWindowsPathSeparator(code)) { rootEnd = 1 isAbsolute = true } } else if (isWindowsPathSeparator(code)) { isAbsolute = true if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { const firstPart = path.substring(last, j) last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len || j !== last) { device = `\\\\${firstPart}\\${path.substring(last, j)}` rootEnd = j } } } } else { rootEnd = 1 } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.substring(0, 2) rootEnd = 2 if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) { isAbsolute = true rootEnd = 3 } } if (device.length > 0) { if (resolvedDevice.length > 0) { if (device.toLowerCase() !== resolvedDevice.toLowerCase()) { continue } } else { resolvedDevice = device } } if (resolvedAbsolute) { if (resolvedDevice.length > 0) { break } } else { resolvedTail = `${path.substring(rootEnd)}\\${resolvedTail}` resolvedAbsolute = isAbsolute if (isAbsolute && resolvedDevice.length > 0) { break } } } resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isWindowsPathSeparator) return resolvedAbsolute ? `${resolvedDevice}\\${resolvedTail}` : `${resolvedDevice}${resolvedTail}` || '.' } exports.normalize = function normalize(path) { const len = path.length if (len === 0) return '.' let rootEnd = 0 let device let isAbsolute = false const code = path.charCodeAt(0) if (len === 1) { return code === CHAR_FORWARD_SLASH ? '\\' : path } if (isWindowsPathSeparator(code)) { isAbsolute = true if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { const firstPart = path.substring(last, j) last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len) { return `\\\\${firstPart}\\${path.substring(last)}\\` } if (j !== last) { device = `\\\\${firstPart}\\${path.substring(last, j)}` rootEnd = j } } } } else { rootEnd = 1 } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.substring(0, 2) rootEnd = 2 if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) { isAbsolute = true rootEnd = 3 } } let tail = rootEnd < len ? normalizeString(path.substring(rootEnd), !isAbsolute, '\\', isWindowsPathSeparator) : '' if (tail.length === 0 && !isAbsolute) { tail = '.' } if (tail.length > 0 && isWindowsPathSeparator(path.charCodeAt(len - 1))) { tail += '\\' } if (device === undefined) { return isAbsolute ? `\\${tail}` : tail } return isAbsolute ? `${device}\\${tail}` : `${device}${tail}` } exports.isAbsolute = function isAbsolute(path) { const len = path.length if (len === 0) return false const code = path.charCodeAt(0) return ( isWindowsPathSeparator(code) || (len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isWindowsPathSeparator(path.charCodeAt(2))) ) } exports.join = function join(...args) { if (args.length === 0) return '.' let joined let firstPart for (let i = 0; i < args.length; ++i) { const arg = args[i] if (arg.length > 0) { if (joined === undefined) joined = firstPart = arg else joined += `\\${arg}` } } if (joined === undefined) return '.' let needsReplace = true let slashCount = 0 if (isWindowsPathSeparator(firstPart.charCodeAt(0))) { ++slashCount const firstLen = firstPart.length if (firstLen > 1 && isWindowsPathSeparator(firstPart.charCodeAt(1))) { ++slashCount if (firstLen > 2) { if (isWindowsPathSeparator(firstPart.charCodeAt(2))) { ++slashCount } else { needsReplace = false } } } } if (needsReplace) { while (slashCount < joined.length && isWindowsPathSeparator(joined.charCodeAt(slashCount))) { slashCount++ } if (slashCount >= 2) { joined = `\\${joined.substring(slashCount)}` } } return exports.normalize(joined) } exports.relative = function relative(from, to) { if (from === to) return '' const fromOrig = exports.resolve(from) const toOrig = exports.resolve(to) if (fromOrig === toOrig) return '' from = fromOrig.toLowerCase() to = toOrig.toLowerCase() if (from === to) return '' let fromStart = 0 while (fromStart < from.length && from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) { fromStart++ } let fromEnd = from.length while (fromEnd - 1 > fromStart && from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) { fromEnd-- } const fromLen = fromEnd - fromStart let toStart = 0 while (toStart < to.length && to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { toStart++ } let toEnd = to.length while (toEnd - 1 > toStart && to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) { toEnd-- } const toLen = toEnd - toStart const length = fromLen < toLen ? fromLen : toLen let lastCommonSep = -1 let i = 0 for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i) if (fromCode !== to.charCodeAt(toStart + i)) { break } else if (fromCode === CHAR_BACKWARD_SLASH) { lastCommonSep = i } } if (i !== length) { if (lastCommonSep === -1) return toOrig } else { if (toLen > length) { if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { return toOrig.substring(toStart + i + 1) } if (i === 2) { return toOrig.substring(toStart + i) } } if (fromLen > length) { if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { lastCommonSep = i } else if (i === 2) { lastCommonSep = 3 } } if (lastCommonSep === -1) lastCommonSep = 0 } let out = '' for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) { out += out.length === 0 ? '..' : '\\..' } } toStart += lastCommonSep if (out.length > 0) { return `${out}${toOrig.substring(toStart, toEnd)}` } if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { ++toStart } return toOrig.substring(toStart, toEnd) } exports.toNamespacedPath = function toNamespacedPath(path) { if (path.length === 0) return path const resolvedPath = exports.resolve(path) if (resolvedPath.length <= 2) return path if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { const code = resolvedPath.charCodeAt(2) if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { return `\\\\?\\UNC\\${resolvedPath.substring(2)}` } } } else if ( isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH ) { return `\\\\?\\${resolvedPath}` } return path } exports.dirname = function dirname(path) { const len = path.length if (len === 0) return '.' let rootEnd = -1 let offset = 0 const code = path.charCodeAt(0) if (len === 1) { return isWindowsPathSeparator(code) ? path : '.' } if (isWindowsPathSeparator(code)) { rootEnd = offset = 1 if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len) { return path } if (j !== last) { rootEnd = offset = j + 1 } } } } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { rootEnd = len > 2 && isWindowsPathSeparator(path.charCodeAt(2)) ? 3 : 2 offset = rootEnd } let end = -1 let matchedSlash = true for (let i = len - 1; i >= offset; --i) { if (isWindowsPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { end = i break } } else { matchedSlash = false } } if (end === -1) { if (rootEnd === -1) return '.' end = rootEnd } return path.substring(0, end) } exports.basename = function basename(path, suffix) { let start = 0 let end = -1 let matchedSlash = true if ( path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON ) { start = 2 } if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) return '' let extIdx = suffix.length - 1 let firstNonSlashEnd = -1 for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i) if (isWindowsPathSeparator(code)) { if (!matchedSlash) { start = i + 1 break } } else { if (firstNonSlashEnd === -1) { matchedSlash = false firstNonSlashEnd = i + 1 } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) { end = i } } else { extIdx = -1 end = firstNonSlashEnd } } } } if (start === end) end = firstNonSlashEnd else if (end === -1) end = path.length return path.substring(start, end) } for (let i = path.length - 1; i >= start; --i) { if (isWindowsPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { start = i + 1 break } } else if (end === -1) { matchedSlash = false end = i + 1 } } if (end === -1) return '' return path.substring(start, end) } exports.extname = function extname(path) { let start = 0 let startDot = -1 let startPart = 0 let end = -1 let matchedSlash = true let preDotState = 0 if ( path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0)) ) { start = startPart = 2 } for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i) if (isWindowsPathSeparator(code)) { if (!matchedSlash) { startPart = i + 1 break } continue } if (end === -1) { matchedSlash = false end = i + 1 } if (code === CHAR_DOT) { if (startDot === -1) startDot = i else if (preDotState !== 1) preDotState = 1 } else if (startDot !== -1) { preDotState = -1 } } if ( startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return '' } return path.substring(startDot, end) } { "name": "bare-path", "version": "3.0.1", "description": "Path manipulation library for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./posix": "./lib/posix.js", "./win32": "./lib/win32.js" }, "files": [ "index.js", "index.d.ts", "lib", "NOTICE" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-path.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-path/issues" }, "homepage": "https://github.com/holepunchto/bare-path#readme", "dependencies": { "bare-os": "^3.0.1" }, "devDependencies": { "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } const b4a = require('b4a') const stream = require('streamx') const { ReadableStream, WritableStream } = require('./web') const defaultEncoding = 'utf8' module.exports = exports = stream.Stream exports.pipeline = stream.pipeline exports.isStream = stream.isStream exports.isEnding = stream.isEnding exports.isEnded = stream.isEnded exports.isFinishing = stream.isFinishing exports.isFinished = stream.isFinished exports.isDisturbed = stream.isDisturbed exports.isErrored = function isErrored(stream) { return exports.getStreamError(stream) !== null } exports.isReadable = function isReadable(stream) { return stream.readable && !stream.destroying && !exports.isEnded(stream) } exports.isWritable = function isWritable(stream) { return stream.writable && !stream.destroying && !exports.isFinishing(stream) } exports.getStreamError = stream.getStreamError exports.addAbortSignal = function addAbortSignal(signal, stream) { function onAbort() { stream.destroy(signal.reason) } if (signal.aborted) onAbort() else signal.addEventListener('abort', onAbort) return stream } exports.Stream = exports exports.Readable = class Readable extends stream.Readable { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, map: null, mapReadable: null }) if (this._construct) this._open = this._construct if (this._read !== stream.Readable.prototype._read) { this._read = read.bind(this, this._read) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } get closed() { return !exports.isReadable(this) } get errored() { return stream.getStreamError(this) } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } static fromWeb(readableStream, opts = {}) { const stream = readableStream._stream if (opts.encoding) stream.setEncoding(opts.encoding) if (opts.signal) exports.addAbortSignal(opts.signal, stream) return stream } static toWeb(readable, opts = {}) { return new ReadableStream(readable, opts.strategy) } async [Symbol.asyncDispose]() { if (!this.destroyed) this.destroy() await new Promise((resolve) => exports.finished(this, resolve)) } } exports.Writable = class Writable extends stream.Writable { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthWritable, map: null, mapWritable: null }) if (this._construct) this._open = this._construct if (this._write !== stream.Writable.prototype._write) { this._write = write.bind(this, this._write) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } get closed() { return !exports.isWritable(this) } get errored() { return stream.getStreamError(this) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding || defaultEncoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } static fromWeb(writableStream, opts = {}) { const stream = writableStream._stream if (opts.signal) exports.addAbortSignal(opts.signal, stream) return stream } static toWeb(writable) { return new WritableStream(writable) } async [Symbol.asyncDispose]() { if (!this.destroyed) this.destroy() await new Promise((resolve) => exports.finished(this, resolve)) } } exports.Duplex = class Duplex extends stream.Duplex { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, byteLengthWritable, map: null, mapReadable: null, mapWritable: null }) if (this._construct) this._open = this._construct if (this._read !== stream.Readable.prototype._read) { this._read = read.bind(this, this._read) } if (this._write !== stream.Duplex.prototype._write) { this._write = write.bind(this, this._write) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } static fromWeb({ readable: readableStream, writable: writableStream }, opts) { const readable = exports.Readable.fromWeb(readableStream, opts) const writable = exports.Writable.fromWeb(writableStream, opts) const duplex = new exports.Duplex({ write(data, encoding, cb) { writable.write(data, encoding, cb) } }) readable .on('data', (data) => duplex.push(data)) .on('end', () => duplex.push(null)) .on('error', (err) => duplex.destroy(err)) writable.on('finish', () => duplex.end()).on('error', (err) => duplex.destroy(err)) return duplex } static toWeb(duplex) { const readableStream = exports.Readable.toWeb(duplex) const writableStream = exports.Writable.toWeb(duplex) return { readable: readableStream, writable: writableStream } } } class DuplexSide extends exports.Duplex { constructor(opts) { super(opts) this._otherSide = null this._cb = null } _read() { const cb = this._cb if (!cb) return this._cb = null cb() } _write(chunk, encoding, cb) { this._otherSide.push(chunk, encoding) this._otherSide._cb = cb } _final(cb) { this._otherSide.on('end', cb) this._otherSide.push(null) } } exports.duplexPair = function duplexPair(opts) { const sideA = new DuplexSide(opts) const sideB = new DuplexSide(opts) sideA._otherSide = sideB sideB._otherSide = sideA return [sideA, sideB] } exports.Transform = class Transform extends stream.Transform { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, byteLengthWritable, map: null, mapReadable: null, mapWritable: null }) if (this._transform !== stream.Transform.prototype._transform) { this._transform = transform.bind(this, this._transform) } else { this._transform = passthrough } } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } } exports.PassThrough = class PassThrough extends exports.Transform {} exports.finished = function finished(stream, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} const { cleanup = false } = opts const done = () => { cb(exports.getStreamError(stream, { all: true })) if (cleanup) detach() } const detach = () => { stream.off('close', done) stream.off('error', noop) } if (stream.destroyed) { done() } else { stream.on('close', done) stream.on('error', noop) } return detach } function read(read, cb) { read.call(this, 65536) cb(null) } function write(write, data, cb) { write.call(this, data.chunk, data.encoding, cb) } function transform(transform, data, cb) { transform.call(this, data.chunk, data.encoding, cb) } function destroy(destroy, cb) { destroy.call(this, exports.getStreamError(this), cb) } function passthrough(data, cb) { cb(null, data.chunk) } function byteLengthWritable(data) { return data.chunk.byteLength } function noop() {} { "name": "bare-stream", "version": "2.13.3", "description": "Streaming data for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./promises": "./promises.js", "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" } }, "files": [ "index.js", "index.d.ts", "promises.js", "web.js", "web.d.ts", "global.js", "global.d.ts" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-stream.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-stream/issues" }, "homepage": "https://github.com/holepunchto/bare-stream#readme", "dependencies": { "b4a": "^1.8.1", "streamx": "^2.25.0", "teex": "^1.0.1" }, "devDependencies": { "bare-abort-controller": "^1.1.0", "bare-buffer": "^3.0.0", "bare-events": "^2.5.4", "brittle": "^3.5.2", "lunte": "^1.6.0", "prettier": "^3.3.3", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "bare-abort-controller": "*", "bare-buffer": "*", "bare-events": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true }, "bare-buffer": { "optional": true }, "bare-events": { "optional": true } } } const { Readable, Writable, Transform, getStreamError, isStreamx, isDisturbed } = require('streamx') const tee = require('teex') const readableKind = Symbol.for('bare.stream.readable.kind') const writableKind = Symbol.for('bare.stream.writable.kind') const transformKind = Symbol.for('bare.stream.transform.kind') // https://streams.spec.whatwg.org/#readablestreamdefaultreader exports.ReadableStreamDefaultReader = class ReadableStreamDefaultReader { constructor(stream) { this._stream = stream this._stream._stream.once('close', onclose).once('error', onerror) const closed = Promise.withResolvers() // Avoid unhandled exceptions closed.promise.catch(noop) this._closed = closed function onclose() { closed.resolve() } function onerror(err) { closed.reject(err) } } get closed() { return this._closed.promise } read() { const stream = this._stream._stream return new Promise((resolve, reject) => { const err = getStreamError(stream) if (err) return reject(err) if (stream.destroyed) { return resolve({ value: undefined, done: true }) } const value = stream.read() if (value !== null) { return resolve({ value, done: false }) } stream.once('readable', onreadable).once('close', onclose).once('error', onerror) function onreadable() { const value = stream.read() ondone(null, value === null ? { value: undefined, done: true } : { value, done: false }) } function onclose() { ondone(null, { value: undefined, done: true }) } function onerror(err) { ondone(err, null) } function ondone(err, value) { stream.off('readable', onreadable).off('close', onclose).off('error', onerror) if (err) reject(err) else resolve(value) } }) } releaseLock() { this._closed.reject(new TypeError('Reader was released')) this._stream._releaseLock() this._stream = null } cancel(reason = new TypeError('Stream was cancelled')) { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).once('error', noop).destroy(reason) ) } } // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller exports.ReadableStreamDefaultController = class ReadableStreamDefaultController { constructor(stream) { this._stream = stream } get desiredSize() { const stream = this._stream._stream return stream._readableState.highWaterMark - stream._readableState.buffered } enqueue(data) { this._stream._stream.push(data) } close() { this._stream._stream.push(null) } error(err) { this._stream._stream.destroy(err) } } // https://streams.spec.whatwg.org/#readablestream class ReadableStream { static get [readableKind]() { return 0 // Compatibility version } static from(iterable) { return new ReadableStream(Readable.from(iterable)) } constructor(underlyingSource = {}, queuingStrategy) { if (isStreamx(underlyingSource)) { this._stream = underlyingSource } else { if (queuingStrategy === undefined) { queuingStrategy = new exports.CountQueuingStrategy() } const { start, pull, cancel } = underlyingSource const { highWaterMark = 1, size = defaultSize } = queuingStrategy this._stream = new Readable({ highWaterMark, byteLength: size }) const controller = new exports.ReadableStreamDefaultController(this) try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (pull) { this._stream._read = this._read.bind(this, starting, pull.bind(this, controller)) } if (cancel) { this._stream.once('error', cancel.bind(this)) } } catch (err) { controller.error(err) } } this._reader = null } get [readableKind]() { return ReadableStream[readableKind] } get locked() { return this._reader !== null } getReader() { if (this.locked) throw new TypeError('Stream is locked') this._reader = new exports.ReadableStreamDefaultReader(this) return this._reader } cancel(reason = new TypeError('Stream was cancelled')) { const stream = this._stream if (stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => stream.once('close', resolve).once('error', noop).destroy(reason) ) } tee() { const [a, b] = tee(this._stream) return [new ReadableStream(a), new ReadableStream(b)] } pipeTo(destination) { return new Promise((resolve, reject) => this._stream.pipe(destination._stream, (err) => { err ? reject(err) : resolve() }) ) } [Symbol.asyncIterator]() { return this._stream[Symbol.asyncIterator]() } _releaseLock() { this._reader = null } async _read(starting, pull, cb) { await starting let err = null try { await pull() } catch (e) { err = e } cb(err) } } function defaultSize() { return 1 } exports.ReadableStream = ReadableStream // https://streams.spec.whatwg.org/#countqueuingstrategy exports.CountQueuingStrategy = class CountQueuingStrategy { constructor(opts = {}) { const { highWaterMark = 1 } = opts this.highWaterMark = highWaterMark } size(chunk) { return 1 } } // https://streams.spec.whatwg.org/#bytelengthqueuingstrategy exports.ByteLengthQueuingStrategy = class ByteLengthQueuingStrategy { constructor(opts = {}) { const { highWaterMark = 16384 } = opts this.highWaterMark = highWaterMark } size(chunk) { return chunk.byteLength } } exports.isReadableStream = function isReadableStream(value) { if (value instanceof ReadableStream) return true return ( typeof value === 'object' && value !== null && value[readableKind] === ReadableStream[readableKind] ) } // https://streams.spec.whatwg.org/#readablestream-errored exports.isReadableStreamErrored = function isReadableStreamErrored(stream) { return getStreamError(stream._stream) !== null } // https://streams.spec.whatwg.org/#is-readable-stream-disturbed exports.isReadableStreamDisturbed = function isReadableStreamDisturbed(stream) { return isDisturbed(stream._stream) } // https://streams.spec.whatwg.org/#writablestreamdefaultwriter exports.WritableStreamDefaultWriter = class WritableStreamDefaultWriter { constructor(stream) { this._stream = stream this._stream._stream.once('close', onclose).once('error', onerror) const closed = Promise.withResolvers() // Avoid unhandled exceptions closed.promise.catch(noop) this._closed = closed function onclose() { closed.resolve() } function onerror(err) { closed.reject(err) } } get desiredSize() { const stream = this._stream._stream return stream._writableState.highWaterMark - stream._writableState.buffered } get closed() { return this._closed.promise } get ready() { const stream = this._stream._stream if (getStreamError(stream)) return Promise.reject() return Writable.drained(stream).then() } async write(chunk) { const stream = this._stream._stream let err = getStreamError(stream) if (err) return Promise.reject(err) stream.write(chunk) await Writable.drained(stream) err = getStreamError(stream) if (err) return Promise.reject(err) } releaseLock() { this._closed.reject(new TypeError('Writer was released')) this._stream._releaseLock() this._stream = null } close() { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).end()) } abort(reason = new TypeError('Stream was aborted')) { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).destroy(reason)) } } // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller exports.WritableStreamDefaultController = class WritableStreamDefaultController { constructor(stream) { this._stream = stream } error(err) { this._stream._stream.destroy(err) } } // https://streams.spec.whatwg.org/#writablestream class WritableStream { static get [writableKind]() { return 0 // Compatibility version } constructor(underlyingSink = {}, queuingStrategy = {}) { if (isStreamx(underlyingSink)) { this._stream = underlyingSink } else { if (queuingStrategy === undefined) { queuingStrategy = new exports.CountQueuingStrategy() } const { start, write, close, abort } = underlyingSink const { highWaterMark = 1, size = defaultSize } = queuingStrategy this._stream = new Writable({ highWaterMark, byteLength: size }) const controller = new exports.WritableStreamDefaultController(this) this._controller = controller try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (write) { this._stream._write = this._write.bind(this, starting, write.bind(this)) } if (close) { this._stream._destroy = this._destroy.bind(this, close.call(this)) } if (abort) { this._stream.once('error', abort.bind(this)) } } catch (err) { controller.error(err) } } this._writer = null } get [writableKind]() { return WritableStream[writableKind] } get locked() { return this._writer !== null } getWriter() { if (this.locked) throw new TypeError('Stream is locked') this._writer = new exports.WritableStreamDefaultWriter(this) return this._writer } abort(reason = new TypeError('Stream was aborted')) { if (this._stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => this._stream.once('close', resolve).destroy(reason)) } close() { if (this._stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => this._stream.once('close', resolve).end()) } _releaseLock() { this._writer = null } async _write(starting, write, data, cb) { await starting let err = null try { await write(data, this._controller) } catch (e) { err = e } cb(err) } async _destroy(closing, cb) { let err = null try { await closing } catch (e) { err = e } cb(err) } } exports.WritableStream = WritableStream exports.isWritableStream = function isWritableStream(value) { if (value instanceof WritableStream) return true return ( typeof value === 'object' && value !== null && value[writableKind] === WritableStream[writableKind] ) } // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller exports.TransformStreamDefaultController = class TransformStreamDefaultController { constructor(stream) { this._stream = stream } get desiredSize() { const stream = this._stream._stream return stream._readableState.highWaterMark - stream._readableState.buffered } enqueue(data) { this._stream._stream.push(data) } error(err) { this._stream._stream.destroy(err) } terminate() { const stream = this._stream._stream stream.push(null) stream.destroy(new TypeError('Stream has been terminated')) } } // https://streams.spec.whatwg.org/#transformstream class TransformStream { static get [transformKind]() { return 0 // Compatibility version } constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) { if (isStreamx(transformer)) { this._stream = transformer } else { const { start, transform, flush } = transformer this._stream = new Transform({ ...writableStrategy, ...readableStrategy }) const controller = new exports.TransformStreamDefaultController(this) this._controller = controller try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (transform) { this._stream._transform = this._transform.bind(this, starting, transform.bind(this)) } if (flush) { this._stream._flush = this._flush.bind(this, flush.call(this, this._controller)) } } catch (err) { controller.error(err) } } this._writable = new WritableStream(this._stream) this._readable = new ReadableStream(this._stream) } get [transformKind]() { return TransformStream[transformKind] } get writable() { return this._writable } get readable() { return this._readable } async _transform(starting, transform, data, cb) { await starting let err = null try { await transform(data, this._controller) } catch (e) { err = e } cb(err) } async _flush(flush, cb) { let err = null try { await flush } catch (e) { err = e } cb(err) } } exports.TransformStream = TransformStream exports.isTransformStream = function isTransformStream(value) { if (value instanceof TransformStream) return true return ( typeof value === 'object' && value !== null && value[transformKind] === TransformStream[transformKind] ) } async function forwardError(promise, controller) { try { await promise } catch (err) { controller.error(err) } } function noop() {} module.exports = require.addon() const binding = require('./binding') const t = binding.constants class Type { constructor(type) { this._type = type } isUndefined() { return this._type === t.UNDEFINED } isNull() { return this._type === t.NULL } isBoolean() { return this._type === t.BOOLEAN } isNumber() { return (this._type & 0xff) === t.NUMBER } isInt32() { return (this._type & (0xff | t.INT32)) === (t.NUMBER | t.INT32) } isUint32() { return (this._type & (0xff | t.UINT32)) === (t.NUMBER | t.UINT32) } isString() { return this._type === t.STRING } isSymbol() { return this._type === t.SYMBOL } isObject() { return (this._type & 0xff) === t.OBJECT } isArray() { return this._type === (t.OBJECT | t.ARRAY) } isArguments() { return this._type === (t.OBJECT | t.ARGUMENTS) } isDate() { return this._type === (t.OBJECT | t.DATE) } isRegExp() { return this._type === (t.OBJECT | t.REGEXP) } isError() { return this._type === (t.OBJECT | t.ERROR) } isPromise() { return this._type === (t.OBJECT | t.PROMISE) } isProxy() { return this._type === (t.OBJECT | t.PROXY) } isGenerator() { return this._type === (t.OBJECT | t.GENERATOR) } isMap() { return this._type === (t.OBJECT | t.MAP) } isSet() { return this._type === (t.OBJECT | t.SET) } isWeakMap() { return this._type === (t.OBJECT | t.WEAK_MAP) } isWeakSet() { return this._type === (t.OBJECT | t.WEAK_SET) } isWeakRef() { return this._type === (t.OBJECT | t.WEAK_REF) } isArrayBuffer() { return this._type === (t.OBJECT | t.ARRAYBUFFER) } isSharedArrayBuffer() { return this._type === (t.OBJECT | t.SHAREDARRAYBUFFER) } isTypedArray() { return (this._type & 0xffff) === (t.OBJECT | t.TYPEDARRAY) } isInt8Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT8ARRAY) } isUint8Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8ARRAY) } isUint8ClampedArray() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8CLAMPEDARRAY) } isInt16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT16ARRAY) } isUint16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT16ARRAY) } isInt32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT32ARRAY) } isUint32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT32ARRAY) } isFloat16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT16ARRAY) } isFloat32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT32ARRAY) } isFloat64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT64ARRAY) } isBigInt64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGINT64ARRAY) } isBigUint64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGUINT64ARRAY) } isDataView() { return this._type === (t.OBJECT | t.DATAVIEW) } isModuleNamespace() { return this._type === (t.OBJECT | t.MODULE_NAMESPACE) } isFunction() { return (this._type & 0xff) === t.FUNCTION } isAsyncFunction() { return ( (this._type & (0xff | t.ASYNC_FUNCTION)) === (t.FUNCTION | t.ASYNC_FUNCTION) ) } isGeneratorFunction() { return ( (this._type & (0xff | t.GENERATOR_FUNCTION)) === (t.FUNCTION | t.GENERATOR_FUNCTION) ) } isExternal() { return this._type === t.EXTERNAL } isBigInt() { return this._type === t.BIGINT } } module.exports = exports = function type(value) { switch (typeof value) { case 'undefined': return new Type(t.UNDEFINED) case 'boolean': return new Type(t.BOOLEAN) case 'number': return new Type( Number.isSafeInteger(value) ? binding.type(value) : t.NUMBER ) case 'string': return new Type(t.STRING) case 'symbol': return new Type(t.SYMBOL) case 'object': return new Type(value === null ? t.NULL : binding.type(value)) case 'function': return new Type(binding.type(value)) case 'bigint': return new Type(t.BIGINT) } } exports.createTag = function createTag(...components) { const tag = new Uint32Array(4) for (let i = 0; i < 4; i++) tag[i] = components[i] || 0 return tag } exports.addTag = function addTag(object, tag) { binding.addTag(object, tag) } exports.checkTag = function checkTag(object, tag) { return binding.checkTag(object, tag) } { "name": "bare-type", "version": "1.1.0", "description": "Cross-realm type predicates for Bare", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-type.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-type/issues" }, "homepage": "https://github.com/holepunchto/bare-type#readme", "engines": { "bare": ">=1.2.0" }, "devDependencies": { "brittle": "^3.4.0", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const path = require('bare-path') const binding = require('./binding') const errors = require('./lib/errors') const URLSearchParams = require('./lib/url-search-params') const kind = Symbol.for('bare.url.kind') const isWindows = Bare.platform === 'win32' class URL { static get [kind]() { return 0 // Compatibility version } constructor(input, base, opts = {}) { if (arguments.length === 0) throw errors.INVALID_URL() input = String(input) if (base !== undefined) base = String(base) this._components = new Uint32Array(8) this._parse(input, base, opts.throw !== false) if (this._href) this._params = new URLSearchParams(this.search, this) } get [kind]() { return URL[kind] } // https://url.spec.whatwg.org/#dom-url-href get href() { return this._href } set href(value) { this._update(value) this._params._parse(this.search) } // https://url.spec.whatwg.org/#dom-url-protocol get protocol() { return this._slice(0, this._components[0]) + ':' } set protocol(value) { this._update(this._replace(value.replace(/:+$/, ''), 0, this._components[0])) } // https://url.spec.whatwg.org/#dom-url-username get username() { return this._slice(this._components[0] + 3 /* :// */, this._components[1]) } set username(value) { if (cannotHaveCredentialsOrPort(this)) { return } if (this.username === '') value += '@' this._update(this._replace(value, this._components[0] + 3 /* :// */, this._components[1])) } // https://url.spec.whatwg.org/#dom-url-password get password() { return this._href.slice(this._components[1] + 1 /* : */, this._components[2] - 1 /* @ */) } set password(value) { if (cannotHaveCredentialsOrPort(this)) { return } let start = this._components[1] + 1 /* : */ let end = this._components[2] - 1 /* @ */ if (this.password === '') { value = ':' + value start-- } if (this.username === '') { value += '@' end++ } this._update(this._replace(value, start, end)) } // https://url.spec.whatwg.org/#dom-url-host get host() { return this._slice(this._components[2], this._components[5]) } set host(value) { if (hasOpaquePath(this)) { return } this._update( this._replace(value, this._components[2], this._components[value.includes(':') ? 5 : 3]) ) } // https://url.spec.whatwg.org/#dom-url-hostname get hostname() { return this._slice(this._components[2], this._components[3]) } set hostname(value) { if (hasOpaquePath(this)) { return } this._update(this._replace(value, this._components[2], this._components[3])) } // https://url.spec.whatwg.org/#dom-url-port get port() { return this._slice(this._components[3] + 1 /* : */, this._components[5]) } set port(value) { if (cannotHaveCredentialsOrPort(this)) { return } let start = this._components[3] + 1 /* : */ if (this.port === '') { value = ':' + value start-- } this._update(this._replace(value, start, this._components[5])) } // https://url.spec.whatwg.org/#dom-url-pathname get pathname() { return this._slice(this._components[5], this._components[6] - 1 /* ? */) } set pathname(value) { if (hasOpaquePath(this)) { return } if (value[0] !== '/' && value[0] !== '\\') { value = '/' + value } this._update(this._replace(value, this._components[5], this._components[6] - 1 /* ? */)) } // https://url.spec.whatwg.org/#dom-url-search get search() { return this._slice(this._components[6] - 1 /* ? */, this._components[7] - 1 /* # */) } set search(value) { if (value && value[0] !== '?') value = '?' + value this._update( this._replace(value, this._components[6] - 1 /* ? */, this._components[7] - 1 /* # */) ) this._params._parse(this.search) } // https://url.spec.whatwg.org/#dom-url-searchparams get searchParams() { return this._params } // https://url.spec.whatwg.org/#dom-url-hash get hash() { return this._slice(this._components[7] - 1 /* # */) } set hash(value) { if (value && value[0] !== '#') value = '#' + value this._update(this._replace(value, this._components[7] - 1 /* # */)) } toString() { return this._href } toJSON() { return this._href } [Symbol.for('bare.inspect')]() { return { __proto__: { constructor: URL }, href: this.href, protocol: this.protocol, username: this.username, password: this.password, host: this.host, hostname: this.hostname, port: this.port, pathname: this.pathname, search: this.search, searchParams: this.searchParams, hash: this.hash } } _slice(start, end = this._href.length) { return this._href.slice(start, end) } _replace(replacement, start, end = this._href.length) { return this._slice(0, start) + replacement + this._slice(end) } _parse(input, base, shouldThrow) { try { this._href = binding.parse( String(input), base ? String(base) : null, this._components, shouldThrow ) } catch (err) { if (err instanceof TypeError) throw err throw errors.INVALID_URL(`Invalid URL '${input}'`, input) } } _update(input) { try { this._parse(input, null, true) } catch (err) { if (err instanceof TypeError) throw err } } } module.exports = exports = URL // https://url.spec.whatwg.org/#url-opaque-path function hasOpaquePath(url) { return url.pathname[0] !== '/' } // https://url.spec.whatwg.org/#cannot-have-a-username-password-port function cannotHaveCredentialsOrPort(url) { return url.hostname === '' || url.protocol === 'file:' } exports.URL = URL exports.URLSearchParams = URLSearchParams exports.errors = errors exports.isURL = function isURL(value) { if (value instanceof URL) return true return typeof value === 'object' && value !== null && value[kind] === URL[kind] } exports.isURLSearchParams = URLSearchParams.isURLSearchParams // https://url.spec.whatwg.org/#dom-url-parse exports.parse = function parse(input, base) { const url = new URL(input, base, { throw: false }) return url._href ? url : null } // https://url.spec.whatwg.org/#dom-url-canparse exports.canParse = function canParse(input, base) { return binding.canParse(String(input), base ? String(base) : null) } exports.fileURLToPath = function fileURLToPath(url) { if (typeof url === 'string') { url = new URL(url) } if (url.protocol !== 'file:') { throw errors.INVALID_URL_SCHEME('The URL must use the file: protocol') } if (isWindows) { if (/%2f|%5c/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH( 'The file: URL path must not include encoded \\ or / characters' ) } } else { if (url.hostname) { throw errors.INVALID_FILE_URL_HOST("The file: URL host must be 'localhost' or empty") } if (/%2f/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must not include encoded / characters') } } if (/%00/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must not include encoded NUL characters') } const pathname = path.normalize(decodeURIComponent(url.pathname)) if (isWindows) { if (url.hostname) return '\\\\' + url.hostname + pathname const letter = pathname.charCodeAt(1) | 0x20 if (letter < 0x61 /* a */ || letter > 0x7a /* z */ || pathname.charCodeAt(2) !== 0x3a /* : */) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must be absolute') } return pathname.slice(1) } return pathname } exports.pathToFileURL = function pathToFileURL(pathname) { let resolved = path.resolve(pathname) if (pathname[pathname.length - 1] === '/') { resolved += '/' } else if (isWindows && pathname[pathname.length - 1] === '\\') { resolved += '\\' } resolved = resolved .replaceAll('%', '%25') // Must be first .replaceAll('#', '%23') .replaceAll('?', '%3f') .replaceAll('\n', '%0a') .replaceAll('\r', '%0d') .replaceAll('\t', '%09') if (!isWindows) { resolved = resolved.replaceAll('\\', '%5c') } return new URL('file:' + resolved) } exports.format = function format(parts) { const { protocol, auth, host, hostname, port, pathname, search, query, hash, slashes } = parts let result = '' if (typeof protocol === 'string') { result += protocol if (protocol[protocol.length - 1] !== ':') { result += ':' } if (slashes === true || /https?|ftp|gopher|file/.test(protocol)) { result += '//' } } if (typeof auth === 'string') { if (host || hostname) result += auth + '@' } if (typeof host === 'string') result += host else { result += hostname if (port) result += ':' + port } if (typeof pathname === 'string' && pathname !== '') { if (pathname[0] !== '/') result += '/' result += pathname } if (typeof search === 'string') { if (search[0] !== '?') result += '?' result += search } else if (typeof query === 'object' && query !== null) { result += '?' + new URLSearchParams(query) } if (typeof hash === 'string') { if (hash[0] !== '#') result += '#' result += hash } return result } module.exports = class URLError extends Error { constructor(msg, fn = URLError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) Error.captureStackTrace(this, fn) } get name() { return 'URLError' } static INVALID_URL(msg, input) { const err = new URLError(msg, URLError.INVALID_URL) err.input = input return err } static INVALID_URL_SCHEME(msg = 'Invalid URL') { return new URLError(msg, URLError.INVALID_URL_SCHEME) } static INVALID_FILE_URL_HOST(msg = 'Invalid file: URL host') { return new URLError(msg, URLError.INVALID_FILE_URL_HOST) } static INVALID_FILE_URL_PATH(msg = 'Invalid file: URL path') { return new URLError(msg, URLError.INVALID_FILE_URL_PATH) } } const kind = Symbol.for('bare.url.search-params.kind') class URLSearchParams { static _urls = new WeakMap() static get [kind]() { return 0 // Compatibility version } // https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams constructor(init, url = null) { this._params = new Map() if (url) URLSearchParams._urls.set(this, url) if (typeof init === 'string') { this._parse(init) } else if (init) { for (const [name, value] of typeof init[Symbol.iterator] === 'function' ? init : Object.entries(init)) { this.append(name, value) } } } get [kind]() { return URLSearchParams[kind] } // https://url.spec.whatwg.org/#dom-urlsearchparams-size get size() { return this._params.length } // https://url.spec.whatwg.org/#dom-urlsearchparams-append append(name, value = null) { if (value === null) return let list = this._params.get(name) if (list === undefined) { list = [] this._params.set(name, list) } list.push(value) this._update() } // https://url.spec.whatwg.org/#dom-urlsearchparams-delete delete(name, value = null) { if (value === null) this._params.delete(name) else { let list = this._params.get(name) if (list === undefined) return list = list.filter((found) => found !== value) if (list.length === 0) this._params.delete(name) else this._params.set(name, list) } this._update() } // https://url.spec.whatwg.org/#dom-urlsearchparams-get get(name) { const list = this._params.get(name) if (list === undefined) return null return list[0] } // https://url.spec.whatwg.org/#dom-urlsearchparams-getall getAll(name) { const list = this._params.get(name) if (list === undefined) return [] return Array.from(list) } // https://url.spec.whatwg.org/#dom-urlsearchparams-has has(name, value = null) { const list = this._params.get(name) if (list === undefined) return false if (value === null) return true return list.includes(value) } // https://url.spec.whatwg.org/#dom-urlsearchparams-set set(name, value = null) { if (value === null) this._params.delete(name) else this._params.set(name, [value]) this._update() } toString() { return this._serialize() } toJSON() { return [...this] } *[Symbol.iterator]() { for (const [name, values] of this._params) { for (const value of values) yield [name, value] } } [Symbol.for('bare.inspect')]() { const object = { __proto__: { constructor: URLSearchParams } } for (const [name, values] of this._params) { if (values.length === 1) object[name] = values[0] else object[name] = values } return object } // https://url.spec.whatwg.org/#concept-urlsearchparams-update _update() { const url = URLSearchParams._urls.get(this) if (url === undefined) return url.search = this._serialize() } // https://url.spec.whatwg.org/#concept-urlencoded-parser _parse(input) { if (input[0] === '?') input = input.substring(1) this._params = new Map() for (let sequence of input.split('&')) { if (sequence.length === 0) continue sequence = sequence.replace(/\+/g, ' ') let i = sequence.indexOf('=') if (i === -1) i = sequence.length const name = decodeURIComponent(sequence.substring(0, i)) const value = decodeURIComponent(sequence.substring(i + 1, sequence.length)) let list = this._params.get(name) if (list === undefined) { list = [] this._params.set(name, list) } list.push(value) } } // https://url.spec.whatwg.org/#concept-urlencoded-serializer _serialize() { let output = '' for (let [name, values] of this._params) { name = encodeURIComponent(name) for (const value of values) { if (output) output += '&' output += name + '=' + encodeURIComponent(value) } } return output } } module.exports = exports = URLSearchParams exports.isURLSearchParams = function isURLSearchParams(value) { if (value instanceof URLSearchParams) return true return typeof value === 'object' && value !== null && value[kind] === URLSearchParams[kind] } { "name": "bare-url", "version": "2.4.5", "description": "WHATWG URL implementation for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" } }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-url.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-url/issues" }, "homepage": "https://github.com/holepunchto/bare-url", "dependencies": { "bare-path": "^3.0.0" }, "devDependencies": { "brittle": "^3.3.2", "cmake-bare": "^1.1.6", "cmake-fetch": "^1.0.0", "lunte": "^1.6.0", "prettier": "^3.3.3", "prettier-config-holepunch": "^2.0.0" } } const LE = (exports.LE = new Uint8Array(new Uint16Array([0xff]).buffer)[0] === 0xff) exports.BE = !LE const b4a = require('b4a') const { BE } = require('./endian') exports.state = function (start = 0, end = 0, buffer = null) { return { start, end, buffer } } const raw = (exports.raw = require('./raw')) const uint = (exports.uint = { preencode(state, n) { state.end += n <= 0xfc ? 1 : n <= 0xffff ? 3 : n <= 0xffffffff ? 5 : 9 }, encode(state, n) { if (n <= 0xfc) uint8.encode(state, n) else if (n <= 0xffff) { state.buffer[state.start++] = 0xfd uint16.encode(state, n) } else if (n <= 0xffffffff) { state.buffer[state.start++] = 0xfe uint32.encode(state, n) } else { state.buffer[state.start++] = 0xff uint64.encode(state, n) } }, decode(state) { const a = uint8.decode(state) if (a <= 0xfc) return a if (a === 0xfd) return uint16.decode(state) if (a === 0xfe) return uint32.decode(state) return uint64.decode(state) } }) const uint8 = (exports.uint8 = { preencode(state, n) { state.end += 1 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n }, decode(state) { if (state.start >= state.end) throw new Error('Out of bounds') return state.buffer[state.start++] } }) const uint16 = (exports.uint16 = { preencode(state, n) { state.end += 2 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 }, decode(state) { if (state.end - state.start < 2) throw new Error('Out of bounds') return state.buffer[state.start++] + state.buffer[state.start++] * 0x100 } }) const uint24 = (exports.uint24 = { preencode(state, n) { state.end += 3 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n >>> 16 }, decode(state) { if (state.end - state.start < 3) throw new Error('Out of bounds') return ( state.buffer[state.start++] + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] * 0x10000 ) } }) const uint32 = (exports.uint32 = { preencode(state, n) { state.end += 4 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n >>> 16 state.buffer[state.start++] = n >>> 24 }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] * 0x10000 + state.buffer[state.start++] * 0x1000000 ) } }) const uint32be = (exports.uint32be = { preencode(state, n) { state.end += 4 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n >>> 24 state.buffer[state.start++] = n >>> 16 state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] * 0x1000000 + state.buffer[state.start++] * 0x10000 + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] ) } }) const uint40 = (exports.uint40 = { preencode(state, n) { state.end += 5 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100) uint8.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 5) throw new Error('Out of bounds') return uint8.decode(state) + 0x100 * uint32.decode(state) } }) const uint48 = (exports.uint48 = { preencode(state, n) { state.end += 6 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x10000) uint16.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 6) throw new Error('Out of bounds') return uint16.decode(state) + 0x10000 * uint32.decode(state) } }) const uint56 = (exports.uint56 = { preencode(state, n) { state.end += 7 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x1000000) uint24.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 7) throw new Error('Out of bounds') return uint24.decode(state) + 0x1000000 * uint32.decode(state) } }) const uint64 = (exports.uint64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100000000) uint32.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') return uint32.decode(state) + 0x100000000 * uint32.decode(state) } }) exports.uint64be = { preencode(state, n) { state.end += 8 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100000000) uint32be.encode(state, r) uint32be.encode(state, n) }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') return 0x100000000 * uint32be.decode(state) + uint32be.decode(state) } } const int = (exports.int = zigZagInt(uint)) exports.int8 = zigZagInt(uint8) exports.int16 = zigZagInt(uint16) exports.int24 = zigZagInt(uint24) exports.int32 = zigZagInt(uint32) exports.int40 = zigZagInt(uint40) exports.int48 = zigZagInt(uint48) exports.int56 = zigZagInt(uint56) exports.int64 = zigZagInt(uint64) const biguint64 = (exports.biguint64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) view.setBigUint64(0, n, true) // little endian state.start += 8 }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) const n = view.getBigUint64(0, true) // little endian state.start += 8 return n } }) exports.bigint64 = zigZagBigInt(biguint64) const biguint = (exports.biguint = { preencode(state, n) { let len = 0 for (let m = n; m; m = m >> 64n) len++ uint.preencode(state, len) state.end += 8 * len }, encode(state, n) { let len = 0 for (let m = n; m; m = m >> 64n) len++ uint.encode(state, len) const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len ) for (let m = n, i = 0; m; m = m >> 64n, i += 8) { view.setBigUint64(i, BigInt.asUintN(64, m), true) // little endian } state.start += 8 * len }, decode(state) { const len = uint.decode(state) if (state.end - state.start < 8 * len) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len ) let n = 0n for (let i = len - 1; i >= 0; i--) n = (n << 64n) + view.getBigUint64(i * 8, true) // little endian state.start += 8 * len return n } }) exports.bigint = zigZagBigInt(biguint) exports.lexint = require('./lexint') exports.float32 = { preencode(state, n) { state.end += 4 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 4 ) view.setFloat32(0, n, true) // little endian state.start += 4 }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 4 ) const float = view.getFloat32(0, true) // little endian state.start += 4 return float } } exports.float64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) view.setFloat64(0, n, true) // little endian state.start += 8 }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) const float = view.getFloat64(0, true) // little endian state.start += 8 return float } } const buffer = (exports.buffer = { preencode(state, b) { uint8array.preencode(state, b) }, encode(state, b) { uint8array.encode(state, b) }, decode(state) { const len = uint.decode(state) if (state.end - state.start < len) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += len)) } }) exports.optionalBuffer = { preencode(state, b) { if (b) uint8array.preencode(state, b) else state.end++ }, encode(state, b) { if (b) uint8array.encode(state, b) else state.buffer[state.start++] = 0 }, decode(state) { const len = uint.decode(state) if (len === 0) return null if (state.end - state.start < len) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += len)) } } exports.binary = { ...buffer, preencode(state, b) { if (typeof b === 'string') utf8.preencode(state, b) else buffer.preencode(state, b) }, encode(state, b) { if (typeof b === 'string') utf8.encode(state, b) else buffer.encode(state, b) } } exports.arraybuffer = { preencode(state, b) { uint.preencode(state, b.byteLength) state.end += b.byteLength }, encode(state, b) { uint.encode(state, b.byteLength) const view = new Uint8Array(b) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const len = uint.decode(state) const b = new ArrayBuffer(len) const view = new Uint8Array(b) view.set(state.buffer.subarray(state.start, (state.start += len))) return b } } function typedarray(TypedArray, swap) { const n = TypedArray.BYTES_PER_ELEMENT return { preencode(state, b) { uint.preencode(state, b.length) state.end += b.byteLength }, encode(state, b) { uint.encode(state, b.length) const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength) if (BE && swap) swap(view) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const len = uint.decode(state) let b = state.buffer.subarray(state.start, (state.start += len * n)) if (b.byteLength !== len * n) throw new Error('Out of bounds') if (b.byteOffset % n !== 0) b = new Uint8Array(b) if (BE && swap) swap(b) return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n) } } } const uint8array = (exports.uint8array = typedarray(Uint8Array)) exports.uint16array = typedarray(Uint16Array, b4a.swap16) exports.uint32array = typedarray(Uint32Array, b4a.swap32) exports.int8array = typedarray(Int8Array) exports.int16array = typedarray(Int16Array, b4a.swap16) exports.int32array = typedarray(Int32Array, b4a.swap32) exports.biguint64array = typedarray(BigUint64Array, b4a.swap64) exports.bigint64array = typedarray(BigInt64Array, b4a.swap64) exports.float32array = typedarray(Float32Array, b4a.swap32) exports.float64array = typedarray(Float64Array, b4a.swap64) function string(encoding) { return { preencode(state, s) { const len = b4a.byteLength(s, encoding) uint.preencode(state, len) state.end += len }, encode(state, s) { const len = b4a.byteLength(s, encoding) uint.encode(state, len) b4a.write(state.buffer, s, state.start, encoding) state.start += len }, decode(state) { const len = uint.decode(state) if (state.end - state.start < len) throw new Error('Out of bounds') return b4a.toString( state.buffer, encoding, state.start, (state.start += len) ) }, fixed(n) { return { preencode(state) { state.end += n }, encode(state, s) { b4a.write(state.buffer, s, state.start, n, encoding) state.start += n }, decode(state) { if (state.end - state.start < n) throw new Error('Out of bounds') return b4a.toString( state.buffer, encoding, state.start, (state.start += n) ) } } } } } const utf8 = (exports.string = exports.utf8 = string('utf-8')) exports.ascii = string('ascii') exports.hex = string('hex') exports.base64 = string('base64') exports.ucs2 = exports.utf16le = string('utf16le') exports.bool = { preencode(state, b) { state.end++ }, encode(state, b) { state.buffer[state.start++] = b ? 1 : 0 }, decode(state) { if (state.start >= state.end) throw Error('Out of bounds') return state.buffer[state.start++] === 1 } } const fixed = (exports.fixed = function fixed(n) { return { preencode(state, s) { if (s.byteLength !== n) throw new Error('Incorrect buffer size') state.end += n }, encode(state, s) { state.buffer.set(s, state.start) state.start += n }, decode(state) { if (state.end - state.start < n) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += n)) } } }) exports.fixed32 = fixed(32) exports.fixed64 = fixed(64) exports.array = function array(enc) { return { preencode(state, list) { uint.preencode(state, list.length) for (let i = 0; i < list.length; i++) enc.preencode(state, list[i]) }, encode(state, list) { uint.encode(state, list.length) for (let i = 0; i < list.length; i++) enc.encode(state, list[i]) }, decode(state) { const len = uint.decode(state) if (len > 0x100000) throw new Error('Array is too big') const arr = new Array(len) for (let i = 0; i < len; i++) arr[i] = enc.decode(state) return arr } } } exports.frame = function frame(enc) { const dummy = exports.state() return { preencode(state, m) { const end = state.end enc.preencode(state, m) uint.preencode(state, state.end - end) }, encode(state, m) { dummy.end = 0 enc.preencode(dummy, m) uint.encode(state, dummy.end) enc.encode(state, m) }, decode(state) { const end = state.end const len = uint.decode(state) state.end = state.start + len const m = enc.decode(state) state.start = state.end state.end = end return m } } } exports.date = { preencode(state, d) { int.preencode(state, d.getTime()) }, encode(state, d) { int.encode(state, d.getTime()) }, decode(state, d) { return new Date(int.decode(state)) } } exports.json = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v)) }, encode(state, v) { utf8.encode(state, JSON.stringify(v)) }, decode(state) { return JSON.parse(utf8.decode(state)) } } exports.ndjson = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v) + '\n') }, encode(state, v) { utf8.encode(state, JSON.stringify(v) + '\n') }, decode(state) { return JSON.parse(utf8.decode(state)) } } // simple helper for when you want to just express nothing exports.none = { preencode(state, n) { // do nothing }, encode(state, n) { // do nothing }, decode(state) { return null } } // "any" encoders here for helping just structure any object without schematising it const anyArray = { preencode(state, arr) { uint.preencode(state, arr.length) for (let i = 0; i < arr.length; i++) { any.preencode(state, arr[i]) } }, encode(state, arr) { uint.encode(state, arr.length) for (let i = 0; i < arr.length; i++) { any.encode(state, arr[i]) } }, decode(state) { const arr = [] let len = uint.decode(state) while (len-- > 0) { arr.push(any.decode(state)) } return arr } } const anyObject = { preencode(state, o) { const keys = Object.keys(o) uint.preencode(state, keys.length) for (const key of keys) { utf8.preencode(state, key) any.preencode(state, o[key]) } }, encode(state, o) { const keys = Object.keys(o) uint.encode(state, keys.length) for (const key of keys) { utf8.encode(state, key) any.encode(state, o[key]) } }, decode(state) { let len = uint.decode(state) const o = {} while (len-- > 0) { const key = utf8.decode(state) o[key] = any.decode(state) } return o } } const anyTypes = [ exports.none, exports.bool, exports.string, exports.buffer, exports.uint, exports.int, exports.float64, anyArray, anyObject, exports.date ] const any = (exports.any = { preencode(state, o) { const t = getType(o) uint.preencode(state, t) anyTypes[t].preencode(state, o) }, encode(state, o) { const t = getType(o) uint.encode(state, t) anyTypes[t].encode(state, o) }, decode(state) { const t = uint.decode(state) if (t >= anyTypes.length) throw new Error('Unknown type: ' + t) return anyTypes[t].decode(state) } }) const port = (exports.port = uint16) const address = (host, family) => { return { preencode(state, m) { host.preencode(state, m.host) port.preencode(state, m.port) }, encode(state, m) { host.encode(state, m.host) port.encode(state, m.port) }, decode(state) { return { host: host.decode(state), family, port: port.decode(state) } } } } const ipv4 = (exports.ipv4 = { preencode(state) { state.end += 4 }, encode(state, string) { const start = state.start const end = start + 4 let i = 0 while (i < string.length) { let n = 0 let c while ( i < string.length && (c = string.charCodeAt(i++)) !== /* . */ 0x2e ) { n = n * 10 + (c - /* 0 */ 0x30) } state.buffer[state.start++] = n } state.start = end }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] + '.' + state.buffer[state.start++] + '.' + state.buffer[state.start++] + '.' + state.buffer[state.start++] ) } }) exports.ipv4Address = address(ipv4, 4) const ipv6 = (exports.ipv6 = { preencode(state) { state.end += 16 }, encode(state, string) { const start = state.start const end = start + 16 let i = 0 let split = null while (i < string.length) { let n = 0 let c while ( i < string.length && (c = string.charCodeAt(i++)) !== /* : */ 0x3a ) { if (c >= 0x30 && c <= 0x39) n = n * 0x10 + (c - /* 0 */ 0x30) else if (c >= 0x41 && c <= 0x46) n = n * 0x10 + (c - /* A */ 0x41 + 10) else if (c >= 0x61 && c <= 0x66) n = n * 0x10 + (c - /* a */ 0x61 + 10) } state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n if (i < string.length && string.charCodeAt(i) === /* : */ 0x3a) { i++ split = state.start } } if (split !== null) { const offset = end - state.start state.buffer .copyWithin(split + offset, split) .fill(0, split, split + offset) } state.start = end }, decode(state) { if (state.end - state.start < 16) throw new Error('Out of bounds') return ( ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) ) } }) exports.ipv6Address = address(ipv6, 6) const ip = (exports.ip = { preencode(state, string) { const family = string.includes(':') ? 6 : 4 uint8.preencode(state, family) if (family === 4) ipv4.preencode(state) else ipv6.preencode(state) }, encode(state, string) { const family = string.includes(':') ? 6 : 4 uint8.encode(state, family) if (family === 4) ipv4.encode(state, string) else ipv6.encode(state, string) }, decode(state) { const family = uint8.decode(state) if (family === 4) return ipv4.decode(state) else return ipv6.decode(state) } }) exports.ipAddress = { preencode(state, m) { ip.preencode(state, m.host) port.preencode(state, m.port) }, encode(state, m) { ip.encode(state, m.host) port.encode(state, m.port) }, decode(state) { const family = uint8.decode(state) return { host: family === 4 ? ipv4.decode(state) : ipv6.decode(state), family, port: port.decode(state) } } } const record = (exports.record = function (keyEncoding, valueEncoding) { return { preencode(state, v) { const keys = Object.keys(v) uint.preencode(state, keys.length) for (const k of keys) { keyEncoding.preencode(state, k) valueEncoding.preencode(state, v[k]) } }, encode(state, v) { const keys = Object.keys(v) uint.encode(state, keys.length) for (const k of keys) { keyEncoding.encode(state, k) valueEncoding.encode(state, v[k]) } }, decode(state) { const out = Object.create(null) const keys = uint.decode(state) for (let i = 0; i < keys; i++) { out[keyEncoding.decode(state)] = valueEncoding.decode(state) } return out } } }) exports.stringRecord = record(utf8, utf8) function getType(o) { if (o === null || o === undefined) return 0 if (typeof o === 'boolean') return 1 if (typeof o === 'string') return 2 if (b4a.isBuffer(o)) return 3 if (typeof o === 'number') { if (Number.isInteger(o)) return o >= 0 ? 4 : 5 return 6 } if (Array.isArray(o)) return 7 if (o instanceof Date) return 9 if (typeof o === 'object') return 8 throw new Error('Unsupported type for ' + o) } exports.from = function from(enc) { if (typeof enc === 'string') return fromNamed(enc) if (enc.preencode) return enc if (enc.encodingLength) return fromAbstractEncoder(enc) return fromCodec(enc) } function fromNamed(enc) { switch (enc) { case 'ascii': return raw.ascii case 'utf-8': case 'utf8': return raw.utf8 case 'hex': return raw.hex case 'base64': return raw.base64 case 'utf16-le': case 'utf16le': case 'ucs-2': case 'ucs2': return raw.ucs2 case 'ndjson': return raw.ndjson case 'json': return raw.json case 'binary': default: return raw.binary } } function fromCodec(enc) { let tmpM = null let tmpBuf = null return { preencode(state, m) { tmpM = m tmpBuf = enc.encode(m) state.end += tmpBuf.byteLength }, encode(state, m) { raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m)) tmpM = tmpBuf = null }, decode(state) { return enc.decode(raw.decode(state)) } } } function fromAbstractEncoder(enc) { return { preencode(state, m) { state.end += enc.encodingLength(m) }, encode(state, m) { enc.encode(m, state.buffer, state.start) state.start += enc.encode.bytes }, decode(state) { const m = enc.decode(state.buffer, state.start, state.end) state.start += enc.decode.bytes return m } } } exports.encode = function encode(enc, m) { const state = exports.state() enc.preencode(state, m) state.buffer = b4a.allocUnsafe(state.end) enc.encode(state, m) return state.buffer } exports.decode = function decode(enc, buffer) { return enc.decode(exports.state(0, buffer.byteLength, buffer)) } function zigZagInt(enc) { return { preencode(state, n) { enc.preencode(state, zigZagEncodeInt(n)) }, encode(state, n) { enc.encode(state, zigZagEncodeInt(n)) }, decode(state) { return zigZagDecodeInt(enc.decode(state)) } } } function zigZagDecodeInt(n) { return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2 } function zigZagEncodeInt(n) { // 0, -1, 1, -2, 2, ... return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n } function zigZagBigInt(enc) { return { preencode(state, n) { enc.preencode(state, zigZagEncodeBigInt(n)) }, encode(state, n) { enc.encode(state, zigZagEncodeBigInt(n)) }, decode(state) { return zigZagDecodeBigInt(enc.decode(state)) } } } function zigZagDecodeBigInt(n) { return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n } function zigZagEncodeBigInt(n) { // 0, -1, 1, -2, 2, ... return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n } function validateUint(n) { if (n >= 0 === false /* Handles NaN as well */) throw new Error('uint must be positive') // Beyond this, Number arithmetic loses precision and silently corrupts the // encoding. The zig-zag int codecs route through here too, so this also // guards int values whose doubled magnitude exceeds the safe range. if (n > Number.MAX_SAFE_INTEGER) throw new Error( 'integer is greater than the maximum safe integer, use biguint/bigint' ) } module.exports = { preencode, encode, decode } function preencode(state, num) { if (num < 251) { state.end++ } else if (num < 256) { state.end += 2 } else if (num < 0x10000) { state.end += 3 } else if (num < 0x1000000) { state.end += 4 } else if (num < 0x100000000) { state.end += 5 } else { state.end++ const exp = Math.floor(Math.log(num) / Math.log(2)) - 32 preencode(state, exp) state.end += 6 } } function encode(state, num) { const max = 251 const x = num - max if (num < max) { state.buffer[state.start++] = num } else if (num < 256) { state.buffer[state.start++] = max state.buffer[state.start++] = x } else if (num < 0x10000) { state.buffer[state.start++] = max + 1 state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else if (num < 0x1000000) { state.buffer[state.start++] = max + 2 state.buffer[state.start++] = x >> 16 state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else if (num < 0x100000000) { state.buffer[state.start++] = max + 3 state.buffer[state.start++] = x >> 24 state.buffer[state.start++] = (x >> 16) & 0xff state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else { // need to use Math here as bitwise ops are 32 bit const exp = Math.floor(Math.log(x) / Math.log(2)) - 32 state.buffer[state.start++] = 0xff encode(state, exp) const rem = x / Math.pow(2, exp - 11) for (let i = 5; i >= 0; i--) { state.buffer[state.start++] = (rem / Math.pow(2, 8 * i)) & 0xff } } } function decode(state) { const max = 251 if (state.end - state.start < 1) throw new Error('Out of bounds') const flag = state.buffer[state.start++] if (flag < max) return flag if (state.end - state.start < flag - max + 1) { throw new Error('Out of bounds.') } if (flag < 252) { return state.buffer[state.start++] + max } if (flag < 253) { return ( (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } if (flag < 254) { return ( (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } // << 24 result may be interpreted as negative if (flag < 255) { return ( state.buffer[state.start++] * 0x1000000 + (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } const exp = decode(state) if (state.end - state.start < 6) throw new Error('Out of bounds') let rem = 0 for (let i = 5; i >= 0; i--) { rem += state.buffer[state.start++] * Math.pow(2, 8 * i) } return rem * Math.pow(2, exp - 11) + max } { "name": "compact-encoding", "version": "3.2.0", "description": "A series of compact encoding schemes for building small and fast parsers and serializers", "main": "index.js", "files": [ "endian.js", "index.js", "lexint.js", "raw.js" ], "dependencies": { "b4a": "^1.3.0" }, "devDependencies": { "brittle": "^3.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" }, "scripts": { "format": "prettier . --write", "test": "prettier . --check && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/compact-encoding.git" }, "author": "Mathias Buus (@mafintosh)", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/compact-encoding/issues" }, "homepage": "https://github.com/holepunchto/compact-encoding" } const b4a = require('b4a') const { BE } = require('./endian') exports = module.exports = { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { state.buffer.set(b, state.start) state.start += b.byteLength }, decode(state) { const b = state.buffer.subarray(state.start, state.end) state.start = state.end return b } } const buffer = (exports.buffer = { preencode(state, b) { uint8array.preencode(state, b) }, encode(state, b) { uint8array.encode(state, b) }, decode(state) { const b = state.buffer.subarray(state.start) state.start = state.end return b } }) exports.binary = { ...buffer, preencode(state, b) { if (typeof b === 'string') utf8.preencode(state, b) else buffer.preencode(state, b) }, encode(state, b) { if (typeof b === 'string') utf8.encode(state, b) else buffer.encode(state, b) } } exports.arraybuffer = { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { const view = new Uint8Array(b) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const b = new ArrayBuffer(state.end - state.start) const view = new Uint8Array(b) view.set(state.buffer.subarray(state.start)) state.start = state.end return b } } function typedarray(TypedArray, swap) { const n = TypedArray.BYTES_PER_ELEMENT return { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength) if (BE && swap) swap(view) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { let b = state.buffer.subarray(state.start) if (b.byteOffset % n !== 0) b = new Uint8Array(b) if (BE && swap) swap(b) state.start = state.end return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n) } } } const uint8array = (exports.uint8array = typedarray(Uint8Array)) exports.uint16array = typedarray(Uint16Array, b4a.swap16) exports.uint32array = typedarray(Uint32Array, b4a.swap32) exports.int8array = typedarray(Int8Array) exports.int16array = typedarray(Int16Array, b4a.swap16) exports.int32array = typedarray(Int32Array, b4a.swap32) exports.biguint64array = typedarray(BigUint64Array, b4a.swap64) exports.bigint64array = typedarray(BigInt64Array, b4a.swap64) exports.float32array = typedarray(Float32Array, b4a.swap32) exports.float64array = typedarray(Float64Array, b4a.swap64) function string(encoding) { return { preencode(state, s) { state.end += b4a.byteLength(s, encoding) }, encode(state, s) { state.start += b4a.write(state.buffer, s, state.start, encoding) }, decode(state) { const s = b4a.toString(state.buffer, encoding, state.start) state.start = state.end return s } } } const utf8 = (exports.string = exports.utf8 = string('utf-8')) exports.ascii = string('ascii') exports.hex = string('hex') exports.base64 = string('base64') exports.ucs2 = exports.utf16le = string('utf16le') exports.array = function array(enc) { return { preencode(state, list) { for (const value of list) enc.preencode(state, value) }, encode(state, list) { for (const value of list) enc.encode(state, value) }, decode(state) { const arr = [] while (state.start < state.end) arr.push(enc.decode(state)) return arr } } } exports.json = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v)) }, encode(state, v) { utf8.encode(state, JSON.stringify(v)) }, decode(state) { return JSON.parse(utf8.decode(state)) } } exports.ndjson = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v) + '\n') }, encode(state, v) { utf8.encode(state, JSON.stringify(v) + '\n') }, decode(state) { return JSON.parse(utf8.decode(state)) } } module.exports = require('bare-events') { "name": "events-universal", "version": "1.0.1", "description": "Universal wrapper for the Node.js events module", "exports": { "./package": "./package.json", ".": { "bare": "./bare.js", "react-native": "./react-native.js", "default": "./default.js" } }, "files": [ "index.js", "default.js", "bare.js", "react-native.js" ], "scripts": { "test": "prettier . --check" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/events-universal.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/events-universal/issues" }, "homepage": "https://github.com/holepunchto/events-universal#readme", "dependencies": { "bare-events": "^2.7.0" }, "devDependencies": { "prettier": "^3.4.2", "prettier-config-holepunch": "^1.0.0" } } module.exports = class FixedFIFO { constructor (hwm) { if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two') this.buffer = new Array(hwm) this.mask = hwm - 1 this.top = 0 this.btm = 0 this.next = null } clear () { this.top = this.btm = 0 this.next = null this.buffer.fill(undefined) } push (data) { if (this.buffer[this.top] !== undefined) return false this.buffer[this.top] = data this.top = (this.top + 1) & this.mask return true } shift () { const last = this.buffer[this.btm] if (last === undefined) return undefined this.buffer[this.btm] = undefined this.btm = (this.btm + 1) & this.mask return last } peek () { return this.buffer[this.btm] } isEmpty () { return this.buffer[this.btm] === undefined } } const FixedFIFO = require('./fixed-size') module.exports = class FastFIFO { constructor (hwm) { this.hwm = hwm || 16 this.head = new FixedFIFO(this.hwm) this.tail = this.head this.length = 0 } clear () { this.head = this.tail this.head.clear() this.length = 0 } push (val) { this.length++ if (!this.head.push(val)) { const prev = this.head this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length) this.head.push(val) } } shift () { if (this.length !== 0) this.length-- const val = this.tail.shift() if (val === undefined && this.tail.next) { const next = this.tail.next this.tail.next = null this.tail = next return this.tail.shift() } return val } peek () { const val = this.tail.peek() if (val === undefined && this.tail.next) return this.tail.next.peek() return val } isEmpty () { return this.length === 0 } } { "name": "fast-fifo", "version": "1.3.2", "description": "A fast fifo implementation similar to the one powering nextTick in Node.js core", "main": "index.js", "files": [ "./index.js", "./fixed-size.js" ], "dependencies": {}, "devDependencies": { "standard": "^17.1.0", "brittle": "^3.3.2" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/fast-fifo.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/fast-fifo/issues" }, "homepage": "https://github.com/mafintosh/fast-fifo" } const sodium = require('sodium-universal') const c = require('compact-encoding') const b4a = require('b4a') // https://en.wikipedia.org/wiki/Merkle_tree#Second_preimage_attack const LEAF_TYPE = b4a.from([0]) const PARENT_TYPE = b4a.from([1]) const ROOT_TYPE = b4a.from([2]) const HYPERCORE = b4a.from('hypercore') exports.keyPair = function (seed) { // key pairs might stay around for a while, so better not to use a default slab to avoid retaining it completely const slab = b4a.allocUnsafeSlow( sodium.crypto_sign_PUBLICKEYBYTES + sodium.crypto_sign_SECRETKEYBYTES ) const publicKey = slab.subarray(0, sodium.crypto_sign_PUBLICKEYBYTES) const secretKey = slab.subarray(sodium.crypto_sign_PUBLICKEYBYTES) if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed) else sodium.crypto_sign_keypair(publicKey, secretKey) return { publicKey, secretKey } } exports.validateKeyPair = function (keyPair) { const pk = b4a.allocUnsafe(sodium.crypto_sign_PUBLICKEYBYTES) sodium.crypto_sign_ed25519_sk_to_pk(pk, keyPair.secretKey) return b4a.equals(pk, keyPair.publicKey) } exports.sign = function (message, secretKey) { // Dedicated slab for the signature, to avoid retaining unneeded mem and for security const signature = b4a.allocUnsafeSlow(sodium.crypto_sign_BYTES) sodium.crypto_sign_detached(signature, message, secretKey) return signature } exports.verify = function (message, signature, publicKey) { if (signature.byteLength !== sodium.crypto_sign_BYTES) return false if (publicKey.byteLength !== sodium.crypto_sign_PUBLICKEYBYTES) return false return sodium.crypto_sign_verify_detached(signature, message, publicKey) } exports.encrypt = function (message, publicKey) { const ciphertext = b4a.alloc(message.byteLength + sodium.crypto_box_SEALBYTES) sodium.crypto_box_seal(ciphertext, message, publicKey) return ciphertext } exports.decrypt = function (ciphertext, keyPair) { if (ciphertext.byteLength < sodium.crypto_box_SEALBYTES) return null const plaintext = b4a.alloc(ciphertext.byteLength - sodium.crypto_box_SEALBYTES) if (!sodium.crypto_box_seal_open(plaintext, ciphertext, keyPair.publicKey, keyPair.secretKey)) { return null } return plaintext } exports.encryptionKeyPair = function (seed) { const publicKey = b4a.alloc(sodium.crypto_box_PUBLICKEYBYTES) const secretKey = b4a.alloc(sodium.crypto_box_SECRETKEYBYTES) if (seed) { sodium.crypto_box_seed_keypair(publicKey, secretKey, seed) } else { sodium.crypto_box_keypair(publicKey, secretKey) } return { publicKey, secretKey } } exports.data = function (data) { const out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, [LEAF_TYPE, c.encode(c.uint64, data.byteLength), data]) return out } exports.parent = function (a, b) { if (a.index > b.index) { const tmp = a a = b b = tmp } const out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, [ PARENT_TYPE, c.encode(c.uint64, a.size + b.size), a.hash, b.hash ]) return out } exports.tree = function (roots, out) { const buffers = new Array(3 * roots.length + 1) let j = 0 buffers[j++] = ROOT_TYPE for (let i = 0; i < roots.length; i++) { const r = roots[i] buffers[j++] = r.hash buffers[j++] = c.encode(c.uint64, r.index) buffers[j++] = c.encode(c.uint64, r.size) } if (!out) out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, buffers) return out } exports.hash = function (data, out) { if (!out) out = b4a.allocUnsafe(32) if (!Array.isArray(data)) data = [data] sodium.crypto_generichash_batch(out, data) return out } exports.randomBytes = function (n) { const buf = b4a.allocUnsafe(n) sodium.randombytes_buf(buf) return buf } exports.discoveryKey = function (key) { if (!key || key.byteLength !== 32) throw new Error('Must pass a 32 byte buffer') // Discovery keys might stay around for a while, so better not to use slab memory (for better gc) const digest = b4a.allocUnsafeSlow(32) sodium.crypto_generichash(digest, HYPERCORE, key) return digest } if (sodium.sodium_free) { exports.free = function (secureBuf) { if (secureBuf.secure) sodium.sodium_free(secureBuf) } } else { exports.free = function () {} } exports.namespace = function (name, count) { const ids = typeof count === 'number' ? range(count) : count // Namespaces are long-lived, so better to use a dedicated slab const buf = b4a.allocUnsafeSlow(32 * ids.length) const list = new Array(ids.length) // ns is ephemeral, so default slab const ns = b4a.allocUnsafe(33) sodium.crypto_generichash(ns.subarray(0, 32), typeof name === 'string' ? b4a.from(name) : name) for (let i = 0; i < list.length; i++) { list[i] = buf.subarray(32 * i, 32 * i + 32) ns[32] = ids[i] sodium.crypto_generichash(list[i], ns) } return list } function range(count) { const arr = new Array(count) for (let i = 0; i < count; i++) arr[i] = i return arr } { "name": "hypercore-crypto", "version": "3.7.0", "description": "The crypto primitives used in hypercore, extracted into a separate module", "main": "index.js", "files": [ "index.js" ], "dependencies": { "b4a": "^1.6.6", "compact-encoding": "^3.0.0", "sodium-universal": "^5.0.0" }, "devDependencies": { "brittle": "^3.5.0", "lunte": "^1.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/hypercore-crypto.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/hypercore-crypto/issues" }, "homepage": "https://github.com/mafintosh/hypercore-crypto" } module.exports = require.addon.bind(require) { "name": "require-addon", "version": "1.2.0", "description": "Import native addons across JavaScript runtimes", "exports": { "./package": "./package.json", ".": { "bare": "./lib/bare.js", "node": "./lib/node.js", "default": "./lib/default.js" } }, "imports": { "fs": { "bare": "bare-fs", "default": "fs" }, "path": { "bare": "bare-path", "default": "path" }, "url": { "bare": "bare-url", "default": "url" } }, "files": [ "lib" ], "scripts": { "test": "npm run lint && npm run test:bare && npm run test:node", "test:bare": "bare test.js", "test:node": "node test.js", "lint": "prettier --check .", "format": "prettier --write ." }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/require-addon.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/require-addon/issues" }, "homepage": "https://github.com/holepunchto/require-addon#readme", "engines": { "bare": ">=1.10.0" }, "dependencies": { "bare-addon-resolve": "^1.3.0" }, "devDependencies": { "bare-bundle": "^1.8.1", "bare-bundle-evaluate": "^1.1.0", "bare-fs": "^4.0.0", "bare-path": "^3.0.0", "bare-url": "^2.1.0", "brittle": "^3.7.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } require.addon = require('require-addon') module.exports = require.addon('.', __filename) const assert = require('assert') const binding = require('./binding') const { isNode } = require('which-runtime') const OPTIONAL = Buffer.from(new ArrayBuffer(0)) module.exports = exports = { ...binding } // memory exports.sodium_memzero = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') binding.sodium_memzero(buf) } exports.sodium_mlock = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') const res = binding.sodium_mlock(buf) if (res !== 0) throw new Error('memory lock failed') } exports.sodium_munlock = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') const res = binding.sodium_munlock(buf) if (res !== 0) throw new Error('memory unlock failed') } exports.sodium_malloc = function (size) { assert(size >= 0, 'invalid size') const buf = Buffer.from(binding.sodium_malloc(size)) buf.secure = true return buf } exports.sodium_free = function (buf) { if (!buf || !buf.secure) return binding.sodium_free(buf.buffer) } exports.sodium_mprotect_noaccess = function (buf) { const res = binding.sodium_mprotect_noaccess(buf.buffer) if (res !== 0) throw new Error('failed to lock buffer') } exports.sodium_mprotect_readonly = function (buf) { const res = binding.sodium_mprotect_readonly(buf.buffer) if (res !== 0) throw new Error('failed to unlock buffer') } exports.sodium_mprotect_readwrite = function (buf) { const res = binding.sodium_mprotect_readwrite(buf.buffer) if (res !== 0) throw new Error('failed to unlock buffer') } // crypto_randombytes exports.randombytes_buf = function (buffer) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') binding.randombytes_buf(buffer.buffer, buffer.byteOffset, buffer.byteLength) } exports.randombytes_buf_deterministic = function (buffer, seed) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( seed.byteLength === binding.randombytes_SEEDBYTES, "seed must be 'randombytes_SEEDBYTES' bytes" ) binding.randombytes_buf_deterministic( buffer.buffer, buffer.byteOffset, buffer.byteLength, seed.buffer, seed.byteOffset, seed.byteLength ) } // sodium_helpers exports.sodium_memcmp = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') return binding.sodium_memcmp(a, b) } exports.sodium_add = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') binding.sodium_add(a, b) } exports.sodium_sub = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') binding.sodium_sub(a, b) } exports.sodium_compare = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') return binding.sodium_compare(a, b) } exports.sodium_is_zero = function (buffer, length) { if (length === undefined) length = buffer.byteLength assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(length >= 0 && length <= buffer.byteLength, 'invalid length') return binding.sodium_is_zero(buffer, length) } exports.sodium_pad = function (buffer, unpaddedBuflen, blockSize) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(unpaddedBuflen <= buffer.byteLength, 'unpadded length cannot exceed buffer length') assert(blockSize <= buffer.byteLength, 'block size cannot exceed buffer length') assert(blockSize >= 1, 'block size must be at least 1 byte') assert( buffer.byteLength >= unpaddedBuflen + (blockSize - (unpaddedBuflen % blockSize)), 'buf not long enough' ) return binding.sodium_pad(buffer, unpaddedBuflen, blockSize) } exports.sodium_unpad = function (buffer, paddedBuflen, blockSize) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(paddedBuflen <= buffer.byteLength, 'unpadded length cannot exceed buffer length') assert(blockSize <= buffer.byteLength, 'block size cannot exceed buffer length') assert(blockSize >= 1, 'block size must be at least 1 byte') return binding.sodium_unpad(buffer, paddedBuflen, blockSize) } // crypto_sign exports.crypto_sign_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) assert( seed.byteLength === binding.crypto_sign_SEEDBYTES, "seed must be 'crypto_sign_SEEDBYTES' bytes" ) const res = binding.crypto_sign_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign = function (sm, m, sk) { assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sm.byteLength === binding.crypto_sign_BYTES + m.byteLength, "sm must be 'm.byteLength + crypto_sign_BYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign(sm, m, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_open = function (m, sm, pk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sm.byteLength >= binding.crypto_sign_BYTES, "sm must be at least 'crypto_sign_BYTES' bytes" ) assert( m.byteLength === sm.byteLength - binding.crypto_sign_BYTES, "m must be 'sm.byteLength - crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_open(m, sm, pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_open = function (m, sm, pk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sm.byteLength >= binding.crypto_sign_BYTES, "sm must be at least 'crypto_sign_BYTES' bytes" ) assert( m.byteLength === sm.byteLength - binding.crypto_sign_BYTES, "m must be 'sm.byteLength - crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) return binding.crypto_sign_open(m, sm, pk) } exports.crypto_sign_detached = function (sig, m, sk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(sig.byteLength === binding.crypto_sign_BYTES, "sig must be 'crypto_sign_BYTES' bytes") assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_detached(sig, m, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_verify_detached = function (sig, m, pk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sig.byteLength >= binding.crypto_sign_BYTES, "sig must be at least 'crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) return binding.crypto_sign_verify_detached( sig.buffer, sig.byteOffset, sig.byteLength, m.buffer, m.byteOffset, m.byteLength, pk.buffer, pk.byteOffset, pk.byteLength ) } exports.crypto_sign_ed25519_sk_to_pk = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_sk_to_pk(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_ed25519_pk_to_curve25519 = function (x25519pk, ed25519pk) { assert(ArrayBuffer.isView(x25519pk), 'x25519pk must be a typed array') assert(ArrayBuffer.isView(ed25519pk), 'ed25519pk must be a typed array') assert( x25519pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "x25519pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( ed25519pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "ed25519pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_pk_to_curve25519(x25519pk, ed25519pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_ed25519_sk_to_curve25519 = function (x25519sk, ed25519sk) { assert(ArrayBuffer.isView(x25519sk), 'x25519sk must be a typed array') assert(ArrayBuffer.isView(ed25519sk), 'ed25519sk must be a typed array') assert( x25519sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "x25519sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const edLen = ed25519sk.byteLength assert( edLen === binding.crypto_sign_SECRETKEYBYTES || edLen === binding.crypto_box_SECRETKEYBYTES, "ed25519sk must be 'crypto_sign_SECRETKEYBYTES' or 'crypto_sign_SECRETKEYBYTES - crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_sk_to_curve25519(x25519sk, ed25519sk) if (res !== 0) throw new Error('status: ' + res) } // crypto_box exports.crypto_box_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( seed.byteLength === binding.crypto_box_SEEDBYTES, "seed must be 'crypto_box_SEEDBYTES' bytes" ) const res = binding.crypto_box_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_easy = function (c, m, n, pk, sk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength === m.byteLength + exports.crypto_box_MACBYTES, "c must be 'm.byteLength + crypto_box_MACBYTES' bytes" ) assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_easy(c, m, n, pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_detached = function (c, mac, m, n, pk, sk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(mac.byteLength === exports.crypto_box_MACBYTES, "mac must be 'crypto_box_MACBYTES' bytes") assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_detached(c, mac, m, n, pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_open_easy = function (m, c, n, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength >= exports.crypto_box_MACBYTES, "c must be at least 'crypto_box_MACBYTES' bytes" ) assert( m.byteLength === c.byteLength - exports.crypto_box_MACBYTES, "m must be 'c.byteLength - crypto_box_MACBYTES' bytes" ) assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_open_easy(m, c, n, pk, sk) } exports.crypto_box_open_detached = function (m, c, mac, n, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(mac.byteLength === exports.crypto_box_MACBYTES, "mac must be 'crypto_box_MACBYTES' bytes") assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_open_detached(m, c, mac, n, pk, sk) } exports.crypto_box_seal = function (c, m, pk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( c.byteLength === m.byteLength + exports.crypto_box_SEALBYTES, "c must be 'm.byteLength + crypto_box_SEALBYTES' bytes" ) assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_box_seal(c, m, pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_seal_open = function (m, c, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength >= exports.crypto_box_SEALBYTES, "c must be at least 'crypto_box_SEALBYTES' bytes" ) assert( m.byteLength === c.byteLength - exports.crypto_box_SEALBYTES, "m must be 'c.byteLength - crypto_box_SEALBYTES' bytes" ) assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_seal_open( m.buffer, m.byteOffset, m.byteLength, c.buffer, c.byteOffset, c.byteLength, pk.buffer, pk.byteOffset, pk.byteLength, sk.buffer, sk.byteOffset, sk.byteLength ) } // crypto_secretbox exports.crypto_secretbox_easy = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_secretbox_MACBYTES, "c must be 'm.byteLength + crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) const res = binding.crypto_secretbox_easy(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretbox_open_easy = function (m, c, n, k) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( c.byteLength >= binding.crypto_secretbox_MACBYTES, "c must be at least 'crypto_secretbox_MACBYTES' bytes" ) assert( m.byteLength === c.byteLength - binding.crypto_secretbox_MACBYTES, "m must be 'c.byteLength - crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) return binding.crypto_secretbox_open_easy(m, c, n, k) } exports.crypto_secretbox_detached = function (c, mac, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( mac.byteLength === binding.crypto_secretbox_MACBYTES, "mac must be 'crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) const res = binding.crypto_secretbox_detached(c, mac, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretbox_open_detached = function (m, c, mac, n, k) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert( mac.byteLength === binding.crypto_secretbox_MACBYTES, "mac must be 'crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) return binding.crypto_secretbox_open_detached(m, c, mac, n, k) } // crypto_generichash exports.crypto_generichash = function (output, input, key) { if (!key) key = OPTIONAL assert(ArrayBuffer.isView(output), 'output must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( output.byteLength >= binding.crypto_generichash_BYTES_MIN && output.byteLength <= binding.crypto_generichash_BYTES_MAX, 'output must be between crypto_generichash_BYTES_MIN and crypto_generichash_BYTES_MAX bytes' ) if (key !== OPTIONAL) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert( key.byteLength >= binding.crypto_generichash_KEYBYTES_MIN && key.byteLength <= binding.crypto_generichash_KEYBYTES_MAX, 'key must be between crypto_generichash_KEYBYTES_MIN and crypto_generichash_KEYBYTES_MAX bytes' ) } const res = binding.crypto_generichash( output.buffer, output.byteOffset, output.byteLength, input.buffer, input.byteOffset, input.byteLength, key.buffer, key.byteOffset, key.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_batch = function (output, batch, key) { assert(ArrayBuffer.isView(output), 'output must be a typed array') if (isNode || batch.length < 4) { const res = binding.crypto_generichash_batch(output, batch, !!key, key || OPTIONAL) if (res !== 0) throw new Error('status: ' + res) } else { const state = Buffer.alloc(binding.crypto_generichash_STATEBYTES) exports.crypto_generichash_init(state, key, output.byteLength) for (const buf of batch) { exports.crypto_generichash_update(state, buf) } exports.crypto_generichash_final(state, output) } } exports.crypto_generichash_keygen = function (key) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert( key.byteLength === binding.crypto_generichash_KEYBYTES, "key must be 'crypto_generichash_KEYBYTES' bytes" ) const res = binding.crypto_generichash_keygen(key.buffer, key.byteOffset, key.byteLength) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_init = function (state, key, outputLength) { if (!key) key = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_init( state.buffer, state.byteOffset, state.byteLength, key.buffer, key.byteOffset, key.byteLength, outputLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_update( state.buffer, state.byteOffset, state.byteLength, input.buffer, input.byteOffset, input.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_final = function (state, output) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(output), 'output must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_final( state.buffer, state.byteOffset, state.byteLength, output.buffer, output.byteOffset, output.byteLength ) if (res !== 0) throw new Error('status: ' + res) } // secretstream exports.crypto_secretstream_xchacha20poly1305_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) binding.crypto_secretstream_xchacha20poly1305_keygen(k.buffer, k.byteOffset, k.byteLength) } exports.crypto_secretstream_xchacha20poly1305_init_push = function (state, header, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(header), 'header must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( header.byteLength === binding.crypto_secretstream_xchacha20poly1305_HEADERBYTES, "header must be 'crypto_secretstream_xchacha20poly1305_HEADERBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_init_push( state.buffer, state.byteOffset, state.byteLength, header.buffer, header.byteOffset, header.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretstream_xchacha20poly1305_init_pull = function (state, header, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(header), 'header must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( header.byteLength === binding.crypto_secretstream_xchacha20poly1305_HEADERBYTES, "header must be 'crypto_secretstream_xchacha20poly1305_HEADERBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_init_pull( state.buffer, state.byteOffset, state.byteLength, header.buffer, header.byteOffset, header.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretstream_xchacha20poly1305_push = function (state, c, m, ad, tag) { if (!ad) ad = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( c.byteLength === m.byteLength + binding.crypto_secretstream_xchacha20poly1305_ABYTES, "c must be 'm.byteLength + crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_push( state.buffer, state.byteOffset, state.byteLength, c.buffer, c.byteOffset, c.byteLength, m.buffer, m.byteOffset, m.byteLength, ad.buffer, ad.byteOffset, ad.byteLength, tag ) if (res < 0) throw new Error('push failed') return res } exports.crypto_secretstream_xchacha20poly1305_pull = function (state, m, tag, c, ad) { if (!ad) ad = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(tag), 'tag must be a typed array') assert(tag.byteLength === 1, 'tag must be 1 byte') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( c.byteLength >= binding.crypto_secretstream_xchacha20poly1305_ABYTES, "c must be at least 'crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_secretstream_xchacha20poly1305_ABYTES, "m must be 'c.byteLength - crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_pull( state.buffer, state.byteOffset, state.byteLength, m.buffer, m.byteOffset, m.byteLength, tag.buffer, tag.byteOffset, tag.byteLength, c.buffer, c.byteOffset, c.byteLength, ad.buffer, ad.byteOffset, ad.byteLength ) if (res < 0) throw new Error('pull failed') return res } exports.crypto_secretstream_xchacha20poly1305_rekey = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) binding.crypto_secretstream_xchacha20poly1305_rekey( state.buffer, state.byteOffset, state.byteLength ) } // crypto_stream exports.crypto_stream = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) const res = binding.crypto_stream(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) const res = binding.crypto_stream_xor( c.buffer, c.byteOffset, c.byteLength, m.buffer, m.byteOffset, m.byteLength, n.buffer, n.byteOffset, n.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } // crypto_auth exports.crypto_auth = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(out.byteLength === binding.crypto_auth_BYTES, "out must be 'crypto_auth_BYTES' bytes") assert(k.byteLength === binding.crypto_auth_KEYBYTES, "k must be 'crypto_auth_KEYBYTES' bytes") const res = binding.crypto_auth(out, input, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_auth_verify = function (h, input, k) { assert(ArrayBuffer.isView(h), 'h must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(h.byteLength === binding.crypto_auth_BYTES, "h must be 'crypto_auth_BYTES' bytes") assert(k.byteLength === binding.crypto_auth_KEYBYTES, "k must be 'crypto_auth_KEYBYTES' bytes") return binding.crypto_auth_verify(h, input, k) } // crypto_onetimeauth exports.crypto_onetimeauth = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( out.byteLength === binding.crypto_onetimeauth_BYTES, "out must be 'crypto_onetimeauth_BYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) const res = binding.crypto_onetimeauth(out, input, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_init = function (state, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) const res = binding.crypto_onetimeauth_init(state, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) const res = binding.crypto_onetimeauth_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) assert( out.byteLength === binding.crypto_onetimeauth_BYTES, "out must be 'crypto_onetimeauth_BYTES' bytes" ) const res = binding.crypto_onetimeauth_final(state, out) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_verify = function (h, input, k) { assert(ArrayBuffer.isView(h), 'h must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( h.byteLength === binding.crypto_onetimeauth_BYTES, "h must be 'crypto_onetimeauth_BYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) return binding.crypto_onetimeauth_verify(h, input, k) } // crypto_pwhash exports.crypto_pwhash = function (out, passwd, salt, opslimit, memlimit, alg) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_BYTES_MIN, "out must be at least 'crypto_pwhash_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_BYTES_MAX, "out must be at most 'crypto_pwhash_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_SALTBYTES, "salt must be 'crypto_pwhash_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) assert(alg >= 1 && alg <= 2, 'alg must be either Argon2i 1.3 or Argon2id 1.3') const res = binding.crypto_pwhash(out, passwd, salt, opslimit, memlimit, alg) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_async = function ( out, passwd, salt, opslimit, memlimit, alg, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_BYTES_MIN, "out must be at least 'crypto_pwhash_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_BYTES_MAX, "out must be at most 'crypto_pwhash_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_SALTBYTES, "salt must be 'crypto_pwhash_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) assert(alg >= 1 && alg <= 2, 'alg must be either Argon2i 1.3 or Argon2id 1.3') const [done, promise] = checkStatus(callback) binding.crypto_pwhash_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, opslimit, memlimit, alg, done ) return promise } exports.crypto_pwhash_str = function (out, passwd, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_STRBYTES, "out must be 'crypto_pwhash_STRBYTES' bytes" ) assert(typeof opslimit === 'number', 'opslimit must be a number') assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert(typeof memlimit === 'number', 'memlimit must be a number') assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_str(out, passwd, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_str_async = function (out, passwd, opslimit, memlimit, callback = undefined) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_STRBYTES, "out must be 'crypto_pwhash_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert(typeof opslimit === 'number', 'opslimit must be a number') assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert(typeof memlimit === 'number', 'memlimit must be a number') assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_str_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_str_verify = function (str, passwd) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) return binding.crypto_pwhash_str_verify(str, passwd) } exports.crypto_pwhash_str_verify_async = function (str, passwd, callback = undefined) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') const [done, promise] = checkStatus(callback, true) binding.crypto_pwhash_str_verify_async( str.buffer, str.byteOffset, str.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, done ) return promise } exports.crypto_pwhash_str_needs_rehash = function (str, opslimit, memlimit) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) return binding.crypto_pwhash_str_needs_rehash(str, opslimit, memlimit) } exports.crypto_pwhash_scryptsalsa208sha256 = function (out, passwd, salt, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN, "out must be at least 'crypto_pwhash_scryptsalsa208sha256_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX, "out must be at most 'crypto_pwhash_scryptsalsa208sha256_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_SALTBYTES, "salt must be 'crypto_pwhash_scryptsalsa208sha256_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_scryptsalsa208sha256(out, passwd, salt, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_scryptsalsa208sha256_async = function ( out, passwd, salt, opslimit, memlimit, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN, "out must be at least 'crypto_pwhash_scryptsalsa208sha256_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX, "out must be at most 'crypto_pwhash_scryptsalsa208sha256_BYTES_MAX' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( salt.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_SALTBYTES, "salt must be 'crypto_pwhash_scryptsalsa208sha256_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_scryptsalsa208sha256_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str_async = function ( out, passwd, opslimit, memlimit, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "out must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_scryptsalsa208sha256_str_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str = function (out, passwd, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "out must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_scryptsalsa208sha256_str(out, passwd, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_scryptsalsa208sha256_str_verify_async = function ( str, passwd, callback = undefined ) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') const [done, promise] = checkStatus(callback, true) binding.crypto_pwhash_scryptsalsa208sha256_str_verify_async( str.buffer, str.byteOffset, str.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str_verify = function (str, passwd) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') return binding.crypto_pwhash_scryptsalsa208sha256_str_verify(str, passwd) } exports.crypto_pwhash_scryptsalsa208sha256_str_needs_rehash = function (str, opslimit, memlimit) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) return binding.crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(str, opslimit, memlimit) } // crypto_kx exports.crypto_kx_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "pk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "sk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) const res = binding.crypto_kx_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( pk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "pk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "sk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( seed.byteLength === binding.crypto_kx_SEEDBYTES, "seed must be 'crypto_kx_SEEDBYTES' bytes" ) const res = binding.crypto_kx_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_client_session_keys = function (rx, tx, clientPk, clientSk, serverPk) { if (!rx) rx = undefined if (!tx) tx = undefined assert(rx || tx, 'at least one session key must be specified') if (rx) { assert(ArrayBuffer.isView(rx), 'rx must be a typed array') assert( rx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "rx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } if (tx) { assert(ArrayBuffer.isView(tx), 'tx must be a typed array') assert( tx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "tx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } assert(ArrayBuffer.isView(clientPk), 'clientPk must be a typed array') assert(ArrayBuffer.isView(clientSk), 'clientSk must be a typed array') assert(ArrayBuffer.isView(serverPk), 'serverPk must be a typed array') assert( clientPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "clientPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( clientSk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "clientSk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( serverPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "serverPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_kx_client_session_keys(rx, tx, clientPk, clientSk, serverPk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_server_session_keys = function (rx, tx, serverPk, serverSk, clientPk) { if (!rx) rx = undefined if (!tx) tx = undefined assert(rx || tx, 'at least one session key must be specified') if (rx) { assert(ArrayBuffer.isView(rx), 'rx must be a typed array') assert( rx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "rx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } if (tx) { assert(ArrayBuffer.isView(tx), 'tx must be a typed array') assert( tx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "tx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } assert(ArrayBuffer.isView(serverPk), 'serverPk must be a typed array') assert(ArrayBuffer.isView(serverSk), 'serverSk must be a typed array') assert(ArrayBuffer.isView(clientPk), 'clientPk must be a typed array') assert( serverPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "serverPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( serverSk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "serverSk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( clientPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "clientPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_kx_server_session_keys(rx, tx, serverPk, serverSk, clientPk) if (res !== 0) throw new Error('status: ' + res) } // crypto_scalarmult exports.crypto_scalarmult_base = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_BYTES, "q must be 'crypto_scalarmult_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_SCALARBYTES, "n must be 'crypto_scalarmult_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_base(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_BYTES, "q must be 'crypto_scalarmult_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_SCALARBYTES, "n must be 'crypto_scalarmult_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_BYTES, "p must be 'crypto_scalarmult_BYTES' bytes" ) const res = binding.crypto_scalarmult(q, n, p) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_base = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_base(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519 = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "p must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519(q, n, p) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_is_valid_point = function (p) { assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) return binding.crypto_core_ed25519_is_valid_point(p) } exports.crypto_core_ed25519_from_uniform = function (p, r) { assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_UNIFORMBYTES, "r must be 'crypto_core_ed25519_UNIFORMBYTES' bytes" ) const res = binding.crypto_core_ed25519_from_uniform(p, r) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_base_noclamp = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_base_noclamp(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_noclamp = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "p must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_noclamp(q, n, p) if (res !== 0) throw new Error('status: ' + res) } // crypto_core exports.crypto_core_ed25519_add = function (r, p, q) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_BYTES, "r must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_core_ed25519_BYTES, "q must be 'crypto_core_ed25519_BYTES' bytes" ) const res = binding.crypto_core_ed25519_add(r, p, q) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_sub = function (r, p, q) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_BYTES, "r must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_core_ed25519_BYTES, "q must be 'crypto_core_ed25519_BYTES' bytes" ) const res = binding.crypto_core_ed25519_sub(r, p, q) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_scalar_random = function (r) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "r must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_random(r) } exports.crypto_core_ed25519_scalar_reduce = function (r, s) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "r must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_NONREDUCEDSCALARBYTES, "s must be 'crypto_core_ed25519_NONREDUCEDSCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_reduce(r, s) } exports.crypto_core_ed25519_scalar_invert = function (recip, s) { assert(ArrayBuffer.isView(recip), 'recip must be a typed array') assert( recip.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "recip must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_invert(recip, s) } exports.crypto_core_ed25519_scalar_negate = function (neg, s) { assert(ArrayBuffer.isView(neg), 'neg must be a typed array') assert( neg.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "neg must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_negate(neg, s) } exports.crypto_core_ed25519_scalar_complement = function (comp, s) { assert(ArrayBuffer.isView(comp), 'comp must be a typed array') assert( comp.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "comp must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_complement(comp, s) } exports.crypto_core_ed25519_scalar_add = function (z, x, y) { assert(ArrayBuffer.isView(z), 'z must be a typed array') assert( z.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "z must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(x), 'x must be a typed array') assert( x.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "x must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(y), 'y must be a typed array') assert( y.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "y must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_add(z, x, y) } exports.crypto_core_ed25519_scalar_sub = function (z, x, y) { assert(ArrayBuffer.isView(z), 'z must be a typed array') assert( z.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "z must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(x), 'x must be a typed array') assert( x.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "x must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(y), 'y must be a typed array') assert( y.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "y must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_sub(z, x, y) } // crypto_shorthash exports.crypto_shorthash = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_shorthash_BYTES, "out must be 'crypto_shorthash_BYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_shorthash_KEYBYTES, "k must be 'crypto_shorthash_KEYBYTES' bytes" ) const res = binding.crypto_shorthash(out, input, k) if (res !== 0) throw new Error('status: ' + res) } // crypto_kdf exports.crypto_kdf_keygen = function (key) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert(key.byteLength === binding.crypto_kdf_KEYBYTES, "key must be 'crypto_kdf_KEYBYTES' bytes") binding.crypto_kdf_keygen(key) } exports.crypto_kdf_derive_from_key = function (subkey, subkeyId, ctx, key) { assert(ArrayBuffer.isView(subkey), 'subkey must be a typed array') assert( subkey.byteLength >= binding.crypto_kdf_BYTES_MIN, "subkey must be at least 'crypto_kdf_BYTES_MIN' bytes" ) assert( subkey.byteLength <= binding.crypto_kdf_BYTES_MAX, "subkey must be at most 'crypto_kdf_BYTES_MAX' bytes" ) assert(ArrayBuffer.isView(ctx), 'ctx must be a typed array') assert( ctx.byteLength === binding.crypto_kdf_CONTEXTBYTES, "ctx must be 'crypto_kdf_CONTEXTBYTES' bytes" ) assert(ArrayBuffer.isView(key), 'key must be a typed array') assert(key.byteLength === binding.crypto_kdf_KEYBYTES, "key must be 'crypto_kdf_KEYBYTES' bytes") const res = binding.crypto_kdf_derive_from_key(subkey, subkeyId, ctx, key) if (res !== 0) throw new Error('status: ' + res) } // crypto_hash exports.crypto_hash = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(out.byteLength === binding.crypto_hash_BYTES, "out must be 'crypto_hash_BYTES' bytes") const res = binding.crypto_hash(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256 = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_hash_sha256_BYTES, "out must be 'crypto_hash_sha256_BYTES' bytes" ) const res = binding.crypto_hash_sha256(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_init = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha256_init(state) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha256_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( out.byteLength === binding.crypto_hash_sha256_BYTES, "out must be 'crypto_hash_sha256_BYTES' bytes" ) const res = binding.crypto_hash_sha256_final(state, out) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512 = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_hash_sha512_BYTES, "out must be 'crypto_hash_sha512_BYTES' bytes" ) const res = binding.crypto_hash_sha512(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_init = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha512_init(state) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha512_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( out.byteLength === binding.crypto_hash_sha512_BYTES, "out must be 'crypto_hash_sha512_BYTES' bytes" ) const res = binding.crypto_hash_sha512_final(state, out) if (res !== 0) throw new Error('status: ' + res) } // crypto_aead exports.crypto_aead_xchacha20poly1305_ietf_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) binding.crypto_aead_xchacha20poly1305_ietf_keygen(k) } exports.crypto_aead_xchacha20poly1305_ietf_encrypt = function (c, m, ad, nsec, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "c must be 'm.byteLength + crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(c.byteLength <= 0xffffffff, 'c.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_encrypt(c, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_xchacha20poly1305_ietf_decrypt = function (m, nsec, c, ad, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "m must be 'c.byteLength - crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(m.byteLength <= 0xffffffff, 'm.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_decrypt(m, c, ad, npub, k) if (res < 0) throw new Error('could not verify data') return res } exports.crypto_aead_xchacha20poly1305_ietf_encrypt_detached = function ( c, mac, m, ad, nsec, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_encrypt_detached(c, mac, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_xchacha20poly1305_ietf_decrypt_detached = function ( m, nsec, c, mac, ad, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_decrypt_detached(m, c, mac, ad, npub, k) if (res !== 0) throw new Error('could not verify data') } exports.crypto_aead_chacha20poly1305_ietf_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) binding.crypto_aead_chacha20poly1305_ietf_keygen(k) } exports.crypto_aead_chacha20poly1305_ietf_encrypt = function (c, m, ad, nsec, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "c must be 'm.byteLength + crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(c.byteLength <= 0xffffffff, 'c.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_encrypt(c, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_chacha20poly1305_ietf_decrypt = function (m, nsec, c, ad, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "m must be 'c.byteLength - crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(m.byteLength <= 0xffffffff, 'm.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_decrypt(m, c, ad, npub, k) if (res < 0) throw new Error('could not verify data') return res } exports.crypto_aead_chacha20poly1305_ietf_encrypt_detached = function ( c, mac, m, ad, nsec, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_encrypt_detached(c, mac, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_chacha20poly1305_ietf_decrypt_detached = function ( m, nsec, c, mac, ad, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_decrypt_detached(m, c, mac, ad, npub, k) if (res !== 0) throw new Error('could not verify data') } // crypto_stream exports.crypto_stream_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) binding.crypto_stream_xor_wrap_init(state, n, k) } exports.crypto_stream_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_xor_wrap_update(state, c, m) } exports.crypto_stream_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) binding.crypto_stream_xor_wrap_final(state) } exports.crypto_stream_chacha20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) binding.crypto_stream_chacha20_xor_wrap_init(state, n, k) } exports.crypto_stream_chacha20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_chacha20_xor_wrap_update(state, c, m) } exports.crypto_stream_chacha20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) binding.crypto_stream_chacha20_xor_wrap_final(state) } exports.crypto_stream_chacha20_ietf_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) binding.crypto_stream_chacha20_ietf_xor_wrap_init(state, n, k) } exports.crypto_stream_chacha20_ietf_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_chacha20_ietf_xor_wrap_update(state, c, m) } exports.crypto_stream_chacha20_ietf_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) binding.crypto_stream_chacha20_ietf_xor_wrap_final(state) } exports.crypto_stream_xchacha20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) binding.crypto_stream_xchacha20_xor_wrap_init(state, n, k) } exports.crypto_stream_xchacha20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_xchacha20_xor_wrap_update(state, c, m) } exports.crypto_stream_xchacha20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) binding.crypto_stream_xchacha20_xor_wrap_final(state) } exports.crypto_stream_salsa20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) binding.crypto_stream_salsa20_xor_wrap_init(state, n, k) } exports.crypto_stream_salsa20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_salsa20_xor_wrap_update(state, c, m) } exports.crypto_stream_salsa20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) binding.crypto_stream_salsa20_xor_wrap_final(state) } // experimental exports.extension_tweak_ed25519_base = function (n, p, ns) { assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.extension_tweak_ed25519_BYTES, "p must be 'extension_tweak_ed25519_BYTES' bytes" ) binding.extension_tweak_ed25519_base(n, p, ns) } exports.extension_tweak_ed25519_sign_detached = function (sig, m, scalar, pk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(sig.byteLength === binding.crypto_sign_BYTES, "sig must be 'crypto_sign_BYTES' bytes") assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) if (pk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) } const res = binding.extension_tweak_ed25519_sign_detached(sig, m, scalar, pk) if (res !== 0) throw new Error('failed to compute signature') } exports.extension_tweak_ed25519_sk_to_scalar = function (n, sk) { assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) binding.extension_tweak_ed25519_sk_to_scalar(n, sk) } exports.extension_tweak_ed25519_scalar = function (scalarOut, scalar, ns) { assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_scalar(scalarOut, scalar, ns) } exports.extension_tweak_ed25519_pk = function (tpk, pk, ns) { assert(ArrayBuffer.isView(tpk), 'tpk must be a typed array') assert( tpk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "tpk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.extension_tweak_ed25519_pk(tpk, pk, ns) if (res !== 0) throw new Error('failed to tweak public key') } exports.extension_tweak_ed25519_keypair = function (pk, scalarOut, scalarIn, ns) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.extension_tweak_ed25519_BYTES, "pk must be 'extension_tweak_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalarIn), 'scalarIn must be a typed array') assert( scalarIn.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarIn must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_keypair(pk, scalarOut, scalarIn, ns) } exports.extension_tweak_ed25519_scalar_add = function (scalarOut, scalar, n) { assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_scalar_add(scalarOut, scalar, n) } exports.extension_tweak_ed25519_pk_add = function (tpk, pk, p) { assert(ArrayBuffer.isView(tpk), 'tpk must be a typed array') assert( tpk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "tpk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "p must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.extension_tweak_ed25519_pk_add(tpk, pk, p) if (res !== 0) throw new Error('failed to add tweak to public key') } exports.extension_tweak_ed25519_keypair_add = function (pk, scalarOut, scalarIn, tweak) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.extension_tweak_ed25519_BYTES, "pk must be 'extension_tweak_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalarIn), 'scalarIn must be a typed array') assert( scalarIn.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarIn must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(tweak), 'tweak must be a typed array') assert( tweak.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "tweak must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) const res = binding.extension_tweak_ed25519_keypair_add(pk, scalarOut, scalarIn, tweak) if (res !== 0) throw new Error('failed to add tweak to keypair') } exports.extension_pbkdf2_sha512_async = function (out, passwd, salt, iter, outlen, callback) { assert( iter >= binding.extension_pbkdf2_sha512_ITERATIONS_MIN, "iter must be at least 'extension_pbkdf2_sha512_ITERATIONS_MIN'" ) assert( outlen <= binding.extension_pbkdf2_sha512_BYTES_MAX, "outlen must be at most 'extension_pbkdf2_sha512_BYTES_MAX'" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(out.byteLength >= outlen, "out must be at least 'outlen' bytes") assert(out.byteLength > 0, 'out must not be empty') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(passwd.byteLength > 0, 'passwd must not be empty') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert(salt.byteLength > 0, 'salt must not be empty') const [done, promise] = checkStatus(callback) binding.extension_pbkdf2_sha512_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, iter, outlen, done ) return promise } exports.extension_pbkdf2_sha512 = function (out, passwd, salt, iter, outlen) { assert( iter >= binding.extension_pbkdf2_sha512_ITERATIONS_MIN, "iter must be at least 'extension_pbkdf2_sha512_ITERATIONS_MIN'" ) assert( outlen <= binding.extension_pbkdf2_sha512_BYTES_MAX, "outlen must be at most 'extension_pbkdf2_sha512_BYTES_MAX'" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(out.byteLength >= outlen, "out must be at least 'outlen' bytes") assert(out.byteLength > 0, 'out must not be empty') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(passwd.byteLength > 0, 'passwd must not be empty') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert(salt.byteLength > 0, 'salt must not be empty') const res = binding.extension_pbkdf2_sha512(out, passwd, salt, iter, outlen) if (res !== 0) throw new Error('failed to add tweak to public key') } function checkStatus(callback, booleanResult = false) { let done, promise if (typeof callback === 'function') { done = function (status) { if (booleanResult) callback(null, status === 0) else if (status === 0) callback(null) else callback(new Error('status: ' + status)) } } else { promise = new Promise(function (resolve, reject) { done = function (status) { if (booleanResult) resolve(status === 0) else if (status === 0) resolve() else reject(new Error('status: ' + status)) } }) } return [done, promise] } { "name": "sodium-native", "version": "5.1.0", "description": "Low level bindings for libsodium", "main": "index.js", "files": [ "index.js", "binding.cc", "binding.js", "extensions", "prebuilds", "CMakeLists.txt" ], "imports": { "assert": { "bare": "bare-assert", "node": "assert" } }, "addon": true, "dependencies": { "bare-assert": "^1.2.0", "require-addon": "^1.1.0", "which-runtime": "^1.2.1" }, "devDependencies": { "bare-compat-napi": "^1.3.5", "brittle": "^3.16.2", "cmake-bare": "^1.6.1", "cmake-fetch": "^1.4.3", "cmake-napi": "^1.2.1", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "test": "prettier . --check && npm run test:node && npm run test:bare", "test:node": "node test/all.js", "test:bare": "bare test/all.js" }, "standard": { "ignore": [ "/test/fixtures/*.js" ] }, "engines": { "bare": ">=1.16.0" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/sodium-native.git" }, "contributors": [ "Emil Bay (http://bayes.dk)", "Mathias Buus (https://mafinto.sh)", "Christophe Diederichs " ], "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/sodium-native/issues" }, "homepage": "https://github.com/holepunchto/sodium-native" } module.exports = require('sodium-native') { "name": "sodium-universal", "version": "5.0.1", "description": "Universal wrapper for sodium-javascript and sodium-native working in Node.js and the Browser", "main": "index.js", "dependencies": { "sodium-native": "^5.0.1" }, "peerDependencies": { "sodium-javascript": "~0.8.0" }, "peerDependenciesMeta": { "sodium-javascript": { "optional": true } }, "scripts": { "prepublish": "./build-scripts/generate.js" }, "browser": { "sodium-native": "sodium-javascript" }, "browserify": { "transform": [ "./build-scripts/transform.js" ] }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/sodium-universal.git" }, "keywords": [ "libsodium", "sodium", "sodium-native", "sodium-javascript", "browserify" ], "contributors": [ "Emil Bay (http://bayes.dk)", "Mathias Buus (https://mafinto.sh)", "Christophe Diederichs " ], "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/sodium-universal/issues" }, "homepage": "https://github.com/holepunchto/sodium-universal#readme" } const { EventEmitter } = require('events-universal') const FIFO = require('fast-fifo') const TextDecoder = require('text-decoder') const StreamError = require('./lib/errors.js') // if we do a future major, expect queue microtask to be there always, for now a bit defensive const qmt = typeof queueMicrotask === 'undefined' ? (fn) => global.process.nextTick(fn) : queueMicrotask // 29 bits used total (4 from shared, 14 from read, and 11 from write) const MAX = (1 << 29) - 1 // Shared state const OPENING = 0b0001 const PREDESTROYING = 0b0010 const DESTROYING = 0b0100 const DESTROYED = 0b1000 const NOT_OPENING = MAX ^ OPENING const NOT_PREDESTROYING = MAX ^ PREDESTROYING // Read state (4 bit offset from shared state) const READ_ACTIVE = 0b00000000000001 << 4 const READ_UPDATING = 0b00000000000010 << 4 const READ_PRIMARY = 0b00000000000100 << 4 const READ_QUEUED = 0b00000000001000 << 4 const READ_RESUMED = 0b00000000010000 << 4 const READ_PIPE_DRAINED = 0b00000000100000 << 4 const READ_ENDING = 0b00000001000000 << 4 const READ_EMIT_DATA = 0b00000010000000 << 4 const READ_EMIT_READABLE = 0b00000100000000 << 4 const READ_EMITTED_READABLE = 0b00001000000000 << 4 const READ_DONE = 0b00010000000000 << 4 const READ_NEXT_TICK = 0b00100000000000 << 4 const READ_NEEDS_PUSH = 0b01000000000000 << 4 const READ_READ_AHEAD = 0b10000000000000 << 4 // Combined read state const READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED const READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH const READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE const READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED const READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD const READ_NOT_ACTIVE = MAX ^ READ_ACTIVE const READ_NON_PRIMARY = MAX ^ READ_PRIMARY const READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH) const READ_PUSHED = MAX ^ READ_NEEDS_PUSH const READ_PAUSED = MAX ^ READ_RESUMED const READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE) const READ_NOT_ENDING = MAX ^ READ_ENDING const READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING const READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK const READ_NOT_UPDATING = MAX ^ READ_UPDATING const READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD const READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD // Write state (18 bit offset, 4 bit offset from shared state and 14 from read state) const WRITE_ACTIVE = 0b00000000001 << 18 const WRITE_UPDATING = 0b00000000010 << 18 const WRITE_PRIMARY = 0b00000000100 << 18 const WRITE_QUEUED = 0b00000001000 << 18 const WRITE_UNDRAINED = 0b00000010000 << 18 const WRITE_DONE = 0b00000100000 << 18 const WRITE_EMIT_DRAIN = 0b00001000000 << 18 const WRITE_NEXT_TICK = 0b00010000000 << 18 const WRITE_WRITING = 0b00100000000 << 18 const WRITE_FINISHING = 0b01000000000 << 18 const WRITE_CORKED = 0b10000000000 << 18 const WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING) const WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY const WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING) const WRITE_DRAINED = MAX ^ WRITE_UNDRAINED const WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED const WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK const WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING const WRITE_NOT_CORKED = MAX ^ WRITE_CORKED // Combined shared state const ACTIVE = READ_ACTIVE | WRITE_ACTIVE const NOT_ACTIVE = MAX ^ ACTIVE const DONE = READ_DONE | WRITE_DONE const DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING const OPEN_STATUS = DESTROY_STATUS | OPENING const AUTO_DESTROY = DESTROY_STATUS | DONE const NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY const ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK const TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE const IS_OPENING = OPEN_STATUS | TICKING // Combined shared state and read state const READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE const READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED const READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED const READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE const SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD const READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE const READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY const READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING // Combined write state const WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE const WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED const WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE const WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE const WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED const WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE const WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING const WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE const WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE const WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY const WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS const asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator') class WritableState { constructor( stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {} ) { this.stream = stream this.queue = new FIFO() this.highWaterMark = highWaterMark this.buffered = 0 this.error = null this.pipeline = null this.drains = null // if we add more seldomly used helpers we might them into a subobject so its a single ptr this.byteLength = byteLengthWritable || byteLength || defaultByteLength this.map = mapWritable || map this.afterWrite = afterWrite.bind(this) this.afterUpdateNextTick = updateWriteNT.bind(this) } get ending() { return (this.stream._duplexState & WRITE_FINISHING) !== 0 } get ended() { return (this.stream._duplexState & WRITE_DONE) !== 0 } push(data) { if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false if (this.map !== null) data = this.map(data) this.buffered += this.byteLength(data) this.queue.push(data) if (this.buffered < this.highWaterMark) { this.stream._duplexState |= WRITE_QUEUED return true } this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED return false } shift() { const data = this.queue.shift() this.buffered -= this.byteLength(data) if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED return data } end(data) { if (typeof data === 'function') { this.stream.once('finish', data) } else if (data !== undefined && data !== null) { this.push(data) } this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY } autoBatch(data, cb) { const buffer = [] const stream = this.stream buffer.push(data) while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) { buffer.push(stream._writableState.shift()) } if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null) stream._writev(buffer, cb) } update() { const stream = this.stream stream._duplexState |= WRITE_UPDATING do { while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) { const data = this.shift() stream._duplexState |= WRITE_ACTIVE_AND_WRITING stream._write(data, this.afterWrite) } if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary() } while (this.continueUpdate() === true) stream._duplexState &= WRITE_NOT_UPDATING } updateNonPrimary() { const stream = this.stream if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) { stream._duplexState = stream._duplexState | WRITE_ACTIVE stream._final(afterFinal.bind(this)) return } if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { stream._duplexState |= ACTIVE stream._destroy(afterDestroy.bind(this)) } return } if ((stream._duplexState & IS_OPENING) === OPENING) { stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING stream._open(afterOpen.bind(this)) } } continueUpdate() { if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false this.stream._duplexState &= WRITE_NOT_NEXT_TICK return true } updateCallback() { if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) { this.update() } else { this.updateNextTick() } } updateNextTick() { if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return this.stream._duplexState |= WRITE_NEXT_TICK if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick) } } class ReadableState { constructor( stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {} ) { this.stream = stream this.queue = new FIFO() this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark this.buffered = 0 this.readAhead = highWaterMark > 0 this.error = null this.pipeline = null this.byteLength = byteLengthReadable || byteLength || defaultByteLength this.map = mapReadable || map this.pipeTo = null this.afterRead = afterRead.bind(this) this.afterUpdateNextTick = updateReadNT.bind(this) } get ending() { return (this.stream._duplexState & READ_ENDING) !== 0 } get ended() { return (this.stream._duplexState & READ_DONE) !== 0 } pipe(pipeTo, cb) { if (this.pipeTo !== null) throw StreamError.BAD_ARGUMENT('Can only pipe to one destination') if (typeof cb !== 'function') cb = null this.stream._duplexState |= READ_PIPE_DRAINED this.pipeTo = pipeTo this.pipeline = new Pipeline(this.stream, pipeTo, cb) if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes if (isStreamx(pipeTo)) { pipeTo._writableState.pipeline = this.pipeline if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself } else { const onerror = this.pipeline.done.bind(this.pipeline, pipeTo) const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool arg pipeTo.on('error', onerror) pipeTo.on('close', onclose) pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) } pipeTo.on('drain', afterDrain.bind(this)) this.stream.emit('piping', pipeTo) pipeTo.emit('pipe', this.stream) } push(data) { const stream = this.stream if (data === null) { this.highWaterMark = 0 stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED return false } if (this.map !== null) { data = this.map(data) if (data === null) { stream._duplexState &= READ_PUSHED return this.buffered < this.highWaterMark } } this.buffered += this.byteLength(data) this.queue.push(data) stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED return this.buffered < this.highWaterMark } shift() { const data = this.queue.shift() this.buffered -= this.byteLength(data) if (this.buffered === 0) { this.stream._duplexState &= READ_NOT_QUEUED } return data } unshift(data) { const pending = [this.map !== null ? this.map(data) : data] while (this.buffered > 0) pending.push(this.shift()) for (let i = 0; i < pending.length - 1; i++) { const data = pending[i] this.buffered += this.byteLength(data) this.queue.push(data) } this.push(pending[pending.length - 1]) } read() { const stream = this.stream if ((stream._duplexState & READ_STATUS) === READ_QUEUED) { const data = this.shift() if (this.pipeTo !== null && this.pipeTo.write(data) === false) { stream._duplexState &= READ_PIPE_NOT_DRAINED } if ((stream._duplexState & READ_EMIT_DATA) !== 0) { stream.emit('data', data) } return data } if (this.readAhead === false) { stream._duplexState |= READ_READ_AHEAD this.updateNextTick() } return null } drain() { const stream = this.stream while ( (stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0 ) { const data = this.shift() if (this.pipeTo !== null && this.pipeTo.write(data) === false) { stream._duplexState &= READ_PIPE_NOT_DRAINED } if ((stream._duplexState & READ_EMIT_DATA) !== 0) { stream.emit('data', data) } } } update() { const stream = this.stream stream._duplexState |= READ_UPDATING do { this.drain() while ( this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD ) { stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH stream._read(this.afterRead) this.drain() } if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) { stream._duplexState |= READ_EMITTED_READABLE stream.emit('readable') } if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) { this.updateNonPrimary() } } while (this.continueUpdate() === true) stream._duplexState &= READ_NOT_UPDATING } updateNonPrimary() { const stream = this.stream if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) { stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING stream.emit('end') if ((stream._duplexState & AUTO_DESTROY) === DONE) { stream._duplexState |= DESTROYING } if (this.pipeTo !== null) { this.pipeTo.end() } } if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { stream._duplexState |= ACTIVE stream._destroy(afterDestroy.bind(this)) } return } if ((stream._duplexState & IS_OPENING) === OPENING) { stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING stream._open(afterOpen.bind(this)) } } continueUpdate() { if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false this.stream._duplexState &= READ_NOT_NEXT_TICK return true } updateCallback() { if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) { this.update() } else { this.updateNextTick() } } updateNextTickIfOpen() { if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return this.stream._duplexState |= READ_NEXT_TICK if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick) } updateNextTick() { if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return this.stream._duplexState |= READ_NEXT_TICK if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick) } } class TransformState { constructor(stream) { this.data = null this.afterTransform = afterTransform.bind(stream) this.afterFinal = null } } class Pipeline { constructor(src, dst, cb) { this.from = src this.to = dst this.afterPipe = cb this.error = null this.pipeToFinished = false } finished() { this.pipeToFinished = true } done(stream, err) { if (err) this.error = err if (stream === this.to) { this.to = null if (this.from !== null) { if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) { this.from.destroy(this.error || StreamError.PREMATURE_CLOSE('Writable stream closed')) } return } } if (stream === this.from) { this.from = null if (this.to !== null) { if ((stream._duplexState & READ_DONE) === 0) { this.to.destroy(this.error || StreamError.PREMATURE_CLOSE('Readable stream closed')) } return } } if (this.afterPipe !== null) this.afterPipe(this.error) this.to = this.from = this.afterPipe = null } } function afterDrain() { this.stream._duplexState |= READ_PIPE_DRAINED this.updateCallback() } function afterFinal(err) { const stream = this.stream if (err) stream.destroy(err) if ((stream._duplexState & DESTROY_STATUS) === 0) { stream._duplexState |= WRITE_DONE stream.emit('finish') } if ((stream._duplexState & AUTO_DESTROY) === DONE) { stream._duplexState |= DESTROYING } stream._duplexState &= WRITE_NOT_FINISHING // no need to wait the extra tick here, so we short circuit that if ((stream._duplexState & WRITE_UPDATING) === 0) { this.update() } else { this.updateNextTick() } } function afterDestroy(err) { const stream = this.stream if (!err && !StreamError.isStreamDestroyed(this.error)) err = this.error if (err) stream.emit('error', err) stream._duplexState |= DESTROYED stream.emit('close') const rs = stream._readableState const ws = stream._writableState if (rs !== null && rs.pipeline !== null) { rs.pipeline.done(stream, err) } if (ws !== null) { while (ws.drains !== null && ws.drains.length > 0) { ws.drains.shift().resolve(false) } if (ws.pipeline !== null) { ws.pipeline.done(stream, err) } } } function afterWrite(err) { const stream = this.stream if (err) stream.destroy(err) stream._duplexState &= WRITE_NOT_ACTIVE if (this.drains !== null) tickDrains(this.drains) if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) { stream._duplexState &= WRITE_DRAINED if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) { stream.emit('drain') } } this.updateCallback() } function afterRead(err) { if (err) this.stream.destroy(err) this.stream._duplexState &= READ_NOT_ACTIVE if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) { this.stream._duplexState &= READ_NO_READ_AHEAD } this.updateCallback() } function updateReadNT() { if ((this.stream._duplexState & READ_UPDATING) === 0) { this.stream._duplexState &= READ_NOT_NEXT_TICK this.update() } } function updateWriteNT() { if ((this.stream._duplexState & WRITE_UPDATING) === 0) { this.stream._duplexState &= WRITE_NOT_NEXT_TICK this.update() } } function tickDrains(drains) { for (let i = 0; i < drains.length; i++) { // drains.writes are monotonic, so if one is 0 its always the first one if (--drains[i].writes === 0) { drains.shift().resolve(true) i-- } } } function afterOpen(err) { const stream = this.stream if (err) stream.destroy(err) if ((stream._duplexState & DESTROYING) === 0) { if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) { stream._duplexState |= READ_PRIMARY } if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) { stream._duplexState |= WRITE_PRIMARY } stream.emit('open') } stream._duplexState &= NOT_ACTIVE if (stream._writableState !== null) { stream._writableState.updateCallback() } if (stream._readableState !== null) { stream._readableState.updateCallback() } } function afterTransform(err, data) { if (data !== undefined && data !== null) this.push(data) this._writableState.afterWrite(err) } function newListener(name) { if (this._readableState !== null) { if (name === 'data') { this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD this._readableState.updateNextTick() } if (name === 'readable') { this._duplexState |= READ_EMIT_READABLE this._readableState.updateNextTick() } } if (this._writableState !== null) { if (name === 'drain') { this._duplexState |= WRITE_EMIT_DRAIN this._writableState.updateNextTick() } } } class Stream extends EventEmitter { constructor(opts) { super() this._duplexState = 0 this._readableState = null this._writableState = null if (opts) { if (opts.open) this._open = opts.open if (opts.destroy) this._destroy = opts.destroy if (opts.predestroy) this._predestroy = opts.predestroy if (opts.signal) opts.signal.addEventListener('abort', abort.bind(this)) } this.on('newListener', newListener) } _open(cb) { cb(null) } _destroy(cb) { cb(null) } _predestroy() { // does nothing } get readable() { return this._readableState !== null ? true : undefined } get writable() { return this._writableState !== null ? true : undefined } get destroyed() { return (this._duplexState & DESTROYED) !== 0 } get destroying() { return (this._duplexState & DESTROY_STATUS) !== 0 } destroy(err) { if ((this._duplexState & DESTROY_STATUS) === 0) { if (!err) err = StreamError.STREAM_DESTROYED() this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY if (this._readableState !== null) { this._readableState.highWaterMark = 0 this._readableState.error = err } if (this._writableState !== null) { this._writableState.highWaterMark = 0 this._writableState.error = err } this._duplexState |= PREDESTROYING this._predestroy() this._duplexState &= NOT_PREDESTROYING if (this._readableState !== null) { this._readableState.updateNextTick() } if (this._writableState !== null) { this._writableState.updateNextTick() } } } } class Readable extends Stream { constructor(opts) { super(opts) this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD this._readableState = new ReadableState(this, opts) if (opts) { if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD if (opts.read) this._read = opts.read if (opts.eagerOpen) this._readableState.updateNextTick() if (opts.encoding) this.setEncoding(opts.encoding) } } static deferred(fn, opts) { const out = new PassThrough(opts) fn() .then((src) => { if (src === null) return out.end() if (out.destroying) return pipeline(src, out, noop) }) .catch((err) => out.destroy(err)) return out } setEncoding(encoding) { const dec = new TextDecoder(encoding) const map = this._readableState.map || echo this._readableState.map = mapOrSkip return this function mapOrSkip(data) { const next = dec.push(data) return next === '' && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next) } } _read(cb) { cb(null) } pipe(dest, cb) { this._readableState.updateNextTick() this._readableState.pipe(dest, cb) return dest } read() { this._readableState.updateNextTick() return this._readableState.read() } push(data) { this._readableState.updateNextTickIfOpen() return this._readableState.push(data) } unshift(data) { this._readableState.updateNextTickIfOpen() return this._readableState.unshift(data) } resume() { this._duplexState |= READ_RESUMED_READ_AHEAD this._readableState.updateNextTick() return this } pause() { this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED return this } static _fromAsyncIterator(ite, opts) { let destroy const rs = new Readable({ ...opts, read(cb) { ite.next().then(push).then(cb.bind(null, null)).catch(cb) }, predestroy() { destroy = ite.return() }, destroy(cb) { if (!destroy) return cb(null) destroy.then(cb.bind(null, null)).catch(cb) } }) return rs function push(data) { if (data.done) rs.push(null) else rs.push(data.value) } } static from(data, opts) { if (isReadStreamx(data)) return data if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts) if (!Array.isArray(data)) data = data === undefined ? [] : [data] let i = 0 return new Readable({ ...opts, read(cb) { this.push(i === data.length ? null : data[i++]) cb(null) } }) } static isBackpressured(rs) { return ( (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark ) } static isPaused(rs) { return (rs._duplexState & READ_RESUMED) === 0 } [asyncIterator]() { const stream = this let error = null let promiseResolve = null let promiseReject = null this.on('error', (err) => { error = err }) this.on('readable', onreadable) this.on('close', onclose) return { [asyncIterator]() { return this }, next() { return new Promise(function (resolve, reject) { promiseResolve = resolve promiseReject = reject const data = stream.read() if (data !== null) ondata(data) else if ((stream._duplexState & DESTROYED) !== 0) ondata(null) }) }, return() { return destroy(null) }, throw(err) { return destroy(err) } } function onreadable() { if (promiseResolve !== null) ondata(stream.read()) } function onclose() { if (promiseResolve !== null) ondata(null) } function ondata(data) { if (promiseReject === null) return if (error) { promiseReject(error) } else if (data === null && (stream._duplexState & READ_DONE) === 0) { promiseReject(StreamError.STREAM_DESTROYED()) } else { promiseResolve({ value: data, done: data === null }) } promiseReject = promiseResolve = null } function destroy(err) { stream.destroy(err) return new Promise((resolve, reject) => { if (stream._duplexState & DESTROYED) return resolve({ value: undefined, done: true }) stream.once('close', function () { if (err) reject(err) else resolve({ value: undefined, done: true }) }) }) } } } class Writable extends Stream { constructor(opts) { super(opts) this._duplexState |= OPENING | READ_DONE this._writableState = new WritableState(this, opts) if (opts) { if (opts.writev) this._writev = opts.writev if (opts.write) this._write = opts.write if (opts.final) this._final = opts.final if (opts.eagerOpen) this._writableState.updateNextTick() } } cork() { this._duplexState |= WRITE_CORKED } uncork() { this._duplexState &= WRITE_NOT_CORKED this._writableState.updateNextTick() } _writev(batch, cb) { cb(null) } _write(data, cb) { this._writableState.autoBatch(data, cb) } _final(cb) { cb(null) } static isBackpressured(ws) { return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0 } static drained(ws) { if (ws.destroyed) return Promise.resolve(false) const state = ws._writableState const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0) if (writes === 0) return Promise.resolve(true) if (state.drains === null) state.drains = [] return new Promise((resolve) => { state.drains.push({ writes, resolve }) }) } write(data) { this._writableState.updateNextTick() return this._writableState.push(data) } end(data) { this._writableState.updateNextTick() this._writableState.end(data) return this } } class Duplex extends Readable { // and Writable constructor(opts) { super(opts) this._duplexState = OPENING | (this._duplexState & READ_READ_AHEAD) this._writableState = new WritableState(this, opts) if (opts) { if (opts.writev) this._writev = opts.writev if (opts.write) this._write = opts.write if (opts.final) this._final = opts.final } } cork() { this._duplexState |= WRITE_CORKED } uncork() { this._duplexState &= WRITE_NOT_CORKED this._writableState.updateNextTick() } _writev(batch, cb) { cb(null) } _write(data, cb) { this._writableState.autoBatch(data, cb) } _final(cb) { cb(null) } write(data) { this._writableState.updateNextTick() return this._writableState.push(data) } end(data) { this._writableState.updateNextTick() this._writableState.end(data) return this } } class Transform extends Duplex { constructor(opts) { super(opts) this._transformState = new TransformState(this) if (opts) { if (opts.transform) this._transform = opts.transform if (opts.flush) this._flush = opts.flush } } _write(data, cb) { if (this._readableState.buffered >= this._readableState.highWaterMark) { this._transformState.data = data } else { this._transform(data, this._transformState.afterTransform) } } _read(cb) { if (this._transformState.data !== null) { const data = this._transformState.data this._transformState.data = null cb(null) this._transform(data, this._transformState.afterTransform) } else { cb(null) } } destroy(err) { super.destroy(err) if (this._transformState.data !== null) { this._transformState.data = null this._transformState.afterTransform() } } _transform(data, cb) { cb(null, data) } _flush(cb) { cb(null) } _final(cb) { this._transformState.afterFinal = cb this._flush(transformAfterFlush.bind(this)) } } class PassThrough extends Transform {} function transformAfterFlush(err, data) { const cb = this._transformState.afterFinal if (err) return cb(err) if (data !== null && data !== undefined) this.push(data) this.push(null) cb(null) } function pipelinePromise(...streams) { return new Promise((resolve, reject) => { return pipeline(...streams, (err) => { if (err) return reject(err) resolve() }) }) } function pipeline(stream, ...streams) { const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams] const done = all.length && typeof all[all.length - 1] === 'function' ? all.pop() : null if (all.length < 2) throw StreamError.BAD_ARGUMENT('Pipeline requires at least 2 streams') let src = all[0] let dest = null let error = null for (let i = 1; i < all.length; i++) { dest = all[i] if (isStreamx(src)) { src.pipe(dest, onerror) } else { errorHandle(src, true, i > 1, onerror) src.pipe(dest) } src = dest } if (done) { let fin = false const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy) dest.on('error', (err) => { if (error === null) error = err }) dest.on('finish', () => { fin = true if (!autoDestroy) done(error) }) if (autoDestroy) { dest.on('close', () => done(error || (fin ? null : StreamError.PREMATURE_CLOSE()))) } } return dest function errorHandle(s, rd, wr, onerror) { s.on('error', onerror) s.on('close', onclose) function onclose() { if (rd && s._readableState && !s._readableState.ended) { return onerror(StreamError.PREMATURE_CLOSE()) } if (wr && s._writableState && !s._writableState.ended) { return onerror(StreamError.PREMATURE_CLOSE()) } } } function onerror(err) { if (!err || error) return error = err for (const s of all) { s.destroy(err) } } } function echo(s) { return s } function isStream(stream) { return !!stream._readableState || !!stream._writableState } function isStreamx(stream) { return typeof stream._duplexState === 'number' && isStream(stream) } function isEnding(stream) { return !!stream._readableState && stream._readableState.ending } function isEnded(stream) { return !!stream._readableState && stream._readableState.ended } function isFinishing(stream) { return !!stream._writableState && stream._writableState.ending } function isFinished(stream) { return !!stream._writableState && stream._writableState.ended } function getStreamError(stream, opts = {}) { const err = (stream._readableState && stream._readableState.error) || (stream._writableState && stream._writableState.error) // avoid implicit errors by default return !opts.all && StreamError.isStreamDestroyed(err) ? null : err } function isReadStreamx(stream) { return isStreamx(stream) && stream.readable } function isDisturbed(stream) { return ( (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0 ) } function isTypedArray(data) { return typeof data === 'object' && data !== null && typeof data.byteLength === 'number' } function defaultByteLength(data) { return isTypedArray(data) ? data.byteLength : 1024 } function noop() {} function abort() { this.destroy(StreamError.ABORTED()) } function isWritev(s) { return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev } module.exports = { pipeline, pipelinePromise, isStream, isStreamx, isEnding, isEnded, isFinishing, isFinished, isDisturbed, getStreamError, Stream, Writable, Readable, Duplex, Transform, // Export PassThrough for compatibility with Node.js core's stream module PassThrough } module.exports = class StreamError extends Error { constructor(msg, code, fn = StreamError) { super(msg) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } static isStreamDestroyed(err) { return err && err.code === 'STREAM_DESTROYED' } static isPrematureClose(err) { return err && err.code === 'PREMATURE_CLOSE' } static isAborted(err) { return err && err.code === 'ABORTED' } static isBadArgument(err) { return err && err.code === 'BAD_ARGUMENT' } get name() { return 'StreamError' } static STREAM_DESTROYED() { return new StreamError('Stream was destroyed', 'STREAM_DESTROYED', StreamError.STREAM_DESTROYED) } static PREMATURE_CLOSE(msg = 'Premature close') { return new StreamError(msg, 'PREMATURE_CLOSE', StreamError.PREMATURE_CLOSE) } static ABORTED() { return new StreamError('Stream aborted', 'ABORTED', StreamError.ABORTED) } static BAD_ARGUMENT(msg = 'Bad argument') { return new StreamError(msg, 'BAD_ARGUMENT', StreamError.BAD_ARGUMENT) } } { "name": "streamx", "version": "2.28.0", "description": "An iteration of the Node.js core streams with a series of improvements", "main": "index.js", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors" } }, "dependencies": { "events-universal": "^1.0.0", "fast-fifo": "^1.3.2", "text-decoder": "^1.1.0" }, "devDependencies": { "b4a": "^1.6.6", "brittle": "^3.1.1", "end-of-stream": "^1.4.4", "lunte": "^1.8.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "files": [ "index.js", "index.d.ts", "runtime.d.ts", "lib" ], "scripts": { "format": "prettier . --write", "test": "brittle test/all.js && brittle-bare test/all.js", "lint": "prettier . --check && lunte" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/streamx.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/streamx/issues" }, "homepage": "https://github.com/mafintosh/streamx" } const { Readable } = require('streamx') module.exports = function (s, forks = 2) { const streams = new Array(forks) const status = new Array(forks).fill(true) let ended = false for (let i = 0; i < forks; i++) { streams[i] = new Readable({ read (cb) { const check = !status[i] status[i] = true if (check && allReadable()) s.resume() cb(null) } }) } s.on('end', function () { ended = true for (const stream of streams) stream.push(null) }) s.on('error', function (err) { for (const stream of streams) stream.destroy(err) }) s.on('close', function () { if (ended) return for (const stream of streams) stream.destroy() }) s.on('data', function (data) { let needsPause = false for (let i = 0; i < streams.length; i++) { if (!(status[i] = streams[i].push(data))) { needsPause = true } } if (needsPause) s.pause() }) return streams function allReadable () { for (let j = 0; j < status.length; j++) { if (!status[j]) return false } return true } } { "name": "teex", "version": "1.0.1", "description": "Turn a readable stream into multiple readable streamx streams", "main": "index.js", "dependencies": { "streamx": "^2.12.5" }, "devDependencies": { "standard": "^14.3.4", "tape": "^5.0.1" }, "scripts": { "test": "standard && tape test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/teex.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/teex/issues" }, "homepage": "https://github.com/mafintosh/teex" } const PassThroughDecoder = require('./lib/pass-through-decoder') const UTF8Decoder = require('./lib/utf8-decoder') module.exports = class TextDecoder { constructor(encoding = 'utf8') { this.encoding = normalizeEncoding(encoding) switch (this.encoding) { case 'utf8': this.decoder = new UTF8Decoder() break case 'utf16le': case 'base64': throw new Error('Unsupported encoding: ' + this.encoding) default: this.decoder = new PassThroughDecoder(this.encoding) } } get remaining() { return this.decoder.remaining } push(data) { if (typeof data === 'string') return data return this.decoder.decode(data) } // For Node.js compatibility write(data) { return this.push(data) } end(data) { let result = '' if (data) result = this.push(data) result += this.decoder.flush() return result } } function normalizeEncoding(encoding) { encoding = encoding.toLowerCase() switch (encoding) { case 'utf8': case 'utf-8': return 'utf8' case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return 'utf16le' case 'latin1': case 'binary': return 'latin1' case 'base64': case 'ascii': case 'hex': return encoding default: throw new Error('Unknown encoding: ' + encoding) } } const b4a = require('b4a') module.exports = class PassThroughDecoder { constructor(encoding) { this.encoding = encoding } get remaining() { return 0 } decode(data) { return b4a.toString(data, this.encoding) } flush() { return '' } } const b4a = require('b4a') /** * https://encoding.spec.whatwg.org/#utf-8-decoder */ module.exports = class UTF8Decoder { constructor() { this._reset() } get remaining() { return this.bytesSeen } decode(data) { if (data.byteLength === 0) return '' if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) { this.bytesSeen = trailingBytesSeen(data) return b4a.toString(data, 'utf8') } let result = '' let start = 0 if (this.bytesNeeded > 0) { while (start < data.byteLength) { const byte = data[start] if (byte < this.lowerBoundary || byte > this.upperBoundary) { result += '\ufffd' this._reset() break } this.lowerBoundary = 0x80 this.upperBoundary = 0xbf this.codePoint = (this.codePoint << 6) | (byte & 0x3f) this.bytesSeen++ start++ if (this.bytesSeen === this.bytesNeeded) { result += String.fromCodePoint(this.codePoint) this._reset() break } } if (this.bytesNeeded > 0) return result } const trailing = trailingIncomplete(data, start) const end = data.byteLength - trailing if (end > start) result += b4a.toString(data, 'utf8', start, end) for (let i = end; i < data.byteLength; i++) { const byte = data[i] if (this.bytesNeeded === 0) { if (byte <= 0x7f) { this.bytesSeen = 0 result += String.fromCharCode(byte) } else if (byte >= 0xc2 && byte <= 0xdf) { this.bytesNeeded = 2 this.bytesSeen = 1 this.codePoint = byte & 0x1f } else if (byte >= 0xe0 && byte <= 0xef) { if (byte === 0xe0) this.lowerBoundary = 0xa0 else if (byte === 0xed) this.upperBoundary = 0x9f this.bytesNeeded = 3 this.bytesSeen = 1 this.codePoint = byte & 0xf } else if (byte >= 0xf0 && byte <= 0xf4) { if (byte === 0xf0) this.lowerBoundary = 0x90 else if (byte === 0xf4) this.upperBoundary = 0x8f this.bytesNeeded = 4 this.bytesSeen = 1 this.codePoint = byte & 0x7 } else { this.bytesSeen = 1 result += '\ufffd' } continue } if (byte < this.lowerBoundary || byte > this.upperBoundary) { result += '\ufffd' i-- this._reset() continue } this.lowerBoundary = 0x80 this.upperBoundary = 0xbf this.codePoint = (this.codePoint << 6) | (byte & 0x3f) this.bytesSeen++ if (this.bytesSeen === this.bytesNeeded) { result += String.fromCodePoint(this.codePoint) this._reset() } } return result } flush() { const result = this.bytesNeeded > 0 ? '\ufffd' : '' this._reset() return result } _reset() { this.codePoint = 0 this.bytesNeeded = 0 this.bytesSeen = 0 this.lowerBoundary = 0x80 this.upperBoundary = 0xbf } } function trailingIncomplete(data, start) { const len = data.byteLength if (len <= start) return 0 const limit = Math.max(start, len - 4) let i = len - 1 while (i > limit && (data[i] & 0xc0) === 0x80) i-- if (i < start) return 0 const byte = data[i] let needed if (byte <= 0x7f) return 0 if (byte >= 0xc2 && byte <= 0xdf) needed = 2 else if (byte >= 0xe0 && byte <= 0xef) needed = 3 else if (byte >= 0xf0 && byte <= 0xf4) needed = 4 else return 0 const available = len - i return available < needed ? available : 0 } function trailingBytesSeen(data) { const len = data.byteLength if (len === 0) return 0 const last = data[len - 1] if (last <= 0x7f) return 0 if ((last & 0xc0) !== 0x80) return 1 const limit = Math.max(0, len - 4) let i = len - 2 while (i >= limit && (data[i] & 0xc0) === 0x80) i-- if (i < 0) return 1 const first = data[i] let needed if (first >= 0xc2 && first <= 0xdf) needed = 2 else if (first >= 0xe0 && first <= 0xef) needed = 3 else if (first >= 0xf0 && first <= 0xf4) needed = 4 else return 1 if (len - i !== needed) return 1 if (needed >= 3) { const second = data[i + 1] if (first === 0xe0 && second < 0xa0) return 1 if (first === 0xed && second > 0x9f) return 1 if (first === 0xf0 && second < 0x90) return 1 if (first === 0xf4 && second > 0x8f) return 1 } return 0 } { "name": "text-decoder", "version": "1.2.7", "description": "Streaming text decoder that preserves multibyte Unicode characters", "exports": { "./package": "./package.json", ".": "./index.js" }, "files": [ "index.js", "lib" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/text-decoder.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/text-decoder/issues" }, "homepage": "https://github.com/holepunchto/text-decoder#readme", "dependencies": { "b4a": "^1.6.4" }, "devDependencies": { "brittle": "^3.3.2", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" } } const { runtime, platform, arch, version } = typeof Bare !== 'undefined' ? { runtime: 'bare', platform: global.Bare.platform, arch: global.Bare.arch, version: global.Bare.version } : typeof process !== 'undefined' ? { runtime: 'node', platform: global.process.platform, arch: global.process.arch, version: global.process.version } : typeof Window !== 'undefined' ? { runtime: 'browser', platform: 'unknown', arch: 'unknown', version: 'unknown' } : { runtime: 'unknown', platform: 'unknown', arch: 'unknown', version: 'unknown' } exports.runtime = runtime exports.version = version exports.platform = platform exports.arch = arch exports.isBare = runtime === 'bare' exports.isBareKit = exports.isBare && typeof BareKit !== 'undefined' exports.isPear = typeof Pear !== 'undefined' exports.isNode = runtime === 'node' exports.isBrowser = runtime === 'browser' exports.isWindows = platform === 'win32' exports.isLinux = platform === 'linux' exports.isMac = platform === 'darwin' exports.isIOS = platform === 'ios' || platform === 'ios-simulator' exports.isAndroid = platform === 'android' exports.isElectron = typeof process !== 'undefined' && !!global.process.versions?.electron exports.isElectronRenderer = exports.isElectron && global.process.type === 'renderer' exports.isElectronWorker = exports.isElectron && global.process.type === 'worker' { "name": "which-runtime", "version": "1.4.0", "description": "Detect if you are in Bare or Node and which os etc", "main": "index.js", "files": [ "index.js" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte .", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/which-runtime.git" }, "author": "Holepunch Inc.", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/which-runtime/issues" }, "homepage": "https://github.com/holepunchto/which-runtime", "devDependencies": { "brittle": "^3.0.0", "lunte": "^1.4.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } { "name": "hyper-overlay", "version": "0.3.13", "description": "Content-addressed P2P file distribution over Protomux — FastCDC chunking, multi-source fetch, resumable transfers, zero blob duplication. Files live on disk; the overlay is a thin index and transfer protocol.", "type": "module", "main": "index.js", "imports": { "#fs": { "bare": "bare-fs", "default": "fs" }, "#path": { "bare": "bare-path", "default": "path" }, "#os": { "bare": "bare-os", "default": "os" }, "#zlib": { "bare": "bare-zlib", "default": "zlib" } }, "exports": { ".": "./index.js", "./overlay": "./lib/overlay.js", "./protocol": "./lib/protocol.js", "./messages": "./lib/messages.js", "./chunker": "./lib/chunker.js", "./chunk-scheduler": "./lib/chunk-scheduler.js", "./transfer": "./lib/transfer.js", "./file-index": "./lib/file-index.js", "./sync-engine": "./lib/sync-engine.js", "./tree": "./lib/tree.js", "./pointer": "./lib/pointer.js", "./ignore": "./lib/ignore.js", "./manifest": "./lib/manifest.js", "./package.json": "./package.json" }, "scripts": { "test": "brittle-bare test/*.test.js test/integration/*.test.js", "test:node": "brittle-node test/*.test.js" }, "engines": { "bare": ">=1.16.0" }, "license": "AGPL-3.0", "keywords": [ "p2p", "hypercore", "hyperbee", "protomux", "overlay", "content-addressed", "deduplication", "file-transfer", "fastcdc", "chunking", "multi-source", "resumable", "bare" ], "dependencies": { "b4a": "^1.0.0", "bare-fs": "^4.7.2", "bare-os": "^3.8.7", "bare-path": "^3.0.0", "bare-zlib": "^1.3.3", "compact-encoding": "^3.2.0", "corestore": "^7.0.0", "hyperbee": "^2.0.0", "hypercore-crypto": "^3.0.0", "protomux": "^3.0.0", "ready-resource": "^1.0.0", "sodium-universal": "^5.0.1", "streamx": "^2.0.0" }, "devDependencies": { "brittle": "^3.0.0", "hyperswarm": "^4.0.0", "@hyperswarm/testnet": "^3.1.4" } } const sodium = require('sodium-universal') const c = require('compact-encoding') const b4a = require('b4a') // https://en.wikipedia.org/wiki/Merkle_tree#Second_preimage_attack const LEAF_TYPE = b4a.from([0]) const PARENT_TYPE = b4a.from([1]) const ROOT_TYPE = b4a.from([2]) const HYPERCORE = b4a.from('hypercore') exports.keyPair = function (seed) { // key pairs might stay around for a while, so better not to use a default slab to avoid retaining it completely const slab = b4a.allocUnsafeSlow( sodium.crypto_sign_PUBLICKEYBYTES + sodium.crypto_sign_SECRETKEYBYTES ) const publicKey = slab.subarray(0, sodium.crypto_sign_PUBLICKEYBYTES) const secretKey = slab.subarray(sodium.crypto_sign_PUBLICKEYBYTES) if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed) else sodium.crypto_sign_keypair(publicKey, secretKey) return { publicKey, secretKey } } exports.validateKeyPair = function (keyPair) { const pk = b4a.allocUnsafe(sodium.crypto_sign_PUBLICKEYBYTES) sodium.crypto_sign_ed25519_sk_to_pk(pk, keyPair.secretKey) return b4a.equals(pk, keyPair.publicKey) } exports.sign = function (message, secretKey) { // Dedicated slab for the signature, to avoid retaining unneeded mem and for security const signature = b4a.allocUnsafeSlow(sodium.crypto_sign_BYTES) sodium.crypto_sign_detached(signature, message, secretKey) return signature } exports.verify = function (message, signature, publicKey) { if (signature.byteLength !== sodium.crypto_sign_BYTES) return false if (publicKey.byteLength !== sodium.crypto_sign_PUBLICKEYBYTES) return false return sodium.crypto_sign_verify_detached(signature, message, publicKey) } exports.encrypt = function (message, publicKey) { const ciphertext = b4a.alloc(message.byteLength + sodium.crypto_box_SEALBYTES) sodium.crypto_box_seal(ciphertext, message, publicKey) return ciphertext } exports.decrypt = function (ciphertext, keyPair) { if (ciphertext.byteLength < sodium.crypto_box_SEALBYTES) return null const plaintext = b4a.alloc(ciphertext.byteLength - sodium.crypto_box_SEALBYTES) if (!sodium.crypto_box_seal_open(plaintext, ciphertext, keyPair.publicKey, keyPair.secretKey)) { return null } return plaintext } exports.encryptionKeyPair = function (seed) { const publicKey = b4a.alloc(sodium.crypto_box_PUBLICKEYBYTES) const secretKey = b4a.alloc(sodium.crypto_box_SECRETKEYBYTES) if (seed) { sodium.crypto_box_seed_keypair(publicKey, secretKey, seed) } else { sodium.crypto_box_keypair(publicKey, secretKey) } return { publicKey, secretKey } } exports.data = function (data) { const out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, [LEAF_TYPE, c.encode(c.uint64, data.byteLength), data]) return out } exports.parent = function (a, b) { if (a.index > b.index) { const tmp = a a = b b = tmp } const out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, [ PARENT_TYPE, c.encode(c.uint64, a.size + b.size), a.hash, b.hash ]) return out } exports.tree = function (roots, out) { const buffers = new Array(3 * roots.length + 1) let j = 0 buffers[j++] = ROOT_TYPE for (let i = 0; i < roots.length; i++) { const r = roots[i] buffers[j++] = r.hash buffers[j++] = c.encode(c.uint64, r.index) buffers[j++] = c.encode(c.uint64, r.size) } if (!out) out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, buffers) return out } exports.hash = function (data, out) { if (!out) out = b4a.allocUnsafe(32) if (!Array.isArray(data)) data = [data] sodium.crypto_generichash_batch(out, data) return out } exports.randomBytes = function (n) { const buf = b4a.allocUnsafe(n) sodium.randombytes_buf(buf) return buf } exports.discoveryKey = function (key) { if (!key || key.byteLength !== 32) throw new Error('Must pass a 32 byte buffer') // Discovery keys might stay around for a while, so better not to use slab memory (for better gc) const digest = b4a.allocUnsafeSlow(32) sodium.crypto_generichash(digest, HYPERCORE, key) return digest } if (sodium.sodium_free) { exports.free = function (secureBuf) { if (secureBuf.secure) sodium.sodium_free(secureBuf) } } else { exports.free = function () {} } exports.namespace = function (name, count) { const ids = typeof count === 'number' ? range(count) : count // Namespaces are long-lived, so better to use a dedicated slab const buf = b4a.allocUnsafeSlow(32 * ids.length) const list = new Array(ids.length) // ns is ephemeral, so default slab const ns = b4a.allocUnsafe(33) sodium.crypto_generichash(ns.subarray(0, 32), typeof name === 'string' ? b4a.from(name) : name) for (let i = 0; i < list.length; i++) { list[i] = buf.subarray(32 * i, 32 * i + 32) ns[32] = ids[i] sodium.crypto_generichash(list[i], ns) } return list } function range(count) { const arr = new Array(count) for (let i = 0; i < count; i++) arr[i] = i return arr } { "name": "hypercore-crypto", "version": "3.7.0", "description": "The crypto primitives used in hypercore, extracted into a separate module", "main": "index.js", "files": [ "index.js" ], "dependencies": { "b4a": "^1.6.6", "compact-encoding": "^3.0.0", "sodium-universal": "^5.0.0" }, "devDependencies": { "brittle": "^3.5.0", "lunte": "^1.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/hypercore-crypto.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/hypercore-crypto/issues" }, "homepage": "https://github.com/mafintosh/hypercore-crypto" } const z32 = require('z32') const b4a = require('b4a') module.exports = { encode, decode, normalize, isValid } function encode (key) { if (!b4a.isBuffer(key)) throw new Error('Key must be a Buffer') if (key.byteLength !== 32) throw new Error('Key must be 32-bytes long') return z32.encode(key) } function decode (id) { if (b4a.isBuffer(id)) { if (id.byteLength !== 32) throw new Error('ID must be 32-bytes long') return id } if (typeof id === 'string') { if (id.startsWith('pear://')) id = id.slice(7).split('/')[0] if (id.length === 52) return z32.decode(id) if (id.length === 64) { const buf = b4a.from(id, 'hex') if (buf.byteLength === 32) return buf } } throw new Error('Invalid Hypercore key') } function normalize (any) { return encode(decode(any)) } function isValid (any) { try { decode(any) return true } catch { return false } } { "name": "hypercore-id-encoding", "version": "1.3.0", "description": "Convert Hypercore keys to/from z-base32 or hex", "main": "index.js", "scripts": { "test": "standard && brittle test.js" }, "files": [ "index.js" ], "dependencies": { "b4a": "^1.5.3", "z32": "^1.0.0" }, "devDependencies": { "brittle": "^3.1.1", "hypercore": "^10.0.0", "random-access-memory": "^6.0.0", "standard": "^17.1.0" }, "license": "Apache-2.0", "repository": { "type": "git", "url": "git+https://github.com/holepunchto/hypercore-id-encoding.git" }, "keywords": [], "author": "", "bugs": { "url": "https://github.com/holepunchto/hypercore-id-encoding/issues" }, "homepage": "https://github.com/holepunchto/hypercore-id-encoding#readme" } const c = require('compact-encoding') const { getEncoding } = require('./spec/hyperschema') const HyperdhtAddress = getEncoding('@hyperdht/address') function decode(buf) { const addr = c.decode(HyperdhtAddress, buf) return addr } function encode(key, nodes) { return c.encode(HyperdhtAddress, { key, nodes }) } module.exports = { decode, encode } { "name": "hyperdht-address", "version": "1.1.1", "description": "hyperdht-address", "main": "index.js", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" } }, "files": [ "package.json", "index.js", "index.d.ts", "spec" ], "devDependencies": { "b4a": "^1.8.0", "brittle": "^3.19.0", "lunte": "^1.2.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "format": "prettier . --write", "test": "prettier . --check && lunte && brittle-bare test/index.js", "lint": "lunte" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/hyperdht-address.git" }, "author": "Holepunch Inc", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/hyperdht-address/issues" }, "homepage": "https://github.com/holepunchto/hyperdht-address", "dependencies": { "compact-encoding": "^3.0.0", "hyperschema": "^1.20.1" } } // This file is autogenerated by the hyperschema compiler // Schema Version: 2 /* eslint-disable camelcase */ /* eslint-disable quotes */ /* eslint-disable space-before-function-paren */ const { c } = require('hyperschema/runtime') const VERSION = 2 // eslint-disable-next-line no-unused-vars let version = VERSION // @hyperdht/address.nodes const encoding0_1 = c.array(c.ipv4Address) // @hyperdht/address const encoding0 = { preencode(state, m) { c.fixed32.preencode(state, m.key) state.end++ // max flag is 1 so always one byte if (version >= 2 && m.nodes) encoding0_1.preencode(state, m.nodes) }, encode(state, m) { const flags = version >= 2 && m.nodes ? 1 : 0 c.fixed32.encode(state, m.key) c.uint.encode(state, flags) if (version >= 2 && m.nodes) encoding0_1.encode(state, m.nodes) }, decode(state) { const r0 = c.fixed32.decode(state) const flags = state.start < state.end ? c.uint.decode(state) : 0 return { key: r0, nodes: version >= 2 && (flags & 1) !== 0 ? encoding0_1.decode(state) : null } } } function setVersion(v) { version = v } function encode(name, value, v = VERSION) { version = v return c.encode(getEncoding(name), value) } function decode(name, buffer, v = VERSION) { version = v return c.decode(getEncoding(name), buffer) } function getEnum(name) { switch (name) { default: throw new Error('Enum not found ' + name) } } function getEncoding(name) { switch (name) { case '@hyperdht/address': return encoding0 default: throw new Error('Encoder not found ' + name) } } function getStruct(name, v = VERSION) { const enc = getEncoding(name) return { preencode(state, m) { version = v enc.preencode(state, m) }, encode(state, m) { version = v enc.encode(state, m) }, decode(state) { version = v return enc.decode(state) } } } const resolveStruct = getStruct // compat module.exports = { resolveStruct, getStruct, getEnum, getEncoding, encode, decode, setVersion, version } const DHT = require('dht-rpc') const sodium = require('sodium-universal') const c = require('compact-encoding') const b4a = require('b4a') const safetyCatch = require('safety-catch') const m = require('./lib/messages') const SocketPool = require('./lib/socket-pool') const Persistent = require('./lib/persistent') const Router = require('./lib/router') const Cache = require('xache') const Server = require('./lib/server') const connect = require('./lib/connect') const { FIREWALL, BOOTSTRAP_NODES, COMMANDS } = require('./lib/constants') const { hash, createKeyPair } = require('./lib/crypto') const RawStreamSet = require('./lib/raw-stream-set') const ConnectionPool = require('./lib/connection-pool') const { STREAM_NOT_CONNECTED } = require('./lib/errors') const DEFAULTS = { ...DHT.DEFAULTS, connectionKeepAlive: 5000, randomPunchInterval: 20000 } class HyperDHT extends DHT { constructor(opts = {}) { const port = opts.port || 49737 const bootstrap = opts.bootstrap || BOOTSTRAP_NODES const nodes = opts.nodes || [] super({ ...opts, port, bootstrap, nodes, filterNode }) const { router, relayAddresses, persistent } = defaultCacheOpts(opts) this.defaultKeyPair = opts.keyPair || createKeyPair(opts.seed) this.listening = new Set() this.connectionKeepAlive = opts.connectionKeepAlive === false ? 0 : opts.connectionKeepAlive || DEFAULTS.connectionKeepAlive this.rawStreams = new RawStreamSet(this) this.plugins = new Map() this._router = new Router(this, router) this._socketPool = new SocketPool(this, opts.host || '0.0.0.0') this._persistent = null this._validatedLocalAddresses = new Map() this._relayAddressesCache = new Cache(relayAddresses) this._deferRandomPunch = !!opts.deferRandomPunch this._lastRandomPunch = this._deferRandomPunch ? Date.now() : 0 this._connectable = true this._randomPunchInterval = opts.randomPunchInterval || DEFAULTS.randomPunchInterval // min 20s between random punches... this._randomPunches = 0 this._randomPunchLimit = 1 // set to one for extra safety for now // stats is inherited from dht-rpc so fwd the ones from there this.stats = { punches: { consistent: 0, random: 0, open: 0, tryLater: 0, tryLaterRelayedHandshakesAtLeastOnce: 0 }, relaying: { attempts: 0, successes: 0, aborts: 0 }, socketPool: this._socketPool.stats, ...this.stats } this.once('persistent', () => { this._persistent = new Persistent(this, persistent) for (const plugin of this.plugins.values()) plugin.onpersistent() }) this.on('network-change', () => { for (const server of this.listening) server.refresh() }) this.on('network-update', () => { if (!this.online) return for (const server of this.listening) server.notifyOnline() }) } static DEFAULTS = DEFAULTS connect(remotePublicKey, opts) { return connect(this, remotePublicKey, opts) } createServer(opts, onconnection) { if (typeof opts === 'function') return this.createServer({}, opts) if (opts && opts.onconnection) onconnection = opts.onconnection const s = new Server(this, opts) if (onconnection) s.on('connection', onconnection) return s } pool() { return new ConnectionPool(this) } async resume({ log = noop } = {}) { if (this._deferRandomPunch) this._lastRandomPunch = Date.now() await super.resume({ log }) const resuming = [] for (const server of this.listening) resuming.push(server.resume()) log('Resuming hyperdht servers') await Promise.allSettled(resuming) log('Done, hyperdht fully resumed') } async suspend({ log = noop } = {}) { this._connectable = false // just so nothing gets connected during suspension const suspending = [] for (const server of this.listening) suspending.push(server.suspend()) log('Suspending all hyperdht servers') await Promise.allSettled(suspending) log('Done, clearing all raw streams') await this.rawStreams.clear() log('Done, suspending dht-rpc') await super.suspend({ log }) log('Done, clearing raw streams again') await this.rawStreams.clear() log('Done, hyperdht fully suspended') this._connectable = true } async destroy({ force = false } = {}) { if (!force) { const closing = [] for (const server of this.listening) closing.push(server.close()) await Promise.allSettled(closing) } this._router.destroy() if (this._persistent) this._persistent.destroy() for (const plugin of this.plugins.values()) plugin.destroy() await this.rawStreams.clear() await this._socketPool.destroy() await super.destroy() } async validateLocalAddresses(addresses) { const list = [] const socks = [] const waiting = [] for (const addr of addresses) { const { host } = addr if (this._validatedLocalAddresses.has(host)) { if (await this._validatedLocalAddresses.get(host)) { list.push(addr) } continue } const sock = this.udx.createSocket() try { sock.bind(0, host) } catch { this._validatedLocalAddresses.set(host, Promise.resolve(false)) continue } socks.push(sock) // semi terrible heuristic until we proper fix local connections by racing them to the remote... const promise = new Promise((resolve) => { sock.on('message', () => resolve(true)) setTimeout(() => resolve(false), 500) sock.trySend(b4a.alloc(1), sock.address().port, addr.host) }) this._validatedLocalAddresses.set(host, promise) waiting.push(addr) } for (const addr of waiting) { const { host } = addr if (this._validatedLocalAddresses.has(host)) { if (await this._validatedLocalAddresses.get(host)) { list.push(addr) } continue } } for (const sock of socks) await sock.close() return list } findPeer(publicKey, opts = {}) { const target = opts.hash === false ? publicKey : hash(publicKey) opts = { ...opts, map: mapFindPeer } return this.query({ target, command: COMMANDS.FIND_PEER, value: null }, opts) } lookup(target, opts = {}) { opts = { ...opts, map: mapLookup } return this.query({ target, command: COMMANDS.LOOKUP, value: null }, opts) } lookupAndUnannounce(target, keyPair, opts = {}) { const unannounces = [] const dht = this const userCommit = opts.commit || noop const signUnannounce = opts.signUnannounce || Persistent.signUnannounce if (this._persistent !== null) { // unlink self this._persistent.unannounce(target, keyPair.publicKey) } opts = { ...opts, map, commit } return this.query({ target, command: COMMANDS.LOOKUP, value: null }, opts) async function commit(reply, dht, query) { await Promise.all(unannounces) // can never fail, caught below return userCommit(reply, dht, query) } function map(reply) { const data = mapLookup(reply) if (!data || !data.token) return data let found = data.peers.length >= 20 for (let i = 0; !found && i < data.peers.length; i++) { found = b4a.equals(data.peers[i].publicKey, keyPair.publicKey) } if (!found) return data if (!data.from.id) return data unannounces.push( dht ._requestUnannounce(keyPair, dht, target, data.token, data.from, signUnannounce) .catch(safetyCatch) ) return data } } unannounce(target, keyPair, opts = {}) { return this.lookupAndUnannounce(target, keyPair, opts).finished() } announce(target, keyPair, relayAddresses, opts = {}) { const signAnnounce = opts.signAnnounce || Persistent.signAnnounce const bump = opts.bump || 0 opts = { ...opts, commit } return opts.clear ? this.lookupAndUnannounce(target, keyPair, opts) : this.lookup(target, opts) function commit(reply, dht) { return dht._requestAnnounce( keyPair, dht, target, reply.token, reply.from, relayAddresses, signAnnounce, bump ) } } async immutableGet(target, opts = {}) { opts = { ...opts, map: mapImmutable } const query = this.query({ target, command: COMMANDS.IMMUTABLE_GET, value: null }, opts) const check = b4a.allocUnsafe(32) for await (const node of query) { const { value } = node sodium.crypto_generichash(check, value) if (b4a.equals(check, target)) return node } return null } async immutablePut(value, opts = {}) { const target = b4a.allocUnsafe(32) sodium.crypto_generichash(target, value) opts = { ...opts, map: mapImmutable, commit(reply, dht) { return dht.request( { token: reply.token, target, command: COMMANDS.IMMUTABLE_PUT, value }, reply.from ) } } const query = this.query({ target, command: COMMANDS.IMMUTABLE_GET, value: null }, opts) await query.finished() return { hash: target, closestNodes: query.closestNodes } } async mutableGet(publicKey, opts = {}) { let refresh = opts.refresh || null let signed = null let result = null opts = { ...opts, map: mapMutable, commit: refresh ? commit : null } const target = b4a.allocUnsafe(32) sodium.crypto_generichash(target, publicKey) const userSeq = opts.seq || 0 const query = this.query( { target, command: COMMANDS.MUTABLE_GET, value: c.encode(c.uint, userSeq) }, opts ) const latest = opts.latest !== false for await (const node of query) { if (result && node.seq <= result.seq) continue if ( node.seq < userSeq || !Persistent.verifyMutable(node.signature, node.seq, node.value, publicKey) ) continue if (!latest) return node if (!result || node.seq > result.seq) result = node } return result function commit(reply, dht) { if (!signed && result && refresh) { if (refresh(result)) { signed = c.encode(m.mutablePutRequest, { publicKey, seq: result.seq, value: result.value, signature: result.signature }) } else { refresh = null } } return signed ? dht.request( { token: reply.token, target, command: COMMANDS.MUTABLE_PUT, value: signed }, reply.from ) : Promise.resolve(null) } } async mutablePut(keyPair, value, opts = {}) { const signMutable = opts.signMutable || Persistent.signMutable const target = b4a.allocUnsafe(32) sodium.crypto_generichash(target, keyPair.publicKey) const seq = opts.seq || 0 const signature = await signMutable(seq, value, keyPair) const signed = c.encode(m.mutablePutRequest, { publicKey: keyPair.publicKey, seq, value, signature }) opts = { ...opts, map: mapMutable, commit(reply, dht) { return dht.request( { token: reply.token, target, command: COMMANDS.MUTABLE_PUT, value: signed }, reply.from ) } } // use seq = 0, for the query part here, as we don't care about the actual values const query = this.query( { target, command: COMMANDS.MUTABLE_GET, value: c.encode(c.uint, 0) }, opts ) await query.finished() return { publicKey: keyPair.publicKey, closestNodes: query.closestNodes, seq, signature } } onrequest(req) { switch (req.command) { case COMMANDS.PEER_HANDSHAKE: { this._router.onpeerhandshake(req) return true } case COMMANDS.PEER_HOLEPUNCH: { this._router.onpeerholepunch(req) return true } } if (this._persistent === null || this.id === null) return false switch (req.command) { case COMMANDS.FIND_PEER: { this._persistent.onfindpeer(req) return true } case COMMANDS.LOOKUP: { this._persistent.onlookup(req) return true } case COMMANDS.ANNOUNCE: { this._persistent.onannounce(req) return true } case COMMANDS.UNANNOUNCE: { this._persistent.onunannounce(req) return true } case COMMANDS.MUTABLE_PUT: { this._persistent.onmutableput(req) return true } case COMMANDS.MUTABLE_GET: { this._persistent.onmutableget(req) return true } case COMMANDS.IMMUTABLE_PUT: { this._persistent.onimmutableput(req) return true } case COMMANDS.IMMUTABLE_GET: { this._persistent.onimmutableget(req) return true } case COMMANDS.PLUGIN: { this._persistent.onplugin(req) return true } } return false } static keyPair(seed) { return createKeyPair(seed) } static hash(data) { return hash(data) } static connectRawStream(encryptedStream, rawStream, remoteId) { const stream = encryptedStream.rawStream if (!stream.connected) throw STREAM_NOT_CONNECTED() rawStream.connect(stream.socket, remoteId, stream.remotePort, stream.remoteHost) } createRawStream(opts) { return this.rawStreams.add(opts) } async _requestAnnounce(keyPair, dht, target, token, from, relayAddresses, sign, bump) { const ann = { peer: { publicKey: keyPair.publicKey, relayAddresses: relayAddresses || [] }, refresh: null, signature: null, bump } ann.signature = await sign(target, token, from.id, ann, keyPair) const value = c.encode(m.announce, ann) return dht.request( { token, target, command: COMMANDS.ANNOUNCE, value }, from ) } async _requestUnannounce(keyPair, dht, target, token, from, sign) { const unann = { peer: { publicKey: keyPair.publicKey, relayAddresses: [] }, signature: null } unann.signature = await sign(target, token, from.id, unann, keyPair) const value = c.encode(m.announce, unann) return dht.request( { token, target, command: COMMANDS.UNANNOUNCE, value }, from ) } register(name, plugin) { this.plugins.set(name, plugin) plugin.onregister(this) } } HyperDHT.BOOTSTRAP = BOOTSTRAP_NODES HyperDHT.FIREWALL = FIREWALL module.exports = HyperDHT function mapLookup(node) { if (!node.value) return null try { const l = c.decode(m.lookupRawReply, node.value) return { token: node.token, from: node.from, to: node.to, peers: l.peers, bump: l.bump } } catch { return null } } function mapFindPeer(node) { if (!node.value) return null try { return { token: node.token, from: node.from, to: node.to, peer: c.decode(m.peer, node.value) } } catch { return null } } function mapImmutable(node) { if (!node.value) return null return { token: node.token, from: node.from, to: node.to, value: node.value } } function mapMutable(node) { if (!node.value) return null try { const { seq, value, signature } = c.decode(m.mutableGetResponse, node.value) return { token: node.token, from: node.from, to: node.to, seq, value, signature } } catch { return null } } function noop() {} function filterNode(node) { // always skip these testnet nodes that got mixed in by accident, until they get updated return ( !(node.port === 49738 && (node.host === '134.209.28.98' || node.host === '167.99.142.185')) && !(node.port === 9400 && node.host === '35.233.47.252') && !(node.host === '150.136.142.116') ) } const defaultMaxSize = 65536 const defaultMaxAge = 20 * 60 * 1000 // 20 minutes function defaultCacheOpts(opts) { const maxSize = opts.maxSize || defaultMaxSize const maxAge = opts.maxAge || defaultMaxAge return { router: { forwards: { maxSize, maxAge } }, relayAddresses: { maxSize: Math.min(maxSize, 512), maxAge: 0 }, persistent: { records: { maxSize, maxAge }, refreshes: { maxSize, maxAge }, mutables: { maxSize: (maxSize / 2) | 0, maxAge: opts.maxAge || 48 * 60 * 60 * 1000 // 48 hours }, immutables: { maxSize: (maxSize / 2) | 0, maxAge: opts.maxAge || 48 * 60 * 60 * 1000 // 48 hours }, bumps: { maxSize, maxAge } } } } const safetyCatch = require('safety-catch') const c = require('compact-encoding') const Signal = require('signal-promise') const { encodeUnslab } = require('./encode') const Sleeper = require('./sleeper') const m = require('./messages') const Persistent = require('./persistent') const { COMMANDS } = require('./constants') const MIN_ACTIVE = 3 module.exports = class Announcer { constructor(dht, keyPair, target, opts = {}) { this.dht = dht this.keyPair = keyPair this.target = target this.relays = [] this.relayAddresses = [] this.stopped = false this.suspended = false this.record = encodeUnslab(m.peer, { publicKey: keyPair.publicKey, relayAddresses: [] }) this.online = new Signal() this._refreshing = false this._closestNodes = null this._active = null this._sleeper = new Sleeper() this._resumed = new Signal() this._signAnnounce = opts.signAnnounce || Persistent.signAnnounce this._signUnannounce = opts.signUnannounce || Persistent.signUnannounce this._updating = null this._activeQuery = null this._unannouncing = null this._serverRelays = [new Map(), new Map(), new Map()] } isRelay(addr) { const id = addr.host + ':' + addr.port const [a, b, c] = this._serverRelays return a.has(id) || b.has(id) || c.has(id) } async suspend({ log = noop } = {}) { if (this.suspended) return this.suspended = true log('Suspending announcer') // Suspend has its own sleep logic // so we don't want to hang on this one this.online.notify() if (this._activeQuery) this._activeQuery.destroy() this._sleeper.resume() if (this._updating) await this._updating log('Suspending announcer (post update)') if (this.suspended === false || this.stopped) return log('Suspending announcer (pre unannounce)') await this._unannounceCurrent() log('Suspending announcer (post unannounce)') } resume() { if (!this.suspended) return this.suspended = false this.refresh() this._sleeper.resume() this._resumed.notify() } refresh() { if (this.stopped) return this._refreshing = true } async start() { if (this.stopped) return this._active = this._runUpdate() await this._active if (this.stopped) return this._active = this._background() } async stop() { this.stopped = true this.online.notify() // Break out of the _background loop if we're offline this._sleeper.resume() this._resumed.notify() await this._active await this._unannounceCurrent() } async _unannounceCurrent() { while (this._unannouncing !== null) await this._unannouncing const un = (this._unannouncing = this._unannounceAll(this._serverRelays[2].values())) await this._unannouncing if (un === this._unannouncing) this._unannouncing = null } async _background() { while (!this.dht.destroyed && !this.stopped) { try { this._refreshing = false // ~5min +- for (let i = 0; i < 100 && !this.stopped && !this._refreshing && !this.suspended; i++) { const pings = [] for (const node of this._serverRelays[2].values()) { pings.push(this.dht.ping(node)) } const active = await resolved(pings) if (active < Math.min(pings.length, MIN_ACTIVE)) { this.refresh() // we lost too many relay nodes, retry all } if (this.stopped) return if (!this.suspended && !this._refreshing) await this._sleeper.pause(3000) } while (!this.stopped && this.suspended) await this._resumed.wait() if (!this.stopped) await this._runUpdate() while (!this.dht.online && !this.stopped && !this.suspended) { // Being offline can make _background repeat very quickly // So wait until we're back online await this.online.wait() } } catch (err) { safetyCatch(err) } } } async _runUpdate() { this._updating = this._update() await this._updating this._updating = null } async _update() { while (this._unannouncing) await this._unannouncing this._cycle() const q = (this._activeQuery = this.dht.findPeer(this.target, { hash: false, nodes: this._closestNodes })) try { await q.finished() } catch { // ignore failures... } this._activeQuery = null if (this.stopped || this.suspended) return const ann = [] const replies = pickBest(q.closestReplies) const relays = [] const relayAddresses = [] if (!this.dht.firewalled) { const addr = this.dht.remoteAddress() if (addr) relayAddresses.push(addr) } for (const msg of replies) { ann.push(this._commit(msg, relays, relayAddresses)) } await Promise.allSettled(ann) if (this.stopped || this.suspended) return this._closestNodes = q.closestNodes this.relays = relays this.relayAddresses = relayAddresses const removed = [] for (const [key, value] of this._serverRelays[1]) { if (!this._serverRelays[2].has(key)) removed.push(value) } await this._unannounceAll(removed) } _unannounceAll(relays) { const unann = [] for (const r of relays) unann.push(this._unannounce(r)) return Promise.allSettled(unann) } async _unannounce(to) { const unann = { peer: { publicKey: this.keyPair.publicKey, relayAddresses: [] }, refresh: null, signature: null } const { from, token, value } = await this.dht.request( { token: null, command: COMMANDS.FIND_PEER, target: this.target, value: null }, to ) if (!token || !from.id || !value) return unann.signature = await this._signUnannounce(this.target, token, from.id, unann, this.keyPair) await this.dht.request( { token, command: COMMANDS.UNANNOUNCE, target: this.target, value: c.encode(m.announce, unann) }, to ) } async _commit(msg, relays, relayAddresses) { const ann = { peer: { publicKey: this.keyPair.publicKey, relayAddresses: [] }, refresh: null, signature: null } ann.signature = await this._signAnnounce(this.target, msg.token, msg.from.id, ann, this.keyPair) const res = await this.dht.request( { token: msg.token, command: COMMANDS.ANNOUNCE, target: this.target, value: c.encode(m.announce, ann) }, msg.from ) if (res.error !== 0) return if (relayAddresses.length < 3) relayAddresses.push({ host: msg.from.host, port: msg.from.port }) relays.push({ relayAddress: msg.from, peerAddress: msg.to }) this._serverRelays[2].set(msg.from.host + ':' + msg.from.port, msg.from) } _cycle() { const tmp = this._serverRelays[0] this._serverRelays[0] = this._serverRelays[1] this._serverRelays[1] = this._serverRelays[2] this._serverRelays[2] = tmp tmp.clear() } } function resolved(ps) { let replied = 0 let ticks = ps.length + 1 return new Promise((resolve) => { for (const p of ps) p.then(push, tick) tick() function push(v) { replied++ tick() } function tick() { if (--ticks === 0) resolve(replied) } }) } function pickBest(replies) { // TODO: pick the ones closest to us RTT wise return replies.slice(0, 3) } function noop() {} const NoiseSecretStream = require('@hyperswarm/secret-stream') const b4a = require('b4a') const relay = require('blind-relay') const { isReserved, isBogon } = require('bogon') const safetyCatch = require('safety-catch') const unslab = require('unslab') const Semaphore = require('./semaphore') const NoiseWrap = require('./noise-wrap') const SecurePayload = require('./secure-payload') const Holepuncher = require('./holepuncher') const Sleeper = require('./sleeper') const { clearRelayTimeout, confirmDirectUpgrade, destroyRelayConnection } = require('./relay-connection') const { FIREWALL, ERROR } = require('./constants') const { unslabbedHash } = require('./crypto') const { CANNOT_HOLEPUNCH, HANDSHAKE_INVALID, HOLEPUNCH_ABORTED, HOLEPUNCH_INVALID, HOLEPUNCH_PROBE_TIMEOUT, HOLEPUNCH_DOUBLE_RANDOMIZED_NATS, PEER_CONNECTION_FAILED, PEER_NOT_FOUND, REMOTE_ABORTED, REMOTE_NOT_HOLEPUNCHABLE, REMOTE_NOT_HOLEPUNCHING, SERVER_ERROR, SERVER_INCOMPATIBLE, RELAY_ABORTED, SUSPENDED } = require('./errors') const { decode } = require('hypercore-id-encoding') const HyperDHTAddress = require('hyperdht-address') module.exports = function connect(dht, publicKey, opts = {}) { const pool = opts.pool || null const { key, nodes: providedNodes } = HyperDHTAddress.decode( b4a.isBuffer(publicKey) ? publicKey : decode(publicKey) ) publicKey = key if (pool && pool.has(publicKey)) return pool.get(publicKey) publicKey = unslab(publicKey) opts.relayAddresses = opts.relayAddresses || providedNodes || [] const keyPair = opts.keyPair || dht.defaultKeyPair const relayThrough = selectRelay(opts.relayThrough || null) const encryptedSocket = (opts.createSecretStream || defaultCreateSecretStream)(true, null, { publicKey: keyPair.publicKey, remotePublicKey: publicKey, autoStart: false, keepAlive: dht.connectionKeepAlive }) // in case a socket is made during suspended state, destroy it immediately if (dht.suspended || !dht._connectable) { encryptedSocket.destroy(SUSPENDED()) return encryptedSocket } if (pool) pool._attachStream(encryptedSocket, false) const id = b4a.toString(publicKey, 'hex') const c = { id, dht, session: dht.session(), relayAddresses: opts.relayAddresses, remoteRelayAddresses: [], pool, round: 0, target: unslabbedHash(publicKey), remotePublicKey: publicKey, reusableSocket: !!opts.reusableSocket, handshake: (opts.createHandshake || defaultCreateHandshake)(keyPair, publicKey), request: null, requesting: false, lan: opts.localConnection !== false, firewall: FIREWALL.UNKNOWN, rawStream: dht.createRawStream({ framed: true, firewall }), connect: null, query: null, puncher: null, payload: null, passiveConnectTimeout: null, serverSocket: null, serverAddress: null, onsocket: null, sleeper: new Sleeper(), encryptedSocket, // Relay state relayTimeout: null, relayThrough, relayToken: relayThrough ? relay.token() : null, relaySocket: null, relayClient: null, relayPaired: false, validUpgrade: true, relayKeepAlive: opts.relayKeepAlive || 5000 } // If the raw stream receives an error signal pre connect (ie from the firewall hook), make sure // to forward that to the encrypted socket for proper teardown c.rawStream.on('error', autoDestroy) c.rawStream.once('connect', () => { c.rawStream.removeListener('error', autoDestroy) }) encryptedSocket.on('close', function () { if (c.passiveConnectTimeout) clearPassiveConnectTimeout(c) if (c.query) c.query.destroy() if (c.puncher) c.puncher.destroy() if (c.rawStream) c.rawStream.destroy() c.session.destroy() c.sleeper.resume() }) // Safe to run in the background - never throws if (dht.suspended) encryptedSocket.destroy(SUSPENDED()) else connectAndHolepunch(c, opts) return encryptedSocket function autoDestroy(err) { maybeDestroyEncryptedSocket(c, err) } function firewall(socket, port, host) { // Check if the traffic originated from the socket on which we're expecting relay traffic. If so, // we haven't hole punched yet and the other side is just sending us traffic through the relay. if (c.relaySocket && isRelay(c.relaySocket, socket, port, host)) { c.validUpgrade = false return false } c.validUpgrade = true if (c.onsocket) { c.onsocket(socket, port, host) } else { c.serverSocket = socket c.serverAddress = { port, host } } return false } } function isDone(c) { // we are destroying or the puncher is connected - done if (c.encryptedSocket.destroying || !!(c.puncher && c.puncher.connected)) { return true } // not destroying, but no raw stream - def not done if (c.encryptedSocket.rawStream === null) { return false } // we are relayed, but the puncher is not done yet if (c.relaySocket && !!(c.puncher && !c.puncher.connected && !c.puncher.destroyed)) { return false } // we are done return true } async function retryRoute(c, route) { const ref = c.dht._socketPool.lookup(route.socket) if (!ref) { if (route.socket === c.dht.socket) { await connectThroughNode(c, route.address, c.dht.socket) } return } ref.active() try { await connectThroughNode(c, route.address, route.socket) } catch { // if error, just ignore, and continue through the existing strat } ref.inactive() } async function connectAndHolepunch(c, opts) { const route = c.reusableSocket ? c.dht._socketPool.routes.get(c.remotePublicKey) : null if (route) { await retryRoute(c, route) if (isDone(c)) return } await findAndConnect(c, opts) if (isDone(c)) return if (!c.connect) { // TODO: just a quick fix for now, should retry prob maybeDestroyEncryptedSocket(c, HANDSHAKE_INVALID()) return } await holepunch(c, opts) } function getFirstRemoteAddress(addrs, serverAddress) { for (const addr of addrs) { if (isBogon(addr.host)) continue return addr } return serverAddress } async function holepunch(c, opts) { let { relayAddress, serverAddress, clientAddress, payload } = c.connect const remoteHolepunchable = !!(payload.holepunch && payload.holepunch.relays.length) const relayed = diffAddress(serverAddress, relayAddress) if (payload.firewall === FIREWALL.OPEN || (relayed && !remoteHolepunchable)) { const addr = getFirstRemoteAddress(payload.addresses4, serverAddress) if (addr) { const socket = c.dht.socket c.dht.stats.punches.open++ c.onsocket(socket, addr.port, addr.host) return } // TODO: check all addresses also obvs } const onabort = () => { c.session.destroy() maybeDestroyEncryptedSocket(c, HOLEPUNCH_ABORTED()) } if (c.firewall === FIREWALL.OPEN) { c.passiveConnectTimeout = setTimeout(onabort, 10000) return } // Race the LAN shortcut with normal holepunch when possible. A blocked LAN ping // should not abort a connection that can still holepunch. If the remote is not // holepunchable, the LAN ping is the only remaining path. if (c.lan && relayed && clientAddress.host === serverAddress.host) { const serverAddresses = payload.addresses4.filter(onlyNonReserved) if (serverAddresses.length > 0) { const myAddresses = Holepuncher.localAddresses(c.dht.io.serverSocket) const addr = Holepuncher.matchAddress(myAddresses, serverAddresses) || serverAddresses[0] const socket = c.dht.io.serverSocket c.dht.ping(addr).then(onlanconnect, onlanerror) if (!remoteHolepunchable) return function onlanconnect() { // LAN and holepunch completions both converge through onsocket, // which claims c.rawStream once and ignores later winners. if (isDone(c)) return c.onsocket(socket, addr.port, addr.host) } function onlanerror() { if (!remoteHolepunchable) { maybeDestroyEncryptedSocket(c, HOLEPUNCH_ABORTED()) } } } } if (!remoteHolepunchable) { maybeDestroyEncryptedSocket(c, CANNOT_HOLEPUNCH()) return } c.puncher = new Holepuncher(c.dht, c.session, true, payload.firewall) c.puncher.onconnect = c.onsocket c.puncher.onabort = onabort const serverRelay = pickServerRelay(payload.holepunch.relays, relayAddress) // Begin holepunching! let probe try { probe = await probeRound(c, opts.fastOpen === false ? null : serverAddress, serverRelay, true) } catch (err) { destroyPuncher(c) // TODO: we should retry here with some of the other relays, bail for now maybeDestroyEncryptedSocket(c, err) return } if (isDone(c) || !probe) return const { token, peerAddress } = probe // If the relay the server picked is the same as the relay the client picked, // then we can use the peerAddress that round one indicates the server wants to use. // This shaves off a roundtrip if the server chose to reroll its socket due to some NAT // issue with the first one it picked (ie mobile nat inconsistencies...). // If the relays were different, then the server would not have a UDP session open on this address // to the client relay, which round2 uses. if ( !diffAddress(serverRelay.relayAddress, relayAddress) && diffAddress(serverAddress, peerAddress) ) { serverAddress = peerAddress await c.puncher.openSession(serverAddress) if (isDone(c)) return } // TODO: still continue here if a local connection might work, but then do not holepunch... if ( opts.holepunch && !opts.holepunch( c.puncher.remoteFirewall, c.puncher.nat.firewall, c.puncher.remoteAddresses, c.puncher.nat.addresses ) ) { await abort(c, serverRelay, HOLEPUNCH_ABORTED('Client aborted holepunch')) return } try { await roundPunch(c, serverAddress, token, relayAddress, serverRelay, false) } catch (err) { destroyPuncher(c) // TODO: retry with another relay? maybeDestroyEncryptedSocket(c, err) } } async function connectThroughNodes(c, addresses, socket) { for (const address of addresses) { if (isDone(c) || c.connect) return c.remoteRelayAddresses.push(address) await connectThroughNode(c, address, socket) } } async function findAndConnect(c, opts) { let attempts = 0 let relayAddresses = opts.relayAddresses && opts.relayAddresses.length ? opts.relayAddresses : null if (!relayAddresses) { const cachedRelayAddresses = c.dht._relayAddressesCache.get(c.id) if (cachedRelayAddresses) relayAddresses = cachedRelayAddresses } if (c.dht._persistent) { // check if we know the route ourself... const route = c.dht._router.get(c.target) if (route && route.relay !== null) { relayAddresses = [{ host: route.relay.host, port: route.relay.port }] } } // 2 is how many parallel connect attempts we want to do, we can make this configurable const preConnect = relayAddresses !== null && relayAddresses.length > 0 const sem = new Semaphore(preConnect ? 3 : 2) const signal = sem.signal.bind(sem) const tries = relayAddresses !== null ? 2 : 1 if (preConnect) { await sem.wait() connectThroughNodes(c, relayAddresses, null).then(signal, signal) } try { for (let i = 0; i < tries && !isDone(c) && !c.connect; i++) { c.query = c.dht.findPeer(c.target, { hash: false, session: c.session, nodes: relayAddresses, retries: 3 }) for await (const data of c.query) { await sem.wait() if (isDone(c)) return if (c.connect) { sem.signal() break } // Skip node already run via preConnect if (preConnect && relayAddresses && isRelayAddress(relayAddresses, data)) { sem.signal() continue } c.remoteRelayAddresses.push(data.from) attempts++ connectThroughNode(c, data.from, null).then(signal, signal) } relayAddresses = null if (attempts > 0) await sem.flush() } c.query = null if (isDone(c)) return // flush the semaphore await sem.flush() if (isDone(c)) return } catch (err) { c.query = null maybeDestroyEncryptedSocket(c, err) return } if (!c.connect) { maybeDestroyEncryptedSocket(c, attempts ? PEER_CONNECTION_FAILED() : PEER_NOT_FOUND()) } } async function connectThroughNode(c, address, socket) { if (!c.requesting) { // If we have a stable server address, send it over now const addr = c.dht.remoteAddress() const localAddrs = c.lan ? Holepuncher.localAddresses(c.dht.io.serverSocket) : null const addresses4 = [] if (addr) addresses4.push(addr) if (localAddrs) addresses4.push(...localAddrs) c.firewall = addr ? FIREWALL.OPEN : FIREWALL.UNKNOWN c.requesting = true c.request = await c.handshake.send({ error: ERROR.NONE, firewall: c.firewall, holepunch: null, addresses4, addresses6: [], udx: { reusableSocket: c.reusableSocket, id: c.rawStream.id, seq: 0 }, secretStream: {}, relayThrough: c.relayThrough ? { publicKey: c.relayThrough, token: c.relayToken } : null }) if (isDone(c)) return } const { serverAddress, clientAddress, relayed, noise } = await c.dht._router.peerHandshake( c.target, { noise: c.request, socket, session: c.session }, address ) if (isDone(c) || c.connect) return const payload = await c.handshake.recv(noise) if (isDone(c) || !payload) return if (payload.version !== 1) { maybeDestroyEncryptedSocket(c, SERVER_INCOMPATIBLE()) return } if (payload.error !== ERROR.NONE) { maybeDestroyEncryptedSocket(c, SERVER_ERROR()) return } if (!payload.udx) { maybeDestroyEncryptedSocket(c, SERVER_ERROR('Server did not send UDX data')) return } const hs = c.handshake.final() c.handshake = null c.request = null c.requesting = false c.connect = { relayed, relayAddress: address, clientAddress, serverAddress, payload } c.payload = new SecurePayload(hs.holepunchSecret) c.onsocket = function (socket, port, host) { if (c.rawStream === null) return // Already hole punched if (c.rawStream.connected) { const rawStream = c.rawStream const remoteChanging = rawStream.changeRemote(socket, c.connect.payload.udx.id, port, host) confirmDirectUpgrade(c, rawStream, remoteChanging) } else { // cache the relay addrs for a future reconnect, we prefer the remote one so they // can give us the correct ones from their pov if (payload.relayAddresses && payload.relayAddresses.length) { c.dht._relayAddressesCache.set(c.id, payload.relayAddresses) } else if (c.remoteRelayAddresses.length) { c.dht._relayAddressesCache.set(c.id, c.remoteRelayAddresses) } c.rawStream.connect(socket, c.connect.payload.udx.id, port, host) c.encryptedSocket.start(c.rawStream, { handshake: hs }) } if (c.reusableSocket && payload.udx.reusableSocket) { c.dht._socketPool.routes.add(c.remotePublicKey, c.rawStream) } if (c.puncher) { c.puncher.onabort = noop c.puncher.destroy() } if (c.passiveConnectTimeout) { clearPassiveConnectTimeout(c) } c.rawStream = null } if (payload.relayThrough || c.relayThrough) { relayConnection(c, c.relayThrough, payload, hs) } if (c.serverSocket) { c.onsocket(c.serverSocket, c.serverAddress.port, c.serverAddress.host) return } if (!relayed) { c.onsocket(socket || c.dht.socket, address.port, address.host) } c.session.destroy() } async function updateHolepunch(c, peerAddress, relayAddr, payload) { const holepunch = await c.dht._router.peerHolepunch( c.target, { id: c.connect.payload.holepunch.id, payload: c.payload.encrypt(payload), peerAddress, socket: c.puncher.socket, session: c.session }, relayAddr ) if (isDone(c)) return null const remotePayload = c.payload.decrypt(holepunch.payload) if (!remotePayload) { throw HOLEPUNCH_INVALID() } const { error, firewall, punching, addresses, remoteToken } = remotePayload if (error === ERROR.TRY_LATER && c.relayToken && payload.punching) { return { tryLater: true, ...holepunch, payload: remotePayload } } if (error !== ERROR.NONE) { throw REMOTE_ABORTED('Remote aborted with error code ' + error) } const echoed = !!(remoteToken && payload.token && b4a.equals(remoteToken, payload.token)) c.puncher.updateRemote({ punching, firewall, addresses, verified: echoed ? peerAddress.host : null }) return { tryLater: false, ...holepunch, payload: remotePayload } } async function probeRound(c, serverAddress, serverRelay, retry) { // Open a quick low ttl session against what we think is the server if (serverAddress) await c.puncher.openSession(serverAddress) if (isDone(c)) return null const reply = await updateHolepunch(c, serverRelay.peerAddress, serverRelay.relayAddress, { error: ERROR.NONE, firewall: c.puncher.nat.firewall, round: c.round++, connected: false, punching: false, addresses: c.puncher.nat.addresses, remoteAddress: serverAddress, token: null, remoteToken: null }) if (isDone(c) || !reply) return null const { peerAddress } = reply const { address, token } = reply.payload c.puncher.nat.add(reply.to, reply.from) // Open another quick low ttl session against what the server says their address is, // if they haven't said they are random yet if ( c.puncher.remoteFirewall < FIREWALL.RANDOM && address && address.host && address.port && diffAddress(address, serverAddress) ) { await c.puncher.openSession(address) if (isDone(c)) return null } // If the remote told us they didn't know their nat firewall yet, give them a chance to figure it out // They might say this to see if the "fast mode" punch comes through first. if (c.puncher.remoteFirewall === FIREWALL.UNKNOWN) { await c.sleeper.pause(1000) if (isDone(c)) return null } let stable = await c.puncher.analyze(false) if (isDone(c)) return null // If the socket seems unstable, try to make it stable by setting the "allowReopen" flag // Mostly relevant for mobile networks if (!stable) { stable = await c.puncher.analyze(true) if (isDone(c)) return null if (stable) return probeRound(c, serverAddress, serverRelay, false) } if ((c.puncher.remoteFirewall === FIREWALL.UNKNOWN || !token) && retry) { return probeRound(c, serverAddress, serverRelay, false) } if ( c.puncher.remoteFirewall === FIREWALL.UNKNOWN || c.puncher.nat.firewall === FIREWALL.UNKNOWN ) { await abort(c, serverRelay, HOLEPUNCH_PROBE_TIMEOUT()) return null } if (c.puncher.remoteFirewall >= FIREWALL.RANDOM && c.puncher.nat.firewall >= FIREWALL.RANDOM) { await abort(c, serverRelay, HOLEPUNCH_DOUBLE_RANDOMIZED_NATS()) return null } return { token, peerAddress } } async function roundPunch(c, serverAddress, remoteToken, clientRelay, serverRelay, delayed) { // We are gossiping our final NAT status to the other peer now // so make sure we don't update our local view for now as that can make things weird c.puncher.nat.freeze() const isRandom = c.puncher.remoteFirewall >= FIREWALL.RANDOM || c.puncher.nat.firewall >= FIREWALL.RANDOM if (isRandom) { while ( c.dht._randomPunches >= c.dht._randomPunchLimit || Date.now() - c.dht._lastRandomPunch < c.dht._randomPunchInterval ) { // if no relay can help, bail if (!c.relayToken) throw HOLEPUNCH_ABORTED() if (!delayed) { delayed = true await updateHolepunch(c, serverAddress, clientRelay, { error: ERROR.NONE, firewall: c.puncher.nat.firewall, round: c.round++, connected: false, punching: false, addresses: c.puncher.nat.addresses, remoteAddress: null, token: c.payload.token(serverAddress), remoteToken }) if (isDone(c)) return } await tryLater(c) if (isDone(c)) return } } // increment now, so we can commit to punching if (isRandom) c.dht._randomPunches++ let reply try { // if delayed switch to the servers chosen relay - we validated anyway reply = await updateHolepunch( c, delayed ? serverRelay.peerAddress : serverAddress, delayed ? serverRelay.relayAddress : clientRelay, { error: ERROR.NONE, firewall: c.puncher.nat.firewall, round: c.round++, connected: false, punching: true, addresses: c.puncher.nat.addresses, remoteAddress: null, token: delayed ? null : c.payload.token(serverAddress), remoteToken } ) } finally { // decrement as punch increments for us if (isRandom) c.dht._randomPunches-- } if (isDone(c)) return if (!reply) return if (reply.tryLater) { await tryLater(c) if (isDone(c)) return return roundPunch(c, serverAddress, remoteToken, clientRelay, serverRelay, true) } if (!c.puncher.remoteHolepunching) { throw REMOTE_NOT_HOLEPUNCHING() } if (!(await c.puncher.punch())) { throw REMOTE_NOT_HOLEPUNCHABLE() } } async function tryLater(c) { if (!c.relayToken) throw HOLEPUNCH_ABORTED() await c.sleeper.pause(10000 + Math.round(Math.random() * 10000)) } function maybeDestroyEncryptedSocket(c, err) { if (isDone(c)) return if (c.encryptedSocket.rawStream) return if (c.relaySocket) return // waiting for the relay if (c.puncher && !c.puncher.destroyed) return // waiting for the puncher c.session.destroy() c.encryptedSocket.destroy(err) } async function abort(c, { peerAddress, relayAddress }, err) { try { await updateHolepunch(c, peerAddress, relayAddress, { error: ERROR.ABORTED, firewall: FIREWALL.UNKNOWN, round: c.round++, connected: false, punching: false, addresses: null, remoteAddress: null, token: null, remoteToken: null }) } catch (err) { safetyCatch(err) } destroyPuncher(c) maybeDestroyEncryptedSocket(c, err) } function relayConnection(c, relayThrough, payload, hs) { let isInitiator let publicKey let token if (payload.relayThrough) { isInitiator = false publicKey = payload.relayThrough.publicKey token = payload.relayThrough.token } else { isInitiator = true publicKey = relayThrough token = c.relayToken } c.relayToken = token c.relaySocket = c.dht.connect(publicKey) c.relaySocket.setKeepAlive(c.relayKeepAlive) c.relayClient = relay.Client.from(c.relaySocket, { id: c.relaySocket.publicKey }) c.relayTimeout = setTimeout(onabort, 15000, null) c.relayClient.pair(isInitiator, token, c.rawStream).on('error', onabort).on('data', ondata) function ondata(remoteId) { if (c.relayTimeout) clearRelayTimeout(c) if (c.rawStream === null) { onabort(null) return } c.relayPaired = true const { remotePort, remoteHost, socket } = c.relaySocket.rawStream c.rawStream .on('close', () => destroyRelayConnection(c)) .connect(socket, remoteId, remotePort, remoteHost) c.encryptedSocket.start(c.rawStream, { handshake: hs }) } function onabort(err) { destroyRelayConnection(c) maybeDestroyEncryptedSocket(c, err || RELAY_ABORTED()) } } function clearPassiveConnectTimeout(c) { clearTimeout(c.passiveConnectTimeout) c.passiveConnectTimeout = null } function destroyPuncher(c) { if (c.puncher) c.puncher.destroy() c.session.destroy() } function pickServerRelay(relays, clientRelay) { for (const r of relays) { if (!diffAddress(r.relayAddress, clientRelay)) return r } return relays[0] } function diffAddress(a, b) { return a.host !== b.host || a.port !== b.port } function defaultCreateHandshake(keyPair, remotePublicKey) { return new NoiseWrap(keyPair, remotePublicKey) } function defaultCreateSecretStream(isInitiator, rawStream, opts) { return new NoiseSecretStream(isInitiator, rawStream, opts) } function onlyNonReserved(addr) { return !isReserved(addr.host) } function isRelay(relaySocket, socket, port, host) { const stream = relaySocket.rawStream if (!stream) return false if (stream.socket !== socket) return false return port === stream.remotePort && host === stream.remoteHost } function selectRelay(relayThrough) { if (typeof relayThrough === 'function') relayThrough = relayThrough() if (relayThrough === null) return null if (Array.isArray(relayThrough)) return relayThrough[Math.floor(Math.random() * relayThrough.length)] return relayThrough } function isRelayAddress(relayAddresses, data) { for (const node of relayAddresses) { if (node.host === data.from.host && node.port === data.from.port) return true } return false } function noop() {} const EventEmitter = require('events') const b4a = require('b4a') const errors = require('./errors') module.exports = class ConnectionPool extends EventEmitter { constructor(dht) { super() this._dht = dht this._servers = new Map() this._connecting = new Map() this._connections = new Map() } _attachServer(server) { const keyString = b4a.toString(server.publicKey, 'hex') this._servers.set(keyString, server) server .on('close', () => { this._servers.delete(keyString) }) .on('connection', (socket) => { this._attachStream(socket, true) }) } _attachStream(stream, opened) { const existing = this.get(stream.remotePublicKey) if (existing) { const keepNew = stream.isInitiator === existing.isInitiator || b4a.compare(stream.publicKey, stream.remotePublicKey) > 0 if (keepNew) { let closed = false const onclose = () => { closed = true } existing .on('error', noop) .on('close', () => { if (closed) return stream.off('error', noop).off('close', onclose) this._attachStream(stream, opened) }) .destroy(errors.DUPLICATE_CONNECTION()) stream.on('error', noop).on('close', onclose) } else { stream.on('error', noop).destroy(errors.DUPLICATE_CONNECTION()) } return } const session = new ConnectionRef(this, stream) const keyString = b4a.toString(stream.remotePublicKey, 'hex') if (opened) { this._connections.set(keyString, session) stream.on('close', () => { this._connections.delete(keyString) }) this.emit('connection', stream, session) } else { this._connecting.set(keyString, session) stream .on('error', noop) .on('close', () => { if (opened) this._connections.delete(keyString) else this._connecting.delete(keyString) }) .on('open', () => { opened = true this._connecting.delete(keyString) this._connections.set(keyString, session) stream.off('error', noop) this.emit('connection', stream, session) }) } return session } get connecting() { return this._connecting.size } get connections() { return this._connections.values() } has(publicKey) { const keyString = b4a.toString(publicKey, 'hex') return this._connections.has(keyString) || this._connecting.has(keyString) } get(publicKey) { const keyString = b4a.toString(publicKey, 'hex') const existing = this._connections.get(keyString) || this._connecting.get(keyString) return existing?._stream || null } } class ConnectionRef { constructor(pool, stream) { this._pool = pool this._stream = stream this._refs = 0 } active() { this._refs++ } inactive() { this._refs-- } release() { this._stream.destroy() } } function noop() {} const crypto = require('hypercore-crypto') const COMMANDS = (exports.COMMANDS = { PEER_HANDSHAKE: 0, PEER_HOLEPUNCH: 1, FIND_PEER: 2, LOOKUP: 3, ANNOUNCE: 4, UNANNOUNCE: 5, MUTABLE_PUT: 6, MUTABLE_GET: 7, IMMUTABLE_PUT: 8, IMMUTABLE_GET: 9, PLUGIN: 10 }) exports.BOOTSTRAP_NODES = [ '88.99.3.86@node1.hyperdht.org:49737', '142.93.90.113@node2.hyperdht.org:49737', '138.68.147.8@node3.hyperdht.org:49737' ] exports.FIREWALL = { UNKNOWN: 0, OPEN: 1, CONSISTENT: 2, RANDOM: 3 } exports.ERROR = { // noise / connection related NONE: 0, ABORTED: 1, VERSION_MISMATCH: 2, TRY_LATER: 3, // dht related SEQ_REUSED: 16, SEQ_TOO_LOW: 17 } const [ NS_ANNOUNCE, NS_UNANNOUNCE, NS_MUTABLE_PUT, NS_PEER_HANDSHAKE, NS_PEER_HOLEPUNCH, NS_PLUGIN ] = crypto.namespace('hyperswarm/dht', [ COMMANDS.ANNOUNCE, COMMANDS.UNANNOUNCE, COMMANDS.MUTABLE_PUT, COMMANDS.PEER_HANDSHAKE, COMMANDS.PEER_HOLEPUNCH, COMMANDS.PLUGIN ]) exports.NS = { ANNOUNCE: NS_ANNOUNCE, UNANNOUNCE: NS_UNANNOUNCE, MUTABLE_PUT: NS_MUTABLE_PUT, PEER_HANDSHAKE: NS_PEER_HANDSHAKE, PEER_HOLEPUNCH: NS_PEER_HOLEPUNCH, PLUGIN: NS_PLUGIN } const sodium = require('sodium-universal') const b4a = require('b4a') function hash(data) { const out = b4a.allocUnsafe(32) sodium.crypto_generichash(out, data) return out } function unslabbedHash(data) { const out = b4a.allocUnsafeSlow(32) sodium.crypto_generichash(out, data) return out } function createKeyPair(seed) { const publicKey = b4a.alloc(32) const secretKey = b4a.alloc(64) if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed) else sodium.crypto_sign_keypair(publicKey, secretKey) return { publicKey, secretKey } } module.exports = { hash, unslabbedHash, createKeyPair } const b4a = require('b4a') const cenc = require('compact-encoding') function encodeUnslab(enc, m) { // Faster than unslab(c.encode(enc, data)) because it avoids the mem copy. // Makes sense to put in compact-encoding when we need it in other modules too const state = cenc.state() enc.preencode(state, m) state.buffer = b4a.allocUnsafeSlow(state.end) enc.encode(state, m) return state.buffer } module.exports = { encodeUnslab } module.exports = class DHTError extends Error { constructor(msg, code, fn = DHTError) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'DHTError' } static BAD_HANDSHAKE_REPLY(msg = 'Bad handshake reply') { return new DHTError(msg, 'BAD_HANDSHAKE_REPLY', DHTError.BAD_HANDSHAKE_REPLY) } static BAD_HOLEPUNCH_REPLY(msg = 'Bad holepunch reply') { return new DHTError(msg, 'BAD_HOLEPUNCH_REPLY', DHTError.BAD_HOLEPUNCH_REPLY) } static HOLEPUNCH_ABORTED(msg = 'Holepunch aborted') { return new DHTError(msg, 'HOLEPUNCH_ABORTED', DHTError.HOLEPUNCH_ABORTED) } static HOLEPUNCH_INVALID(msg = 'Invalid holepunch payload') { return new DHTError(msg, 'HOLEPUNCH_INVALID', DHTError.HOLEPUNCH_INVALID) } static HOLEPUNCH_PROBE_TIMEOUT(msg = 'Holepunching probe did not finish in time') { return new DHTError(msg, 'HOLEPUNCH_PROBE_TIMEOUT', DHTError.HOLEPUNCH_PROBE_TIMEOUT) } static HOLEPUNCH_DOUBLE_RANDOMIZED_NATS(msg = 'Both remote and local NATs are randomized') { return new DHTError( msg, 'HOLEPUNCH_DOUBLE_RANDOMIZED_NATS', DHTError.HOLEPUNCH_DOUBLE_RANDOMIZED_NATS ) } static CANNOT_HOLEPUNCH(msg = 'Cannot holepunch to remote') { return new DHTError(msg, 'CANNOT_HOLEPUNCH', DHTError.CANNOT_HOLEPUNCH) } static REMOTE_NOT_HOLEPUNCHING(msg = 'Remote is not holepunching') { return new DHTError(msg, 'REMOTE_NOT_HOLEPUNCHING', DHTError.REMOTE_NOT_HOLEPUNCHING) } static REMOTE_NOT_HOLEPUNCHABLE(msg = 'Remote is not holepunchable') { return new DHTError(msg, 'REMOTE_NOT_HOLEPUNCHABLE', DHTError.REMOTE_NOT_HOLEPUNCHABLE) } static REMOTE_ABORTED(msg = 'Remote aborted') { return new DHTError(msg, 'REMOTE_ABORTED', DHTError.REMOTE_ABORTED) } static HANDSHAKE_UNFINISHED(msg = 'Handshake did not finish') { return new DHTError(msg, 'HANDSHAKE_UNFINISHED', DHTError.HANDSHAKE_UNFINISHED) } static HANDSHAKE_INVALID(msg = 'Received invalid handshake') { return new DHTError(msg, 'HANDSHAKE_INVALID', DHTError.HANDSHAKE_INVALID) } static ALREADY_LISTENING(msg = 'Already listening') { return new DHTError(msg, 'ALREADY_LISTENING', DHTError.ALREADY_LISTENING) } static KEYPAIR_ALREADY_USED(msg = 'Keypair already used') { return new DHTError(msg, 'KEYPAIR_ALREADY_USED', DHTError.KEYPAIR_ALREADY_USED) } static NODE_DESTROYED(msg = 'Node destroyed') { return new DHTError(msg, 'NODE_DESTROYED', DHTError.NODE_DESTROYED) } static PEER_CONNECTION_FAILED(msg = 'Could not connect to peer') { return new DHTError(msg, 'PEER_CONNECTION_FAILED', DHTError.PEER_CONNECTION_FAILED) } static PEER_NOT_FOUND(msg = 'Peer not found') { return new DHTError(msg, 'PEER_NOT_FOUND', DHTError.PEER_NOT_FOUND) } static STREAM_NOT_CONNECTED(msg = 'Stream is not connected') { return new DHTError(msg, 'STREAM_NOT_CONNECTED', DHTError.STREAM_NOT_CONNECTED) } static SERVER_INCOMPATIBLE(msg = 'Server is using an incompatible version') { return new DHTError(msg, 'SERVER_INCOMPATIBLE', DHTError.SERVER_INCOMPATIBLE) } static SERVER_ERROR(msg = 'Server returned an error') { return new DHTError(msg, 'SERVER_ERROR', DHTError.SERVER_ERROR) } static DUPLICATE_CONNECTION(msg = 'Duplicate connection') { return new DHTError(msg, 'DUPLICATE_CONNECTION', DHTError.DUPLICATE_CONNECTION) } static RELAY_ABORTED(msg = 'Relay aborted') { return new DHTError(msg, 'RELAY_ABORTED', DHTError.RELAY_ABORTED) } static SUSPENDED(msg = 'Suspended') { return new DHTError(msg, 'SUSPENDED', DHTError.SUSPENDED) } } const b4a = require('b4a') const Nat = require('./nat') const Sleeper = require('./sleeper') const { FIREWALL } = require('./constants') const BIRTHDAY_SOCKETS = 256 const HOLEPUNCH = b4a.from([0]) const HOLEPUNCH_TTL = 5 const DEFAULT_TTL = 64 const MAX_REOPENS = 3 module.exports = class Holepuncher { constructor(dht, session, isInitiator, remoteFirewall = FIREWALL.UNKNOWN) { const holder = dht._socketPool.acquire() this.dht = dht this.session = session this.nat = new Nat(dht, session, holder.socket) this.nat.autoSample() this.isInitiator = isInitiator // events this.onconnect = noop this.onabort = noop this.punching = false this.connected = false this.destroyed = false this.randomized = false // track remote state this.remoteFirewall = remoteFirewall this.remoteAddresses = [] this.remoteHolepunching = false this._sleeper = new Sleeper() this._reopening = null this._timeout = null this._punching = null this._allHolders = [] this._holder = this._addRef(holder) } get socket() { return this._holder.socket } updateRemote({ punching, firewall, addresses, verified }) { const remoteAddresses = [] if (addresses) { for (const addr of addresses) { remoteAddresses.push({ host: addr.host, port: addr.port, verified: verified === addr.host || this._isVerified(addr.host) }) } } this.remoteFirewall = firewall this.remoteAddresses = remoteAddresses this.remoteHolepunching = punching } _isVerified(host) { for (const addr of this.remoteAddresses) { if (addr.verified && addr.host === host) { return true } } return false } ping(addr, socket = this._holder.socket) { return holepunch(socket, addr, false) } openSession(addr, socket = this._holder.socket) { return holepunch(socket, addr, true) } async analyze(allowReopen) { await this.nat.analyzing if (this._unstable()) { if (!allowReopen) return false if (!this._reopening) this._reopening = this._reopen() return this._reopening } return true } _unstable() { // TODO!!: We need an additional heuristic here... If we were NOT random in the past we should also do this. const firewall = this.nat.firewall return ( (this.remoteFirewall >= FIREWALL.RANDOM && firewall >= FIREWALL.RANDOM) || firewall === FIREWALL.UNKNOWN ) } _reset() { const prev = this._holder this._allHolders.pop() this._holder = this._addRef(this.dht._socketPool.acquire()) prev.release() this.nat.destroy() this.nat = new Nat(this.dht, this.session, this._holder.socket) // TODO: maybe make auto sampling configurable somehow? this.nat.autoSample() } _addRef(ref) { this._allHolders.push(ref) ref.onholepunchmessage = (msg, rinfo) => this._onholepunchmessage(msg, rinfo, ref) return ref } _onholepunchmessage(_, addr, ref) { if (!this.isInitiator) { // TODO: we don't need this if we had a way to connect a socket to many hosts holepunch(ref.socket, addr, false) // never fails return } if (this.connected) return this.connected = true this.punching = false for (const r of this._allHolders) { if (r === ref) continue r.release() } this._allHolders[0] = ref while (this._allHolders.length > 1) this._allHolders.pop() this._decrementRandomized() this.onconnect(ref.socket, addr.port, addr.host) } _done() { return this.destroyed || this.connected } async _reopen() { for (let i = 0; this._unstable() && i < MAX_REOPENS && !this._done() && !this.punching; i++) { this._reset() await this.nat.analyzing } return coerceFirewall(this.nat.firewall) === FIREWALL.CONSISTENT } punch() { if (!this._punching) this._punching = this._punch() return this._punching } async _punch() { if (this._done() || !this.remoteAddresses.length) return false this.punching = true // Coerce into consistency for now. Obvs we could make this this more efficient if we use that info // but that's seldomly used since those will just use tcp most of the time. const local = coerceFirewall(this.nat.firewall) const remote = coerceFirewall(this.remoteFirewall) // Note that most of these async functions are meant to run in the background // which is why we don't await them here and why they are not allowed to throw let remoteVerifiedAddress = null for (const addr of this.remoteAddresses) { if (addr.verified) { remoteVerifiedAddress = addr break } } if (local === FIREWALL.CONSISTENT && remote === FIREWALL.CONSISTENT) { this.dht.stats.punches.consistent++ this._consistentProbe() return true } if (!remoteVerifiedAddress) return false if (local === FIREWALL.CONSISTENT && remote >= FIREWALL.RANDOM) { this.dht.stats.punches.random++ this._incrementRandomized() this._randomProbes(remoteVerifiedAddress) return true } if (local >= FIREWALL.RANDOM && remote === FIREWALL.CONSISTENT) { this.dht.stats.punches.random++ this._incrementRandomized() await this._openBirthdaySockets(remoteVerifiedAddress) if (this.punching) this._keepAliveRandomNat(remoteVerifiedAddress) return true } return false } // Note that this never throws so it is safe to run in the background async _consistentProbe() { // Here we do the sleep first because the "fast open" mode in the server just fired a ping if (!this.isInitiator) await this._sleeper.pause(1000) let tries = 0 while (this.punching && tries++ < 10) { for (const addr of this.remoteAddresses) { // only try unverified addresses every 4 ticks if (!addr.verified && (tries & 3) !== 0) continue await holepunch(this._holder.socket, addr, false) } if (this.punching) await this._sleeper.pause(1000) } this._autoDestroy() } // Note that this never throws so it is safe to run in the background async _randomProbes(remoteAddr) { let tries = 1750 // ~35s while (this.punching && tries-- > 0) { const addr = { host: remoteAddr.host, port: randomPort() } await holepunch(this._holder.socket, addr, false) if (this.punching) await this._sleeper.pause(20) } this._autoDestroy() } // Note that this never throws so it is safe to run in the background async _keepAliveRandomNat(remoteAddr) { let i = 0 let lowTTLRounds = 1 // TODO: experiment with this here. We just bursted all the messages in // openOtherSockets to ensure the sockets are open, so it's potentially // a good idea to slow down for a bit. await this._sleeper.pause(100) let tries = 1750 // ~35s while (this.punching && tries-- > 0) { if (i === this._allHolders.length) { i = 0 if (lowTTLRounds > 0) lowTTLRounds-- } await holepunch(this._allHolders[i++].socket, remoteAddr, lowTTLRounds > 0) if (this.punching) await this._sleeper.pause(20) } this._autoDestroy() } async _openBirthdaySockets(remoteAddr) { while (this.punching && this._allHolders.length < BIRTHDAY_SOCKETS) { const ref = this._addRef(this.dht._socketPool.acquire()) await holepunch(ref.socket, remoteAddr, HOLEPUNCH_TTL) } } _autoDestroy() { if (!this.connected) this.destroy() } _incrementRandomized() { if (!this.randomized) { this.randomized = true this.dht._randomPunches++ } } _decrementRandomized() { if (this.randomized) { this.dht._lastRandomPunch = Date.now() this.randomized = false this.dht._randomPunches-- } } destroy() { if (this.destroyed) return this.destroyed = true this.punching = false for (const ref of this._allHolders) ref.release() this._allHolders = [] this.nat.destroy() if (!this.connected) { this._decrementRandomized() this.onabort() } } static ping(socket, addr) { return holepunch(socket, addr, false) } static localAddresses(socket) { return localAddresses(socket) } static matchAddress(myAddresses, externalAddresses) { return matchAddress(myAddresses, externalAddresses) } } function holepunch(socket, addr, lowTTL) { return socket.send(HOLEPUNCH, addr.port, addr.host, lowTTL ? HOLEPUNCH_TTL : DEFAULT_TTL) } function randomPort() { return (1000 + Math.random() * 64536) | 0 } function coerceFirewall(fw) { return fw === FIREWALL.OPEN ? FIREWALL.CONSISTENT : fw } function localAddresses(socket) { const addrs = [] const { host, port } = socket.address() if (host === '127.0.0.1') return [{ host, port }] for (const n of socket.udx.networkInterfaces()) { if (n.family !== 4 || n.internal) continue addrs.push({ host: n.host, port }) } if (addrs.length === 0) { addrs.push({ host: '127.0.0.1', port }) } return addrs } function matchAddress(localAddresses, remoteLocalAddresses) { if (remoteLocalAddresses.length === 0) return null let best = { segment: 1, addr: null } for (const localAddress of localAddresses) { // => 192.168.122.238 const a = localAddress.host.split('.') for (const remoteAddress of remoteLocalAddresses) { // => 192.168.0.23 // => 192.168.122.1 const b = remoteAddress.host.split('.') // Matches 192.*.*.* if (a[0] === b[0]) { if (best.segment === 1) best = { segment: 2, addr: remoteAddress } // Matches 192.168.*.* if (a[1] === b[1]) { if (best.segment === 2) best = { segment: 3, addr: remoteAddress } // Matches 192.168.122.* if (a[2] === b[2]) return remoteAddress } } } } return best.addr } function noop() {} const c = require('compact-encoding') const ipv4 = { ...c.ipv4Address, decode(state) { const ip = c.ipv4Address.decode(state) return { host: ip.host, port: ip.port } } } const ipv4Array = c.array(ipv4) const ipv6 = { ...c.ipv6Address, decode(state) { const ip = c.ipv6Address.decode(state) return { host: ip.host, port: ip.port } } } const ipv6Array = c.array(ipv6) exports.handshake = { preencode(state, m) { state.end += 1 + 1 + (m.peerAddress ? 6 : 0) + (m.relayAddress ? 6 : 0) c.buffer.preencode(state, m.noise) }, encode(state, m) { const flags = (m.peerAddress ? 1 : 0) | (m.relayAddress ? 2 : 0) c.uint.encode(state, flags) c.uint.encode(state, m.mode) c.buffer.encode(state, m.noise) if (m.peerAddress) ipv4.encode(state, m.peerAddress) if (m.relayAddress) ipv4.encode(state, m.relayAddress) }, decode(state) { const flags = c.uint.decode(state) return { mode: c.uint.decode(state), noise: c.buffer.decode(state), peerAddress: flags & 1 ? ipv4.decode(state) : null, relayAddress: flags & 2 ? ipv4.decode(state) : null } } } const relayInfo = { preencode(state, m) { state.end += 12 }, encode(state, m) { ipv4.encode(state, m.relayAddress) ipv4.encode(state, m.peerAddress) }, decode(state) { return { relayAddress: ipv4.decode(state), peerAddress: ipv4.decode(state) } } } const relayInfoArray = c.array(relayInfo) const holepunchInfo = { preencode(state, m) { c.uint.preencode(state, m.id) relayInfoArray.preencode(state, m.relays) }, encode(state, m) { c.uint.encode(state, m.id) relayInfoArray.encode(state, m.relays) }, decode(state) { return { id: c.uint.decode(state), relays: relayInfoArray.decode(state) } } } const udxInfo = { preencode(state, m) { state.end += 2 // version + features c.uint.preencode(state, m.id) c.uint.preencode(state, m.seq) }, encode(state, m) { c.uint.encode(state, 1) c.uint.encode(state, m.reusableSocket ? 1 : 0) c.uint.encode(state, m.id) c.uint.encode(state, m.seq) }, decode(state) { const version = c.uint.decode(state) const features = c.uint.decode(state) return { version, reusableSocket: (features & 1) !== 0, id: c.uint.decode(state), seq: c.uint.decode(state) } } } const secretStreamInfo = { preencode(state, m) { c.uint.preencode(state, 1) }, encode(state, m) { c.uint.encode(state, 1) }, decode(state) { return { version: c.uint.decode(state) } } } const relayThroughInfo = { preencode(state, m) { c.uint.preencode(state, 1) // version c.uint.preencode(state, 0) // flags c.fixed32.preencode(state, m.publicKey) c.fixed32.preencode(state, m.token) }, encode(state, m) { c.uint.encode(state, 1) c.uint.encode(state, 0) c.fixed32.encode(state, m.publicKey) c.fixed32.encode(state, m.token) }, decode(state) { const version = c.uint.decode(state) c.uint.decode(state) return { version, publicKey: c.fixed32.decode(state), token: c.fixed32.decode(state) } } } exports.noisePayload = { preencode(state, m) { state.end += 4 // version + flags + error + firewall if (m.holepunch) holepunchInfo.preencode(state, m.holepunch) if (m.addresses4 && m.addresses4.length) ipv4Array.preencode(state, m.addresses4) if (m.addresses6 && m.addresses6.length) ipv6Array.preencode(state, m.addresses6) if (m.udx) udxInfo.preencode(state, m.udx) if (m.secretStream) secretStreamInfo.preencode(state, m.secretStream) if (m.relayThrough) relayThroughInfo.preencode(state, m.relayThrough) if (m.relayAddresses) ipv4Array.preencode(state, m.relayAddresses) }, encode(state, m) { let flags = 0 if (m.holepunch) flags |= 1 if (m.addresses4 && m.addresses4.length) flags |= 2 if (m.addresses6 && m.addresses6.length) flags |= 4 if (m.udx) flags |= 8 if (m.secretStream) flags |= 16 if (m.relayThrough) flags |= 32 if (m.relayAddresses) flags |= 64 c.uint.encode(state, 1) // version c.uint.encode(state, flags) c.uint.encode(state, m.error) c.uint.encode(state, m.firewall) if (m.holepunch) holepunchInfo.encode(state, m.holepunch) if (m.addresses4 && m.addresses4.length) ipv4Array.encode(state, m.addresses4) if (m.addresses6 && m.addresses6.length) ipv6Array.encode(state, m.addresses6) if (m.udx) udxInfo.encode(state, m.udx) if (m.secretStream) secretStreamInfo.encode(state, m.secretStream) if (m.relayThrough) relayThroughInfo.encode(state, m.relayThrough) if (m.relayAddresses) ipv4Array.encode(state, m.relayAddresses) }, decode(state) { const version = c.uint.decode(state) if (version !== 1) { // Do not attempt to decode but return this back to the user so they can // actually handle it return { version, error: 0, firewall: 0, holepunch: null, addresses4: [], addresses6: [], udx: null, secretStream: null, relayThrough: null, relayAddresses: null } } const flags = c.uint.decode(state) return { version, error: c.uint.decode(state), firewall: c.uint.decode(state), holepunch: (flags & 1) !== 0 ? holepunchInfo.decode(state) : null, addresses4: (flags & 2) !== 0 ? ipv4Array.decode(state) : [], addresses6: (flags & 4) !== 0 ? ipv6Array.decode(state) : [], udx: (flags & 8) !== 0 ? udxInfo.decode(state) : null, secretStream: (flags & 16) !== 0 ? secretStreamInfo.decode(state) : null, relayThrough: (flags & 32) !== 0 ? relayThroughInfo.decode(state) : null, relayAddresses: (flags & 64) !== 0 ? ipv4Array.decode(state) : null } } } exports.holepunch = { preencode(state, m) { state.end += 2 c.uint.preencode(state, m.id) c.buffer.preencode(state, m.payload) if (m.peerAddress) ipv4.preencode(state, m.peerAddress) }, encode(state, m) { const flags = m.peerAddress ? 1 : 0 c.uint.encode(state, flags) c.uint.encode(state, m.mode) c.uint.encode(state, m.id) c.buffer.encode(state, m.payload) if (m.peerAddress) ipv4.encode(state, m.peerAddress) }, decode(state) { const flags = c.uint.decode(state) return { mode: c.uint.decode(state), id: c.uint.decode(state), payload: c.buffer.decode(state), peerAddress: flags & 1 ? ipv4.decode(state) : null } } } exports.holepunchPayload = { preencode(state, m) { state.end += 4 // flags + error + firewall + round if (m.addresses) ipv4Array.preencode(state, m.addresses) if (m.remoteAddress) state.end += 6 if (m.token) state.end += 32 if (m.remoteToken) state.end += 32 }, encode(state, m) { const flags = (m.connected ? 1 : 0) | (m.punching ? 2 : 0) | (m.addresses ? 4 : 0) | (m.remoteAddress ? 8 : 0) | (m.token ? 16 : 0) | (m.remoteToken ? 32 : 0) c.uint.encode(state, flags) c.uint.encode(state, m.error) c.uint.encode(state, m.firewall) c.uint.encode(state, m.round) if (m.addresses) ipv4Array.encode(state, m.addresses) if (m.remoteAddress) ipv4.encode(state, m.remoteAddress) if (m.token) c.fixed32.encode(state, m.token) if (m.remoteToken) c.fixed32.encode(state, m.remoteToken) }, decode(state) { const flags = c.uint.decode(state) return { error: c.uint.decode(state), firewall: c.uint.decode(state), round: c.uint.decode(state), connected: (flags & 1) !== 0, punching: (flags & 2) !== 0, addresses: (flags & 4) !== 0 ? ipv4Array.decode(state) : null, remoteAddress: (flags & 8) !== 0 ? ipv4.decode(state) : null, token: (flags & 16) !== 0 ? c.fixed32.decode(state) : null, remoteToken: (flags & 32) !== 0 ? c.fixed32.decode(state) : null } } } const peer = (exports.peer = { preencode(state, m) { state.end += 32 ipv4Array.preencode(state, m.relayAddresses) }, encode(state, m) { c.fixed32.encode(state, m.publicKey) ipv4Array.encode(state, m.relayAddresses) }, decode(state) { return { publicKey: c.fixed32.decode(state), relayAddresses: ipv4Array.decode(state) } } }) const peers = (exports.peers = c.array(peer)) const rawPeers = c.array(c.raw) exports.lookupRawReply = { preencode(state, m) { rawPeers.preencode(state, m.peers) c.uint.preencode(state, m.bump) }, encode(state, m) { rawPeers.encode(state, m.peers) c.uint.encode(state, m.bump) }, decode(state) { return { peers: peers.decode(state), bump: state.start < state.end ? c.uint.decode(state) : 0 } } } exports.announce = { preencode(state, m) { state.end++ // flags if (m.peer) peer.preencode(state, m.peer) if (m.refresh) state.end += 32 if (m.signature) state.end += 64 if (m.bump) c.uint.preencode(state, m.bump) }, encode(state, m) { const flags = (m.peer ? 1 : 0) | (m.refresh ? 2 : 0) | (m.signature ? 4 : 0) | (m.bump ? 8 : 0) c.uint.encode(state, flags) if (m.peer) peer.encode(state, m.peer) if (m.refresh) c.fixed32.encode(state, m.refresh) if (m.signature) c.fixed64.encode(state, m.signature) if (m.bump) c.uint.encode(state, m.bump) }, decode(state) { const flags = c.uint.decode(state) return { peer: (flags & 1) !== 0 ? peer.decode(state) : null, refresh: (flags & 2) !== 0 ? c.fixed32.decode(state) : null, signature: (flags & 4) !== 0 ? c.fixed64.decode(state) : null, bump: (flags & 8) !== 0 ? c.uint.decode(state) : 0 } } } exports.mutableSignable = { preencode(state, m) { c.uint.preencode(state, m.seq) c.buffer.preencode(state, m.value) }, encode(state, m) { c.uint.encode(state, m.seq) c.buffer.encode(state, m.value) }, decode(state) { return { seq: c.uint.decode(state), value: c.buffer.decode(state) } } } exports.mutablePutRequest = { preencode(state, m) { c.fixed32.preencode(state, m.publicKey) c.uint.preencode(state, m.seq) c.buffer.preencode(state, m.value) c.fixed64.preencode(state, m.signature) }, encode(state, m) { c.fixed32.encode(state, m.publicKey) c.uint.encode(state, m.seq) c.buffer.encode(state, m.value) c.fixed64.encode(state, m.signature) }, decode(state) { return { publicKey: c.fixed32.decode(state), seq: c.uint.decode(state), value: c.buffer.decode(state), signature: c.fixed64.decode(state) } } } exports.mutableGetResponse = { preencode(state, m) { c.uint.preencode(state, m.seq) c.buffer.preencode(state, m.value) c.fixed64.preencode(state, m.signature) }, encode(state, m) { c.uint.encode(state, m.seq) c.buffer.encode(state, m.value) c.fixed64.encode(state, m.signature) }, decode(state) { return { seq: c.uint.decode(state), value: c.buffer.decode(state), signature: c.fixed64.decode(state) } } } exports.pluginRequest = { preencode(state, m) { c.string.preencode(state, m.plugin) c.uint.preencode(state, m.version) c.uint.preencode(state, m.command) state.end++ // max flag is 1 so always one byte if (m.value) c.buffer.preencode(state, m.value) }, encode(state, m) { const flags = m.value ? 1 : 0 c.string.encode(state, m.plugin) c.uint.encode(state, m.version) c.uint.encode(state, m.command) c.uint.encode(state, flags) if (m.value) c.buffer.encode(state, m.value) }, decode(state) { const r0 = c.string.decode(state) const r1 = c.uint.decode(state) const r2 = c.uint.decode(state) const flags = c.uint.decode(state) return { plugin: r0, version: r1, command: r2, value: (flags & 1) !== 0 ? c.buffer.decode(state) : null } } } const { FIREWALL } = require('../lib/constants') module.exports = class Nat { constructor(dht, session, socket) { this._samplesHost = [] this._samplesFull = [] this._visited = new Map() this._resolve = null this._minSamples = 4 this._autoSampling = false this.dht = dht this.session = session this.socket = socket this.sampled = 0 this.firewall = dht.firewalled ? FIREWALL.UNKNOWN : FIREWALL.OPEN this.addresses = null this.analyzing = new Promise((resolve) => { this._resolve = resolve }) } autoSample(retry = true) { if (this._autoSampling) return this._autoSampling = true const self = this const socket = this.socket const maxPings = this._minSamples let skip = this.dht.nodes.length >= 8 ? 5 : 0 let pending = 0 // TODO: it would be best to pick the nodes to help us based on latency to us // That should reduce connect latency in general. We should investigate tracking that later on. // TODO 2: try to pick nodes with different IPs as well, as that'll help multi IP cell connections... // If we expose this from the nat sampler then the DHT should be able to help us filter out scams as well... for ( let node = this.dht.nodes.latest; node && this.sampled + pending < maxPings; node = node.prev ) { if (skip > 0) { skip-- continue } const ref = node.host + ':' + node.port if (this._visited.has(ref)) continue this._visited.set(ref, 1) pending++ this.session.ping(node, { socket, retry: false }).then(onpong, onskip) } pending++ onskip() function onpong(res) { self.add(res.to, res.from) onskip() } function onskip() { if (--pending === 0 && self.sampled < self._minSamples) { if (retry) { self._autoSampling = false self.autoSample(false) return } self._resolve() } } } destroy() { this._autoSampling = true this._minSamples = 0 this._resolve() } unfreeze() { this.frozen = false this._updateFirewall() this._updateAddresses() } freeze() { this.frozen = true } _updateFirewall() { if (!this.dht.firewalled) { this.firewall = FIREWALL.OPEN return } if (this.sampled < 3) return const max = this._samplesFull[0].hits if (max >= 3) { this.firewall = FIREWALL.CONSISTENT return } if (max === 1) { this.firewall = FIREWALL.RANDOM return } // else max === 2 // 1 host, >= 4 total samples ie, 2 bad ones -> random if (this._samplesHost.length === 1 && this.sampled > 3) { this.firewall = FIREWALL.RANDOM return } // double hit on two different ips -> assume consistent if (this._samplesHost.length > 1 && this._samplesFull[1].hits > 1) { this.firewall = FIREWALL.CONSISTENT return } // (4 is just means - all the samples we expect) - no decision - assume random if (this.sampled > 4) { this.firewall = FIREWALL.RANDOM } } _updateAddresses() { if (this.firewall === FIREWALL.UNKNOWN) { this.addresses = null return } if (this.firewall === FIREWALL.RANDOM) { this.addresses = [this._samplesHost[0]] return } if (this.firewall === FIREWALL.CONSISTENT) { this.addresses = [] for (const addr of this._samplesFull) { if (addr.hits >= 2 || this.addresses.length < 2) this.addresses.push(addr) } } } update() { if (this.dht.firewalled && this.firewall === FIREWALL.OPEN) { this.firewall = FIREWALL.UNKNOWN } this._updateFirewall() this._updateAddresses() } add(addr, from) { const ref = from.host + ':' + from.port if (this._visited.get(ref) === 2) return this._visited.set(ref, 2) addSample(this._samplesHost, addr.host, 0) addSample(this._samplesFull, addr.host, addr.port) if ((++this.sampled >= 3 || !this.dht.firewalled) && !this.frozen) { this.update() } if (this.firewall === FIREWALL.CONSISTENT || this.firewall === FIREWALL.OPEN) { this._resolve() } else if (this.sampled >= this._minSamples) { this._resolve() } } } function addSample(samples, host, port) { for (let i = 0; i < samples.length; i++) { const s = samples[i] if (s.port !== port || s.host !== host) continue s.hits++ for (; i > 0; i--) { const prev = samples[i - 1] if (prev.hits >= s.hits) return samples[i - 1] = s samples[i] = prev } return } samples.push({ host, port, hits: 1 }) } const NoiseSecretStream = require('@hyperswarm/secret-stream') const NoiseHandshake = require('noise-handshake') const curve = require('noise-curve-ed') const c = require('compact-encoding') const b4a = require('b4a') const sodium = require('sodium-universal') const m = require('./messages') const { NS } = require('./constants') const { HANDSHAKE_UNFINISHED } = require('./errors') const NOISE_PROLOUGE = NS.PEER_HANDSHAKE module.exports = class NoiseWrap { constructor(keyPair, remotePublicKey) { this.isInitiator = !!remotePublicKey this.remotePublicKey = remotePublicKey this.keyPair = keyPair this.handshake = new NoiseHandshake('IK', this.isInitiator, keyPair, { curve }) this.handshake.initialise(NOISE_PROLOUGE, remotePublicKey) } send(payload) { const buf = c.encode(m.noisePayload, payload) return this.handshake.send(buf) } recv(buf) { const payload = c.decode(m.noisePayload, this.handshake.recv(buf)) this.remotePublicKey = b4a.toBuffer(this.handshake.rs) return payload } final() { if (!this.handshake.complete) throw HANDSHAKE_UNFINISHED() const holepunchSecret = b4a.allocUnsafe(32) sodium.crypto_generichash(holepunchSecret, NS.PEER_HOLEPUNCH, this.handshake.hash) return { isInitiator: this.isInitiator, publicKey: this.keyPair.publicKey, streamId: this.streamId, remotePublicKey: this.remotePublicKey, remoteId: NoiseSecretStream.id(this.handshake.hash, !this.isInitiator), holepunchSecret, hash: b4a.toBuffer(this.handshake.hash), rx: b4a.toBuffer(this.handshake.rx), tx: b4a.toBuffer(this.handshake.tx) } } } const c = require('compact-encoding') const sodium = require('sodium-universal') const RecordCache = require('record-cache') const Cache = require('xache') const b4a = require('b4a') const unslab = require('unslab') const { encodeUnslab } = require('./encode') const m = require('./messages') const { NS, ERROR } = require('./constants') const EMPTY = b4a.alloc(0) const TMP = b4a.allocUnsafe(32) const MAX_BUMP_DRIFT = 60_000 module.exports = class Persistent { constructor(dht, opts) { this.dht = dht this.records = new RecordCache(opts.records) this.bumps = new Cache(opts.bumps) this.refreshes = new Cache(opts.refreshes) this.mutables = new Cache(opts.mutables) this.immutables = new Cache(opts.immutables) } onlookup(req) { if (!req.target) return const k = b4a.toString(req.target, 'hex') const records = this.records.get(k, 20) const bump = this.bumps.get(k) || 0 const fwd = this.dht._router.get(k) if (fwd && records.length < 20) records.push(fwd.record) req.reply(records.length ? c.encode(m.lookupRawReply, { peers: records, bump }) : null) } onfindpeer(req) { if (!req.target) return const fwd = this.dht._router.get(req.target) req.reply(fwd ? fwd.record : null) } unannounce(target, publicKey) { const k = b4a.toString(target, 'hex') sodium.crypto_generichash(TMP, publicKey) if (b4a.equals(TMP, target)) this.dht._router.delete(k) this.records.remove(k, publicKey) } onunannounce(req) { if (!req.target || !req.token) return const unann = decode(m.announce, req.value) if (unann === null) return const { peer, signature } = unann if (!peer || !signature) return const signable = annSignable(req.target, req.token, this.dht.id, unann, NS.UNANNOUNCE) if (!sodium.crypto_sign_verify_detached(signature, signable, peer.publicKey)) { return } this.unannounce(req.target, peer.publicKey) req.reply(null, { token: false, closerNodes: false }) } _onrefresh(token, req) { sodium.crypto_generichash(TMP, token) const activeRefresh = b4a.toString(TMP, 'hex') const r = this.refreshes.get(activeRefresh) if (!r) return const { announceSelf, k, record } = r const publicKey = record.subarray(0, 32) if (announceSelf) { this.dht._router.set(k, { relay: req.from, record, onconnect: null, onholepunch: null }) this.records.remove(k, publicKey) } else { this.records.add(k, publicKey, record) } this.refreshes.delete(activeRefresh) this.refreshes.set(b4a.toString(token, 'hex'), r) req.reply(null, { token: false, closerNodes: false }) } onannounce(req) { if (!req.target || !req.token || !this.dht.id) return const ann = decode(m.announce, req.value) if (ann === null) return const { peer, refresh, signature, bump } = ann if (!peer) { if (!refresh) return this._onrefresh(refresh, req) return } const signable = annSignable(req.target, req.token, this.dht.id, ann, NS.ANNOUNCE) if (!signature || !sodium.crypto_sign_verify_detached(signature, signable, peer.publicKey)) { return } // TODO: it would be potentially be more optimal to allow more than 3 addresses here for a findPeer response // and only use max 3 for a lookup reply if (peer.relayAddresses.length > 3) { peer.relayAddresses = peer.relayAddresses.slice(0, 3) } sodium.crypto_generichash(TMP, peer.publicKey) const k = b4a.toString(req.target, 'hex') const announceSelf = b4a.equals(TMP, req.target) const record = encodeUnslab(m.peer, peer) if (announceSelf) { this.dht._router.set(k, { relay: req.from, record, onconnect: null, onholepunch: null }) this.records.remove(k, peer.publicKey) } else { const currentBump = this.bumps.get(k) || 0 if (bump > currentBump && bump <= Date.now() + MAX_BUMP_DRIFT) this.bumps.set(k, bump) this.records.add(k, peer.publicKey, record) } if (refresh) { this.refreshes.set(b4a.toString(refresh, 'hex'), { k, record, announceSelf }) } req.reply(null, { token: false, closerNodes: false }) } onmutableget(req) { if (!req.target || !req.value) return let seq = 0 try { seq = c.decode(c.uint, req.value) } catch { return } const k = b4a.toString(req.target, 'hex') const value = this.mutables.get(k) if (!value) { req.reply(null) return } const localSeq = c.decode(c.uint, value) req.reply(localSeq < seq ? null : value) } onmutableput(req) { if (!req.target || !req.token || !req.value) return const p = decode(m.mutablePutRequest, req.value) if (!p) return const { publicKey, seq, value, signature } = p const hash = b4a.allocUnsafe(32) sodium.crypto_generichash(hash, publicKey) if (!b4a.equals(hash, req.target)) return if (!value || !verifyMutable(signature, seq, value, publicKey)) return const k = b4a.toString(hash, 'hex') const local = this.mutables.get(k) if (local) { const existing = c.decode(m.mutableGetResponse, local) if (existing.value && existing.seq === seq && b4a.compare(value, existing.value) !== 0) { req.error(ERROR.SEQ_REUSED) return } if (seq < existing.seq) { req.error(ERROR.SEQ_TOO_LOW) return } } this.mutables.set(k, encodeUnslab(m.mutableGetResponse, { seq, value, signature })) req.reply(null) } onimmutableget(req) { if (!req.target) return const k = b4a.toString(req.target, 'hex') const value = this.immutables.get(k) req.reply(value || null) } onimmutableput(req) { if (!req.target || !req.token || !req.value) return const hash = b4a.alloc(32) sodium.crypto_generichash(hash, req.value) if (!b4a.equals(hash, req.target)) return const k = b4a.toString(hash, 'hex') this.immutables.set(k, unslab(req.value)) req.reply(null) } onplugin(req) { if (!req.value) return const plugreq = decode(m.pluginRequest, req.value) if (plugreq === null) return const p = this.dht.plugins.get(plugreq.plugin) if (!p || p.version !== plugreq.version) return p.onrequest(plugreq, req) } destroy() { this.records.destroy() this.refreshes.destroy() this.mutables.destroy() this.immutables.destroy() } static signMutable(seq, value, keyPair) { const signable = b4a.allocUnsafe(32 + 32) const hash = signable.subarray(32) signable.set(NS.MUTABLE_PUT, 0) sodium.crypto_generichash(hash, c.encode(m.mutableSignable, { seq, value })) return sign(signable, keyPair) } static verifyMutable(signature, seq, value, publicKey) { return verifyMutable(signature, seq, value, publicKey) } static signAnnounce(target, token, id, ann, keyPair) { return sign(annSignable(target, token, id, ann, NS.ANNOUNCE), keyPair) } static signUnannounce(target, token, id, ann, keyPair) { return sign(annSignable(target, token, id, ann, NS.UNANNOUNCE), keyPair) } } function verifyMutable(signature, seq, value, publicKey) { const signable = b4a.allocUnsafe(32 + 32) const hash = signable.subarray(32) signable.set(NS.MUTABLE_PUT, 0) sodium.crypto_generichash(hash, c.encode(m.mutableSignable, { seq, value })) return sodium.crypto_sign_verify_detached(signature, signable, publicKey) } function annSignable(target, token, id, ann, ns) { const signable = b4a.allocUnsafe(32 + 32) const hash = signable.subarray(32) signable.set(ns, 0) sodium.crypto_generichash_batch(hash, [ target, id, token, c.encode(m.peer, ann.peer), // note that this is the partial encoding of the announce message so we could just use that for perf ann.refresh || EMPTY ]) return signable } function sign(signable, keyPair) { if (keyPair.sign) { return keyPair.sign(signable) } const secretKey = keyPair.secretKey ? keyPair.secretKey : keyPair const signature = b4a.allocUnsafe(64) sodium.crypto_sign_detached(signature, signable, secretKey) return signature } function decode(enc, val) { try { return val && c.decode(enc, val) } catch (err) { return null } } module.exports = class RawStreamSet { constructor(dht) { this._dht = dht this._prefix = 16 - 1 // 16 is the default stream-set side in udx this._streams = new Map() } get size() { return this._streams.size } [Symbol.iterator]() { return this._streams.values() } add(opts) { const self = this // TODO: we should prob have a udx helper for id generation, given the slight complexity // of the below. requires a PRNG in udx tho. let id = 0 while (true) { id = (Math.random() * 0x100000000) >>> 0 if (this._streams.has(id & this._prefix)) continue break } // always have ~50% change of rolling a free one if (2 * this._streams.size >= this._prefix) { // ie 0b11111 = 0b1111 + 1 + 0b1111 this._prefix = 2 * this._prefix + 1 // move the prefixes over const next = new Map() for (const stream of this._streams.values()) { next.set(stream.id & this._prefix, stream) } this._streams = next } const stream = this._dht.udx.createStream(id, opts) this._streams.set(id & this._prefix, stream) stream.on('close', onclose) return stream function onclose() { self._streams.delete(id & self._prefix) } } async clear() { const destroying = [] for (const stream of this._streams.values()) { destroying.push(new Promise((resolve) => stream.once('close', resolve).destroy())) } await Promise.allSettled(destroying) } } const b4a = require('b4a') const safetyCatch = require('safety-catch') exports.clearRelayTimeout = clearRelayTimeout exports.closeRelayConnection = closeRelayConnection exports.confirmDirectUpgrade = confirmDirectUpgrade exports.destroyRelayConnection = destroyRelayConnection function clearRelayTimeout(connectionOrHandshake) { clearTimeout(connectionOrHandshake.relayTimeout) connectionOrHandshake.relayTimeout = null } function closeRelayConnection(connectionOrHandshake) { const socket = resetRelayConnection(connectionOrHandshake) if (socket) socket.end() } function confirmDirectUpgrade(connectionOrHandshake, rawStream, remoteChanging) { const cleanup = () => { rawStream.off('data', ondirect) rawStream.off('message', ondirect) rawStream.off('close', cleanup) } function ondirect() { if (!connectionOrHandshake.validUpgrade) { // reset, aka assume from direct connectionOrHandshake.validUpgrade = true return } cleanup() closeRelayConnection(connectionOrHandshake) } const confirm = () => { rawStream.on('data', ondirect) rawStream.on('message', ondirect) rawStream.once('close', cleanup) // Use a raw UDX message to make the peer observe the direct path without // writing application data into the secret stream. if (rawStream.trySend) rawStream.trySend(b4a.alloc(0)) } if (!remoteChanging) { confirm() return } remoteChanging.then(confirm).catch(safetyCatch) } function destroyRelayConnection(connectionOrHandshake) { const socket = resetRelayConnection(connectionOrHandshake) if (socket) socket.destroy() } function resetRelayConnection(connectionOrHandshake) { if (connectionOrHandshake.relayTimeout) clearRelayTimeout(connectionOrHandshake) const socket = connectionOrHandshake.relaySocket // Drop relay references so the app connection no longer keeps relay state alive. connectionOrHandshake.relayToken = null connectionOrHandshake.relaySocket = null connectionOrHandshake.relayClient = null return socket } const c = require('compact-encoding') const Cache = require('xache') const safetyCatch = require('safety-catch') const b4a = require('b4a') const { handshake, holepunch } = require('./messages') const { COMMANDS } = require('./constants') const { BAD_HANDSHAKE_REPLY, BAD_HOLEPUNCH_REPLY } = require('./errors') const FROM_CLIENT = 0 const FROM_SERVER = 1 const FROM_RELAY = 2 const FROM_SECOND_RELAY = 3 const REPLY = 4 // TODO: While the current design is very trustless in regards to clients/servers trusting the DHT, // we should add a bunch of rate limits everywhere, especially including here to avoid bad users // using a DHT node to relay traffic indiscriminately using the connect/holepunch messages. // That's mostly from an abuse POV as none of the messsages do amplication. module.exports = class Router { constructor(dht, opts) { this.dht = dht this.forwards = new Cache(opts.forwards) } set(target, state) { if (state.onpeerhandshake) { this.forwards.retain(toString(target), state) } else { this.forwards.set(toString(target), state) } } get(target) { return this.forwards.get(toString(target)) } delete(target) { this.forwards.delete(toString(target)) } destroy() { this.forwards.destroy() } async peerHandshake(target, { noise, peerAddress, relayAddress, socket, session }, to) { const dht = this.dht const requestValue = c.encode(handshake, { mode: FROM_CLIENT, noise, peerAddress, relayAddress }) const res = await dht.request( { command: COMMANDS.PEER_HANDSHAKE, target, value: requestValue }, to, { socket, session } ) const hs = decode(handshake, res.value) if ( !hs || hs.mode !== REPLY || to.host !== res.from.host || to.port !== res.from.port || !hs.noise ) { throw BAD_HANDSHAKE_REPLY() } return { noise: hs.noise, relayed: !!hs.peerAddress, serverAddress: hs.peerAddress || to, clientAddress: res.to } } async onpeerhandshake(req) { const hs = req.value && decode(handshake, req.value) if (!hs) return const { mode, noise, peerAddress, relayAddress } = hs const state = req.target && this.get(req.target) const isServer = !!(state && state.onpeerhandshake) const relay = state && state.relay if (isServer) { let reply = null try { reply = noise && (await state.onpeerhandshake({ noise, peerAddress }, req)) } catch (e) { safetyCatch(e) return } if (!reply || !reply.noise) return const opts = { socket: reply.socket, closerNodes: false, token: false } switch (mode) { case FROM_CLIENT: { req.reply( c.encode(handshake, { mode: REPLY, noise: reply.noise, peerAddress: null }), opts ) return } case FROM_RELAY: { req.relay( c.encode(handshake, { mode: FROM_SERVER, noise: reply.noise, peerAddress }), req.from, opts ) return } case FROM_SECOND_RELAY: { if (!relayAddress) return req.relay( c.encode(handshake, { mode: FROM_SERVER, noise: reply.noise, peerAddress }), relayAddress, opts ) return // eslint-disable-line } } } else { switch (mode) { case FROM_CLIENT: { // TODO: if no relay is known route closer to the target instead of timing out if (!noise) return if (!relay && !relayAddress) { // help the user route req.reply(null, { token: false, closerNodes: true }) return } req.relay( c.encode(handshake, { mode: FROM_RELAY, noise, peerAddress: req.from, relayAddress: null }), relayAddress || relay ) return } case FROM_RELAY: { if (!relay || !noise) return req.relay( c.encode(handshake, { mode: FROM_SECOND_RELAY, noise, peerAddress, relayAddress: req.from }), relay ) return } case FROM_SERVER: { if (!peerAddress || !noise) return req.reply( c.encode(handshake, { mode: REPLY, noise, peerAddress: req.from, relayAddress: null }), { to: peerAddress, closerNodes: false, token: false } ) return // eslint-disable-line } } } } async peerHolepunch(target, { id, payload, peerAddress, socket, session }, to) { const dht = this.dht const requestValue = c.encode(holepunch, { mode: FROM_CLIENT, id, payload, peerAddress }) const res = await dht.request( { command: COMMANDS.PEER_HOLEPUNCH, target, value: requestValue }, to, { socket, session } ) const hp = decode(holepunch, res.value) if (!hp || hp.mode !== REPLY || to.host !== res.from.host || to.port !== res.from.port) { throw BAD_HOLEPUNCH_REPLY() } return { from: res.from, to: res.to, payload: hp.payload, peerAddress: hp.peerAddress || to } } async onpeerholepunch(req) { const hp = req.value && decode(holepunch, req.value) if (!hp) return const { mode, id, payload, peerAddress } = hp const state = req.target && this.get(req.target) const isServer = !!(state && state.onpeerholepunch) const relay = state && state.relay switch (mode) { case FROM_CLIENT: { if (!peerAddress && !relay) return req.relay( c.encode(holepunch, { mode: FROM_RELAY, id, payload, peerAddress: req.from }), peerAddress || relay ) return } case FROM_RELAY: { if (!isServer || !peerAddress) return let reply = null try { reply = await state.onpeerholepunch({ id, payload, peerAddress }, req) } catch (e) { safetyCatch(e) return } if (!reply) return const opts = { socket: reply.socket, closerNodes: false, token: false } req.relay( c.encode(holepunch, { mode: FROM_SERVER, id: 0, payload: reply.payload, peerAddress }), req.from, opts ) return } case FROM_SERVER: { req.reply(c.encode(holepunch, { mode: REPLY, id, payload, peerAddress: req.from }), { to: peerAddress, closerNodes: false, token: false }) return // eslint-disable-line } } } } function decode(enc, val) { try { return c.decode(enc, val) } catch { return null } } function toString(t) { return typeof t === 'string' ? t : b4a.toString(t, 'hex') } const sodium = require('sodium-universal') const b4a = require('b4a') const { holepunchPayload } = require('./messages') module.exports = class HolepunchPayload { constructor(holepunchSecret) { this._sharedSecret = holepunchSecret this._localSecret = b4a.allocUnsafe(32) sodium.randombytes_buf(this._localSecret) } decrypt(buffer) { const state = { start: 24, end: buffer.byteLength - 16, buffer } if (state.end <= state.start) return null const nonce = buffer.subarray(0, 24) const msg = state.buffer.subarray(state.start, state.end) const cipher = state.buffer.subarray(state.start) if (!sodium.crypto_secretbox_open_easy(msg, cipher, nonce, this._sharedSecret)) return null try { return holepunchPayload.decode(state) } catch { return null } } encrypt(payload) { const state = { start: 24, end: 24, buffer: null } holepunchPayload.preencode(state, payload) state.buffer = b4a.allocUnsafe(state.end + 16) const nonce = state.buffer.subarray(0, 24) const msg = state.buffer.subarray(state.start, state.end) const cipher = state.buffer.subarray(state.start) holepunchPayload.encode(state, payload) sodium.randombytes_buf(nonce) sodium.crypto_secretbox_easy(cipher, msg, nonce, this._sharedSecret) return state.buffer } token(addr) { const out = b4a.allocUnsafe(32) sodium.crypto_generichash(out, b4a.from(addr.host), this._localSecret) return out } } const DONE = Promise.resolve(true) const DESTROYED = Promise.resolve(false) module.exports = class Semaphore { constructor(limit = 1) { this.limit = limit this.active = 0 this.waiting = [] this.flushedPromise = null this.flushedResolve = null this.destroyed = false this._onwait = this._queueWaiting.bind(this) this._onflush = this._queueFlushed.bind(this) } _queueWaiting(resolve) { this.waiting.push(resolve) } _queueFlushed(resolve) { this.flushedResolve = resolve } wait() { if (this.destroyed === true) return DESTROYED if (this.active < this.limit && this.waiting.length === 0) { this.active++ return DONE } return new Promise(this._onwait) } signal() { if (this.destroyed === true) return this.active-- while (this.active < this.limit && this.waiting.length > 0 && this.destroyed === false) { this.active++ this.waiting.shift()(true) } if (this.active === 0 && this.flushedResolve) { const resolve = this.flushedResolve this.flushedResolve = null this.flushedPromise = null resolve(true) } } async flush() { if (this.destroyed === true) return if (this.active === 0) return if (this.flushedPromise) return this.flushedPromise this.flushedPromise = new Promise(this._onflush) return this.flushedPromise } destroy() { this.destroyed = true this.active = 0 while (this.waiting.length) this.waiting.pop()(false) if (this.flushedResolve) this.flushedResolve(false) } } const { EventEmitter } = require('events') const safetyCatch = require('safety-catch') const NoiseSecretStream = require('@hyperswarm/secret-stream') const b4a = require('b4a') const relay = require('blind-relay') const NoiseWrap = require('./noise-wrap') const Announcer = require('./announcer') const { FIREWALL, ERROR } = require('./constants') const { unslabbedHash } = require('./crypto') const SecurePayload = require('./secure-payload') const Holepuncher = require('./holepuncher') const { clearRelayTimeout, confirmDirectUpgrade, destroyRelayConnection } = require('./relay-connection') const { isPrivate } = require('bogon') const { ALREADY_LISTENING, NODE_DESTROYED, KEYPAIR_ALREADY_USED } = require('./errors') const HANDSHAKE_CLEAR_WAIT = 10000 const HANDSHAKE_INITIAL_TIMEOUT = 10000 module.exports = class Server extends EventEmitter { constructor(dht, opts = {}) { super() this.dht = dht this.target = null this.closed = false this.firewall = opts.firewall || (() => false) this.holepunch = opts.holepunch || (() => true) this.relayThrough = opts.relayThrough || null this.relayKeepAlive = opts.relayKeepAlive || 5000 this.pool = opts.pool || null this.createHandshake = opts.createHandshake || defaultCreateHandshake this.createSecretStream = opts.createSecretStream || defaultCreateSecretStream this.suspended = false this.handshakeClearWait = opts.handshakeClearWait || HANDSHAKE_CLEAR_WAIT this._shareLocalAddress = opts.shareLocalAddress !== false this._reusableSocket = !!opts.reusableSocket this._neverPunch = opts.holepunch === false // useful for fully disabling punching this._keyPair = null this._announcer = null this._connects = new Map() this._holepunches = [] this._listening = null this._closing = null } get listening() { return this._listening !== null } get publicKey() { return this._keyPair && this._keyPair.publicKey } get relayAddresses() { return this._announcer ? this._announcer.relayAddresses : [] } onconnection(encryptedSocket) { this.emit('connection', encryptedSocket) } async suspend({ log = noop } = {}) { log('Suspending hyperdht server') if (this._listening !== null) await this._listening log('Suspending hyperdht server (post listening)') this.suspended = true this._clearAll() return this._announcer ? this._announcer.suspend({ log }) : Promise.resolve() } async resume() { if (this._listening !== null) await this._listening this.suspended = false return this._announcer ? this._announcer.resume() : Promise.resolve() } address() { if (!this._keyPair) return null return { publicKey: this._keyPair.publicKey, host: this.dht.host, port: this.dht.port } } close() { if (this._closing) return this._closing this._closing = this._close() return this._closing } _gc() { this.dht.listening.delete(this) if (this.target) this.dht._router.delete(this.target) } async _stopListening() { try { if (this._announcer) await this._announcer.stop() } catch { // ignore } this._announcer = null this._listening = null this._keyPair = null } async _close() { if (this._listening === null) { this.closed = true this.emit('close') return } try { await this._listening } catch (err) { safetyCatch(err) } this._gc() this._clearAll() await this._stopListening() this.closed = true this.emit('close') } _clearAll() { while (this._holepunches.length > 0) { const h = this._holepunches.pop() if (h && h.puncher) h.puncher.destroy() if (h && h.clearing) clearTimeout(h.clearing) if (h && h.prepunching) clearTimeout(h.prepunching) if (h && h.rawStream) h.rawStream.destroy() } this._connects.clear() } async listen(keyPair = this.dht.defaultKeyPair, opts = {}) { if (this._listening !== null) throw ALREADY_LISTENING() if (this.dht.destroyed) throw NODE_DESTROYED() this._listening = this._listen(keyPair, opts) await this._listening return this } async _listen(keyPair, opts) { // From now on, the DHT object which created me is responsible for closing me this.dht.listening.add(this) try { await this.dht.bind() if (this._closing) return for (const s of this.dht.listening) { if (s._keyPair && b4a.equals(s._keyPair.publicKey, keyPair.publicKey)) { throw KEYPAIR_ALREADY_USED() } } this.target = unslabbedHash(keyPair.publicKey) this._keyPair = keyPair this._announcer = new Announcer(this.dht, keyPair, this.target, opts) this.dht._router.set(this.target, { relay: null, record: this._announcer.record, onpeerhandshake: this._onpeerhandshake.bind(this), onpeerholepunch: this._onpeerholepunch.bind(this) }) // warm it up for now this._localAddresses().catch(safetyCatch) await this._announcer.start() } catch (err) { await this._stopListening() this._gc() throw err } if (this._closing) return if (this.suspended) await this._announcer.suspend() if (this._closing) return if (this.dht.destroyed) throw NODE_DESTROYED() if (this.pool) this.pool._attachServer(this) this.emit('listening') } refresh() { if (this._announcer && !this.suspended) this._announcer.refresh() } notifyOnline() { if (this._announcer) this._announcer.online.notify() } _localAddresses() { return this.dht.validateLocalAddresses(Holepuncher.localAddresses(this.dht.io.serverSocket)) } async _addHandshake(k, noise, clientAddress, { to: serverAddress, socket }, direct) { let id = this._holepunches.indexOf(null) if (id === -1) id = this._holepunches.push(null) - 1 const hs = { round: 0, reply: null, puncher: null, payload: null, rawStream: null, encryptedSocket: null, prepunching: null, firewalled: true, clearing: null, replyFromPuncher: false, onsocket: null, aborted: false, // Relay state relayTimeout: null, relayToken: null, relaySocket: null, relayClient: null, relayPaired: false, validUpgrade: true } this._holepunches[id] = hs const handshake = this.createHandshake(this._keyPair, null) let remotePayload try { remotePayload = await handshake.recv(noise) } catch (err) { safetyCatch(err) this._clearLater(hs, id, k) return null } if (this._closing || this.suspended) { this._clearLater(hs, id, k) return null } try { hs.firewalled = await this.firewall(handshake.remotePublicKey, remotePayload, clientAddress) } catch (err) { safetyCatch(err) } if (this._closing || this.suspended || hs.firewalled) { this._clearLater(hs, id, k) return null } const error = remotePayload.version === 1 ? remotePayload.udx ? ERROR.NONE : ERROR.ABORTED : ERROR.VERSION_MISMATCH const addresses = [] const ourRemoteAddr = this.dht.remoteAddress() const ourLocalAddrs = this._shareLocalAddress ? await this._localAddresses() : null if (this._closing || this.suspended) { this._clearLater(hs, id, k) return null } if (ourRemoteAddr) addresses.push(ourRemoteAddr) if (ourLocalAddrs) addresses.push(...ourLocalAddrs) if (error === ERROR.NONE) { hs.rawStream = this.dht.createRawStream({ framed: true, firewall(socket, port, host) { if (!(port > 0 && port < 65536)) return true // Check if the traffic originated from the socket on which we're expecting relay traffic. If so, // we haven't hole punched yet and the other side is just sending us traffic through the relay. if (hs.relaySocket && isRelay(hs.relaySocket, socket, port, host)) { hs.validUpgrade = false return false } hs.onsocket(socket, port, host) hs.validUpgrade = true return false } }) hs.rawStream.on('error', autoDestroy) // Handles the case where onsocket is never called, but the stream got setup // This can happen on a relayed connection which never connects directly // (onsocket is called there only when the direct connection is established) const onrawstreamclose = () => { if (this._closing) return if (hs.puncher) { hs.puncher.onabort = noop hs.puncher.destroy() } this._clearLater(hs, id, k) } hs.rawStream.on('close', onrawstreamclose) hs.onsocket = (socket, port, host) => { if (hs.rawStream === null) return // Already hole punched this._clearLater(hs, id, k) if (hs.prepunching) { clearTimeout(hs.prepunching) hs.prepunching = null } if (this._reusableSocket && remotePayload.udx.reusableSocket) { this.dht._socketPool.routes.add(handshake.remotePublicKey, hs.rawStream) } hs.rawStream.removeListener('error', autoDestroy) hs.rawStream.removeListener('close', onrawstreamclose) if (hs.rawStream.connected) { const rawStream = hs.rawStream const remoteChanging = rawStream.changeRemote(socket, remotePayload.udx.id, port, host) confirmDirectUpgrade(hs, rawStream, remoteChanging) } else { hs.rawStream.connect(socket, remotePayload.udx.id, port, host) hs.encryptedSocket = this.createSecretStream(false, hs.rawStream, { handshake: h, keepAlive: this.dht.connectionKeepAlive }) this.onconnection(hs.encryptedSocket) } if (hs.puncher) { hs.puncher.onabort = noop hs.puncher.destroy() } hs.rawStream = null } function autoDestroy() { if (hs.puncher) hs.puncher.destroy() } } const relayAddresses = this.relayAddresses const relayThrough = selectRelay(this.relayThrough) if (relayThrough) hs.relayToken = relay.token() try { hs.reply = await handshake.send({ error, firewall: ourRemoteAddr ? FIREWALL.OPEN : FIREWALL.UNKNOWN, holepunch: ourRemoteAddr ? null : { id, relays: this._announcer.relays }, addresses4: addresses, addresses6: null, udx: { reusableSocket: this._reusableSocket, id: hs.rawStream ? hs.rawStream.id : 0, seq: 0 }, secretStream: {}, relayThrough: relayThrough ? { publicKey: relayThrough, token: hs.relayToken } : null, relayAddresses: relayAddresses.length ? relayAddresses : null }) } catch (err) { safetyCatch(err) if (hs.rawStream) hs.rawStream.destroy() this._clearLater(hs, id, k) return null } if (this._closing || this.suspended) { if (hs.rawStream) hs.rawStream.destroy() this._clearLater(hs, id, k) return null } const h = handshake.final() if (error !== ERROR.NONE) { if (hs.rawStream) hs.rawStream.destroy() this._clearLater(hs, id, k) return hs } if (remotePayload.firewall === FIREWALL.OPEN || direct) { const sock = direct ? socket : this.dht.socket this.dht.stats.punches.open++ hs.onsocket(sock, clientAddress.port, clientAddress.host) return hs } if (relayThrough || remotePayload.relayThrough) { this._relayConnection(hs, relayThrough, remotePayload, h) } const onabort = () => { hs.aborted = true if (hs.prepunching) clearTimeout(hs.prepunching) hs.prepunching = null if (hs.puncher) { hs.puncher.onabort = noop hs.puncher.destroy() } if (hs.rawStream.destroyed) { this._clearLater(hs, id, k) return } hs.rawStream.on('close', () => this._clearLater(hs, id, k)) if (hs.relayToken === null) hs.rawStream.destroy() } if (!direct && clientAddress.host === serverAddress.host) { const clientAddresses = remotePayload.addresses4.filter((addr) => isPrivate(addr.host)) if (clientAddresses.length > 0 && this._shareLocalAddress) { const myAddresses = await this._localAddresses() const addr = Holepuncher.matchAddress(myAddresses, clientAddresses) if (addr) { hs.payload = new SecurePayload(h.holepunchSecret) setupHolepuncher(this.dht, hs, remotePayload.firewall, onabort) hs.prepunching = setTimeout(onabort, HANDSHAKE_INITIAL_TIMEOUT) return hs } } } if (this._closing || this.suspended) { this._clearLater(hs, id, k) return null } if (ourRemoteAddr || this._neverPunch) { hs.prepunching = setTimeout(onabort, HANDSHAKE_INITIAL_TIMEOUT) return hs } hs.payload = new SecurePayload(h.holepunchSecret) setupHolepuncher(this.dht, hs, remotePayload.firewall, onabort) hs.replyFromPuncher = true hs.prepunching = setTimeout(hs.puncher.destroy.bind(hs.puncher), HANDSHAKE_INITIAL_TIMEOUT) return hs } _clearLater(hs, id, k) { if (hs.clearing) return hs.clearing = setTimeout(() => this._clear(hs, id, k), this.handshakeClearWait) hs.clearing.unref() } _clear(hs, id, k) { if (id >= this._holepunches.length || this._holepunches[id] !== hs) return if (hs.clearing) clearTimeout(hs.clearing) this._holepunches[id] = null while ( this._holepunches.length > 0 && this._holepunches[this._holepunches.length - 1] === null ) { this._holepunches.pop() } this._connects.delete(k) } async _onpeerhandshake({ noise, peerAddress }, req) { const k = b4a.toString(noise, 'hex') // The next couple of statements MUST run within the same tick to prevent // a malicious peer from flooding us with handshakes. let p = this._connects.get(k) if (!p) { p = this._addHandshake(k, noise, peerAddress || req.from, req, !peerAddress) this._connects.set(k, p) } const h = await p if (!h) return null if (this._closing !== null || this.suspended) return null // Routed handshake replies advertise the socket they are sent from as the // server address. Same-LAN prepunch also creates a puncher, but it must // keep advertising the normal server socket so the LAN shortcut can open. return { socket: h.replyFromPuncher ? h.puncher.socket : null, noise: h.reply } } async _onpeerholepunch({ id, peerAddress, payload }, req) { const h = id < this._holepunches.length ? this._holepunches[id] : null if (!h) return null if (!peerAddress || this._closing !== null || this.suspended) return null if (!h.payload) return this._abort(h) // not opened const remotePayload = h.payload.decrypt(payload) if (!remotePayload) return null const p = h.puncher if (!p || !p.socket) return this._abort(h) // not opened const isServerRelay = this._announcer.isRelay(req.from) const { error, firewall, round, punching, addresses, remoteAddress, remoteToken } = remotePayload if (error !== ERROR.NONE) { // We actually do not need to set the round here, but just do it for consistency. if (round >= h.round) h.round = round return this._abort(h) } const token = h.payload.token(peerAddress) const echoed = isServerRelay && !!remoteToken && b4a.equals(token, remoteToken) // Update our heuristics here if (req.socket === p.socket) { p.nat.add(req.to, req.from) } if (round >= h.round) { h.round = round p.updateRemote({ punching, firewall, addresses, verified: echoed ? peerAddress.host : null }) } // Wait for the analyzer to reach a conclusion... let stable = await p.analyze(false) if (p.destroyed) return null if (!p.remoteHolepunching && !stable) { stable = await p.analyze(true) if (p.destroyed) return null if (!stable) return this._abort(h) } // Fast mode! If we are consistent and the remote has opened a session to us (remoteAddress) // then fire a quick punch back. Note the await here just waits for the udp socket to flush. if ( isConsistent(p.nat.firewall) && remoteAddress && hasSameAddr(p.nat.addresses, remoteAddress) ) { await p.ping(peerAddress) if (p.destroyed) return null } // Remote said they are punching (or willing to), so we will punch as well. // Note that this returns when the punching has STARTED, so no guarantee // we will have a connection after this promise etc. if (p.remoteHolepunching) { // TODO: still continue here if a local connection might work, but then do not holepunch... if (!this.holepunch(p.remoteFirewall, p.nat.firewall, p.remoteAddresses, p.nat.addresses)) { return p.destroyed ? null : this._abort(h) } if (h.prepunching) { clearTimeout(h.prepunching) h.prepunching = null } if (p.remoteFirewall >= FIREWALL.RANDOM || p.nat.firewall >= FIREWALL.RANDOM) { if ( this.dht._randomPunches >= this.dht._randomPunchLimit || Date.now() - this.dht._lastRandomPunch < this.dht._randomPunchInterval ) { this.dht.stats.punches.tryLater++ if (!h.relayToken) return this._abort(h, ERROR.TRY_LATER) if (!h.tryLaterCounted) { h.tryLaterCounted = true this.dht.stats.punches.tryLaterRelayedHandshakesAtLeastOnce++ } return { socket: p.socket, payload: h.payload.encrypt({ error: ERROR.TRY_LATER, firewall: p.nat.firewall, round: h.round, connected: p.connected, punching: p.punching, addresses: p.nat.addresses, remoteAddress: null, token: isServerRelay ? token : null, remoteToken: remotePayload.token }) } } } const punching = await p.punch() if (p.destroyed) return null if (!punching) return this._abort(h) } // Freeze that analysis as soon as we have a result we are giving to the other peer if (p.nat.firewall !== FIREWALL.UNKNOWN) { p.nat.freeze() } return { socket: p.socket, payload: h.payload.encrypt({ error: ERROR.NONE, firewall: p.nat.firewall, round: h.round, connected: p.connected, punching: p.punching, addresses: p.nat.addresses, remoteAddress: null, token: isServerRelay ? token : null, remoteToken: remotePayload.token }) } } _abort(h, error = ERROR.ABORTED) { if (!h.payload) { if (h.puncher) h.puncher.destroy() return null } const payload = h.payload.encrypt({ error, firewall: FIREWALL.UNKNOWN, round: h.round, connected: false, punching: false, addresses: null, remoteAddress: null, token: null, remoteToken: null }) if (h.puncher) h.puncher.destroy() return { socket: this.dht.socket, payload } } _relayConnection(hs, relayThrough, remotePayload, h) { this.dht.stats.relaying.attempts++ let isInitiator let publicKey let token if (relayThrough) { isInitiator = true publicKey = relayThrough token = hs.relayToken } else { isInitiator = false publicKey = remotePayload.relayThrough.publicKey token = remotePayload.relayThrough.token } hs.relayToken = token hs.relaySocket = this.dht.connect(publicKey) hs.relaySocket.setKeepAlive(this.relayKeepAlive) hs.relayClient = relay.Client.from(hs.relaySocket, { id: hs.relaySocket.publicKey }) hs.relayTimeout = setTimeout(onabort, 15000) hs.relayClient .pair(isInitiator, token, hs.rawStream) .on('error', onabort) .on('data', (remoteId) => { if (hs.relayTimeout) clearRelayTimeout(hs) if (hs.rawStream === null) { onabort(null) return } hs.relayPaired = true this.dht.stats.relaying.successes++ if (hs.prepunching) clearTimeout(hs.prepunching) hs.prepunching = null const { remotePort, remoteHost, socket } = hs.relaySocket.rawStream hs.rawStream .on('close', () => destroyRelayConnection(hs)) .connect(socket, remoteId, remotePort, remoteHost) hs.encryptedSocket = this.createSecretStream(false, hs.rawStream, { handshake: h, keepAlive: this.dht.connectionKeepAlive }) this.onconnection(hs.encryptedSocket) }) const dht = this.dht function onabort() { if (!hs.relayPaired) dht.stats.relaying.aborts++ destroyRelayConnection(hs) if (hs.aborted && hs.rawStream) hs.rawStream.destroy() } } } function isConsistent(fw) { return fw === FIREWALL.OPEN || fw === FIREWALL.CONSISTENT } function hasSameAddr(addrs, other) { if (addrs === null) return false for (const addr of addrs) { if (addr.port === other.port && addr.host === other.host) return true } return false } function defaultCreateHandshake(keyPair, remotePublicKey) { return new NoiseWrap(keyPair, remotePublicKey) } function defaultCreateSecretStream(isInitiator, rawStream, opts) { return new NoiseSecretStream(isInitiator, rawStream, opts) } function setupHolepuncher(dht, hs, remoteFirewall, onabort) { if (hs.puncher) return hs.puncher = new Holepuncher(dht, dht.session(), false, remoteFirewall) hs.puncher.onconnect = hs.onsocket hs.puncher.onabort = onabort } function isRelay(relaySocket, socket, port, host) { const stream = relaySocket.rawStream if (!stream) return false if (stream.socket !== socket) return false return port === stream.remotePort && host === stream.remoteHost } function selectRelay(relayThrough) { if (typeof relayThrough === 'function') relayThrough = relayThrough() if (relayThrough === null) return null if (Array.isArray(relayThrough)) { return relayThrough[Math.floor(Math.random() * relayThrough.length)] } return relayThrough } function noop() {} module.exports = class Sleeper { constructor() { this._timeout = null this._resolve = null this._start = (resolve) => { this._resolve = resolve } this._trigger = () => { if (this._resolve === null) return const resolve = this._resolve this._timeout = null this._resolve = null resolve() } } pause(ms) { const p = new Promise(this._start) if (this._timeout !== null) { clearTimeout(this._timeout) this._trigger() } this._timeout = setTimeout(this._trigger, ms) return p } resume() { if (this._timeout !== null) { clearTimeout(this._timeout) this._trigger() } } } const b4a = require('b4a') const LINGER_TIME = 3000 module.exports = class SocketPool { constructor(dht, host) { this._dht = dht this._sockets = new Map() this._lingering = new Set() // updated by the ref this._host = host this.routes = new SocketRoutes(this) this.stats = { socketsAdded: 0, socketsRemoved: 0 } } _onmessage(ref, data, address) { this._dht.onmessage(ref.socket, data, address) } _add(ref) { this._sockets.set(ref.socket, ref) this.stats.socketsAdded++ } _remove(ref) { const removed = this._sockets.delete(ref.socket) this._lingering.delete(ref) if (removed) this.stats.socketsRemoved++ } lookup(socket) { return this._sockets.get(socket) || null } setReusable(socket, bool) { const ref = this.lookup(socket) if (ref) ref.reusable = bool } acquire() { // TODO: Enable socket reuse return new SocketRef(this) } async destroy() { const closing = [] for (const ref of this._sockets.values()) { ref._unlinger() closing.push(ref.socket.close()) } await Promise.allSettled(closing) } } class SocketRoutes { constructor(pool) { this._pool = pool this._routes = new Map() } add(publicKey, rawStream) { if (rawStream.socket) this._onconnect(publicKey, rawStream) else rawStream.on('connect', this._onconnect.bind(this, publicKey, rawStream)) } get(publicKey) { const id = b4a.toString(publicKey, 'hex') const route = this._routes.get(id) if (!route) return null return route } _onconnect(publicKey, rawStream) { const id = b4a.toString(publicKey, 'hex') const socket = rawStream.socket let route = this._routes.get(id) if (!route) { const gc = () => { if (this._routes.get(id) === route) this._routes.delete(id) socket.removeListener('close', gc) } route = { socket, address: { host: rawStream.remoteHost, port: rawStream.remotePort }, gc } this._routes.set(id, route) socket.on('close', gc) } this._pool.setReusable(socket, true) rawStream.on('error', () => { this._pool.setReusable(socket, false) if (!route) route = this._routes.get(id) if (route && route.socket === socket) route.gc() }) } } // TODO: we should just make some "user data" object on udx to allow to attach this info class SocketRef { constructor(pool) { this._pool = pool // Events this.onholepunchmessage = noop // Whether it should teardown immediately or wait a bit this.reusable = false this.socket = pool._dht.udx.createSocket() this.socket .on('close', this._onclose.bind(this)) .on('message', this._onmessage.bind(this)) .on('idle', this._onidle.bind(this)) .on('busy', this._onbusy.bind(this)) .bind(0, this._pool._host) this._refs = 1 this._released = false this._closed = false this._timeout = null this._wasBusy = false this._pool._add(this) } _onclose() { this._pool._remove(this) } _onmessage(data, address) { if (data.byteLength > 1) { this._pool._onmessage(this, data, address) } else { this.onholepunchmessage(data, address, this) } } _onidle() { this._closeMaybe() } _onbusy() { this._wasBusy = true this._unlinger() } _reset() { this.onholepunchmessage = noop } _closeMaybe() { if (this._refs === 0 && this.socket.idle && !this._timeout) this._close() } _lingeringClose() { this._pool._lingering.delete(this) this._timeout = null this._closeMaybe() } _close() { this._unlinger() if (this.reusable && this._wasBusy) { this._wasBusy = false this._pool._lingering.add(this) this._timeout = setTimeout(this._lingeringClose.bind(this), LINGER_TIME) return } this._closed = true this.socket.close() } _unlinger() { if (this._timeout !== null) { clearTimeout(this._timeout) this._pool._lingering.delete(this) this._timeout = null } } get free() { return this._refs === 0 } active() { this._refs++ this._unlinger() } inactive() { this._refs-- this._closeMaybe() } address() { return this.socket.address() } release() { if (this._released) return this._released = true this._reset() this._refs-- this._closeMaybe() } } function noop() {} { "name": "hyperdht", "version": "6.34.0", "description": "The DHT powering Hyperswarm", "main": "index.js", "browser": "browser.js", "bin": { "hyperdht": "./bin.js" }, "files": [ "index.js", "browser.js", "testnet.js", "bin.js", "lib/**.js" ], "imports": { "events": { "bare": "bare-events", "default": "events" }, "child_process": { "bare": "bare-node-child-process", "default": "child_process" } }, "dependencies": { "@hyperswarm/secret-stream": "^6.6.2", "b4a": "^1.3.1", "bare-events": "^2.2.0", "blind-relay": "^1.3.0", "bogon": "^1.0.0", "compact-encoding": "^3.0.0", "dht-rpc": "^6.15.1", "hypercore-crypto": "^3.3.0", "hypercore-id-encoding": "^1.2.0", "hyperdht-address": "^1.0.1", "noise-curve-ed": "^2.0.0", "noise-handshake": "^4.0.0", "record-cache": "^1.1.1", "safety-catch": "^1.0.1", "signal-promise": "^1.0.3", "sodium-universal": "^5.0.1", "streamx": "^2.16.1", "unslab": "^1.3.0", "xache": "^1.1.0" }, "devDependencies": { "bare-node-child-process": "^1.0.1", "brittle": "^3.0.0", "graceful-goodbye": "^1.3.0", "newline-decoder": "^1.0.2", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "format": "prettier --write .", "test": "prettier --check . && node test/all.js", "test:bare": "bare test/all.js", "test:generate": "brittle -r test/all.js test/*.js", "integration": "brittle test/integration/*.js", "end-to-end": "brittle test/end-to-end/*.js" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "directories": { "lib": "lib", "test": "test" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/hyperdht.git" }, "keywords": [], "bugs": { "url": "https://github.com/holepunchto/hyperdht/issues" }, "homepage": "https://github.com/holepunchto/hyperdht#readme" } { "name": "hyperschema", "version": "1.23.0", "description": "Create registries of declarative compact-encoding schemas", "files": [ "lib/*.js", "builder.mjs", "builder.cjs", "builder.d.ts", "runtime.mjs", "runtime.cjs", "primitives.mjs", "primitives.cjs" ], "exports": { "./package": "./package.json", ".": { "types": "./builder.d.ts", "import": "./builder.mjs", "default": "./builder.cjs" }, "./runtime": { "import": "./runtime.mjs", "default": "./runtime.cjs" }, "./primitives": { "import": "./primitives.mjs", "default": "./primitives.cjs" } }, "imports": { "fs": { "bare": "bare-fs", "default": "fs" }, "path": { "bare": "bare-path", "default": "path" } }, "scripts": { "format": "prettier . --write", "test": "prettier . --check && brittle test/index.js", "test:bare": "prettier . --check && bare test/index.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/hyperschema.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/hyperschema/issues" }, "homepage": "https://github.com/holepunchto/hyperschema#readme", "dependencies": { "bare-fs": "^4.0.1", "compact-encoding": "^3.0.0", "generate-object-property": "^2.0.0", "generate-string": "^1.0.1" }, "devDependencies": { "brittle": "^3.7.0", "hyperschema-test": "^1.1.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "test-tmp": "^1.3.0" } } module.exports = { c: require('compact-encoding') } const { EventEmitter } = require('events') const { getStreamError } = require('streamx') const DHT = require('hyperdht') const spq = require('shuffled-priority-queue') const b4a = require('b4a') const unslab = require('unslab') const PeerInfo = require('./lib/peer-info') const RetryTimer = require('./lib/retry-timer') const ConnectionSet = require('./lib/connection-set') const PeerDiscovery = require('./lib/peer-discovery') const MAX_PEERS = 64 const MAX_PARALLEL = 3 const MAX_CLIENT_CONNECTIONS = Infinity // TODO: Change const MAX_SERVER_CONNECTIONS = Infinity const ERR_MISSING_TOPIC = 'Topic is required and must be a 32-byte buffer' const ERR_DESTROYED = 'Swarm has been destroyed' const ERR_DUPLICATE = 'Duplicate connection' const ERR_FIREWALL = 'Peer is firewalled' module.exports = class Hyperswarm extends EventEmitter { constructor(opts = {}) { super() const { seed, relayThrough, keyPair = DHT.keyPair(seed), maxPeers = MAX_PEERS, maxClientConnections = MAX_CLIENT_CONNECTIONS, maxServerConnections = MAX_SERVER_CONNECTIONS, maxParallel = MAX_PARALLEL, firewall = allowAll } = opts this.keyPair = keyPair this.dht = opts.dht || new DHT({ bootstrap: opts.bootstrap, nodes: opts.nodes, port: opts.port, deferRandomPunch: opts.deferRandomPunch, randomPunchInterval: opts.randomPunchInterval }) this.server = this.dht.createServer( { firewall: this._handleFirewall.bind(this), relayThrough: this._maybeRelayConnection.bind(this), handshakeClearWait: opts.handshakeClearWait }, this._handleServerConnection.bind(this) ) this.destroyed = false this.suspended = false this.maxPeers = maxPeers this.maxClientConnections = maxClientConnections this.maxServerConnections = maxServerConnections this.maxParallel = maxParallel this.relayThrough = relayThrough ? toRelayFunction(relayThrough) : null this.connecting = 0 this.connections = new Set() this.peers = new Map() this.explicitPeers = new Set() this.listening = null this.stats = { updates: 0, connects: { client: { opened: 0, closed: 0, attempted: 0 }, server: { // Note: there is no notion of 'attempts' for server connections opened: 0, closed: 0 } }, bannedPeers: 0 } this._discovery = new Map() this._timer = new RetryTimer(this._requeue.bind(this), { backoffs: opts.backoffs, jitter: opts.jitter }) this._queue = spq() this._allConnections = new ConnectionSet() this._pendingFlushes = [] this._flushTick = 0 this._drainingQueue = false this._clientConnections = 0 this._serverConnections = 0 this._firewall = firewall this.dht.on('network-change', this._handleNetworkChange.bind(this)) this.dht.on('network-update', this._handleNetworkUpdate.bind(this)) this.on('update', this._handleUpdate) } _maybeRelayConnection(force) { if (!this.relayThrough) return null return this.relayThrough(force, this) } _enqueue(peerInfo) { if (peerInfo.queued) return peerInfo.queued = true peerInfo._flushTick = this._flushTick this._queue.add(peerInfo) this._attemptClientConnections() } _requeue(batch) { if (this.suspended) return for (const peerInfo of batch) { peerInfo.waiting = false if ( peerInfo._updatePriority() === false || this._allConnections.has(peerInfo.publicKey) || peerInfo.queued ) { continue } peerInfo.queued = true peerInfo._flushTick = this._flushTick this._queue.add(peerInfo) } this._attemptClientConnections() } _flushMaybe(peerInfo) { for (let i = 0; i < this._pendingFlushes.length; i++) { const flush = this._pendingFlushes[i] if (peerInfo._flushTick > flush.tick) continue if (--flush.missing > 0) continue flush.onflush(true) this._pendingFlushes.splice(i--, 1) } } _withinMaxPeers() { const e = this.explicitPeers.size const factor = e === 0 ? 1 : e < 2 ? 2 : e < 4 ? 3 : 4 return factor * this._allConnections.size < this.maxPeers } _flushAllMaybe() { if ( this.connecting > 0 || (this._withinMaxPeers() && this._clientConnections < this.maxClientConnections) ) { return false } while (this._pendingFlushes.length) { const flush = this._pendingFlushes.pop() flush.onflush(true) } return true } _shouldConnectExplicit() { return !this.destroyed && !this.suspended && this.connecting < this.maxParallel } _shouldConnect() { return ( !this.destroyed && !this.suspended && this.connecting < this.maxParallel && this._withinMaxPeers() && this._clientConnections < this.maxClientConnections ) } _shouldRequeue(peerInfo) { if (this.suspended) return false if (peerInfo.explicit) return true for (const topic of peerInfo.topics) { if (this._discovery.has(b4a.toString(topic, 'hex')) && !this.destroyed) { return true } } return false } _connect(peerInfo, queued) { if (peerInfo.banned || this._allConnections.has(peerInfo.publicKey)) { if (queued) this._flushMaybe(peerInfo) return } // TODO: Support async firewalling at some point. if (this._handleFirewall(peerInfo.publicKey, null)) { if (queued) this._flushMaybe(peerInfo) return } const relayThrough = this._maybeRelayConnection(peerInfo.forceRelaying) const conn = this.dht.connect(peerInfo.publicKey, { relayAddresses: peerInfo.relayAddresses, keyPair: this.keyPair, relayThrough }) this._allConnections.add(conn) this.stats.connects.client.attempted++ this.connecting++ this._clientConnections++ let opened = false const onerror = (err) => { if (this.relayThrough && shouldForceRelaying(err.code)) { peerInfo.forceRelaying = true // Reset the attempts in order to fast connect to relay peerInfo.attempts = 0 } } // Removed once a connection is opened conn.on('error', onerror) conn.on('open', () => { opened = true this.stats.connects.client.opened++ this._connectDone() this.connections.add(conn) conn.removeListener('error', onerror) peerInfo._connected() peerInfo.client = true this.emit('connection', conn, peerInfo) if (queued) this._flushMaybe(peerInfo) this.emit('update') }) conn.on('close', () => { if (!opened) this._connectDone() this.stats.connects.client.closed++ const err = getStreamError(conn) if (shouldBan(err)) { this._banPeer(peerInfo, true, err) } this.connections.delete(conn) this._allConnections.delete(conn) this._clientConnections-- peerInfo._disconnected() peerInfo.waiting = this._shouldRequeue(peerInfo) && this._timer.add(peerInfo) this._maybeDeletePeer(peerInfo) if (!opened && queued) this._flushMaybe(peerInfo) this._attemptClientConnections() this.emit('update') }) this.emit('update') } _connectDone() { this.connecting-- if (this.connecting < this.maxParallel) this._attemptClientConnections() if (this.connecting === 0) this._flushAllMaybe() } // Called when the PeerQueue indicates a connection should be attempted. _attemptClientConnections() { // Guard against re-entries - unsure if it still needed but doesn't hurt if (this._drainingQueue || this.suspended) return this._drainingQueue = true for (const peerInfo of this.explicitPeers) { if (!this._shouldConnectExplicit()) break if ( peerInfo.attempts >= 5 || Date.now() - peerInfo.disconnectedTime < peerInfo.attempts * 1000 ) { continue } this._connect(peerInfo, false) } while (this._queue.length && this._shouldConnect()) { const peerInfo = this._queue.shift() peerInfo.queued = false this._connect(peerInfo, true) } this._drainingQueue = false if (this.connecting === 0) this._flushAllMaybe() } _handleFirewall(remotePublicKey, payload) { if (b4a.equals(remotePublicKey, this.keyPair.publicKey)) return true let peerInfo = this.peers.get(b4a.toString(remotePublicKey, 'hex')) if (peerInfo && peerInfo.banned) return true const firewalled = this._firewall(remotePublicKey, payload) if (firewalled) { if (!peerInfo) peerInfo = this._upsertPeer(remotePublicKey) this._banPeer(peerInfo, true, new Error(ERR_FIREWALL)) } return firewalled } _handleServerConnectionSwap(existing, conn) { let closed = false existing.on('close', () => { if (closed) return conn.removeListener('error', noop) conn.removeListener('close', onclose) this._handleServerConnection(conn) }) conn.on('error', noop) conn.on('close', onclose) function onclose() { closed = true } } // Called when the DHT receives a new server connection. _handleServerConnection(conn) { if (this.destroyed || this.suspended) { // TODO: Investigate why a final server connection can be received after close conn.on('error', noop) return conn.destroy(ERR_DESTROYED) } const existing = this._allConnections.get(conn.remotePublicKey) if (existing) { // If both connections are from the same peer, // - pick the new one if the existing stream is already established (has sent and received bytes), // because the other client must have lost that connection and be reconnecting // - otherwise, pick the one thats expected to initiate in a tie break const existingIsOutdated = existing.rawBytesRead > 0 && existing.rawBytesWritten > 0 const expectedInitiator = b4a.compare(conn.publicKey, conn.remotePublicKey) > 0 const keepNew = existingIsOutdated || expectedInitiator === conn.isInitiator if (keepNew === false) { existing.sendKeepAlive() conn.on('error', noop) conn.destroy(new Error(ERR_DUPLICATE)) return } existing.on('error', noop) existing.destroy(new Error(ERR_DUPLICATE)) this._handleServerConnectionSwap(existing, conn) return } // When reaching here, the connection will always be 'opened' next tick this.stats.connects.server.opened++ const peerInfo = this._upsertPeer(conn.remotePublicKey, null) this.connections.add(conn) this._allConnections.add(conn) this._serverConnections++ conn.on('close', () => { const err = getStreamError(conn) if (shouldBan(err)) { this._banPeer(peerInfo, true, err) } this.connections.delete(conn) this._allConnections.delete(conn) this._serverConnections-- this.stats.connects.server.closed++ this._maybeDeletePeer(peerInfo) this._attemptClientConnections() this.emit('update') }) peerInfo.client = false this.emit('connection', conn, peerInfo) this.emit('update') } _upsertPeer(publicKey, relayAddresses) { if (b4a.equals(publicKey, this.keyPair.publicKey)) return null const keyString = b4a.toString(publicKey, 'hex') let peerInfo = this.peers.get(keyString) if (peerInfo) { peerInfo.relayAddresses = relayAddresses // new is always better return peerInfo } peerInfo = new PeerInfo({ publicKey, relayAddresses }) this.peers.set(keyString, peerInfo) return peerInfo } _handleUpdate() { this.stats.updates++ } _maybeDeletePeer(peerInfo) { if (!peerInfo.shouldGC()) return const hasActiveConn = this._allConnections.has(peerInfo.publicKey) if (hasActiveConn) return const keyString = b4a.toString(peerInfo.publicKey, 'hex') this.peers.delete(keyString) } /* * Called when a peer is actively discovered during a lookup. * * Three conditions: * 1. Not a known peer -- insert into queue * 2. A known peer with normal priority -- do nothing * 3. A known peer with low priority -- bump priority, because it's been rediscovered */ _handlePeer(peer, topic) { const peerInfo = this._upsertPeer(peer.publicKey, peer.relayAddresses) if (peerInfo) peerInfo._topic(topic) if (!peerInfo || this._allConnections.has(peer.publicKey)) return if (!peerInfo.prioritized || peerInfo.server) peerInfo._reset() if (peerInfo._updatePriority()) { this._enqueue(peerInfo) } } async _handleNetworkUpdate() { if (!this.online) return this._handleNetworkChange() } async _handleNetworkChange() { if (this.suspended) return // prioritize figuring out if existing connections are dead for (const conn of this._allConnections) { conn.sendKeepAlive() } const refreshes = [] for (const discovery of this._discovery.values()) { refreshes.push(discovery.refresh()) } await Promise.allSettled(refreshes) } _banPeer(peerInfo, banned, err) { peerInfo.ban(banned) this.stats.bannedPeers++ this.emit('ban', peerInfo, err) } status(key) { return this._discovery.get(b4a.toString(key, 'hex')) || null } listen() { if (!this.listening) { if (this.destroyed) throw new Error('Swarm destroyed') this.listening = this.server.listen(this.keyPair) } return this.listening } // Object that exposes a cancellation method (destroy) // TODO: When you rejoin, it should reannounce + bump lookup priority join(topic, opts = {}) { if (this.destroyed) throw new Error('Swarm destroyed') if (!topic) throw new Error(ERR_MISSING_TOPIC) topic = unslab(topic) const topicString = b4a.toString(topic, 'hex') let discovery = this._discovery.get(topicString) if (discovery && !discovery.destroyed) { return discovery.session(opts) } discovery = new PeerDiscovery(this, topic, { limit: opts.limit, wait: discovery ? discovery.destroy() : null, suspended: this.suspended, onpeer: (peer) => this._handlePeer(peer, topic) }) this._discovery.set(topicString, discovery) return discovery.session(opts) } // Returns a promise async leave(topic) { if (!topic) throw new Error(ERR_MISSING_TOPIC) const topicString = b4a.toString(topic, 'hex') if (!this._discovery.has(topicString)) return Promise.resolve() const discovery = this._discovery.get(topicString) try { await discovery.destroy() } catch { // ignore, prop network } if (this._discovery.get(topicString) === discovery) { this._discovery.delete(topicString) } } joinPeer(publicKey) { const peerInfo = this._upsertPeer(publicKey, null) if (!peerInfo) return if (!this.explicitPeers.has(peerInfo)) { peerInfo.explicit = true this.explicitPeers.add(peerInfo) } if (this._allConnections.has(publicKey)) return if (peerInfo._updatePriority()) { this._enqueue(peerInfo) } } leavePeer(publicKey) { const keyString = b4a.toString(publicKey, 'hex') if (!this.peers.has(keyString)) return const peerInfo = this.peers.get(keyString) peerInfo.explicit = false this.explicitPeers.delete(peerInfo) this._maybeDeletePeer(peerInfo) } // Returns a promise async flush() { const allFlushed = [...this._discovery.values()].map((v) => v.flushed()) await Promise.all(allFlushed) if (this._flushAllMaybe()) return true const pendingSize = this._allConnections.size - this.connections.size if (!this._queue.length && !pendingSize) return true return new Promise((resolve) => { this._pendingFlushes.push({ onflush: resolve, missing: this._queue.length + pendingSize, tick: this._flushTick++ }) }) } async clear() { const cleared = Promise.allSettled([...this._discovery.values()].map((d) => d.destroy())) this._discovery.clear() return cleared } async destroy({ force } = {}) { if (this.destroyed && !force) return this.destroyed = true this._timer.destroy() if (!force) await this.clear() await this.server.close() while (this._pendingFlushes.length) { const flush = this._pendingFlushes.pop() flush.onflush(false) } await this.dht.destroy({ force }) } async suspend({ log = noop } = {}) { if (this.suspended) return const promises = [] promises.push(this.server.suspend({ log })) for (const discovery of this._discovery.values()) { promises.push(discovery.suspend({ log })) } const pending = [] for (const connection of this._allConnections) { connection.destroy() pending.push(new Promise((resolve) => connection.on('close', resolve))) } this.suspended = true log('Suspending server and discovery... (' + promises.length + ')') await Promise.allSettled(promises) log('Done, suspending the dht...') await this.dht.suspend({ log }) log('Done, swarm fully suspended') await Promise.all(pending) // reset queue this._timer.destroy() this._timer = new RetryTimer(this._requeue.bind(this), { backoffs: this._timer.backoffs, jitter: this._timer.jitter }) this._queue = spq() } async resume({ log = noop } = {}) { if (!this.suspended) return log('Resuming the dht') await this.dht.resume() log('Done, resuming the server') await this.server.resume() log('Done, all discovery') for (const discovery of this._discovery.values()) { discovery.resume() } this.suspended = false this._attemptClientConnections() } topics() { return this._discovery.values() } } function noop() {} function allowAll() { return false } function shouldForceRelaying(code) { return ( code === 'HOLEPUNCH_ABORTED' || code === 'HOLEPUNCH_DOUBLE_RANDOMIZED_NATS' || code === 'REMOTE_NOT_HOLEPUNCHABLE' ) } function shouldBan() { // return !!err && err.name === 'HypercoreError' && err.code === 'INVALID_OPERATION' return false } function toRelayFunction(relayThrough) { return typeof relayThrough === 'function' ? relayThrough : (force, swarm) => (force || swarm.dht.randomized ? relayThrough : null) } module.exports = class BulkTimer { constructor(time, fn) { this._time = time this._fn = fn this._interval = null this._next = [] this._pending = [] this._destroyed = false } destroy() { if (this._destroyed) return this._destroyed = true clearInterval(this._interval) this._interval = null } _ontick() { if (!this._next.length && !this._pending.length) return if (this._next.length) this._fn(this._next) this._next = this._pending this._pending = [] } add(info) { if (this._destroyed) return if (!this._interval) { this._interval = setInterval(this._ontick.bind(this), Math.floor(this._time * 0.66)) } this._pending.push(info) } } const b4a = require('b4a') module.exports = class ConnectionSet { constructor() { this._byPublicKey = new Map() } [Symbol.iterator]() { return this._byPublicKey.values() } get size() { return this._byPublicKey.size } has(publicKey) { return this._byPublicKey.has(toHex(publicKey)) } get(publicKey) { return this._byPublicKey.get(toHex(publicKey)) } add(connection) { this._byPublicKey.set(b4a.toString(connection.remotePublicKey, 'hex'), connection) } delete(connection) { const keyString = b4a.toString(connection.remotePublicKey, 'hex') const existing = this._byPublicKey.get(keyString) if (existing !== connection) return this._byPublicKey.delete(keyString) } } function toHex(b) { return typeof b === 'string' ? b : b4a.toString(b, 'hex') } const safetyCatch = require('safety-catch') const b4a = require('b4a') const REFRESH_INTERVAL = 1000 * 60 * 10 // 10 min const RANDOM_JITTER = 1000 * 60 * 2 // 2 min const DELAY_GRACE_PERIOD = 1000 * 30 // 30s const MAX_DISCOVERY_CACHE = 64 module.exports = class PeerDiscovery { constructor( swarm, topic, { limit = Infinity, wait = null, suspended = false, onpeer = noop, onerror = safetyCatch } ) { this.limit = limit this.swarm = swarm this.topic = topic this.isClient = false this.isServer = false this.destroyed = false this.destroying = null this.suspended = suspended this._sessions = [] this._clientSessions = 0 this._serverSessions = 0 this._onpeer = onpeer this._onerror = onerror this._discovered = new Set() this._activeQuery = null this._timer = null this._currentRefresh = null this._closestNodes = null this._firstAnnounce = true this._needsUnannounce = false this._refreshes = 0 this._wait = wait } session({ server = true, client = true, limit = Infinity, onerror = safetyCatch }) { if (this.destroyed) throw new Error('PeerDiscovery is destroyed') const session = new PeerDiscoverySession(this) session.refresh({ server, client, limit }).catch(onerror) this._sessions.push(session) return session } _refreshLater(eager) { const jitter = Math.round(Math.random() * RANDOM_JITTER) const delay = !eager ? REFRESH_INTERVAL + jitter : jitter if (this._timer) clearTimeout(this._timer) const startTime = Date.now() this._timer = setTimeout(() => { // If your laptop went to sleep, and is coming back online... const overdue = Date.now() - startTime > delay + DELAY_GRACE_PERIOD if (overdue) this._refreshLater(true) else this.refresh().catch(this._onerror) }, delay) } _isActive() { return !this.destroyed && !this.suspended } // TODO: Allow announce to be an argument to this // TODO: Maybe announce should be a setter? async _refresh() { if (this.suspended) return const clock = ++this._refreshes if (this._wait) { await this._wait this._wait = null if (clock !== this._refreshes || !this._isActive()) return } const clear = this.isServer && this._firstAnnounce if (clear) this._firstAnnounce = false const opts = { clear, closestNodes: this._closestNodes } if (this.isServer) { await this.swarm.listen() // if a parallel refresh is happening, yield to the new one if (clock !== this._refreshes || !this._isActive()) return this._needsUnannounce = true } let limit = this.limit if (limit < Infinity && limit > 0) { for (const id of this._discovered) { if (!this.swarm.connections.has(id)) continue if (--limit === 0) break } } this._discovered.clear() const announcing = this.isServer const query = (this._activeQuery = announcing ? this.swarm.dht.announce( this.topic, this.swarm.keyPair, this.swarm.server.relayAddresses, opts ) : this._needsUnannounce ? this.swarm.dht.lookupAndUnannounce(this.topic, this.swarm.keyPair, opts) : this.swarm.dht.lookup(this.topic, opts)) try { for await (const data of this._activeQuery) { if (!this.isClient || !this._isActive()) continue for (const peer of data.peers) { if (limit < Infinity) { const id = b4a.toString(peer.publicKey, 'hex') if (this._discovered.size < MAX_DISCOVERY_CACHE) { this._discovered.add(id) } if (limit === 0) continue // there is a chance it has updated a connection during discovery and we go over // the limit - thats acceptable to avoid a complexity spiral here. if (!this.swarm.connections.has(id)) limit-- } this._onpeer(peer, data) } } } catch (err) { if (this._isActive()) throw err } finally { if (this._activeQuery === query) { this._activeQuery = null if (!this.destroyed && !this.suspended) this._refreshLater(false) } } // This is set at the very end, when the query completes successfully. this._closestNodes = query.closestNodes if (clock !== this._refreshes) return // In this is the latest query, unannounce has been fulfilled as well if (!announcing) this._needsUnannounce = false } async refresh() { if (this.destroyed) throw new Error('PeerDiscovery is destroyed') const server = this._serverSessions > 0 const client = this._clientSessions > 0 if (this.suspended) return if (server === this.isServer && client === this.isClient) { if (this._currentRefresh) return this._currentRefresh this._currentRefresh = this._refresh() } else { if (this._activeQuery) this._activeQuery.destroy() this.isServer = server this.isClient = client this._currentRefresh = this._refresh() } const refresh = this._currentRefresh try { await refresh } catch { return false } finally { if (refresh === this._currentRefresh) { this._currentRefresh = null } } return true } async flushed() { if (this.swarm.listening) await this.swarm.listening try { await this._currentRefresh return true } catch { return false } } async _destroyMaybe() { if (this.destroyed) return try { if (this._sessions.length === 0) await this.swarm.leave(this.topic) else if (this._serverSessions === 0 && this._needsUnannounce) await this.refresh() } catch (err) { // ignore network failures here, as we are tearing down safetyCatch(err) } } destroy() { if (this.destroying) return this.destroying this.destroying = this._destroy() return this.destroying } async _abort(log) { const id = log === noop ? '' : b4a.toString(this.topic, 'hex') log('Aborting discovery', id) if (this._wait) await this._wait log('Aborting discovery (post wait)', id) if (this._activeQuery) { this._activeQuery.destroy() this._activeQuery = null } if (this._timer) { clearTimeout(this._timer) this._timer = null } let nodes = this._closestNodes if (this._currentRefresh) { try { await this._currentRefresh } catch { // If the destroy causes the refresh to fail, suppress it. } } log('Aborting discovery (post refresh)', id) if (this._isActive()) return if (!nodes) nodes = this._closestNodes else if (this._closestNodes !== nodes) { const len = nodes.length for (const newer of this._closestNodes) { if (newer.id && !hasNode(nodes, len, newer)) nodes.push(newer) } } if (this._needsUnannounce) { log('Unannouncing discovery', id) if (nodes && nodes.length) { await this.swarm.dht.unannounce(this.topic, this.swarm.keyPair, { closestNodes: nodes, onlyClosestNodes: true, force: true }) } this._needsUnannounce = false log('Unannouncing discovery (done)', id) } } _destroy() { if (this.destroyed) return this.destroyed = true return this._abort(noop) } async suspend({ log = noop } = {}) { if (this.suspended) return this.suspended = true try { await this._abort(log) } catch { // ignore } } resume() { if (!this.suspended) return this.suspended = false this.refresh().catch(noop) } } class PeerDiscoverySession { constructor(discovery) { this.discovery = discovery this.isClient = false this.isServer = false this.destroyed = false } get swarm() { return this.discovery.swarm } get topic() { return this.discovery.topic } async refresh({ client = this.isClient, server = this.isServer, limit = Infinity } = {}) { if (this.destroyed) throw new Error('PeerDiscovery is destroyed') if (!client && !server) throw new Error('Cannot refresh with neither client nor server option') if (client !== this.isClient) { this.isClient = client this.discovery._clientSessions += client ? 1 : -1 } if (server !== this.isServer) { this.isServer = server this.discovery._serverSessions += server ? 1 : -1 } this.discovery.limit = limit return this.discovery.refresh() } async flushed() { return this.discovery.flushed() } async destroy() { if (this.destroyed) return this.destroyed = true if (this.isClient) this.discovery._clientSessions-- if (this.isServer) this.discovery._serverSessions-- const index = this.discovery._sessions.indexOf(this) const head = this.discovery._sessions.pop() if (head !== this) this.discovery._sessions[index] = head return this.discovery._destroyMaybe() } } function hasNode(nodes, len, node) { for (let i = 0; i < len; i++) { const existing = nodes[i] if (existing.id && b4a.equals(existing.id, node.id)) return true } return false } function noop() {} const { EventEmitter } = require('events') const b4a = require('b4a') const unslab = require('unslab') const MIN_CONNECTION_TIME = 15000 const VERY_LOW_PRIORITY = 0 const LOW_PRIORITY = 1 const NORMAL_PRIORITY = 2 const HIGH_PRIORITY = 3 const VERY_HIGH_PRIORITY = 4 module.exports = class PeerInfo extends EventEmitter { constructor({ publicKey, relayAddresses }) { super() this.publicKey = unslab(publicKey) this.relayAddresses = relayAddresses this.reconnecting = true this.proven = false this.connectedTime = -1 this.disconnectedTime = 0 this.banned = false this.tried = false this.explicit = false this.waiting = false this.forceRelaying = false // Set by the Swarm this.queued = false this.client = false this.topics = [] // TODO: remove on next major (check with mafintosh for context) this.attempts = 0 this.priority = NORMAL_PRIORITY // Used by shuffled-priority-queue this._index = 0 // Used for flush management this._flushTick = 0 // Used for topic multiplexing this._seenTopics = new Set() } get server() { return !this.client } get prioritized() { return this.priority >= NORMAL_PRIORITY } _getPriority() { const peerIsStale = this.tried && !this.proven if (peerIsStale || this.attempts > 3) return VERY_LOW_PRIORITY if (this.attempts === 3) return LOW_PRIORITY if (this.attempts === 2) return HIGH_PRIORITY if (this.attempts === 1) return VERY_HIGH_PRIORITY return NORMAL_PRIORITY } _connected() { this.proven = true this.connectedTime = Date.now() } _disconnected() { this.disconnectedTime = Date.now() if (this.connectedTime > -1) { if (this.disconnectedTime - this.connectedTime >= MIN_CONNECTION_TIME) this.attempts = 0 // fast retry this.connectedTime = -1 } this.attempts++ } _deprioritize() { this.attempts = 3 } _reset() { this.client = false this.proven = false this.tried = false this.attempts = 0 } _updatePriority() { if (this.explicit && this.attempts > 3) this._deprioritize() if (this.banned || this.queued || this.attempts > 3) return false this.priority = this._getPriority() return true } _topic(topic) { const topicString = b4a.toString(topic, 'hex') if (this._seenTopics.has(topicString)) return this._seenTopics.add(topicString) this.topics.push(topic) this.emit('topic', topic) } reconnect(val) { this.reconnecting = !!val } ban(val) { this.banned = !!val } shouldGC() { return !(this.banned || this.queued || this.explicit || this.waiting) } } const BulkTimer = require('./bulk-timer') const BACKOFF_JITTER = 500 const BACKOFF_S = 1000 + Math.round(BACKOFF_JITTER * Math.random()) const BACKOFF_M = 5000 + Math.round(2 * BACKOFF_JITTER * Math.random()) const BACKOFF_L = 15000 + Math.round(4 * BACKOFF_JITTER * Math.random()) const BACKOFF_X = 1000 * 60 * 10 + Math.round(240 * BACKOFF_JITTER * Math.random()) module.exports = class RetryTimer { constructor( push, { backoffs = [BACKOFF_S, BACKOFF_M, BACKOFF_L, BACKOFF_X], jitter = BACKOFF_JITTER } = {} ) { this.jitter = jitter this.backoffs = backoffs this._sTimer = new BulkTimer(backoffs[0] + Math.round(jitter * Math.random()), push) this._mTimer = new BulkTimer(backoffs[1] + Math.round(jitter * Math.random()), push) this._lTimer = new BulkTimer(backoffs[2] + Math.round(jitter * Math.random()), push) this._xTimer = new BulkTimer(backoffs[3] + Math.round(jitter * Math.random()), push) } _selectRetryTimer(peerInfo) { if (peerInfo.banned || !peerInfo.reconnecting) return null if (peerInfo.attempts > 3) { return peerInfo.explicit ? this._xTimer : null } if (peerInfo.attempts === 0) return this._sTimer if (peerInfo.proven) { switch (peerInfo.attempts) { case 1: return this._sTimer case 2: return this._mTimer case 3: return this._lTimer } } else { switch (peerInfo.attempts) { case 1: return this._mTimer case 2: return this._lTimer case 3: return this._lTimer } } return null } add(peerInfo) { const timer = this._selectRetryTimer(peerInfo) if (!timer) return false timer.add(peerInfo) return true } destroy() { this._sTimer.destroy() this._mTimer.destroy() this._lTimer.destroy() this._xTimer.destroy() } } { "name": "hyperswarm", "version": "4.17.0", "description": "A distributed networking stack for connecting peers", "files": [ "index.js", "lib/**.js" ], "imports": { "events": { "bare": "bare-events", "default": "events" }, "process": { "bare": "bare-process", "default": "process" } }, "dependencies": { "b4a": "^1.3.1", "bare-events": "^2.2.0", "hyperdht": "^6.21.0", "safety-catch": "^1.0.2", "shuffled-priority-queue": "^2.1.0", "streamx": "^2.22.1", "unslab": "^1.3.0" }, "devDependencies": { "bare-process": "^4.2.2", "brittle": "^3.0.2", "hypercore-crypto": "^3.4.0", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "which-runtime": "^1.3.2" }, "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:generate": "brittle -r test/all.js test/*.js", "test:node": "brittle-node --coverage test/*.js", "test:bare": "bare test/all.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/hyperswarm.git" }, "author": "Mathias Buus (@mafintosh)", "contributors": [ "David Mark Clements (@davidmarkclem)", "Andrew Osheroff (@andrewosh)" ], "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/hyperswarm/issues" }, "homepage": "https://github.com/holepunchto/hyperswarm" } const { EventEmitter } = require('events') module.exports = class RoutingTable extends EventEmitter { constructor (id, opts) { if (!opts) opts = {} super() this.id = id this.k = opts.k || 20 this.size = 0 this.rows = new Array(id.length * 8) } add (node) { const i = this._diff(node.id) let row = this.rows[i] if (!row) { row = this.rows[i] = new Row(this, i) this.emit('row', row) } const len = row.nodes.length if (!row.add(node, this.k)) return false this.size += row.nodes.length - len return true } remove (id) { const i = this._diff(id) const row = this.rows[i] if (!row) return false if (!row.remove(id)) return false this.size-- return true } get (id) { const i = this._diff(id) const row = this.rows[i] if (!row) return null return row.get(id) } has (id) { return this.get(id) !== null } random () { let n = (Math.random() * this.size) | 0 for (let i = 0; i < this.rows.length; i++) { const r = this.rows[i] if (!r) continue if (n < r.nodes.length) return r.nodes[n] n -= r.nodes.length } return null } closest (id, k) { if (!k) k = this.k const result = [] const d = this._diff(id) // push close nodes for (let i = d; i >= 0 && result.length < k; i--) this._pushNodes(i, k, result) // if we don't have enough close nodes, populate from other rows, re the paper for (let i = d + 1; i < this.rows.length && result.length < k; i++) this._pushNodes(i, k, result) return result } _pushNodes (i, k, result) { const row = this.rows[i] if (!row) return const missing = Math.min(k - result.length, row.nodes.length) for (let j = 0; j < missing; j++) result.push(row.nodes[j]) } toArray () { return this.closest(this.id, Infinity) } _diff (id) { for (let i = 0; i < id.length; i++) { const a = id[i] const b = this.id[i] if (a !== b) return i * 8 + Math.clz32(a ^ b) - 24 } return this.rows.length - 1 } } class Row extends EventEmitter { constructor (table, index) { super() this.data = null // can be used be upstream for whatevs this.byteOffset = index >> 3 this.index = index this.table = table this.nodes = [] } add (node) { const id = node.id let l = 0 let r = this.nodes.length - 1 while (l <= r) { const m = (l + r) >> 1 const c = this.compare(id, this.nodes[m].id) if (c === 0) { this.nodes[m] = node return true } if (c < 0) r = m - 1 else l = m + 1 } if (this.nodes.length >= this.table.k) { this.emit('full', node) return false } this.insert(l, node) return true } remove (id) { let l = 0 let r = this.nodes.length - 1 while (l <= r) { const m = (l + r) >> 1 const c = this.compare(id, this.nodes[m].id) if (c === 0) { this.splice(m) return true } if (c < 0) r = m - 1 else l = m + 1 } return false } get (id) { let l = 0 let r = this.nodes.length - 1 while (l <= r) { const m = (l + r) >> 1 const node = this.nodes[m] const c = this.compare(id, node.id) if (c === 0) return node if (c < 0) r = m - 1 else l = m + 1 } return null } insert (i, node) { this.nodes.push(node) // push node or null or whatevs, just trying to not be polymorphic for (let j = this.nodes.length - 1; j > i; j--) this.nodes[j] = this.nodes[j - 1] this.nodes[i] = node this.emit('add', node) } splice (i) { for (; i < this.nodes.length - 1; i++) this.nodes[i] = this.nodes[i + 1] this.emit('remove', this.nodes.pop()) } // very likely they diverge after a couple of bytes so a simple impl, like this is prop fastest vs Buffer.compare compare (a, b) { for (let i = this.byteOffset; i < a.length; i++) { const ai = a[i] const bi = b[i] if (ai === bi) continue return ai < bi ? -1 : 1 } return 0 } } { "name": "kademlia-routing-table", "version": "1.0.6", "description": "XOR based routing table used for P2P networks such as a Kademlia DHT.", "main": "index.js", "files": [ "index.js" ], "imports": { "events": { "bare": "bare-events", "default": "events" } }, "dependencies": { "bare-events": "^2.2.0" }, "devDependencies": { "brittle": "^3.3.2", "standard": "^17.1.0" }, "scripts": { "test": "standard && brittle test.js" }, "keywords": [ "kademlia", "p2p", "k-bucket", "k-buckets", "xor", "routing", "distributed", "systems" ], "repository": { "type": "git", "url": "https://github.com/mafintosh/kademlia-routing-table.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/kademlia-routing-table/issues" }, "homepage": "https://github.com/mafintosh/kademlia-routing-table" } module.exports = assert class AssertionError extends Error {} AssertionError.prototype.name = 'AssertionError' /** * Minimal assert function * @param {any} t Value to check if falsy * @param {string=} m Optional assertion error message * @throws {AssertionError} */ function assert (t, m) { if (!t) { var err = new AssertionError(m) if (Error.captureStackTrace) Error.captureStackTrace(err, assert) throw err } } { "name": "nanoassert", "version": "2.0.0", "description": "Nanoscale assertion module", "main": "index.js", "dependencies": {}, "devDependencies": { "tape": "^4.9.1" }, "scripts": { "test": "tape test.js" }, "repository": { "type": "git", "url": "git+https://github.com/emilbayes/nanoassert.git" }, "keywords": [ "assert", "unassert", "power-assert", "tiny", "nano", "pico" ], "author": "Emil Bay ", "license": "ISC", "bugs": { "url": "https://github.com/emilbayes/nanoassert/issues" }, "homepage": "https://github.com/emilbayes/nanoassert#readme" } module.exports = class NatSampler { constructor () { this.host = null this.port = 0 this.size = 0 this._a = null this._b = null this._threshold = 0 this._top = 0 this._samples = [] } add (host, port) { const a = this._bump(host, port, 2) const b = this._bump(host, 0, 1) if (this._samples.length < 32) { this.size++ this._threshold = this.size - (this.size < 4 ? 0 : this.size < 8 ? 1 : this.size < 12 ? 2 : 3) this._samples.push(a, b) this._top += 2 } else { if (this._top === 32) this._top = 0 const oa = this._samples[this._top] this._samples[this._top++] = a oa.hits-- const ob = this._samples[this._top] this._samples[this._top++] = b ob.hits-- } if (this._a === null || this._a.hits < a.hits) this._a = a if (this._b === null || this._b.hits < b.hits) this._b = b if (this._a.hits >= this._threshold) { this.host = this._a.host this.port = this._a.port } else if (this._b.hits >= this._threshold) { this.host = this._b.host this.port = 0 } else { this.host = null this.port = 0 } return a.hits } _bump (host, port, inc) { for (let i = 0; i < 4; i++) { const j = (this._top - inc - (2 * i)) & 31 if (j >= this._samples.length) return { host, port, hits: 1 } const s = this._samples[j] if (s.port === port && s.host === host) { s.hits++ return s } } return { host, port, hits: 1 } } } { "name": "nat-sampler", "version": "1.0.1", "description": "Sample addresses to figure out if a host + port is consistent", "main": "index.js", "dependencies": {}, "devDependencies": { "standard": "^16.0.3", "tape": "^5.2.2" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/nat-sampler.git" }, "scripts": { "test": "standard && tape test.js" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/nat-sampler/issues" }, "homepage": "https://github.com/mafintosh/nat-sampler" } /* eslint-disable camelcase */ const sodium = require('sodium-universal') const assert = require('nanoassert') const b4a = require('b4a') const DHLEN = sodium.crypto_scalarmult_ed25519_BYTES const PKLEN = sodium.crypto_scalarmult_ed25519_BYTES const SCALARLEN = sodium.crypto_scalarmult_ed25519_BYTES const SKLEN = sodium.crypto_sign_SECRETKEYBYTES const ALG = 'Ed25519' module.exports = { DHLEN, PKLEN, SCALARLEN, SKLEN, ALG, name: ALG, generateKeyPair, dh } function generateKeyPair (privKey) { if (privKey) return generateSeedKeyPair(privKey.subarray(0, 32)) const keyPair = {} keyPair.secretKey = b4a.alloc(SKLEN) keyPair.publicKey = b4a.alloc(PKLEN) sodium.crypto_sign_keypair(keyPair.publicKey, keyPair.secretKey) return keyPair } function generateSeedKeyPair (seed) { const keyPair = {} keyPair.secretKey = b4a.alloc(SKLEN) keyPair.publicKey = b4a.alloc(PKLEN) sodium.crypto_sign_seed_keypair(keyPair.publicKey, keyPair.secretKey, seed) return keyPair } function dh (publicKey, { scalar, secretKey }) { // tweaked keys expose scalar directly if (!scalar) { assert(secretKey.byteLength === SKLEN) // libsodium stores seed not actual scalar const sk = b4a.alloc(64) sodium.crypto_hash_sha512(sk, secretKey.subarray(0, 32)) sk[0] &= 248 sk[31] &= 127 sk[31] |= 64 scalar = sk.subarray(0, 32) } assert(scalar.byteLength === SCALARLEN) assert(publicKey.byteLength === PKLEN) const output = b4a.alloc(DHLEN) // we clamp if necessary above sodium.crypto_scalarmult_ed25519_noclamp( output, scalar, publicKey ) return output } { "name": "noise-curve-ed", "version": "2.1.0", "description": "Ed25519 elliptic curve operations for [`noise-handshake`](https://github.com/chm-diederichs/noise-handshake)", "main": "index.js", "scripts": { "test": "npx standard && tape test.js" }, "repository": { "type": "git", "url": "git+https://github.com/chm-diederichs/noise-curve-ed.git" }, "keywords": [], "author": "", "license": "ISC", "bugs": { "url": "https://github.com/chm-diederichs/noise-curve-ed/issues" }, "homepage": "https://github.com/chm-diederichs/noise-curve-ed#readme", "dependencies": { "b4a": "^1.1.0", "nanoassert": "^2.0.0", "sodium-universal": "^5.0.0" }, "devDependencies": { "noise-handshake": "^3.0.0", "standard": "^16.0.3", "tape": "^5.2.2" } } const sodium = require('sodium-universal') const b4a = require('b4a') module.exports = class CipherState { constructor (key) { this.key = key || null this.nonce = 0 this.CIPHER_ALG = 'ChaChaPoly' } initialiseKey (key) { this.key = key this.nonce = 0 } setNonce (nonce) { this.nonce = nonce } encrypt (plaintext, ad) { if (!this.hasKey) return plaintext if (!ad) ad = b4a.alloc(0) const ciphertext = encryptWithAD(this.key, this.nonce, ad, plaintext) if (ciphertext.length > 65535) throw new Error(`ciphertext length of ${ciphertext.length} exceeds maximum Noise message length of 65535`) this.nonce++ return ciphertext } decrypt (ciphertext, ad) { if (!this.hasKey) return ciphertext if (!ad) ad = b4a.alloc(0) if (ciphertext.length > 65535) throw new Error(`ciphertext length of ${ciphertext.length} exceeds maximum Noise message length of 65535`) const plaintext = decryptWithAD(this.key, this.nonce, ad, ciphertext) this.nonce++ return plaintext } get hasKey () { return this.key !== null } _clear () { sodium.sodium_memzero(this.key) this.key = null this.nonce = null } static get MACBYTES () { return 16 } static get NONCEBYTES () { return 8 } static get KEYBYTES () { return 32 } } function encryptWithAD (key, counter, additionalData, plaintext) { // for our purposes, additionalData will always be a pubkey so we encode from hex if (!b4a.isBuffer(additionalData)) additionalData = b4a.from(additionalData, 'hex') if (!b4a.isBuffer(plaintext)) plaintext = b4a.from(plaintext, 'hex') const nonce = b4a.alloc(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES) const view = new DataView(nonce.buffer, nonce.byteOffset, nonce.byteLength) view.setUint32(4, counter, true) const ciphertext = b4a.alloc(plaintext.byteLength + sodium.crypto_aead_chacha20poly1305_ietf_ABYTES) sodium.crypto_aead_chacha20poly1305_ietf_encrypt(ciphertext, plaintext, additionalData, null, nonce, key) return ciphertext } function decryptWithAD (key, counter, additionalData, ciphertext) { // for our purposes, additionalData will always be a pubkey so we encode from hex if (!b4a.isBuffer(additionalData)) additionalData = b4a.from(additionalData, 'hex') if (!b4a.isBuffer(ciphertext)) ciphertext = b4a.from(ciphertext, 'hex') const nonce = b4a.alloc(sodium.crypto_aead_chacha20poly1305_ietf_NPUBBYTES) const view = new DataView(nonce.buffer, nonce.byteOffset, nonce.byteLength) view.setUint32(4, counter, true) const plaintext = b4a.alloc(ciphertext.byteLength - sodium.crypto_aead_chacha20poly1305_ietf_ABYTES) sodium.crypto_aead_chacha20poly1305_ietf_decrypt(plaintext, null, ciphertext, additionalData, nonce, key) return plaintext } /* eslint-disable camelcase */ const { crypto_kx_SEEDBYTES, crypto_kx_keypair, crypto_kx_seed_keypair, crypto_scalarmult_BYTES, crypto_scalarmult_SCALARBYTES, crypto_scalarmult, crypto_scalarmult_base } = require('sodium-universal') const assert = require('nanoassert') const b4a = require('b4a') const DHLEN = crypto_scalarmult_BYTES const PKLEN = crypto_scalarmult_BYTES const SKLEN = crypto_scalarmult_SCALARBYTES const SEEDLEN = crypto_kx_SEEDBYTES const ALG = '25519' module.exports = { DHLEN, PKLEN, SKLEN, SEEDLEN, ALG, generateKeyPair, generateSeedKeyPair, dh } function generateKeyPair (privKey) { const keyPair = {} keyPair.secretKey = privKey || b4a.alloc(SKLEN) keyPair.publicKey = b4a.alloc(PKLEN) if (privKey) { crypto_scalarmult_base(keyPair.publicKey, keyPair.secretKey) } else { crypto_kx_keypair(keyPair.publicKey, keyPair.secretKey) } return keyPair } function generateSeedKeyPair (seed) { assert(seed.byteLength === SKLEN) const keyPair = {} keyPair.secretKey = b4a.alloc(SKLEN) keyPair.publicKey = b4a.alloc(PKLEN) crypto_kx_seed_keypair(keyPair.publicKey, keyPair.secretKey, seed) return keyPair } function dh (publicKey, { secretKey }) { assert(secretKey.byteLength === SKLEN) assert(publicKey.byteLength === PKLEN) const output = b4a.alloc(DHLEN) crypto_scalarmult( output, secretKey, publicKey ) return output } const hmacBlake2b = require('./hmac') const b4a = require('b4a') const HASHLEN = 64 module.exports = { hkdf, HASHLEN } // HMAC-based Extract-and-Expand KDF // https://www.ietf.org/rfc/rfc5869.txt function hkdf (salt, inputKeyMaterial, info = '', length = 2 * HASHLEN) { const pseudoRandomKey = hkdfExtract(salt, inputKeyMaterial) return hkdfExpand(pseudoRandomKey, info, length) } function hkdfExtract (salt, inputKeyMaterial) { const hmac = b4a.alloc(HASHLEN) return hmacDigest(hmac, salt, inputKeyMaterial) } function hkdfExpand (key, info, length) { // Put in dedicated slab to avoid keeping shared slab from being gc'ed const buffer = b4a.allocUnsafeSlow(length) const infoBuf = b4a.from(info) let prev = infoBuf const result = [] for (let i = 0; i < length; i += HASHLEN) { const pos = b4a.from([(i / HASHLEN) + 1]) const out = buffer.subarray(i, i + HASHLEN) result.push(out) prev = hmacDigest(out, key, [prev, infoBuf, pos]) } return result } function hmacDigest (out, key, input) { hmacBlake2b(out, input, key) return out } /* eslint-disable camelcase */ const b4a = require('b4a') const { sodium_memzero, crypto_generichash, crypto_generichash_batch } = require('sodium-universal') const HASHLEN = 64 const BLOCKLEN = 128 const scratch = b4a.alloc(BLOCKLEN * 3) const HMACKey = scratch.subarray(BLOCKLEN * 0, BLOCKLEN * 1) const OuterKeyPad = scratch.subarray(BLOCKLEN * 1, BLOCKLEN * 2) const InnerKeyPad = scratch.subarray(BLOCKLEN * 2, BLOCKLEN * 3) // Post-fill is done in the cases where someone caught an exception that // happened before we were able to clear data at the end module.exports = function hmac (out, batch, key) { if (key.byteLength > BLOCKLEN) { crypto_generichash(HMACKey.subarray(0, HASHLEN), key) sodium_memzero(HMACKey.subarray(HASHLEN)) } else { // Covers key <= BLOCKLEN HMACKey.set(key) sodium_memzero(HMACKey.subarray(key.byteLength)) } for (let i = 0; i < HMACKey.byteLength; i++) { OuterKeyPad[i] = 0x5c ^ HMACKey[i] InnerKeyPad[i] = 0x36 ^ HMACKey[i] } sodium_memzero(HMACKey) crypto_generichash_batch(out, [InnerKeyPad].concat(batch)) sodium_memzero(InnerKeyPad) crypto_generichash_batch(out, [OuterKeyPad, out]) sodium_memzero(OuterKeyPad) } module.exports.BYTES = HASHLEN module.exports.KEYBYTES = BLOCKLEN const assert = require('nanoassert') const b4a = require('b4a') const SymmetricState = require('./symmetric-state') const { HASHLEN } = require('./hkdf') const PRESHARE_IS = Symbol('initiator static key preshared') const PRESHARE_RS = Symbol('responder static key preshared') const TOK_PSK = Symbol('psk') const TOK_S = Symbol('s') const TOK_E = Symbol('e') const TOK_ES = Symbol('es') const TOK_SE = Symbol('se') const TOK_EE = Symbol('ee') const TOK_SS = Symbol('ss') const HANDSHAKES = Object.freeze({ NN: [ [TOK_E], [TOK_E, TOK_EE] ], NNpsk0: [ [TOK_PSK, TOK_E], [TOK_E, TOK_EE] ], XX: [ [TOK_E], [TOK_E, TOK_EE, TOK_S, TOK_ES], [TOK_S, TOK_SE] ], XXpsk0: [ [TOK_PSK, TOK_E], [TOK_E, TOK_EE, TOK_S, TOK_ES], [TOK_S, TOK_SE] ], IK: [ PRESHARE_RS, [TOK_E, TOK_ES, TOK_S, TOK_SS], [TOK_E, TOK_EE, TOK_SE] ], XK: [ PRESHARE_RS, [TOK_E, TOK_ES], [TOK_E, TOK_EE], [TOK_S, TOK_SE] ] }) class Writer { constructor () { this.size = 0 this.buffers = [] } push (b) { this.size += b.byteLength this.buffers.push(b) } end () { const all = b4a.alloc(this.size) let offset = 0 for (const b of this.buffers) { all.set(b, offset) offset += b.byteLength } return all } } class Reader { constructor (buf) { this.offset = 0 this.buffer = buf } shift (n) { const start = this.offset const end = this.offset += n if (end > this.buffer.byteLength) throw new Error('Insufficient bytes') return this.buffer.subarray(start, end) } end () { return this.shift(this.buffer.byteLength - this.offset) } } module.exports = class NoiseState extends SymmetricState { constructor (pattern, initiator, staticKeypair, opts = {}) { super(opts) this.s = staticKeypair || this.curve.generateKeyPair() this.e = null this.psk = null if (opts && opts.psk) this.psk = opts.psk this.re = null this.rs = null this.pattern = pattern this.handshake = HANDSHAKES[this.pattern].slice() this.isPskHandshake = !!this.psk && hasPskToken(this.handshake) this.protocol = b4a.from([ 'Noise', this.pattern, this.DH_ALG, this.CIPHER_ALG, 'BLAKE2b' ].join('_')) this.initiator = initiator this.complete = false this.rx = null this.tx = null this.hash = null } initialise (prologue, remoteStatic) { if (this.protocol.byteLength <= HASHLEN) this.digest.set(this.protocol) else this.mixHash(this.protocol) this.chainingKey = b4a.from(this.digest) this.mixHash(prologue) while (!Array.isArray(this.handshake[0])) { const message = this.handshake.shift() // handshake steps should be as arrays, only // preshare tokens are provided otherwise assert(message === PRESHARE_RS || message === PRESHARE_IS, 'Unexpected pattern') const takeRemoteKey = this.initiator ? message === PRESHARE_RS : message === PRESHARE_IS if (takeRemoteKey) this.rs = remoteStatic const key = takeRemoteKey ? this.rs : this.s.publicKey assert(key != null, 'Remote pubkey required') this.mixHash(key) } } final () { const [k1, k2] = this.split() this.tx = this.initiator ? k1 : k2 this.rx = this.initiator ? k2 : k1 this.complete = true this.hash = this.getHandshakeHash() this._clear() } recv (buf) { const r = new Reader(buf) for (const pattern of this.handshake.shift()) { switch (pattern) { case TOK_PSK : this.mixKeyAndHash(this.psk) break case TOK_E : this.re = r.shift(this.curve.PKLEN) this.mixHash(this.re) if (this.isPskHandshake) this.mixKeyNormal(this.re) break case TOK_S : { const klen = this.hasKey ? this.curve.PKLEN + 16 : this.curve.PKLEN this.rs = this.decryptAndHash(r.shift(klen)) break } case TOK_EE : case TOK_ES : case TOK_SE : case TOK_SS : { const useStatic = keyPattern(pattern, this.initiator) const localKey = useStatic.local ? this.s : this.e const remoteKey = useStatic.remote ? this.rs : this.re this.mixKey(remoteKey, localKey) break } default : throw new Error('Unexpected message') } } const payload = this.decryptAndHash(r.end()) if (!this.handshake.length) this.final() return payload } send (payload = b4a.alloc(0)) { const w = new Writer() for (const pattern of this.handshake.shift()) { switch (pattern) { case TOK_PSK : this.mixKeyAndHash(this.psk) break case TOK_E : if (this.e === null) this.e = this.curve.generateKeyPair() this.mixHash(this.e.publicKey) if (this.isPskHandshake) this.mixKeyNormal(this.e.publicKey) w.push(this.e.publicKey) break case TOK_S : w.push(this.encryptAndHash(this.s.publicKey)) break case TOK_ES : case TOK_SE : case TOK_EE : case TOK_SS : { const useStatic = keyPattern(pattern, this.initiator) const localKey = useStatic.local ? this.s : this.e const remoteKey = useStatic.remote ? this.rs : this.re this.mixKey(remoteKey, localKey) break } default : throw new Error('Unexpected message') } } w.push(this.encryptAndHash(payload)) const response = w.end() if (!this.handshake.length) this.final() return response } _clear () { super._clear() this.e.secretKey.fill(0) this.e.publicKey.fill(0) this.re.fill(0) this.e = null this.re = null } } function keyPattern (pattern, initiator) { const ret = { local: false, remote: false } switch (pattern) { case TOK_EE: return ret case TOK_ES: ret.local ^= !initiator ret.remote ^= initiator return ret case TOK_SE: ret.local ^= initiator ret.remote ^= !initiator return ret case TOK_SS: ret.local ^= 1 ret.remote ^= 1 return ret } } function hasPskToken (handshake) { return handshake.some(x => { return Array.isArray(x) && x.indexOf(TOK_PSK) !== -1 }) } { "name": "noise-handshake", "version": "4.2.0", "description": "Noise protocol handshake", "main": "noise.js", "files": [ "*.js" ], "scripts": { "test": "standard && brittle test/*.js" }, "author": "Holepunch", "license": "Apache-2.0", "repository": { "type": "git", "url": "git+https://github.com/holepunchto/noise-handshake.git" }, "dependencies": { "b4a": "^1.1.0", "nanoassert": "^2.0.0", "sodium-universal": "^5.0.0" }, "devDependencies": { "brittle": "^3.3.2", "noise-protocol": "chm-diederichs/noise-protocol.git#xx-ephemeral-key", "standard": "^16.0.3" } } const sodium = require('sodium-universal') const assert = require('nanoassert') const b4a = require('b4a') const CipherState = require('./cipher') const curve = require('./dh') const { HASHLEN, hkdf } = require('./hkdf') module.exports = class SymmetricState extends CipherState { constructor (opts = {}) { super() this.curve = opts.curve || curve this.digest = b4a.alloc(HASHLEN) this.chainingKey = null this.offset = 0 this.DH_ALG = this.curve.ALG } mixHash (data) { accumulateDigest(this.digest, data) } mixKeyAndHash (key) { const [ck, tempH, tempK] = hkdf(this.chainingKey, key, '', 3 * HASHLEN) this.chainingKey = ck this.mixHash(tempH) this.initialiseKey(tempK.subarray(0, 32)) } mixKeyNormal (key) { const [ck, tempK] = hkdf(this.chainingKey, key) this.chainingKey = ck this.initialiseKey(tempK.subarray(0, 32)) } mixKey (remoteKey, localKey) { const dh = this.curve.dh(remoteKey, localKey) const hkdfResult = hkdf(this.chainingKey, dh) this.chainingKey = hkdfResult[0] this.initialiseKey(hkdfResult[1].subarray(0, 32)) } encryptAndHash (plaintext) { const ciphertext = this.encrypt(plaintext, this.digest) accumulateDigest(this.digest, ciphertext) return ciphertext } decryptAndHash (ciphertext) { const plaintext = this.decrypt(ciphertext, this.digest) accumulateDigest(this.digest, ciphertext) return plaintext } getHandshakeHash (out) { if (!out) return this.getHandshakeHash(b4a.alloc(HASHLEN)) assert(out.byteLength === HASHLEN, `output must be ${HASHLEN} bytes`) out.set(this.digest) return out } split () { const res = hkdf(this.chainingKey, b4a.alloc(0)) return res.map(k => k.subarray(0, 32)) } _clear () { super._clear() sodium.sodium_memzero(this.digest) sodium.sodium_memzero(this.chainingKey) this.digest = null this.chainingKey = null this.offset = null this.curve = null } static get alg () { return CipherState.alg + '_BLAKE2b' } } function accumulateDigest (digest, input) { const toHash = b4a.concat([digest, input]) sodium.crypto_generichash(digest, toHash) } /** * pgh-runtime — per-app OTA updater. * * An installed app imports this module and instantiates a PghRuntime * with its own upgrade source, a store handle, and a fetcher. The * runtime periodically checks for a newer release and, when found, * materializes the new tree into the store and emits events. The app * decides when to actually apply the update (typically on next restart). * * Mirrors pear-runtime-updater's shape (~127 LOC) but uses hyper-overlay * tree content-addressing instead of Hyperdrive. * * Usage: * * import { PghRuntime } from 'pgh-runtime' * const runtime = new PghRuntime({ * name: 'my-app', * currentTreeHash: process.env.PGH_CURRENT_TREE_HASH, * fetcher, * store, * interval: 60 * 60 * 1000 * }) * runtime.on('updating', () => console.log('downloading...')) * runtime.on('updated', (info) => console.log('ready:', info.newTreeHash)) * runtime.on('error', (err) => console.error(err)) * await runtime.start() * * Expected interfaces: * * fetcher: * async getLatestRelease(name) -> { treeHash, version, ... } | null * async getTree(hash) -> { entries: [...], size } * async getContent(contentHash)-> Buffer * * store (TreeStore-compatible): * init() * hasTree(hash) -> boolean * materialize(hash, entries, { fetchContent, fetchTree, source? }) * * The runtime is transport-agnostic — any fetcher conforming to that * shape works. See pgh's NetworkFetcher for the Hyperswarm implementation. */ import EventEmitter from '#node:events' import { computeTreeHash } from 'hyper-overlay/tree' const DEFAULT_INTERVAL = 30 * 60 * 1000 // 30 min export class PghRuntime extends EventEmitter { /** * @param {object} opts * @param {string} opts.name app name * @param {string} [opts.currentTreeHash] hex hash of the tree this app currently runs at * @param {object} opts.fetcher { getTree, getContent, getLatestRelease(name) } * @param {object} opts.store TreeStore-compatible (hasTree / materialize / init) * @param {number} [opts.interval] ms between polls (default 30m; 0 = no polling) * @param {boolean} [opts.startImmediately] do an initial check on start (default true) * @param {string} [opts.host] host label for per-arch prebuild trees (e.g. "linux-x64") * @param {function} [opts.materialize] injected materializer ({ store, appName, rootTreeHash, deps, host }) * — pgh's node materializer or any compatible fn. Omit for store-only. */ constructor (opts = {}) { super() if (!opts.name) throw new Error('PghRuntime requires opts.name') if (!opts.fetcher) throw new Error('PghRuntime requires opts.fetcher') if (!opts.store) throw new Error('PghRuntime requires opts.store') this.name = opts.name this.currentTreeHash = opts.currentTreeHash || null this.fetcher = opts.fetcher this.store = opts.store this.interval = opts.interval != null ? opts.interval : DEFAULT_INTERVAL this.startImmediately = opts.startImmediately !== false this.host = opts.host || null this.materialize = typeof opts.materialize === 'function' ? opts.materialize : null this.latest = null this.updating = false this.updated = false this.newTreeHash = null this._timer = null this._started = false } async start () { if (this._started) return this._started = true if (this.startImmediately) await this._check() if (this.interval > 0) { this._timer = setInterval(() => { this._check().catch(e => this.emit('error', e)) }, this.interval) if (this._timer.unref) this._timer.unref() } } async stop () { if (!this._started) return this._started = false if (this._timer) { clearInterval(this._timer); this._timer = null } } /** * Force an immediate check. Returns the release entry if a new tree * was materialized, null otherwise. */ async checkNow () { return this._check() } async _check () { let release try { release = await this.fetcher.getLatestRelease(this.name) } catch (err) { this.emit('error', err) return null } if (!release) return null // Nothing to do if we already run this tree. if (this.currentTreeHash && release.treeHash === this.currentTreeHash) { this.latest = release return null } // We've already staged this tree; don't re-emit. if (this.updated && release.treeHash === this.newTreeHash) { return null } this.latest = release this.updating = true this.emit('updating', release) try { // Full RELEASE install — root tree PLUS its dependency closure (and, // when a materializer is injected, the wired install layout). Using // installTree alone here fetched only the root tree → a broken install // for any app with deps (see installRelease). const result = await installRelease(this.store, release, this.fetcher, { host: this.host, materialize: this.materialize, appName: this.name, source: 'pgh-runtime:' + this.name }) this.newTreeHash = release.treeHash this.updating = false this.updated = true this.emit('updated', { name: this.name, newTreeHash: release.treeHash, release, materialized: result.materialized, skipped: result.skipped }) return release } catch (err) { this.updating = false this.emit('error', err) return null } } /** * Descriptor for the staged update. Apply via the app's own mechanism * (pgh app update --tree is the usual CLI path). */ readyToApply () { if (!this.updated) return null return { name: this.name, previousTreeHash: this.currentTreeHash, newTreeHash: this.newTreeHash, release: this.latest } } } /** * Walk a tree from the root, fetching each subtree and materializing * content into the store. Inlined here so pgh-runtime has no dependency * on the pgh CLI package — any store + fetcher that conform to the * expected shapes work. * * @param {object} store — TreeStore-compatible * @param {string} rootHash * @param {object} fetcher — { getTree, getContent } * @param {object} [opts] * @returns {Promise<{ materialized: number, skipped: number }>} */ export async function installTree (store, rootHash, fetcher, opts = {}) { store.init() if (store.hasTree(rootHash)) { return { materialized: 0, skipped: 1 } } const tree = await fetcher.getTree(rootHash) if (!tree || !Array.isArray(tree.entries)) { throw new Error('fetcher returned invalid tree for ' + rootHash) } // Content-address verification: entries MUST hash to rootHash. A P2P peer // can answer with empty/wrong entries to signal "I don't have this tree"; // without this check that silently materializes an empty/partial dir. Let // the caller retry on another peer (EHASHMISMATCH). Matches pgh's installTree. const actualRootHash = computeTreeHash(tree.entries) if (actualRootHash !== rootHash) { throw Object.assign( new Error('root tree-hash mismatch: expected ' + rootHash.slice(0, 12) + '…, got ' + actualRootHash.slice(0, 12) + '… (peer may not have this tree)'), { code: 'EHASHMISMATCH', expected: rootHash, actual: actualRootHash } ) } // Single self-contained materialize — store.materialize recursively inlines // subtree content via fetchTree/fetchContent. Subtree hashes do NOT get their // own dependencies// dir (that would duplicate every file N times // across levels); dedup happens at the top-level tree layer. `skipPath` skips // foreign subtrees (e.g. by-arch//). Mirrors pgh's tree-install.js // — the manual subtree recursion this replaced created redundant store dirs // and could not honor skipPath. await store.materialize(rootHash, tree.entries, { fetchContent: fetcher.getContent.bind(fetcher), fetchTree: async (h) => { const t = await fetcher.getTree(h) return t.entries }, source: opts.source, skipPath: opts.skipPath }) return { materialized: 1, skipped: 0 } } /** * Install a full RELEASE — the root tree PLUS its dependency closure. * * `installTree` fetches a single tree and its nested subdirectories, but an * app's node_modules dependencies are SEPARATE content-addressed trees listed * in the release's `deps` array (each with its own tree hash and a per-host * prebuild tree). Fetching only the root tree therefore yields a BROKEN * install — the deps are never fetched and node_modules is never wired. (This * is exactly why pear-git-v3 constructs a PghRuntime but refuses to call * checkNow(): "pgh-runtime only fetches root trees, not dep closures, so using * it here would produce a broken install.") * * installRelease closes that gap: * 1. fetch the FULL closure (root + every dep.tree + prebuilds[host]) into * the store via installTree, then * 2. hand the closure to a materializer that wires the install layout * (hardlink deps + symlink node_modules). * * The materializer is INJECTED (`opts.materialize`) — same dependency-injection * philosophy as fetcher/store — so pgh-runtime stays free of any dependency on * the pgh CLI's materializer. pgh's node materializer * (`materialize({ store, appName, rootTreeHash, deps, host })`) is the canonical * one; any function with that shape works. Without a materializer the closure * is fetched into the store but the install layout is not wired (store-only). * * @param {object} store TreeStore-compatible (init / hasTree / materialize) * @param {object} release { treeHash, deps?: [{ name, version, tree, prebuilds }], name? } * @param {object} fetcher { getTree, getContent } * @param {object} [opts] { host?, appName?, materialize?, source? } * @returns {Promise<{ closure: number, materialized: number, skipped: number, install: any }>} */ export async function installRelease (store, release, fetcher, opts = {}) { if (!release || !release.treeHash) { throw new Error('installRelease requires release.treeHash') } store.init() const host = opts.host || null const deps = Array.isArray(release.deps) ? release.deps : [] // Build the full closure: root tree + each dep's tree + its per-host prebuild. const closureHashes = [release.treeHash] for (const dep of deps) { if (dep.tree) closureHashes.push(dep.tree) if (host && dep.prebuilds && dep.prebuilds[host]) closureHashes.push(dep.prebuilds[host]) } const source = opts.source || ('pgh-runtime:' + (release.name || 'app')) let materialized = 0 let skipped = 0 for (const hash of closureHashes) { const r = await installTree(store, hash, fetcher, { source, skipPath: opts.skipPath }) materialized += r.materialized skipped += r.skipped } let install = null if (typeof opts.materialize === 'function') { install = await opts.materialize({ store, appName: opts.appName || release.name, rootTreeHash: release.treeHash, deps, host }) } return { closure: closureHashes.length, materialized, skipped, install } } const errors = require('./lib/errors') class EventListener { constructor() { this.list = [] this.count = 0 } append(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.push([fn, once]) } prepend(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.unshift([fn, once]) } remove(ctx, name, fn) { for (let i = 0, n = this.list.length; i < n; i++) { const l = this.list[i] if (l[0] === fn) { this.list.splice(i, 1) if (this.count === 1) delete ctx._events[name] ctx.emit('removeListener', name, fn) // Emit AFTER removing this.count-- return } } } removeAll(ctx, name) { const list = [...this.list] this.list = [] if (this.count === list.length) delete ctx._events[name] for (let i = list.length - 1; i >= 0; i--) { ctx.emit('removeListener', name, list[i][0]) // Emit AFTER removing } this.count -= list.length } emit(ctx, name, ...args) { const list = [...this.list] for (let i = 0, n = list.length; i < n; i++) { const l = list[i] if (l[1] === true) this.remove(ctx, name, l[0]) Reflect.apply(l[0], ctx, args) } return list.length > 0 } } function appendListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.append(ctx, name, fn, once) return ctx } function prependListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.prepend(ctx, name, fn, once) return ctx } function removeListener(ctx, name, fn) { if (ctx._events === undefined) return ctx const e = ctx._events[name] if (e !== undefined) e.remove(ctx, name, fn) return ctx } function throwUnhandledError(...args) { let err if (args.length > 0) err = args[0] if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err) if (Error.captureStackTrace) { Error.captureStackTrace(err, exports.prototype.emit) } queueMicrotask(() => { throw err }) } module.exports = exports = class EventEmitter { constructor() { this._events = Object.create(null) } addListener(name, fn) { return appendListener(this, name, fn, false) } addOnceListener(name, fn) { return appendListener(this, name, fn, true) } prependListener(name, fn) { return prependListener(this, name, fn, false) } prependOnceListener(name, fn) { return prependListener(this, name, fn, true) } removeListener(name, fn) { return removeListener(this, name, fn) } on(name, fn) { return appendListener(this, name, fn, false) } once(name, fn) { return appendListener(this, name, fn, true) } off(name, fn) { return removeListener(this, name, fn) } emit(name, ...args) { if (name === 'error' && this._events !== undefined && this._events.error === undefined) { throwUnhandledError(...args) } if (this._events === undefined) return false const e = this._events[name] return e === undefined ? false : e.emit(this, name, ...args) } listeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : [...e.list] } rawListeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : e.list.map((l) => l[0]) } eventNames() { if (this._events === undefined) return [] return Reflect.ownKeys(this._events) } listenerCount(name) { if (this._events === undefined) return 0 const e = this._events[name] return e === undefined ? 0 : e.list.length } getMaxListeners() { return EventEmitter.defaultMaxListeners } setMaxListeners(n) {} removeAllListeners(name) { if (arguments.length === 0) { for (const key of Reflect.ownKeys(this._events)) { if (key === 'removeListener') continue this.removeAllListeners(key) } this.removeAllListeners('removeListener') } else { const e = this._events[name] if (e !== undefined) e.removeAll(this, name) } return this } } exports.EventEmitter = exports exports.errors = errors exports.defaultMaxListeners = 10 exports.on = function on(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { throw errors.OPERATION_ABORTED(signal.reason) } let error = null let done = false const events = [] const promises = [] if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.on(name, onevent) return { next() { if (events.length) { return Promise.resolve({ value: events.shift(), done: false }) } if (error) { const err = error error = null return Promise.reject(err) } if (done) return onclose() return new Promise((resolve, reject) => promises.push({ resolve, reject })) }, return() { return onclose() }, throw(err) { return onerror(err) }, [Symbol.asyncIterator]() { return this } } function onevent(...args) { if (promises.length) { promises.shift().resolve({ value: args, done: false }) } else { events.push(args) } } function onerror(err) { emitter.off(name, onevent).off('error', onerror) if (promises.length) { promises.shift().reject(err) } else { error = err } return Promise.resolve({ done: true }) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } function onclose() { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) done = true if (promises.length) promises.shift().resolve({ done: true }) return Promise.resolve({ done: true }) } } exports.once = function once(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { return Promise.reject(errors.OPERATION_ABORTED(signal.reason)) } return new Promise((resolve, reject) => { if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.once(name, onevent) function onevent(...args) { if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) resolve(args) } function onerror(err) { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) reject(err) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } }) } exports.forward = function forward(from, to, names, opts = {}) { if (typeof names === 'string') names = [names] const { emit = to.emit.bind(to) } = opts const listeners = names.map( (name) => function onevent(...args) { emit(name, ...args) } ) to.on('newListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.on(name, listeners[i]) } }).on('removeListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.off(name, listeners[i]) } }) } exports.listenerCount = function listenerCount(emitter, name) { return emitter.listenerCount(name) } exports.getMaxListeners = function getMaxListeners(emitter) { if (typeof emitter.getMaxListeners === 'function') { return emitter.getMaxListeners() } return exports.defaultMaxListeners } exports.setMaxListeners = function setMaxListeners(n, ...emitters) { if (emitters.length === 0) exports.defaultMaxListeners = n else { for (const emitter of emitters) { if (typeof emitter.setMaxListeners === 'function') { emitter.setMaxListeners(n) } } } } module.exports = class EventEmitterError extends Error { constructor(msg, code, fn = EventEmitterError, opts) { super(`${code}: ${msg}`, opts) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'EventEmitterError' } static OPERATION_ABORTED(cause, msg = 'Operation aborted') { return new EventEmitterError(msg, 'OPERATION_ABORTED', EventEmitterError.OPERATION_ABORTED, { cause }) } static UNHANDLED_ERROR(cause, msg = 'Unhandled error') { return new EventEmitterError(msg, 'UNHANDLED_ERROR', EventEmitterError.UNHANDLED_ERROR, { cause }) } } { "name": "bare-events", "version": "2.9.1", "description": "Event emitters for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" }, "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./errors": "./lib/errors.js" }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "web.js", "web.d.ts", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.js", "test:node": "brittle-node --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-events.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-events/issues" }, "homepage": "https://github.com/holepunchto/bare-events#readme", "devDependencies": { "bare-abort-controller": "^1.0.0", "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0", "uncaughts": "^1.1.1" }, "peerDependencies": { "bare-abort-controller": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true } } } /** * Tree — content-addressable directory hashing for hyper-overlay * * A tree is a canonical serialization of a directory's immediate entries. * Each entry is one of: file, subdirectory, symlink. The tree's identity * is blake2b-256 of its canonical bytes. * * Format (P.10 Phase 0.5a): * * tree := "pgh-tree-1\n" || * varint(n_entries) || * entry[0] || ... || entry[n-1] * * entry := u8(kind) || // 0=file, 1=dir, 2=symlink * u8(exec) || // 0 or 1; always 0 for dir/symlink * varint(name_len) || name || // UTF-8 NFC, no NUL, no "/" * 32_bytes(child_hash) * * tree_hash := blake2b-256(tree_bytes) * * Identity fields (in the hash): kind, exec-bit, name, child_hash. * Explicitly excluded: mtime, size, uid/gid, full mode. * * Entries MUST be sorted byte-wise by name (after NFC normalization). * Encoders emit sorted; decoders reject unsorted trees. * * Symlinks: child_hash = blake2b-256 of the target path bytes (not followed). * Empty directories: zero-entry tree, valid, deterministic. */ import fs from '#fs' import path from '#path' import crypto from 'hypercore-crypto' import c from 'compact-encoding' // ── Constants ───────────────────────────────────────────────── export const MAGIC = Buffer.from('pgh-tree-1\n', 'utf8') export const KIND_FILE = 0 export const KIND_DIR = 1 export const KIND_SYMLINK = 2 // Windows reserved device names (case-insensitive, with or without extension) const WINDOWS_RESERVED = new Set([ 'CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9' ]) // Chars forbidden in filenames on Windows (beyond format-layer rules) // eslint-disable-next-line no-control-regex const WINDOWS_FORBIDDEN = /[\\:*?"<>|\x00-\x1f]/ // Default skip list for walkTree — minimal, just obvious platform cruft. // Consumers that want more (e.g. .git for pgh publish) pass their own. export const DEFAULT_SKIP = new Set(['.DS_Store', 'Thumbs.db']) // ── Name validation (format layer) ──────────────────────────── /** * Normalize a filename for hashing and validate format-layer rules. * Throws on unrepresentable names. Returns the canonical form. * * @param {string} name - single path component (no "/") * @returns {string} NFC-normalized name */ export function normalizeName (name) { if (typeof name !== 'string') { throw new Error('tree entry name must be string, got ' + typeof name) } if (name.length === 0) { throw new Error('tree entry name cannot be empty') } if (name === '.' || name === '..') { throw new Error('tree entry name cannot be "." or ".."') } if (name.indexOf('/') !== -1) { throw new Error('tree entry name cannot contain "/": ' + JSON.stringify(name)) } if (name.indexOf('\x00') !== -1) { throw new Error('tree entry name cannot contain NUL: ' + JSON.stringify(name)) } const normalized = name.normalize('NFC') // Verify the normalized form is valid UTF-8 that round-trips through // Buffer (catches lone surrogates and other malformed sequences). const asBytes = Buffer.from(normalized, 'utf8') if (asBytes.toString('utf8') !== normalized) { throw new Error('tree entry name is not valid UTF-8: ' + JSON.stringify(name)) } return normalized } // ── Consumer-policy layer ───────────────────────────────────── /** * Check a name against Windows compatibility rules. * Does NOT throw — returns a reason string (or null if the name is OK). * Used by pgh publish for strict cross-platform validation. * * @param {string} name * @returns {string|null} reason if incompatible, null if OK */ export function windowsIncompatibleReason (name) { if (WINDOWS_FORBIDDEN.test(name)) { return 'contains Windows-forbidden character (\\:*?"<>| or control code)' } const trimmed = name.replace(/\.+$/, '').replace(/ +$/, '') if (trimmed !== name) { return 'trailing "." or space (Windows strips these silently)' } // Reserved device names apply with any extension: AUX.log, PRN.txt etc. const base = name.split('.')[0].toUpperCase() if (WINDOWS_RESERVED.has(base)) { return `"${base}" is a reserved Windows device name (even with extension)` } return null } // ── Canonical encoding ──────────────────────────────────────── /** * Encode a single entry to its canonical byte representation. * * @param {object} state - compact-encoding state * @param {{kind: number, exec: number, name: string, childHash: Buffer|string}} e */ function encodeEntry (state, e) { if (e.kind !== KIND_FILE && e.kind !== KIND_DIR && e.kind !== KIND_SYMLINK) { throw new Error('invalid entry kind: ' + e.kind) } if (e.exec !== 0 && e.exec !== 1) { throw new Error('entry exec must be 0 or 1') } if (e.kind !== KIND_FILE && e.exec !== 0) { throw new Error('non-file entry must have exec=0') } const hash = toBuffer32(e.childHash) c.uint8.encode(state, e.kind) c.uint8.encode(state, e.exec) c.string.encode(state, e.name) // compact-encoding: varint len + utf8 bytes state.buffer.set(hash, state.start) state.start += 32 } function preencodeEntry (state, e) { c.uint8.preencode(state, e.kind) c.uint8.preencode(state, e.exec) c.string.preencode(state, e.name) state.end += 32 } /** * Serialize a list of entries to canonical tree bytes. * Entries are sorted + normalized as a side-effect of the call. * * @param {Array<{kind: number, exec: number, name: string, childHash: Buffer|string}>} entries * @returns {Buffer} */ export function encodeTree (entries) { const normalized = entries.map(e => ({ kind: e.kind, exec: e.exec || 0, name: normalizeName(e.name), childHash: e.childHash })) normalized.sort(compareEntries) // Sanity: no duplicate names after normalization for (let i = 1; i < normalized.length; i++) { if (normalized[i].name === normalized[i - 1].name) { throw new Error('duplicate entry name after NFC normalization: ' + normalized[i].name) } } const state = { start: 0, end: 0, buffer: null } state.end += MAGIC.length c.uint.preencode(state, normalized.length) for (const e of normalized) preencodeEntry(state, e) state.buffer = Buffer.alloc(state.end) state.buffer.set(MAGIC, state.start) state.start += MAGIC.length c.uint.encode(state, normalized.length) for (const e of normalized) encodeEntry(state, e) return state.buffer } /** * Byte-wise comparator for entry names (after NFC normalization). */ function compareEntries (a, b) { const ab = Buffer.from(a.name, 'utf8') const bb = Buffer.from(b.name, 'utf8') return Buffer.compare(ab, bb) } /** * Decode canonical tree bytes back to an entries list. * Rejects unsorted or malformed trees. * * @param {Buffer} buf * @returns {Array<{kind: number, exec: number, name: string, childHash: string}>} */ export function decodeTree (buf) { if (!Buffer.isBuffer(buf)) throw new Error('decodeTree expects a Buffer') if (buf.length < MAGIC.length) throw new Error('tree too short') if (buf.compare(MAGIC, 0, MAGIC.length, 0, MAGIC.length) !== 0) { throw new Error('tree magic mismatch (expected "pgh-tree-1")') } const state = { start: MAGIC.length, end: buf.length, buffer: buf } const count = c.uint.decode(state) const entries = [] let prevName = null for (let i = 0; i < count; i++) { const kind = c.uint8.decode(state) const exec = c.uint8.decode(state) const name = c.string.decode(state) if (state.start + 32 > state.end) throw new Error('truncated tree: missing hash bytes') const childHash = buf.subarray(state.start, state.start + 32).toString('hex') state.start += 32 // Validate format rules on read — reject invalid trees rather than silently accept const normalized = normalizeName(name) if (normalized !== name) { throw new Error('tree entry name not NFC-normalized: ' + JSON.stringify(name)) } if (kind !== KIND_FILE && exec !== 0) { throw new Error('non-file entry with exec=1 is invalid') } if (prevName !== null) { const cmp = Buffer.compare(Buffer.from(prevName, 'utf8'), Buffer.from(name, 'utf8')) if (cmp === 0) throw new Error('tree has duplicate entry: ' + name) if (cmp > 0) throw new Error('tree entries not sorted: ' + prevName + ' before ' + name) } prevName = name entries.push({ kind, exec, name, childHash }) } if (state.start !== state.end) throw new Error('tree has trailing bytes after entries') return entries } /** * Compute the tree hash of an entries list. * * @param {Array<{kind: number, exec: number, name: string, childHash: Buffer|string}>} entries * @returns {string} hex-encoded blake2b-256 */ export function computeTreeHash (entries) { const buf = encodeTree(entries) return crypto.data(buf).toString('hex') } // ── Helpers ─────────────────────────────────────────────────── function toBuffer32 (hashOrBuf) { if (Buffer.isBuffer(hashOrBuf)) { if (hashOrBuf.length !== 32) throw new Error('childHash buffer must be 32 bytes') return hashOrBuf } if (typeof hashOrBuf !== 'string') { throw new Error('childHash must be Buffer or hex string') } if (hashOrBuf.length !== 64) throw new Error('childHash hex string must be 64 chars') return Buffer.from(hashOrBuf, 'hex') } // ── Filesystem walk ─────────────────────────────────────────── /** * Walk a directory recursively, producing tree hashes bottom-up. * * Returns a nested object keyed by path, where each entry has: * { hash: hex, entries: [{kind, exec, name, childHash, size?}] } * * File entries carry their content hash as childHash (blake2b of bytes). * Dir entries carry the subtree hash. * Symlink entries carry blake2b of the link target bytes. * * @param {string} rootDir - absolute path to scan * @param {object} [opts] * @param {Set} [opts.skip] - basenames to skip (default: DEFAULT_SKIP) * @param {(relPath: string, baseName: string) => boolean} [opts.matcher] * Optional gitignore-style matcher. Returns true to EXCLUDE an entry. * Receives the path relative to rootDir plus the basename. Applies to * all kinds (file/dir/symlink). Used by `pgh publish` for publishIgnore. * @returns {Map} * map keyed by relative path ('' = root); root tree is at key '' */ export function walkTree (rootDir, opts = {}) { const skip = opts.skip || DEFAULT_SKIP const matcher = opts.matcher || null const trees = new Map() function visit (relPath) { const absPath = relPath === '' ? rootDir : path.join(rootDir, relPath) const raw = fs.readdirSync(absPath) const entries = [] let totalSize = 0 for (const name of raw) { if (skip.has(name)) continue const entryAbs = path.join(absPath, name) const entryRel = relPath === '' ? name : relPath + '/' + name if (matcher && matcher(entryRel, name)) continue let stat try { stat = fs.lstatSync(entryAbs) } catch { continue } if (stat.isSymbolicLink()) { const target = fs.readlinkSync(entryAbs) const targetBytes = Buffer.from(target, 'utf8') const childHash = crypto.data(targetBytes).toString('hex') entries.push({ kind: KIND_SYMLINK, exec: 0, name: normalizeName(name), childHash, size: targetBytes.length, linkTarget: target }) totalSize += targetBytes.length } else if (stat.isDirectory()) { visit(entryRel) const sub = trees.get(entryRel) if (!sub) continue entries.push({ kind: KIND_DIR, exec: 0, name: normalizeName(name), childHash: sub.hash, size: sub.size }) totalSize += sub.size } else if (stat.isFile()) { const content = fs.readFileSync(entryAbs) const childHash = crypto.data(content).toString('hex') // Executable bit from stat.mode — works on POSIX; Windows always 0 const exec = (stat.mode & 0o100) ? 1 : 0 entries.push({ kind: KIND_FILE, exec, name: normalizeName(name), childHash, size: stat.size }) totalSize += stat.size } // device files, sockets, fifos: silently skipped (unrepresentable) } entries.sort(compareEntries) const hash = computeTreeHash(entries) trees.set(relPath, { hash, entries, size: totalSize }) } visit('') return trees } // ── Publish-time validation (consumer policy) ───────────────── /** * Scan entries (recursively via walkTree output) for cross-platform-hostile * names. Returns an array of {path, name, reason} for every problem found. * Does NOT throw — caller decides how to present. * * @param {Map} trees - from walkTree * @returns {Array<{path: string, name: string, reason: string}>} */ export function validateForPublish (trees) { const problems = [] for (const [relPath, tree] of trees) { for (const e of tree.entries) { const reason = windowsIncompatibleReason(e.name) if (reason) { problems.push({ path: relPath ? relPath + '/' + e.name : e.name, name: e.name, reason }) } } } return problems } function isBuffer(value) { return Buffer.isBuffer(value) || value instanceof Uint8Array } function isEncoding(encoding) { return Buffer.isEncoding(encoding) } function alloc(size, fill, encoding) { return Buffer.alloc(size, fill, encoding) } function allocUnsafe(size) { return Buffer.allocUnsafe(size) } function allocUnsafeSlow(size) { return Buffer.allocUnsafeSlow(size) } function byteLength(string, encoding) { return Buffer.byteLength(string, encoding) } function compare(a, b) { return Buffer.compare(a, b) } function concat(buffers, totalLength) { return Buffer.concat(buffers, totalLength) } function copy(source, target, targetStart, start, end) { return toBuffer(source).copy(target, targetStart, start, end) } function equals(a, b) { return toBuffer(a).equals(b) } function fill(buffer, value, offset, end, encoding) { return toBuffer(buffer).fill(value, offset, end, encoding) } function from(value, encodingOrOffset, length) { return Buffer.from(value, encodingOrOffset, length) } function includes(buffer, value, byteOffset, encoding) { return toBuffer(buffer).includes(value, byteOffset, encoding) } function indexOf(buffer, value, byfeOffset, encoding) { return toBuffer(buffer).indexOf(value, byfeOffset, encoding) } function lastIndexOf(buffer, value, byteOffset, encoding) { return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding) } function swap16(buffer) { return toBuffer(buffer).swap16() } function swap32(buffer) { return toBuffer(buffer).swap32() } function swap64(buffer) { return toBuffer(buffer).swap64() } function toBuffer(buffer) { if (Buffer.isBuffer(buffer)) return buffer return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength) } function toString(buffer, encoding, start, end) { return toBuffer(buffer).toString(encoding, start, end) } function write(buffer, string, offset, length, encoding) { return toBuffer(buffer).write(string, offset, length, encoding) } function readDoubleBE(buffer, offset) { return toBuffer(buffer).readDoubleBE(offset) } function readDoubleLE(buffer, offset) { return toBuffer(buffer).readDoubleLE(offset) } function readFloatBE(buffer, offset) { return toBuffer(buffer).readFloatBE(offset) } function readFloatLE(buffer, offset) { return toBuffer(buffer).readFloatLE(offset) } function readInt32BE(buffer, offset) { return toBuffer(buffer).readInt32BE(offset) } function readInt32LE(buffer, offset) { return toBuffer(buffer).readInt32LE(offset) } function readUInt32BE(buffer, offset) { return toBuffer(buffer).readUInt32BE(offset) } function readUInt32LE(buffer, offset) { return toBuffer(buffer).readUInt32LE(offset) } function writeDoubleBE(buffer, value, offset) { return toBuffer(buffer).writeDoubleBE(value, offset) } function writeDoubleLE(buffer, value, offset) { return toBuffer(buffer).writeDoubleLE(value, offset) } function writeFloatBE(buffer, value, offset) { return toBuffer(buffer).writeFloatBE(value, offset) } function writeFloatLE(buffer, value, offset) { return toBuffer(buffer).writeFloatLE(value, offset) } function writeInt32BE(buffer, value, offset) { return toBuffer(buffer).writeInt32BE(value, offset) } function writeInt32LE(buffer, value, offset) { return toBuffer(buffer).writeInt32LE(value, offset) } function writeUInt32BE(buffer, value, offset) { return toBuffer(buffer).writeUInt32BE(value, offset) } function writeUInt32LE(buffer, value, offset) { return toBuffer(buffer).writeUInt32LE(value, offset) } module.exports = { isBuffer, isEncoding, alloc, allocUnsafe, allocUnsafeSlow, byteLength, compare, concat, copy, equals, fill, from, includes, indexOf, lastIndexOf, swap16, swap32, swap64, toBuffer, toString, write, readDoubleBE, readDoubleLE, readFloatBE, readFloatLE, readInt32BE, readInt32LE, readUInt32BE, readUInt32LE, writeDoubleBE, writeDoubleLE, writeFloatBE, writeFloatLE, writeInt32BE, writeInt32LE, writeUInt32BE, writeUInt32LE } { "name": "b4a", "version": "1.8.1", "description": "Bridging the gap between buffers and typed arrays", "exports": { "./package": "./package.json", ".": { "react-native": "./react-native.js", "browser": "./browser.js", "default": "./index.js" } }, "files": [ "browser.js", "index.js", "react-native.js", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.mjs", "test:node": "brittle-node --coverage test.mjs" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/b4a.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/b4a/issues" }, "homepage": "https://github.com/holepunchto/b4a#readme", "devDependencies": { "brittle": "^3.5.2", "lunte": "^1.7.0", "nanobench": "^3.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "react-native-b4a": "*" }, "peerDependenciesMeta": { "react-native-b4a": { "optional": true } } } const ESC = '\x1b' const CSI = ESC + '[' const SGR = (n) => CSI + n + 'm' exports.constants = { ESC, CSI, SGR } // https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_(Control_Sequence_Introducer)_sequences exports.cursorHide = CSI + '?25l' exports.cursorShow = CSI + '?25h' exports.cursorUp = function cursorUp(n = 1) { return CSI + n + 'A' } exports.cursorDown = function cursorDown(n = 1) { return CSI + n + 'B' } exports.cursorForward = function cursorForward(n = 1) { return CSI + n + 'C' } exports.cursorBack = function cursorBack(n = 1) { return CSI + n + 'D' } exports.cursorNextLine = function cursorNextLine(n = 1) { return CSI + n + 'E' } exports.cursorPreviousLine = function cursorPreviousLine(n = 1) { return CSI + n + 'F' } exports.cursorPosition = function cursorPosition(column, row = 0) { if (row === 0) return CSI + (column + 1) + 'G' return CSI + (row + 1) + ';' + (column + 1) + 'H' } exports.eraseDisplayEnd = CSI + 'J' exports.eraseDisplayStart = CSI + '1J' exports.eraseDisplay = CSI + '2J' exports.eraseLineEnd = CSI + 'K' exports.eraseLineStart = CSI + '1K' exports.eraseLine = CSI + '2K' exports.scrollUp = function scrollUp(n = 1) { return CSI + n + 'S' } exports.scrollDown = function scrollDown(n = 1) { return CSI + n + 'T' } // https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters exports.modifierReset = SGR(0) exports.modifierBold = SGR(1) exports.modifierDim = SGR(2) exports.modifierItalic = SGR(3) exports.modifierUnderline = SGR(4) exports.modifierNormal = SGR(22) exports.modifierNotItalic = SGR(23) exports.modifierNotUnderline = SGR(24) // https://en.wikipedia.org/wiki/ANSI_escape_code#Colors exports.colorBlack = SGR(30) exports.colorRed = SGR(31) exports.colorGreen = SGR(32) exports.colorYellow = SGR(33) exports.colorBlue = SGR(34) exports.colorMagenta = SGR(35) exports.colorCyan = SGR(36) exports.colorWhite = SGR(37) exports.colorDefault = SGR(39) exports.colorBrightBlack = SGR(90) exports.colorBrightRed = SGR(91) exports.colorBrightGreen = SGR(92) exports.colorBrightYellow = SGR(93) exports.colorBrightBlue = SGR(94) exports.colorBrightMagenta = SGR(95) exports.colorBrightCyan = SGR(96) exports.colorBrightWhite = SGR(97) { "name": "bare-ansi-escapes", "version": "2.2.3", "description": "Parse and produce ANSI escape sequences", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./key-decoder": { "types": "./key-decoder.d.ts", "default": "./key-decoder.js" } }, "files": [ "index.js", "index.d.ts", "key-decoder.js", "key-decoder.d.ts" ], "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-ansi-escapes.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-ansi-escapes/issues" }, "homepage": "https://github.com/holepunchto/bare-ansi-escapes#readme", "dependencies": { "bare-stream": "^2.6.5" }, "devDependencies": { "bare-buffer": "^3.0.2", "brittle": "^3.3.2", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" }, "peerDependencies": { "bare-buffer": "*" }, "peerDependenciesMeta": { "bare-buffer": { "optional": true } } } const inspect = require('bare-inspect') class AssertionError extends Error { constructor(opts = {}) { let { message = null, actual, expected, operator } = opts if (message === null) { message = `${inspect(actual)} ${operator} ${inspect(expected)}` } super(message) this.actual = actual this.expected = expected this.operator = operator } get name() { return 'AssertionError' } get code() { 'ASSERTION' } } function assertFail(opts, fn) { if (opts.message instanceof Error) throw opts.message const err = new AssertionError(opts) if (Error.captureStackTrace) Error.captureStackTrace(err, fn) throw err } module.exports = exports = function assert(actual, message) { if (actual) return assertFail({ message, actual, expected: true, operator: '==' }, assert) } exports.AssertionError = AssertionError exports.fail = function fail(message) { if (message === undefined) message = 'Failed' assertFail({ message, operator: 'fail' }, fail) } exports.ok = function ok(actual, message) { if (actual) return assertFail({ message, actual, expected: true, operator: '==' }, ok) } exports.notOk = function ok(actual, message) { if (!actual) return assertFail({ message, actual, expected: false, operator: '==' }, ok) } exports.equal = function equal(actual, expected, message) { if (actual == expected || (actual !== actual && expected !== expected)) { return } assertFail({ message, actual, expected, operator: '==' }, equal) } exports.notEqual = function notEqual(actual, expected, message) { if (actual != expected && (actual === actual || expected === expected)) { return } assertFail({ message, actual, expected, operator: '!=' }, notEqual) } exports.strictEqual = function strictEqual(actual, expected, message) { if (Object.is(actual, expected)) return assertFail( { message, actual, expected, operator: 'strictEqual' }, strictEqual ) } exports.notStrictEqual = function notStrictEqual(actual, expected, message) { if (!Object.is(actual, expected)) return assertFail( { message, actual, expected, operator: 'notStrictEqual' }, notStrictEqual ) } { "name": "bare-assert", "version": "1.2.0", "description": "Assertion library for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts" ], "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-assert.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-assert/issues" }, "homepage": "https://github.com/holepunchto/bare-assert#readme", "dependencies": { "bare-inspect": "^3.1.2" }, "devDependencies": { "brittle": "^3.1.1", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" } } const errors = require('./lib/errors') class EventListener { constructor() { this.list = [] this.count = 0 } append(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.push([fn, once]) } prepend(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.unshift([fn, once]) } remove(ctx, name, fn) { for (let i = 0, n = this.list.length; i < n; i++) { const l = this.list[i] if (l[0] === fn) { this.list.splice(i, 1) if (this.count === 1) delete ctx._events[name] ctx.emit('removeListener', name, fn) // Emit AFTER removing this.count-- return } } } removeAll(ctx, name) { const list = [...this.list] this.list = [] if (this.count === list.length) delete ctx._events[name] for (let i = list.length - 1; i >= 0; i--) { ctx.emit('removeListener', name, list[i][0]) // Emit AFTER removing } this.count -= list.length } emit(ctx, name, ...args) { const list = [...this.list] for (let i = 0, n = list.length; i < n; i++) { const l = list[i] if (l[1] === true) this.remove(ctx, name, l[0]) Reflect.apply(l[0], ctx, args) } return list.length > 0 } } function appendListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.append(ctx, name, fn, once) return ctx } function prependListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.prepend(ctx, name, fn, once) return ctx } function removeListener(ctx, name, fn) { if (ctx._events === undefined) return ctx const e = ctx._events[name] if (e !== undefined) e.remove(ctx, name, fn) return ctx } function throwUnhandledError(...args) { let err if (args.length > 0) err = args[0] if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err) if (Error.captureStackTrace) { Error.captureStackTrace(err, exports.prototype.emit) } queueMicrotask(() => { throw err }) } module.exports = exports = class EventEmitter { constructor() { this._events = Object.create(null) } addListener(name, fn) { return appendListener(this, name, fn, false) } addOnceListener(name, fn) { return appendListener(this, name, fn, true) } prependListener(name, fn) { return prependListener(this, name, fn, false) } prependOnceListener(name, fn) { return prependListener(this, name, fn, true) } removeListener(name, fn) { return removeListener(this, name, fn) } on(name, fn) { return appendListener(this, name, fn, false) } once(name, fn) { return appendListener(this, name, fn, true) } off(name, fn) { return removeListener(this, name, fn) } emit(name, ...args) { if (name === 'error' && this._events !== undefined && this._events.error === undefined) { throwUnhandledError(...args) } if (this._events === undefined) return false const e = this._events[name] return e === undefined ? false : e.emit(this, name, ...args) } listeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : [...e.list] } rawListeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : e.list.map((l) => l[0]) } eventNames() { if (this._events === undefined) return [] return Reflect.ownKeys(this._events) } listenerCount(name) { if (this._events === undefined) return 0 const e = this._events[name] return e === undefined ? 0 : e.list.length } getMaxListeners() { return EventEmitter.defaultMaxListeners } setMaxListeners(n) {} removeAllListeners(name) { if (arguments.length === 0) { for (const key of Reflect.ownKeys(this._events)) { if (key === 'removeListener') continue this.removeAllListeners(key) } this.removeAllListeners('removeListener') } else { const e = this._events[name] if (e !== undefined) e.removeAll(this, name) } return this } } exports.EventEmitter = exports exports.errors = errors exports.defaultMaxListeners = 10 exports.on = function on(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { throw errors.OPERATION_ABORTED(signal.reason) } let error = null let done = false const events = [] const promises = [] if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.on(name, onevent) return { next() { if (events.length) { return Promise.resolve({ value: events.shift(), done: false }) } if (error) { const err = error error = null return Promise.reject(err) } if (done) return onclose() return new Promise((resolve, reject) => promises.push({ resolve, reject })) }, return() { return onclose() }, throw(err) { return onerror(err) }, [Symbol.asyncIterator]() { return this } } function onevent(...args) { if (promises.length) { promises.shift().resolve({ value: args, done: false }) } else { events.push(args) } } function onerror(err) { emitter.off(name, onevent).off('error', onerror) if (promises.length) { promises.shift().reject(err) } else { error = err } return Promise.resolve({ done: true }) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } function onclose() { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) done = true if (promises.length) promises.shift().resolve({ done: true }) return Promise.resolve({ done: true }) } } exports.once = function once(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { return Promise.reject(errors.OPERATION_ABORTED(signal.reason)) } return new Promise((resolve, reject) => { if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.once(name, onevent) function onevent(...args) { if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) resolve(args) } function onerror(err) { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) reject(err) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } }) } exports.forward = function forward(from, to, names, opts = {}) { if (typeof names === 'string') names = [names] const { emit = to.emit.bind(to) } = opts const listeners = names.map( (name) => function onevent(...args) { emit(name, ...args) } ) to.on('newListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.on(name, listeners[i]) } }).on('removeListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.off(name, listeners[i]) } }) } exports.listenerCount = function listenerCount(emitter, name) { return emitter.listenerCount(name) } exports.getMaxListeners = function getMaxListeners(emitter) { if (typeof emitter.getMaxListeners === 'function') { return emitter.getMaxListeners() } return exports.defaultMaxListeners } exports.setMaxListeners = function setMaxListeners(n, ...emitters) { if (emitters.length === 0) exports.defaultMaxListeners = n else { for (const emitter of emitters) { if (typeof emitter.setMaxListeners === 'function') { emitter.setMaxListeners(n) } } } } module.exports = class EventEmitterError extends Error { constructor(msg, code, fn = EventEmitterError, opts) { super(`${code}: ${msg}`, opts) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'EventEmitterError' } static OPERATION_ABORTED(cause, msg = 'Operation aborted') { return new EventEmitterError(msg, 'OPERATION_ABORTED', EventEmitterError.OPERATION_ABORTED, { cause }) } static UNHANDLED_ERROR(cause, msg = 'Unhandled error') { return new EventEmitterError(msg, 'UNHANDLED_ERROR', EventEmitterError.UNHANDLED_ERROR, { cause }) } } { "name": "bare-events", "version": "2.9.1", "description": "Event emitters for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" }, "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./errors": "./lib/errors.js" }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "web.js", "web.d.ts", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.js", "test:node": "brittle-node --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-events.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-events/issues" }, "homepage": "https://github.com/holepunchto/bare-events#readme", "devDependencies": { "bare-abort-controller": "^1.0.0", "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0", "uncaughts": "^1.1.1" }, "peerDependencies": { "bare-abort-controller": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true } } } module.exports = require.addon() const FIFO = require('fast-fifo') const EventEmitter = require('bare-events') const path = require('bare-path') const { isURL, fileURLToPath } = require('bare-url') const { Readable, Writable } = require('bare-stream') const binding = require('./binding') const constants = require('./lib/constants') const FileError = require('./lib/errors') const isWindows = Bare.platform === 'win32' exports.constants = constants class FileRequest { static borrow() { if (this._free.length > 0) return this._free.pop() return new FileRequest() } static return(req) { if (this._free.length < 32) this._free.push(req.reset()) else req.destroy() } constructor() { this._reset() this._handle = binding.requestInit(this, this._onresult) } get handle() { return this._handle } retain(value) { this._retain = value // Tie the lifetime of `value` to the lifetime of `this` } reset() { if (this._handle === null) return this binding.requestReset(this._handle) this._reset() return this } destroy() { if (this._handle === null) return this binding.requestDestroy(this._handle) this._reset() this._handle = null return this } then(resolve, reject) { return this._promise.then(resolve, reject) } return() { if (this._handle === null) return this FileRequest.return(this) return this } _reset() { this._promise = new Promise((resolve, reject) => { this._resolve = resolve this._reject = reject }) this._retain = null } _onresult(err, status) { if (err) this._reject(err) else this._resolve(status) } } FileRequest._free = [] function ok(result, cb) { if (typeof result === 'function') { cb = result result = undefined } if (cb) cb(null, result) else return result } function fail(err, cb) { if (cb) cb(err) else throw err } function done(err, result, cb) { if (typeof result === 'function') { cb = result result = undefined } if (err) fail(err, cb) else return ok(result, cb) } async function open(filepath, flags = 'r', mode = 0o666, cb) { if (typeof flags === 'function') { cb = flags flags = 'r' mode = 0o666 } else if (typeof mode === 'function') { cb = mode mode = 0o666 } if (typeof flags === 'string') flags = toFlags(flags) if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let fd let err = null try { binding.open(req.handle, filepath, flags, mode) fd = await req } catch (e) { err = new FileError(e.message, { operation: 'open', code: e.code, path: filepath }) } finally { req.return() } return done(err, fd, cb) } function openSync(filepath, flags = 'r', mode = 0o666) { if (typeof flags === 'string') flags = toFlags(flags) if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { return binding.openSync(req.handle, filepath, flags, mode) } catch (e) { throw new FileError(e.message, { operation: 'open', code: e.code, path: filepath }) } finally { req.return() } } async function close(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.close(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'close', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function closeSync(fd) { const req = FileRequest.borrow() try { binding.closeSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'close', code: e.code, fd }) } finally { req.return() } } async function access(filepath, mode = constants.F_OK, cb) { if (typeof mode === 'function') { cb = mode mode = constants.F_OK } filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.access(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'access', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function accessSync(filepath, mode = constants.F_OK) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.accessSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'access', code: e.code, path: filepath }) } finally { req.return() } } async function exists(filepath, cb) { let ok = true try { await access(filepath) } catch { ok = false } return done(null, ok, cb) } function existsSync(filepath) { try { accessSync(filepath) } catch { return false } return true } async function read(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1, cb) { if (typeof offset === 'function') { cb = offset offset = 0 len = buffer.byteLength pos = -1 } else if (typeof len === 'function') { cb = len len = buffer.byteLength - offset pos = -1 } else if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.read(req.handle, fd, buffer, offset, len, pos) req.retain(buffer) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'read', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function readSync(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1) { const req = FileRequest.borrow() try { return binding.readSync(req.handle, fd, buffer, offset, len, pos) } catch (e) { throw new FileError(e.message, { operation: 'read', code: e.code, fd }) } finally { req.return() } } async function readv(fd, buffers, pos = -1, cb) { if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.readv(req.handle, fd, buffers, pos) req.retain(buffers) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'readv', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function readvSync(fd, buffers, pos = -1) { if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.readvSync(req.handle, fd, buffers, pos) } catch (e) { throw new FileError(e.message, { operation: 'readv', code: e.code, fd }) } finally { req.return() } } async function write(fd, data, offset, len, pos = -1, cb) { if (typeof data === 'string') { let encoding = len cb = pos pos = offset if (typeof pos === 'function') { cb = pos pos = -1 encoding = 'utf8' } else if (typeof encoding === 'function') { cb = encoding encoding = 'utf8' } if (typeof pos === 'string') { encoding = pos pos = -1 } data = Buffer.from(data, encoding) offset = 0 len = data.byteLength } else if (typeof offset === 'function') { cb = offset offset = 0 len = data.byteLength pos = -1 } else if (typeof len === 'function') { cb = len len = data.byteLength - offset pos = -1 } else if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof offset !== 'number') offset = 0 if (typeof len !== 'number') len = data.byteLength - offset if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.write(req.handle, fd, data, offset, len, pos) req.retain(data) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'write', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function writeSync(fd, data, offset, len, pos = -1) { if (typeof data === 'string') { let encoding = len pos = offset if (typeof pos === 'string') { encoding = pos pos = -1 } data = Buffer.from(data, encoding) offset = 0 len = data.byteLength } if (typeof offset !== 'number') offset = 0 if (typeof len !== 'number') len = data.byteLength - offset if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.writeSync(req.handle, fd, data, offset, len, pos) } catch (e) { throw new FileError(e.message, { operation: 'write', code: e.code, fd }) } finally { req.return() } } async function writev(fd, buffers, pos = -1, cb) { if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.writev(req.handle, fd, buffers, pos) req.retain(buffers) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'writev', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function writevSync(fd, buffers, pos = -1) { if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.writevSync(req.handle, fd, buffers, pos) } catch (e) { throw new FileError(e.message, { operation: 'writev', code: e.code, fd }) } finally { req.return() } } async function stat(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.stat(req.handle, filepath) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'stat', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function statSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.statSync(req.handle, filepath) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'stat', code: e.code, path: filepath }) } finally { req.return() } } async function lstat(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.lstat(req.handle, filepath) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'lstat', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function lstatSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lstatSync(req.handle, filepath) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'lstat', code: e.code, path: filepath }) } finally { req.return() } } async function fstat(fd, cb) { const req = FileRequest.borrow() let st let err = null try { binding.fstat(req.handle, fd) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'fstat', code: e.code, fd }) } finally { req.return() } return done(err, st, cb) } function fstatSync(fd) { const req = FileRequest.borrow() try { binding.fstatSync(req.handle, fd) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'fstat', code: e.code, fd }) } finally { req.return() } } async function statfs(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.statfs(req.handle, filepath) await req st = new StatFs(...binding.requestResultStatfs(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'statfs', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function statfsSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.statfsSync(req.handle, filepath) return new StatFs(...binding.requestResultStatfs(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'statfs', code: e.code, path: filepath }) } finally { req.return() } } async function ftruncate(fd, len = 0, cb) { if (typeof len === 'function') { cb = len len = 0 } if (typeof len !== 'number') len = 0 const req = FileRequest.borrow() let err = null try { binding.ftruncate(req.handle, fd, len) await req } catch (e) { err = new FileError(e.message, { operation: 'ftruncate', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function ftruncateSync(fd, len = 0) { if (typeof len !== 'number') len = 0 const req = FileRequest.borrow() try { binding.ftruncateSync(req.handle, fd, len) } catch (e) { throw new FileError(e.message, { operation: 'ftruncate', code: e.code, fd }) } finally { req.return() } } async function truncate(filepath, len, cb) { let fd = -1 let err try { fd = await open(filepath, 'r+') await ftruncate(fd, len) } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, cb) } function truncateSync(filepath, len) { let fd = -1 let err try { fd = openSync(filepath, 'r+') ftruncateSync(fd, len) } catch (e) { err = e } finally { if (fd !== -1) closeSync(fd) } } async function chmod(filepath, mode, cb) { if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.chmod(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'chmod', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function chmodSync(filepath, mode) { if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.chmodSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'chmod', code: e.code, path: filepath }) } finally { req.return() } } async function fchmod(fd, mode, cb) { if (typeof mode === 'string') mode = toMode(mode) const req = FileRequest.borrow() let err = null try { binding.fchmod(req.handle, fd, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'fchmod', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fchmodSync(fd, mode) { if (typeof mode === 'string') mode = toMode(mode) const req = FileRequest.borrow() try { binding.fchmodSync(req.handle, fd, mode) } catch (e) { throw new FileError(e.message, { operation: 'fchmod', code: e.code, fd }) } finally { req.return() } } async function chown(filepath, uid, gid, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.chown(req.handle, filepath, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'chown', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function chownSync(filepath, uid, gid) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.chownSync(req.handle, filepath, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'chownSync', code: e.code, path: filepath }) } finally { req.return() } } async function lchown(filepath, uid, gid, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.lchown(req.handle, filepath, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'lchown', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function lchownSync(filepath, uid, gid) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lchownSync(req.handle, filepath, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'lchownSync', code: e.code, path: filepath }) } finally { req.return() } } async function fchown(fd, uid, gid, cb) { const req = FileRequest.borrow() let err = null try { binding.fchown(req.handle, fd, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'fchown', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fchownSync(fd, uid, gid) { const req = FileRequest.borrow() try { binding.fchownSync(req.handle, fd, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'fchownSync', code: e.code, fd }) } finally { req.return() } } async function utimes(filepath, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.utimes(req.handle, filepath, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'utimes', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function utimesSync(filepath, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.utimesSync(req.handle, filepath, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'utimes', code: e.code, path: filepath }) } finally { req.return() } } async function lutimes(filepath, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.lutimes(req.handle, filepath, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'lutimes', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function lutimesSync(filepath, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lutimesSync(req.handle, filepath, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'lutimes', code: e.code, path: filepath }) } finally { req.return() } } async function futimes(fd, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 const req = FileRequest.borrow() let err = null try { binding.futimes(req.handle, fd, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'futimes', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function futimesSync(fd, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 const req = FileRequest.borrow() try { binding.futimesSync(req.handle, fd, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'futimesSync', code: e.code, fd }) } finally { req.return() } } async function link(src, dst, cb) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.link(req.handle, src, dst) await req } catch (e) { err = new FileError(e.message, { operation: 'link', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function linkSync(src, dst) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.linkSync(req.handle, src, dst) } catch (e) { throw new FileError(e.message, { operation: 'linkSync', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function mkdir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = { mode: 0o777 } } if (typeof opts === 'number') opts = { mode: opts } else if (!opts) opts = {} const mode = typeof opts.mode === 'number' ? opts.mode : 0o777 filepath = toNamespacedPath(filepath) if (opts.recursive) { let err = null try { try { await mkdir(filepath, { mode }) } catch (err) { if (err.code !== 'ENOENT') { if (!(await stat(filepath)).isDirectory()) throw err } else { while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1) const i = filepath.lastIndexOf(path.sep) if (i <= 0) throw err await mkdir(filepath.slice(0, i), { mode, recursive: true }) try { await mkdir(filepath, { mode }) } catch (err) { if (!(await stat(filepath)).isDirectory()) throw err } } } } catch (e) { err = e } return done(err, cb) } const req = FileRequest.borrow() let err = null try { binding.mkdir(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'mkdir', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function mkdirSync(filepath, opts) { if (typeof opts === 'number') opts = { mode: opts } else if (!opts) opts = {} const mode = typeof opts.mode === 'number' ? opts.mode : 0o777 filepath = toNamespacedPath(filepath) if (opts.recursive) { try { mkdirSync(filepath, { mode }) } catch (err) { if (err.code !== 'ENOENT') { if (!statSync(filepath).isDirectory()) throw err } else { while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1) const i = filepath.lastIndexOf(path.sep) if (i <= 0) throw err mkdirSync(filepath.slice(0, i), { mode, recursive: true }) try { mkdirSync(filepath, { mode }) } catch (err) { if (!statSync(filepath).isDirectory()) throw err } } } return } const req = FileRequest.borrow() try { binding.mkdirSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'mkdir', code: e.code, path: filepath }) } finally { req.return() } } async function mkdtemp(prefix, cb) { prefix = toNamespacedPath(prefix) const req = FileRequest.borrow() let res let err = null try { binding.mkdtemp(req.handle, prefix + 'XXXXXX') await req res = binding.requestResultPath(req.handle) } catch (e) { err = new FileError(e.message, { operation: 'mkdtemp', code: e.code, path: prefix }) } finally { req.return() } return done(err, res, cb) } function mkdtempSync(prefix) { prefix = toNamespacedPath(prefix) const req = FileRequest.borrow() try { binding.mkdtempSync(req.handle, prefix + 'XXXXXX') return binding.requestResultPath(req.handle) } catch (e) { throw new FileError(e.message, { operation: 'mkdtempSync', code: e.code, path: prefix }) } finally { req.return() } } async function rmdir(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.rmdir(req.handle, filepath) await req } catch (e) { err = new FileError(e.message, { operation: 'rmdir', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function rmdirSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.rmdirSync(req.handle, filepath) } catch (e) { throw new FileError(e.message, { operation: 'rmdir', code: e.code, path: filepath }) } finally { req.return() } } async function rm(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} filepath = toNamespacedPath(filepath) let err = null try { const st = await lstat(filepath) if (st.isDirectory()) { if (opts.recursive) { try { await rmdir(filepath) } catch (err) { if (err.code !== 'ENOTEMPTY') throw err const files = await readdir(filepath) for (const file of files) { await rm(filepath + path.sep + file, opts) } await rmdir(filepath) } } else { throw new FileError('is a directory', { operation: 'rm', code: 'EISDIR', path: filepath }) } } else { await unlink(filepath) } } catch (e) { if (e.code !== 'ENOENT' || !opts.force) err = e } return done(err, cb) } function rmSync(filepath, opts) { if (!opts) opts = {} filepath = toNamespacedPath(filepath) try { const st = lstatSync(filepath) if (st.isDirectory()) { if (opts.recursive) { try { rmdirSync(filepath) } catch (err) { if (err.code !== 'ENOTEMPTY') throw err const files = readdirSync(filepath) for (const file of files) { rmSync(filepath + path.sep + file, opts) } rmdirSync(filepath) } } else { throw new FileError('is a directory', { operation: 'rm', code: 'EISDIR', path: filepath }) } } else { unlinkSync(filepath) } } catch (err) { if (err.code !== 'ENOENT' || !opts.force) throw err } } async function unlink(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.unlink(req.handle, filepath) await req } catch (e) { err = new FileError(e.message, { operation: 'unlink', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function unlinkSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.unlinkSync(req.handle, filepath) } catch (e) { throw new FileError(e.message, { operation: 'unlink', code: e.code, path: filepath }) } finally { req.return() } } async function rename(src, dst, cb) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.rename(req.handle, src, dst) await req } catch (e) { err = new FileError(e.message, { operation: 'rename', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function renameSync(src, dst) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.renameSync(req.handle, src, dst) } catch (e) { throw new FileError(e.message, { operation: 'rename', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function copyFile(src, dst, mode = 0, cb) { if (typeof mode === 'function') { cb = mode mode = 0 } src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.copyfile(req.handle, src, dst, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'copyfile', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function copyFileSync(src, dst, mode = 0) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.copyfileSync(req.handle, src, dst, mode) } catch (e) { throw new FileError(e.message, { operation: 'copyfile', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function cp(src, dst, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} src = toNamespacedPath(src) dst = toNamespacedPath(dst) let err = null try { const st = await lstat(src) if (st.isDirectory()) { if (opts.recursive !== true) { throw new FileError('is a directory', { operation: 'cp', code: 'EISDIR', path: src }) } try { await lstat(dst) } catch (e) { if (e.code !== 'ENOENT') throw e await mkdir(dst, { mode: st.mode, recursive: true }) } const dir = await opendir(src) for await (const { name } of dir) { await cp(path.join(src, name), path.join(dst, name), opts) } } else if (st.isFile()) { await copyFile(src, dst) await chmod(dst, st.mode) } } catch (e) { err = e } return done(err, cb) } function cpSync(src, dst, opts = {}) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const st = lstatSync(src) if (st.isDirectory()) { if (opts.recursive !== true) { throw new FileError('is a directory', { operation: 'cp', code: 'EISDIR', path: src }) } try { lstatSync(dst) } catch (e) { if (e.code !== 'ENOENT') throw e mkdirSync(dst, { mode: st.mode, recursive: true }) } const dir = opendirSync(src) for (const { name } of dir) { cpSync(path.join(src, name), path.join(dst, name), opts) } } else if (st.isFile()) { copyFileSync(src, dst) chmodSync(dst, st.mode) } } async function realpath(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let res let err = null try { binding.realpath(req.handle, filepath) await req res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) } catch (e) { err = new FileError(e.message, { operation: 'realpath', code: e.code, path: filepath }) } finally { req.return() } return done(err, res, cb) } function realpathSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.realpathSync(req.handle, filepath) let res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) return res } catch (e) { throw new FileError(e.message, { operation: 'realpath', code: e.code, path: filepath }) } finally { req.return() } } async function readlink(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let res let err = null try { binding.readlink(req.handle, filepath) await req res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) } catch (e) { err = new FileError(e.message, { operation: 'readlink', code: e.code, path: filepath }) } finally { req.return() } return done(err, res, cb) } function readlinkSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.readlinkSync(req.handle, filepath) let res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) return res } catch (e) { throw new FileError(e.message, { operation: 'readlink', code: e.code, path: filepath }) } finally { req.return() } } async function fsync(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.fsync(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'fsync', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fsyncSync(fd) { const req = FileRequest.borrow() try { binding.fsyncSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'fsyncSync', code: e.code, fd }) } finally { req.return() } } async function fdatasync(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.fdatasync(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'fdatasync', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fdatasyncSync(fd) { const req = FileRequest.borrow() try { binding.fdatasyncSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'fdatasyncSync', code: e.code, fd }) } finally { req.return() } } function normalizeSymlinkTarget(target, type, filepath) { if (isWindows) { if (type === constants.UV_FS_SYMLINK_JUNCTION) target = path.resolve(filepath, '..', target) if (path.isAbsolute(target)) return path.toNamespacedPath(target) return target.replace(/\//g, path.sep) } return target } async function symlink(target, filepath, type, cb) { if (typeof type === 'function') { cb = type type = null } filepath = toNamespacedPath(filepath) if (typeof type === 'string') { switch (type) { case 'dir': type = constants.UV_FS_SYMLINK_DIR break case 'junction': type = constants.UV_FS_SYMLINK_JUNCTION break case 'file': default: type = 0 break } } else if (typeof type !== 'number') { if (isWindows) { target = path.resolve(filepath, '..', target) try { type = (await stat(target)).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION } catch { type = 0 } } else { type = 0 } } target = normalizeSymlinkTarget(target, type, filepath) const req = FileRequest.borrow() let err = null try { binding.symlink(req.handle, target, filepath, type) await req } catch (e) { err = new FileError(e.message, { operation: 'symlink', code: e.code, path: target, destination: filepath }) } finally { req.return() } return done(err, cb) } function symlinkSync(target, filepath, type) { filepath = toNamespacedPath(filepath) if (typeof type === 'string') { switch (type) { case 'dir': type = constants.UV_FS_SYMLINK_DIR break case 'junction': type = constants.UV_FS_SYMLINK_JUNCTION break case 'file': default: type = 0 break } } else if (typeof type !== 'number') { if (isWindows) { target = path.resolve(filepath, '..', target) try { type = statSync(target).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION } catch { type = 0 } } else { type = 0 } } target = normalizeSymlinkTarget(target, type, filepath) const req = FileRequest.borrow() try { binding.symlinkSync(req.handle, target, filepath, type) } catch (e) { throw new FileError(e.message, { operation: 'symlink', code: e.code, path: target, destination: filepath }) } finally { req.return() } } async function opendir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let dir let err = null try { binding.opendir(req.handle, filepath) await req dir = new Dir(filepath, binding.requestResultDir(req.handle), opts) } catch (e) { err = new FileError(e.message, { operation: 'opendir', code: e.code, path: filepath }) } finally { req.return() } return done(err, dir, cb) } function opendirSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.opendirSync(req.handle, filepath) return new Dir(filepath, binding.requestResultDir(req.handle), opts) } catch (e) { throw new FileError(e.message, { operation: 'opendir', code: e.code, path: filepath }) } finally { req.return() } } async function readdir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { withFileTypes = false, recursive = false } = opts filepath = toNamespacedPath(filepath) const queue = [filepath] let result = [] let err = null try { while (queue.length !== 0) { const dir = await opendir(queue.pop()) for await (const entry of dir) { const entryPath = path.join(entry.parentPath, entry.name) if (withFileTypes) { result.push(entry) } else { result.push(path.relative(filepath, entryPath)) } if (recursive && entry.isDirectory()) queue.push(entryPath) } } } catch (e) { result = [] err = e } return done(err, result, cb) } function readdirSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { withFileTypes = false, recursive = false } = opts filepath = toNamespacedPath(filepath) const queue = [filepath] const result = [] while (queue.length !== 0) { const dir = opendirSync(queue.pop(), opts) for (const entry of dir) { const entryPath = path.join(entry.parentPath, entry.name) if (withFileTypes) { result.push(entry) } else { result.push(path.relative(filepath, entryPath)) } if (recursive && entry.isDirectory()) queue.push(entryPath) } } return result } async function readFile(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'buffer' } = opts let fd = -1 let buffer = null let err = null try { fd = await open(filepath, opts.flag || 'r') const st = await fstat(fd) let len = 0 if (st.size === 0) { const buffers = [] while (true) { buffer = Buffer.allocUnsafe(8192) const r = await read(fd, buffer) len += r if (r === 0) break buffers.push(buffer.subarray(0, r)) } buffer = Buffer.concat(buffers) } else { buffer = Buffer.allocUnsafe(st.size) while (true) { const r = await read(fd, len ? buffer.subarray(len) : buffer) len += r if (r === 0 || len === buffer.byteLength) break } if (len !== buffer.byteLength) buffer = buffer.subarray(0, len) } if (encoding !== 'buffer') buffer = buffer.toString(encoding) } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, buffer, cb) } function readFileSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'buffer' } = opts let fd = -1 try { fd = openSync(filepath, opts.flag || 'r') const st = fstatSync(fd) let buffer let len = 0 if (st.size === 0) { const buffers = [] while (true) { buffer = Buffer.allocUnsafe(8192) const r = readSync(fd, buffer) len += r if (r === 0) break buffers.push(buffer.subarray(0, r)) } buffer = Buffer.concat(buffers) } else { buffer = Buffer.allocUnsafe(st.size) while (true) { const r = readSync(fd, len ? buffer.subarray(len) : buffer) len += r if (r === 0 || len === buffer.byteLength) break } if (len !== buffer.byteLength) buffer = buffer.subarray(0, len) } if (encoding !== 'buffer') buffer = buffer.toString(encoding) return buffer } finally { if (fd !== -1) closeSync(fd) } } async function writeFile(filepath, data, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (typeof data === 'string') data = Buffer.from(data, opts.encoding) let fd = -1 let len = 0 let err = null try { fd = await open(filepath, opts.flag || 'w', opts.mode || 0o666) while (true) { len += await write(fd, len ? data.subarray(len) : data) if (len === data.byteLength) break } } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, len, cb) } function writeFileSync(filepath, data, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (typeof data === 'string') data = Buffer.from(data, opts.encoding) let fd = -1 try { fd = openSync(filepath, opts.flag || 'w', opts.mode || 0o666) let len = 0 while (true) { len += writeSync(fd, len ? data.subarray(len) : data) if (len === data.byteLength) break } } finally { if (fd !== -1) closeSync(fd) } } function appendFile(filepath, data, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (!opts.flag) opts = { ...opts, flag: 'a' } return writeFile(filepath, data, opts, cb) } function appendFileSync(filepath, data, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (!opts.flag) opts = { ...opts, flag: 'a' } return writeFileSync(filepath, data, opts) } function watch(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) return new Watcher(filepath, opts, cb) } class Stats { constructor( dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs ) { this.dev = dev this.mode = mode this.nlink = nlink this.uid = uid this.gid = gid this.rdev = rdev this.blksize = blksize this.ino = ino this.size = size this.blocks = blocks this.atimeMs = atimeMs this.mtimeMs = mtimeMs this.ctimeMs = ctimeMs this.birthtimeMs = birthtimeMs this.atime = new Date(atimeMs) this.mtime = new Date(mtimeMs) this.ctime = new Date(ctimeMs) this.birthtime = new Date(birthtimeMs) } isDirectory() { return (this.mode & constants.S_IFMT) === constants.S_IFDIR } isFile() { return (this.mode & constants.S_IFMT) === constants.S_IFREG } isBlockDevice() { return (this.mode & constants.S_IFMT) === constants.S_IFBLK } isCharacterDevice() { return (this.mode & constants.S_IFMT) === constants.S_IFCHR } isFIFO() { return (this.mode & constants.S_IFMT) === constants.S_IFIFO } isSymbolicLink() { return (this.mode & constants.S_IFMT) === constants.S_IFLNK } isSocket() { return (this.mode & constants.S_IFMT) === constants.S_IFSOCK } } class StatFs { constructor(type, bsize, blocks, bfree, bavail, files, ffree) { this.type = type this.bsize = bsize this.blocks = blocks this.bfree = bfree this.bavail = bavail this.files = files this.ffree = ffree } } class Dir { constructor(path, handle, opts = {}) { const { encoding = 'utf8', bufferSize = 32 } = opts this.path = path this._encoding = encoding this._capacity = bufferSize this._buffer = new FIFO() this._ended = false this._handle = handle } async read(cb) { if (this._buffer.length) return ok(this._buffer.shift(), cb) if (this._ended) return ok(null, cb) const req = FileRequest.borrow() let entries let err = null try { req.retain(binding.readdir(req.handle, this._handle, this._capacity)) await req entries = binding.requestResultDirents(req.handle) } catch (e) { err = new FileError(e.message, { operation: 'readdir', code: e.code, path: this.path }) } finally { req.return() } if (err) return fail(err, cb) if (entries.length === 0) { this._ended = true return ok(null, cb) } for (const entry of entries) { let name = Buffer.from(entry.name) if (this._encoding !== 'buffer') name = name.toString(this._encoding) this._buffer.push(new Dirent(this.path, name, entry.type)) } return ok(this._buffer.shift(), cb) } readSync() { if (this._buffer.length) return this._buffer.shift() if (this._ended) return null const req = FileRequest.borrow() let entries try { req.retain(binding.readdirSync(req.handle, this._handle, this._capacity)) entries = binding.requestResultDirents(req.handle) } catch (e) { throw new FileError(e.message, { operation: 'readdir', code: e.code, path: this.path }) } finally { req.return() } if (entries.length === 0) { this._ended = true return null } for (const entry of entries) { let name = Buffer.from(entry.name) if (this._encoding !== 'buffer') name = name.toString(this._encoding) this._buffer.push(new Dirent(this.path, name, entry.type)) } return this._buffer.shift() } async close(cb) { const req = FileRequest.borrow() let err = null try { binding.closedir(req.handle, this._handle) await req } catch (e) { err = new FileError(e.message, { operation: 'closedir', code: e.code, path: this.path }) } finally { req.return() } this._handle = null return done(err, cb) } closeSync() { const req = FileRequest.borrow() try { binding.closedirSync(req.handle, this._handle) } catch (e) { throw new FileError(e.message, { operation: 'closedir', code: e.code, path: this.path }) } finally { req.return() } this._handle = null } [Symbol.dispose]() { this.closeSync() } async [Symbol.asyncDispose]() { await this.close() } *[Symbol.iterator]() { while (true) { const entry = this.readSync() if (entry === null) break yield entry } this.closeSync() } async *[Symbol.asyncIterator]() { while (true) { const entry = await this.read() if (entry === null) break yield entry } await this.close() } } class Dirent { constructor(parentPath, name, type) { this.parentPath = parentPath this.name = name this.type = type } isFile() { return this.type === constants.UV_DIRENT_FILE } isDirectory() { return this.type === constants.UV_DIRENT_DIR } isSymbolicLink() { return this.type === constants.UV_DIRENT_LINK } isFIFO() { return this.type === constants.UV_DIRENT_FIFO } isSocket() { return this.type === constants.UV_DIRENT_SOCKET } isCharacterDevice() { return this.type === constants.UV_DIRENT_CHAR } isBlockDevice() { return this.type === constants.UV_DIRENT_BLOCK } } class FileReadStream extends Readable { constructor(path, opts = {}) { const { eagerOpen = true } = opts super({ eagerOpen, ...opts }) this.path = path this.fd = typeof opts.fd === 'number' ? opts.fd : -1 this.flags = opts.flags || 'r' this.mode = opts.mode || 0o666 this._offset = opts.start || 0 this._missing = 0 if (opts.length) { this._missing = opts.length } else if (typeof opts.end === 'number') { this._missing = opts.end - this._offset + 1 } else { this._missing = -1 } } async _open(cb) { let err if (this.fd === -1) { err = null try { this.fd = await open(this.path, this.flags, this.mode) } catch (e) { err = e } if (err) return cb(err) } let st err = null try { st = await fstat(this.fd) } catch (e) { err = e } if (err) return cb(err) if (this._missing === -1) this._missing = st.size if (st.size < this._offset) { this._offset = st.size this._missing = 0 } else if (st.size < this._offset + this._missing) { this._missing = st.size - this._offset } cb(null) } async _read(size) { if (this._missing <= 0) return this.push(null) const data = Buffer.allocUnsafe(Math.min(this._missing, size)) let len let err = null try { len = await read(this.fd, data, 0, data.byteLength, this._offset) } catch (e) { err = e } if (err) return this.destroy(err) if (len === 0) return this.push(null) if (this._missing < len) len = this._missing this._missing -= len this._offset += len this.push(data.subarray(0, len)) } async _destroy(err, cb) { if (this.fd === -1) return cb(err) try { await close(this.fd) } catch (e) { err = err || e } cb(err) } } class FileWriteStream extends Writable { constructor(path, opts = {}) { const { eagerOpen = true } = opts super({ eagerOpen, ...opts }) this.path = path this.fd = typeof opts.fd === 'number' ? opts.fd : -1 this.flags = opts.flags || 'w' this.mode = opts.mode || 0o666 } async _open(cb) { if (this.fd !== -1) return cb(null) let err = null try { this.fd = await open(this.path, this.flags, this.mode) } catch (e) { err = e } cb(err) } async _writev(batch, cb) { let err = null try { await writev( this.fd, batch.map(({ chunk }) => chunk) ) } catch (e) { err = e } cb(err) } async _destroy(err, cb) { if (this.fd === -1) return cb(err) try { await close(this.fd) } catch (e) { err = err || e } cb(err) } } class Watcher extends EventEmitter { constructor(path, opts, onchange) { if (typeof opts === 'function') { onchange = opts opts = {} } if (!opts) opts = {} const { persistent = true, recursive = false, encoding = 'utf8' } = opts super() this._closed = false this._encoding = encoding this._handle = binding.watcherInit(path, recursive, this, this._onevent, this._onclose) if (!persistent) this.unref() if (onchange) this.on('change', onchange) } close() { if (this._closed) return this._closed = true binding.watcherClose(this._handle) } ref() { if (this._handle) binding.watcherRef(this._handle) return this } unref() { if (this._handle) binding.watcherUnref(this._handle) return this } [Symbol.asyncIterator]() { const buffer = [] let done = false let error = null let next = null this.on('change', (eventType, filename) => { if (next) { next.resolve({ done: false, value: { eventType, filename } }) next = null } else { buffer.push({ eventType, filename }) } }) .on('error', (err) => { done = true error = err if (next) { next.reject(error) next = null } }) .on('close', () => { done = true if (next) { next.resolve({ done }) next = null } }) return { next: () => new Promise((resolve, reject) => { if (error) return reject(error) if (buffer.length) return resolve({ done: false, value: buffer.shift() }) if (done) return resolve({ done }) next = { resolve, reject } }) } } _onevent(err, events, filename) { if (err) { this.close() this.emit('error', err) } else { const path = this._encoding === 'buffer' ? Buffer.from(filename) : Buffer.from(filename).toString(this._encoding) if (events & binding.UV_RENAME) { this.emit('change', 'rename', path) } if (events & binding.UV_CHANGE) { this.emit('change', 'change', path) } } } _onclose() { this._handle = null this.emit('close') } } exports.access = access exports.appendFile = appendFile exports.chmod = chmod exports.chown = chown exports.close = close exports.copyFile = copyFile exports.cp = cp exports.exists = exists exports.fchmod = fchmod exports.fchown = fchown exports.fdatasync = fdatasync exports.fstat = fstat exports.fsync = fsync exports.ftruncate = ftruncate exports.futimes = futimes exports.lchown = lchown exports.lutimes = lutimes exports.link = link exports.lstat = lstat exports.mkdir = mkdir exports.mkdtemp = mkdtemp exports.open = open exports.opendir = opendir exports.read = read exports.readFile = readFile exports.readdir = readdir exports.readlink = readlink exports.readv = readv exports.realpath = realpath exports.rename = rename exports.rm = rm exports.rmdir = rmdir exports.stat = stat exports.statfs = statfs exports.symlink = symlink exports.truncate = truncate exports.unlink = unlink exports.utimes = utimes exports.watch = watch exports.write = write exports.writeFile = writeFile exports.writev = writev exports.accessSync = accessSync exports.appendFileSync = appendFileSync exports.chmodSync = chmodSync exports.chownSync = chownSync exports.closeSync = closeSync exports.copyFileSync = copyFileSync exports.cpSync = cpSync exports.existsSync = existsSync exports.fchmodSync = fchmodSync exports.fchownSync = fchownSync exports.fdatasyncSync = fdatasyncSync exports.fstatSync = fstatSync exports.fsyncSync = fsyncSync exports.ftruncateSync = ftruncateSync exports.futimesSync = futimesSync exports.lchownSync = lchownSync exports.lutimesSync = lutimesSync exports.linkSync = linkSync exports.lstatSync = lstatSync exports.mkdirSync = mkdirSync exports.mkdtempSync = mkdtempSync exports.openSync = openSync exports.opendirSync = opendirSync exports.readFileSync = readFileSync exports.readSync = readSync exports.readdirSync = readdirSync exports.readlinkSync = readlinkSync exports.readvSync = readvSync exports.realpathSync = realpathSync exports.renameSync = renameSync exports.rmSync = rmSync exports.rmdirSync = rmdirSync exports.statSync = statSync exports.statfsSync = statfsSync exports.symlinkSync = symlinkSync exports.truncateSync = truncateSync exports.unlinkSync = unlinkSync exports.utimesSync = utimesSync exports.writeFileSync = writeFileSync exports.writeSync = writeSync exports.writevSync = writevSync exports.promises = require('./promises') exports.Stats = Stats exports.StatFs = StatFs exports.Dir = Dir exports.Dirent = Dirent exports.Watcher = Watcher exports.ReadStream = FileReadStream exports.createReadStream = function createReadStream(path, opts) { return new FileReadStream(path, opts) } exports.WriteStream = FileWriteStream exports.createWriteStream = function createWriteStream(path, opts) { return new FileWriteStream(path, opts) } function toNamespacedPath(filepath) { if (typeof filepath !== 'string') { if (isURL(filepath)) filepath = fileURLToPath(filepath) else filepath = filepath.toString() } return path.toNamespacedPath(filepath) } function toFlags(flags) { switch (flags) { case 'r': return constants.O_RDONLY case 'rs': // Fall through. case 'sr': return constants.O_RDONLY | constants.O_SYNC case 'r+': return constants.O_RDWR case 'rs+': // Fall through. case 'sr+': return constants.O_RDWR | constants.O_SYNC case 'w': return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY case 'wx': // Fall through. case 'xw': return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL case 'w+': return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR case 'wx+': // Fall through. case 'xw+': return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL case 'a': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY case 'ax': // Fall through. case 'xa': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL case 'as': // Fall through. case 'sa': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_SYNC case 'a+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR case 'ax+': // Fall through. case 'xa+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL case 'as+': // Fall through. case 'sa+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_SYNC default: return 0 } } function toMode(mode) { return parseInt(mode, 8) } const binding = require('../binding') module.exports = { O_RDWR: binding.O_RDWR, O_RDONLY: binding.O_RDONLY, O_WRONLY: binding.O_WRONLY, O_CREAT: binding.O_CREAT, O_TRUNC: binding.O_TRUNC, O_APPEND: binding.O_APPEND, F_OK: binding.F_OK || 0, R_OK: binding.R_OK || 0, W_OK: binding.W_OK || 0, X_OK: binding.X_OK || 0, S_IFMT: binding.S_IFMT, S_IFREG: binding.S_IFREG, S_IFDIR: binding.S_IFDIR, S_IFCHR: binding.S_IFCHR, S_IFLNK: binding.S_IFLNK, S_IFBLK: binding.S_IFBLK || 0, S_IFIFO: binding.S_IFIFO || 0, S_IFSOCK: binding.S_IFSOCK || 0, S_IRUSR: binding.S_IRUSR || 0, S_IWUSR: binding.S_IWUSR || 0, S_IXUSR: binding.S_IXUSR || 0, S_IRGRP: binding.S_IRGRP || 0, S_IWGRP: binding.S_IWGRP || 0, S_IXGRP: binding.S_IXGRP || 0, S_IROTH: binding.S_IROTH || 0, S_IWOTH: binding.S_IWOTH || 0, S_IXOTH: binding.S_IXOTH || 0, UV_DIRENT_UNKNOWN: binding.UV_DIRENT_UNKNOWN, UV_DIRENT_FILE: binding.UV_DIRENT_FILE, UV_DIRENT_DIR: binding.UV_DIRENT_DIR, UV_DIRENT_LINK: binding.UV_DIRENT_LINK, UV_DIRENT_FIFO: binding.UV_DIRENT_FIFO, UV_DIRENT_SOCKET: binding.UV_DIRENT_SOCKET, UV_DIRENT_CHAR: binding.UV_DIRENT_CHAR, UV_DIRENT_BLOCK: binding.UV_DIRENT_BLOCK, COPYFILE_EXCL: binding.UV_FS_COPYFILE_EXCL, COPYFILE_FICLONE: binding.UV_FS_COPYFILE_FICLONE, COPYFILE_FICLONE_FORCE: binding.UV_FS_COPYFILE_FICLONE_FORCE, UV_FS_SYMLINK_DIR: binding.UV_FS_SYMLINK_DIR, UV_FS_SYMLINK_JUNCTION: binding.UV_FS_SYMLINK_JUNCTION } const os = require('bare-os') module.exports = class FileError extends Error { constructor(msg, opts = {}) { const { code, operation = null, path = null, destination = null, fd = -1 } = opts if (operation !== null) msg += describe(operation, opts) super(`${code}: ${msg}`) this.code = code if (operation !== null) this.operation = operation if (path !== null) this.path = path if (destination !== null) this.destination = destination if (fd !== -1) this.fd = fd } get name() { return 'FileError' } // For Node.js compatibility get errno() { return os.constants.errnos[this.code] } // For Node.js compatibility get syscall() { return this.operation } // For Node.js compatibility get dest() { return this.destination } } function describe(operation, opts) { const { path = null, destination = null, fd = -1 } = opts let result = `, ${operation}` if (path !== null) { result += ` ${JSON.stringify(path)}` if (destination !== null) { result += ` -> ${JSON.stringify(destination)}` } } else if (fd !== -1) { result += ` ${fd}` } return result } { "name": "bare-fs", "version": "4.7.2", "description": "Native file system operations for Bare", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./promises": { "types": "./promises.d.ts", "default": "./promises.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" } }, "files": [ "index.js", "index.d.ts", "promises.js", "promises.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-fs.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-fs/issues" }, "homepage": "https://github.com/holepunchto/bare-fs#readme", "engines": { "bare": ">=1.16.0" }, "dependencies": { "bare-events": "^2.5.4", "bare-path": "^3.0.0", "bare-stream": "^2.6.4", "bare-url": "^2.2.2", "fast-fifo": "^1.3.2" }, "devDependencies": { "bare-buffer": "^3.0.2", "bare-crypto": "^1.11.2", "brittle": "^3.1.1", "cmake-bare": "^1.1.7", "lunte": "^1.6.0", "prettier": "^3.4.1", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "bare-buffer": "*" }, "peerDependenciesMeta": { "bare-buffer": { "optional": true } } } const EventEmitter = require('bare-events') const fs = require('.') class FileHandle extends EventEmitter { constructor(fd) { super() this.fd = fd } async close() { await fs.close(this.fd) this.fd = -1 this.emit('close') } async read(buffer, ...args) { return { bytesRead: await fs.read(this.fd, buffer, ...args), buffer } } async readv(buffers, ...args) { return { bytesRead: await fs.readv(this.fd, buffers, ...args), buffers } } async write(buffer, ...args) { return { bytesWritten: await fs.write(this.fd, buffer, ...args), buffer } } async writev(buffers, ...args) { return { bytesWritten: await fs.writev(this.fd, buffers, ...args), buffers } } async stat() { return fs.fstat(this.fd) } async chmod(mode) { await fs.fchmod(this.fd, mode) } async chown(uid, gid) { await fs.fchown(this.fd, uid, gid) } async datasync() { return fs.fdatasync(this.fd) } async sync() { return fs.fsync(this.fd) } async truncate(len) { await fs.ftruncate(this.fd, len) } async utimes(atime, mtime) { await fs.futimes(this.fd, atime, mtime) } createReadStream(opts) { return fs.createReadStream(null, { ...opts, fd: this.fd }) } createWriteStream(opts) { return fs.createWriteStream(null, { ...opts, fd: this.fd }) } async [Symbol.asyncDispose]() { await this.close() } } exports.open = async function open(filepath, flags, mode) { return new FileHandle(await fs.open(filepath, flags, mode)) } exports.access = fs.access exports.appendFile = fs.appendFile exports.chmod = fs.chmod exports.chown = fs.chown exports.constants = fs.constants exports.copyFile = fs.copyFile exports.cp = fs.cp exports.lchown = fs.lchown exports.lutimes = fs.lutimes exports.link = fs.link exports.lstat = fs.lstat exports.mkdir = fs.mkdir exports.mkdtemp = fs.mkdtemp exports.opendir = fs.opendir exports.readFile = fs.readFile exports.readdir = fs.readdir exports.readlink = fs.readlink exports.realpath = fs.realpath exports.rename = fs.rename exports.rm = fs.rm exports.rmdir = fs.rmdir exports.stat = fs.stat exports.statfs = fs.statfs exports.truncate = fs.truncate exports.symlink = fs.symlink exports.unlink = fs.unlink exports.utimes = fs.utimes exports.watch = fs.watch exports.writeFile = fs.writeFile module.exports = require.addon() const ansiEscapes = require('bare-ansi-escapes') const getType = require('bare-type') const binding = require('./binding') const PLAIN_KEY = /^[a-zA-Z_][a-zA-Z_0-9]*$/ const defaultDepth = 2 const defaultBreakLength = 80 const defaultMaxArrayLength = 40 module.exports = exports = function inspect(value, opts = {}) { const { colors = false, depth = defaultDepth, breakLength = defaultBreakLength, stylize = defaultStylize(colors) } = opts const references = new InspectRefMap() const tree = inspectValue(value, 0, { colors, depth, breakLength, stylize, references }) return tree.toString() } exports.styles = { bigint: ansiEscapes.colorYellow, boolean: ansiEscapes.colorYellow, date: ansiEscapes.colorMagenta, module: ansiEscapes.modifierUnderline, name: ansiEscapes.modifierReset, null: ansiEscapes.modifierBold, number: ansiEscapes.colorYellow, regexp: ansiEscapes.colorRed, special: ansiEscapes.colorCyan, string: ansiEscapes.colorGreen, symbol: ansiEscapes.colorGreen, undefined: ansiEscapes.colorBrightBlack } const styles = exports.styles function defaultStylize(colors) { return function stylize(value, style) { const color = colors && styles[style] if (color) return color + value + ansiEscapes.modifierReset return value } } class InspectRefMap { constructor() { this.refs = new WeakMap() this.ids = new WeakMap() this.nextId = 1 } has(object) { return this.refs.has(object) } get(object) { return this.refs.get(object) || null } set(object, ref) { this.refs.set(object, ref) } id(object) { let id = this.ids.get(object) if (id) return id id = this.nextId++ this.ids.set(object, id) return id } } class InspectNode { constructor(depth, length, opts) { const { breakLength = defaultBreakLength, breakAlways = false } = opts this.depth = depth this.length = length this.breakLength = breakLength this.breakAlways = breakAlways } pad(n, string) { return string.padStart(n, ' ') } indent(n, string) { return ' '.repeat(n) + string } } class InspectRef extends InspectNode { constructor(depth, opts) { super(depth, '[circular *]'.length, opts) this.refs = opts.references this.count = 0 this.circular = false this.color = opts.colors && styles.special } get id() { return this.refs.id(this) } increment() { return ++this.count } decrement() { return --this.count } toString(opts = {}) { const { offset = 0, pad = 0, indent = 0 } = opts let value = this.pad(pad, '[circular *' + this.id + ']') if (this.color) value = this.color + value + ansiEscapes.modifierReset return offset ? value : this.indent(indent, value) } } class InspectLeaf extends InspectNode { constructor(value, color, depth, opts) { const length = value.length if (value.includes('\n')) { value = value.replaceAll('\n', '\n' + ' '.repeat(depth)) opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.value = value this.color = opts.colors && color } toString(opts = {}) { const { offset = 0, pad = 0, indent = 0 } = opts let value = this.pad(pad, this.value) if (this.color) value = this.color + value + ansiEscapes.modifierReset return offset ? value : this.indent(indent, value) } } class InspectPair extends InspectNode { constructor(delim, left, right, depth, opts) { const length = left.length + delim.length + right.length if (left.breakAlways || right.breakAlways) { opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.delim = delim this.left = left this.right = right } toString(opts = {}) { const { indent = 0 } = opts return this.indent( indent, this.left + this.delim + this.right.toString({ indent, offset: this.left.length + this.delim.length }) ) } } class InspectSuspension extends InspectNode { constructor(overflow, depth, opts) { const label = `... ${overflow} more` super(depth, label.length, opts) this.label = label } toString(opts = {}) { const { indent = 0 } = opts return this.indent(indent, this.label) } } class InspectSequence extends InspectNode { constructor(header, footer, delim, values, ref, depth, opts) { const { tabulate = false } = opts const length = (ref.circular ? ''.length + 1 : 0) + header.length + values.reduce( (length, value, i) => length + value.length + (i === 0 ? 0 : delim.length), 0 ) + footer.length if (values.some((value) => value.breakAlways)) { opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.header = header this.footer = footer this.delim = delim this.values = values this.ref = ref this.tabulate = tabulate } toString(opts = {}) { const { offset = 0, indent = 0 } = opts const split = this.breakAlways || (this.values.length && (offset + this.length > this.breakLength || indent * 2 + this.length > this.breakLength)) let header = this.header if (this.ref.circular) { header = ' ' + header } if (this.values.length === 0) { header = header.trimEnd() } if (offset === 0) { header = this.indent(indent, header) } if (split) { header = header.trimEnd() + '\n' } let string = header let columns = 1 let pad = 0 if (this.tabulate) { const widest = this.values.reduce( (length, value) => value.breakAlways ? length : Math.max(length, value.length), 0 ) if (widest) { columns = Math.max( columns, Math.floor( (this.breakLength - indent * 2) / (widest + this.delim.length) ) ) if (columns > 1) pad = widest } } for (let i = 0, n = this.values.length, offset = 0; i < n; i++) { const value = this.values[i] if (split) { let part if (i % columns === 0 || value.breakAlways) { part = value.toString({ indent: indent + 1, pad }) } else { part = value.toString({ pad }) } string += part if (i < n - 1) { if (i % columns === columns - 1 || this.values[i + 1].breakAlways) { string += this.delim.trimEnd() + '\n' } else { string += this.delim } } } else { if (i > 0) string += this.delim string += value.toString({ offset }) offset += value.length } } let footer = this.footer if (this.values.length === 0) { footer = footer.trimStart() } if (split) { string += '\n' + this.indent(indent, footer.trimStart()) } else { string += footer } return string } } function inspectValue(value, depth, opts) { const type = getType(value) if (type.isUndefined()) return inspectUndefined(depth, opts) if (type.isNull()) return inspectNull(depth, opts) if (type.isBoolean()) return inspectBoolean(value, depth, opts) if (type.isNumber()) return inspectNumber(value, depth, opts) if (type.isBigInt()) return inspectBigInt(value, depth, opts) if (type.isString()) return inspectString(value, depth, opts) if (type.isSymbol()) return inspectSymbol(value, depth, opts) if (type.isObject()) return inspectObject(type, value, depth, opts) if (type.isFunction()) return inspectFunction(type, value, depth, opts) if (type.isExternal()) return inspectExternal(value, opts, opts) } function inspectUndefined(depth, opts) { return new InspectLeaf('undefined', styles.undefined, depth, opts) } function inspectNull(depth, opts) { return new InspectLeaf('null', styles.null, depth, opts) } function inspectBoolean(value, depth, opts) { return new InspectLeaf(value.toString(), styles.boolean, depth, opts) } function inspectNumber(value, depth, opts) { let string if (Object.is(value, -0)) { string = '-0' } else { string = value.toString(10) } return new InspectLeaf(string, styles.number, depth, opts) } function inspectBigInt(value, depth, opts) { return new InspectLeaf(value.toString(10) + 'n', styles.bigint, depth, opts) } const STRING_ESCAPES = /[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f'\\\ud800-\udfff]/g function inspectString(value, depth, opts) { // https://tc39.es/ecma262/multipage/structured-data.html#sec-quotejsonstring const string = value.replace(STRING_ESCAPES, (match) => { if (match.length === 2) return match switch (match) { case "'": return "\\'" case '\\': return '\\\\' case '\b': return '\\b' case '\t': return '\\t' case '\n': return '\\n' case '\f': return '\\f' case '\r': return '\\r' default: return '\\u' + match.charCodeAt(0).toString(16).padStart(4, '0') } }) return new InspectLeaf("'" + string + "'", styles.string, depth, opts) } function inspectSymbol(value, depth, opts) { return new InspectLeaf(value.toString(), styles.symbol, depth, opts) } function inspectKey(value, depth, opts) { if (PLAIN_KEY.test(value)) { return new InspectLeaf(value, null, depth, opts) } else { return inspectValue(value, depth, opts) } } function inspectObject(type, object, depth, opts) { const refs = opts.references let ref = refs.get(object) if (ref === null) { ref = new InspectRef(depth, opts) refs.set(object, ref) } else if (ref.count) { ref.circular = true return ref } const maxDepth = typeof opts.depth === 'number' ? opts.depth : Infinity if (maxDepth < depth) { const constructor = object.constructor return new InspectLeaf( '[' + (constructor && constructor.name ? constructor.name : 'Object') + ']', styles.special, depth, opts ) } const inspect = object[Symbol.for('bare.inspect')] || object[Symbol.for('nodejs.util.inspect.custom')] if (typeof inspect === 'function') { const value = inspect.call( object, typeof opts.depth === 'number' ? opts.depth - depth : null, { colors: opts.colors, breakLength: opts.breakLength, stylize: opts.stylize }, exports ) if (typeof value === 'object' && value !== null) { refs.set(value, ref) } if (typeof value !== 'string') { return inspectValue(value, depth, opts) } return new InspectLeaf(value, null, depth, opts) } if (type.isArray()) return inspectArray(object, ref, depth, opts) if (type.isDate()) return inspectDate(object, ref, depth, opts) if (type.isRegExp()) return inspectRegExp(object, ref, depth, opts) if (type.isError()) return inspectError(object, ref, depth, opts) if (type.isPromise()) return inspectPromise(object, ref, depth, opts) if (type.isMap()) return inspectMap(object, ref, depth, opts) if (type.isSet()) return inspectSet(object, ref, depth, opts) if (type.isWeakMap()) return inspectWeakMap(object, ref, depth, opts) if (type.isWeakSet()) return inspectWeakSet(object, ref, depth, opts) if (type.isWeakRef()) return inspectWeakRef(object, ref, depth, opts) if (type.isArrayBuffer()) return inspectArrayBuffer(object, ref, depth, opts) if (type.isSharedArrayBuffer()) return inspectSharedArrayBuffer(object, ref, depth, opts) if (type.isTypedArray()) return inspectTypedArray(object, ref, depth, opts) if (type.isDataView()) return inspectDataView(object, ref, depth, opts) ref.increment() const values = [] for (const key in object) { if (key === 'constructor') continue values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(object[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() let header = '{ ' const tag = object[Symbol.toStringTag] if (tag) header = '[' + tag + '] ' + header if (object.constructor) { const name = object.constructor.name if (name && name !== 'Object') { header = object.constructor.name + ' ' + header } } return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectArray(array, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxArrayLength, 0) for (let i = 0, n = array.length; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(array.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(array[i], depth + 1, opts)) } for (const key of binding.getOwnNonIndexPropertyNames(array)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(array[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() let header = '[ ' if (array.constructor.name !== 'Array') { header = array.constructor.name + '(' + array.length + ') ' + header } return new InspectSequence(header, ' ]', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectDate(date, ref, depth, opts) { return new InspectLeaf(date.toISOString(), styles.date, depth, opts) } function inspectRegExp(regExp, ref, depth, opts) { return new InspectLeaf(regExp.toString(), styles.regexp, depth, opts) } function inspectError(error, ref, depth, opts) { let header if ('stack' in error) { header = error.stack if (depth > 0) { header = header.replaceAll('\n', '\n' + ' '.repeat(depth)) } } else { header = error.toString() } const builtins = ['cause'] if (error.name === 'AggregateError') { builtins.push('errors') } else if (error.name === 'SuppressedError') { builtins.push('error', 'suppressed') } const values = [] for (const key of builtins) { if (key in error === false) continue values.push( new InspectPair( ': ', new InspectLeaf('[' + key + ']', null, depth + 1, opts), inspectValue(error[key], depth + 1, opts), depth + 1, opts ) ) } for (const key in error) { if (key === 'constructor' || builtins.includes(key)) continue values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(error[key], depth + 1, opts), depth + 1, opts ) ) } if (values.length === 0) return new InspectLeaf(header, null, depth, opts) return new InspectSequence( header + ' {', ' }', ', ', values, ref, depth, opts ) } function inspectPromise(promise, ref, depth, opts) { ref.increment() const state = binding.getPromiseState(promise) const values = [] switch (state) { case 0: // Pending values.push(new InspectLeaf('', styles.special, depth, opts)) break case 1: // Fulfilled values.push(inspectValue(binding.getPromiseResult(promise), depth, opts)) break case 2: // Rejected values.push( new InspectLeaf('', styles.special, depth, opts), inspectValue(binding.getPromiseResult(promise), depth, opts) ) } ref.decrement() const header = promise.constructor.name + ' { ' return new InspectSequence(header, ' }', ' ', values, ref, depth, opts) } function inspectMap(map, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxMapLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = maxMapLength for (const entry of map) { if (remaining-- === 0) { values.push( new InspectSuspension(map.size - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push( new InspectPair( ' => ', inspectValue(entry[0], depth + 1, opts), inspectValue(entry[1], depth + 1, opts), depth + 1, opts ) ) } for (const key in map) { if (key === 'constructor') continue const value = inspectValue(map[key], depth + 1, opts) values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), value, depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = map.constructor.name + '(' + map.size + ') { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectSet(set, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxSetLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = maxSetLength for (const entry of set) { if (remaining-- === 0) { values.push( new InspectSuspension(set.size - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(entry, depth + 1, opts)) } for (const key in set) { if (key === 'constructor') continue const value = inspectValue(set[key], depth + 1, opts) values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), value, depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = set.constructor.name + '(' + set.size + ') { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectWeakMap(weakMap, ref, depth, opts) { const header = weakMap.constructor.name + ' { ' return new InspectSequence( header, ' }', ' ', [new InspectLeaf('', styles.special, depth + 1, opts)], ref, depth, opts ) } function inspectWeakSet(weakSet, ref, depth, opts) { const header = weakSet.constructor.name + ' { ' return new InspectSequence( header, ' }', ' ', [new InspectLeaf('', styles.special, depth + 1, opts)], ref, depth, opts ) } function inspectWeakRef(weakRef, ref, depth, opts) { const target = weakRef.deref() let value if (target === undefined) { value = new InspectLeaf('', styles.special, depth + 1, opts) } else { value = inspectValue(target, depth + 1, opts) } const header = weakRef.constructor.name + ' { ' return new InspectSequence(header, ' }', ' ', [value], ref, depth, opts) } function inspectArrayBuffer(arrayBuffer, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(arrayBuffer[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = arrayBuffer.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectSharedArrayBuffer(sharedArrayBuffer, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(sharedArrayBuffer[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = sharedArrayBuffer.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectTypedArray(typedArray, ref, depth, opts) { if (Buffer.isBuffer(typedArray)) { return inspectBuffer(typedArray, ref, depth, opts) } const { maxArrayLength = defaultMaxArrayLength, maxTypedArrayLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxTypedArrayLength, 0) for (let i = 0, n = typedArray.length; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(typedArray.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(typedArray[i], depth + 1, opts)) } for (const key of binding.getOwnNonIndexPropertyNames(typedArray)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(typedArray[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = typedArray.constructor.name + '(' + typedArray.length + ') [ ' return new InspectSequence(header, ' ]', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectBuffer(buffer, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxBufferLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxBufferLength, 0) for (let i = 0, n = buffer.byteLength; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(buffer.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push( new InspectLeaf( buffer[i].toString(16).padStart(2, '0'), null, depth + 1, opts ) ) } for (const key of binding.getOwnNonIndexPropertyNames(buffer)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(buffer[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() return new InspectSequence('', ' ', values, ref, depth, { ...opts, tabulate: true }) } function inspectDataView(dataView, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength', 'byteOffset', 'buffer']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(dataView[key], depth + 1, opts), depth + 1, opts ) ) } for (const key of binding.getOwnNonIndexPropertyNames(dataView)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(dataView[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = dataView.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectFunction(type, fn, depth, opts) { if (fn.toString().startsWith('class')) return inspectClass(fn, depth, opts) let tag = 'function' if (type.isGeneratorFunction()) tag = 'generator ' + tag if (type.isAsyncFunction()) tag = 'async ' + tag return new InspectLeaf( '[' + tag + ' ' + (fn.name ? fn.name : '(anonymous)') + ']', styles.special, depth, opts ) } function inspectClass(ctor, depth, opts) { return new InspectLeaf( '[class ' + (ctor.name ? ctor.name : '(anonymous)') + ']', styles.special, depth, opts ) } function inspectExternal(external, depth, opts) { return new InspectLeaf( '[external 0x' + binding.getExternal(external).toString(16) + ']', styles.special, depth, opts ) } { "name": "bare-inspect", "version": "3.1.4", "description": "Inspect objects as strings for debugging", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-inspect.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-inspect/issues" }, "homepage": "https://github.com/holepunchto/bare-inspect#readme", "engines": { "bare": ">=1.18.0" }, "dependencies": { "bare-ansi-escapes": "^2.1.0", "bare-type": "^1.0.0" }, "devDependencies": { "brittle": "^3.3.2", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const binding = require('./binding') const errors = require('./lib/errors') const constants = require('./lib/constants') exports.constants = constants exports.errors = errors exports.EOL = binding.platform === 'win32' ? '\r\n' : '\n' exports.devNull = binding.platform === 'win32' ? '\\\\.\\nul' : '/dev/null' exports.platform = function platform() { return binding.platform } exports.arch = function arch() { return binding.arch } exports.type = binding.type exports.version = binding.version exports.release = binding.release exports.machine = binding.machine exports.execPath = binding.execPath exports.pid = binding.pid exports.ppid = binding.ppid exports.cwd = binding.cwd exports.chdir = binding.chdir exports.tmpdir = binding.tmpdir exports.homedir = binding.homedir exports.hostname = binding.hostname exports.userInfo = binding.userInfo exports.groupInfo = binding.groupInfo exports.networkInterfaces = function networkInterfaces() { const result = {} for (const entry of binding.networkInterfaces()) { const { name, ...properties } = entry if (result[name]) result[name].push(properties) else result[name] = [properties] } return result } exports.kill = function kill(pid, signal = constants.signals.SIGTERM) { if (typeof signal === 'string') { if (signal in constants.signals === false) { throw errors.UNKNOWN_SIGNAL('Unknown signal: ' + signal) } signal = constants.signals[signal] } binding.kill(pid, signal) } exports.endianness = function endianness() { return binding.isLittleEndian ? 'LE' : 'BE' } exports.availableParallelism = binding.availableParallelism exports.cpuUsage = function cpuUsage(previous) { const current = binding.cpuUsage() if (previous) { return { user: current.user - previous.user, system: current.system - previous.system } } return current } exports.threadCpuUsage = function threadCpuUsage(previous) { const current = binding.threadCpuUsage() if (previous) { return { user: current.user - previous.user, system: current.system - previous.system } } return current } exports.resourceUsage = binding.resourceUsage exports.memoryUsage = binding.memoryUsage exports.freemem = binding.freemem exports.totalmem = binding.totalmem exports.availableMemory = binding.availableMemory exports.constrainedMemory = binding.constrainedMemory exports.uptime = binding.uptime exports.loadavg = binding.loadavg exports.cpus = binding.cpus exports.getProcessTitle = binding.getProcessTitle exports.setProcessTitle = function setProcessTitle(title) { if (typeof title !== 'string') title = title.toString() if (title.length >= 256) { throw errors.TITLE_OVERFLOW('Process title is too long') } binding.setProcessTitle(title) } exports.getPriority = function getPriority(pid = 0) { return binding.getPriority(pid) } exports.setPriority = function setPriority(pid, priority) { if (priority === undefined) { priority = pid pid = 0 } binding.setPriority(pid, priority) } exports.getEnvKeys = binding.getEnvKeys exports.getEnv = binding.getEnv exports.hasEnv = binding.hasEnv exports.setEnv = binding.setEnv exports.unsetEnv = binding.unsetEnv const binding = require('../binding') module.exports = { signals: binding.signals, errnos: binding.errnos, priority: binding.priority } module.exports = class OSError extends Error { constructor(msg, fn = OSError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'OSError' } static UNKNOWN_SIGNAL(msg) { return new OSError(msg, OSError.UNKNOWN_SIGNAL) } static TITLE_OVERFLOW(msg) { return new OSError(msg, OSError.TITLE_OVERFLOW) } } { "name": "bare-os", "version": "3.9.1", "description": "Operating system utilities for Bare", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" }, "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors.js" } }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-os.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-os/issues" }, "homepage": "https://github.com/holepunchto/bare-os#readme", "engines": { "bare": ">=1.14.0" }, "devDependencies": { "brittle": "^3.1.1", "cmake-bare": "^1.1.6", "lunte": "^1.6.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0" } } // This export SHOULD NOT be shortened in any way as having the full // `module.exports = require(...)` statement is crucial for synthesizing // ESM exports. if (Bare.platform === 'win32') { module.exports = require('./lib/win32') } else { module.exports = require('./lib/posix') } module.exports = { CHAR_UPPERCASE_A: 0x41, CHAR_LOWERCASE_A: 0x61, CHAR_UPPERCASE_Z: 0x5a, CHAR_LOWERCASE_Z: 0x7a, CHAR_DOT: 0x2e, CHAR_FORWARD_SLASH: 0x2f, CHAR_BACKWARD_SLASH: 0x5c, CHAR_COLON: 0x3a, CHAR_QUESTION_MARK: 0x3f } const os = require('bare-os') const { normalizeString } = require('./shared') const { CHAR_DOT, CHAR_FORWARD_SLASH } = require('./constants') function isPosixPathSeparator(code) { return code === CHAR_FORWARD_SLASH } exports.win32 = require('./win32') exports.posix = exports exports.sep = '/' exports.delimiter = ':' exports.resolve = function resolve(...args) { let resolvedPath = '' let resolvedAbsolute = false for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) { const path = i >= 0 ? args[i] : os.cwd() if (path.length === 0) { continue } resolvedPath = `${path}/${resolvedPath}` resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH } resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator) if (resolvedAbsolute) { return `/${resolvedPath}` } return resolvedPath.length > 0 ? resolvedPath : '.' } exports.normalize = function normalize(path) { if (path.length === 0) return '.' const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator) if (path.length === 0) { if (isAbsolute) return '/' return trailingSeparator ? './' : '.' } if (trailingSeparator) path += '/' return isAbsolute ? `/${path}` : path } exports.isAbsolute = function isAbsolute(path) { return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH } exports.join = function join(...args) { if (args.length === 0) return '.' let joined for (let i = 0; i < args.length; ++i) { const arg = args[i] if (arg.length > 0) { if (joined === undefined) joined = arg else joined += `/${arg}` } } if (joined === undefined) return '.' return exports.normalize(joined) } exports.relative = function relative(from, to) { if (from === to) return '' from = exports.resolve(from) to = exports.resolve(to) if (from === to) return '' const fromStart = 1 const fromEnd = from.length const fromLen = fromEnd - fromStart const toStart = 1 const toLen = to.length - toStart const length = fromLen < toLen ? fromLen : toLen let lastCommonSep = -1 let i = 0 for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i) if (fromCode !== to.charCodeAt(toStart + i)) { break } else if (fromCode === CHAR_FORWARD_SLASH) { lastCommonSep = i } } if (i === length) { if (toLen > length) { if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) { return to.substring(toStart + i + 1) } if (i === 0) { return to.substring(toStart + i) } } else if (fromLen > length) { if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) { lastCommonSep = i } else if (i === 0) { lastCommonSep = 0 } } } let out = '' for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { out += out.length === 0 ? '..' : '/..' } } return `${out}${to.substring(toStart + lastCommonSep)}` } exports.toNamespacedPath = function toNamespacedPath(path) { return path } exports.dirname = function dirname(path) { if (path.length === 0) return '.' const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH let end = -1 let matchedSlash = true for (let i = path.length - 1; i >= 1; --i) { if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { if (!matchedSlash) { end = i break } } else { matchedSlash = false } } if (end === -1) return hasRoot ? '/' : '.' if (hasRoot && end === 1) return '//' return path.substring(0, end) } exports.basename = function basename(path, suffix) { let start = 0 let end = -1 let matchedSlash = true if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) { return '' } let extIdx = suffix.length - 1 let firstNonSlashEnd = -1 for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i) if (code === CHAR_FORWARD_SLASH) { if (!matchedSlash) { start = i + 1 break } } else { if (firstNonSlashEnd === -1) { matchedSlash = false firstNonSlashEnd = i + 1 } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) { end = i } } else { extIdx = -1 end = firstNonSlashEnd } } } } if (start === end) end = firstNonSlashEnd else if (end === -1) end = path.length return path.substring(start, end) } for (let i = path.length - 1; i >= 0; --i) { if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { if (!matchedSlash) { start = i + 1 break } } else if (end === -1) { matchedSlash = false end = i + 1 } } if (end === -1) return '' return path.substring(start, end) } exports.extname = function extname(path) { let startDot = -1 let startPart = 0 let end = -1 let matchedSlash = true let preDotState = 0 for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i) if (code === CHAR_FORWARD_SLASH) { if (!matchedSlash) { startPart = i + 1 break } continue } if (end === -1) { matchedSlash = false end = i + 1 } if (code === CHAR_DOT) { if (startDot === -1) startDot = i else if (preDotState !== 1) preDotState = 1 } else if (startDot !== -1) { preDotState = -1 } } if ( startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return '' } return path.substring(startDot, end) } const { CHAR_DOT, CHAR_FORWARD_SLASH } = require('./constants') exports.normalizeString = function normalizeString( path, allowAboveRoot, separator, isPathSeparator ) { let res = '' let lastSegmentLength = 0 let lastSlash = -1 let dots = 0 let code = 0 for (let i = 0; i <= path.length; ++i) { if (i < path.length) { code = path.charCodeAt(i) } else if (isPathSeparator(code)) { break } else { code = CHAR_FORWARD_SLASH } if (isPathSeparator(code)) { if (lastSlash === i - 1 || dots === 1); else if (dots === 2) { if ( res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT ) { if (res.length > 2) { const lastSlashIndex = res.lastIndexOf(separator) if (lastSlashIndex === -1) { res = '' lastSegmentLength = 0 } else { res = res.substring(0, lastSlashIndex) lastSegmentLength = res.length - 1 - res.lastIndexOf(separator) } lastSlash = i dots = 0 continue } else if (res.length !== 0) { res = '' lastSegmentLength = 0 lastSlash = i dots = 0 continue } } if (allowAboveRoot) { res += res.length > 0 ? `${separator}..` : '..' lastSegmentLength = 2 } } else { if (res.length > 0) { res += `${separator}${path.substring(lastSlash + 1, i)}` } else { res = path.substring(lastSlash + 1, i) } lastSegmentLength = i - lastSlash - 1 } lastSlash = i dots = 0 } else if (code === CHAR_DOT && dots !== -1) { ++dots } else { dots = -1 } } return res } const os = require('bare-os') const { normalizeString } = require('./shared') const { CHAR_UPPERCASE_A, CHAR_LOWERCASE_A, CHAR_UPPERCASE_Z, CHAR_LOWERCASE_Z, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_QUESTION_MARK } = require('./constants') function isWindowsPathSeparator(code) { return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH } function isWindowsDeviceRoot(code) { return ( (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) || (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ) } exports.posix = require('./posix') exports.win32 = exports exports.sep = '\\' exports.delimiter = ';' exports.resolve = function resolve(...args) { let resolvedDevice = '' let resolvedTail = '' let resolvedAbsolute = false for (let i = args.length - 1; i >= -1; i--) { let path if (i >= 0) { path = args[i] if (path.length === 0) continue } else if (resolvedDevice.length === 0) { path = os.cwd() } else { path = os.getEnv(`=${resolvedDevice}`) || os.cwd() if ( path === undefined || (path.substring(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH) ) { path = `${resolvedDevice}\\` } } const len = path.length let rootEnd = 0 let device = '' let isAbsolute = false const code = path.charCodeAt(0) if (len === 1) { if (isWindowsPathSeparator(code)) { rootEnd = 1 isAbsolute = true } } else if (isWindowsPathSeparator(code)) { isAbsolute = true if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { const firstPart = path.substring(last, j) last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len || j !== last) { device = `\\\\${firstPart}\\${path.substring(last, j)}` rootEnd = j } } } } else { rootEnd = 1 } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.substring(0, 2) rootEnd = 2 if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) { isAbsolute = true rootEnd = 3 } } if (device.length > 0) { if (resolvedDevice.length > 0) { if (device.toLowerCase() !== resolvedDevice.toLowerCase()) { continue } } else { resolvedDevice = device } } if (resolvedAbsolute) { if (resolvedDevice.length > 0) { break } } else { resolvedTail = `${path.substring(rootEnd)}\\${resolvedTail}` resolvedAbsolute = isAbsolute if (isAbsolute && resolvedDevice.length > 0) { break } } } resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isWindowsPathSeparator) return resolvedAbsolute ? `${resolvedDevice}\\${resolvedTail}` : `${resolvedDevice}${resolvedTail}` || '.' } exports.normalize = function normalize(path) { const len = path.length if (len === 0) return '.' let rootEnd = 0 let device let isAbsolute = false const code = path.charCodeAt(0) if (len === 1) { return code === CHAR_FORWARD_SLASH ? '\\' : path } if (isWindowsPathSeparator(code)) { isAbsolute = true if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { const firstPart = path.substring(last, j) last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len) { return `\\\\${firstPart}\\${path.substring(last)}\\` } if (j !== last) { device = `\\\\${firstPart}\\${path.substring(last, j)}` rootEnd = j } } } } else { rootEnd = 1 } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.substring(0, 2) rootEnd = 2 if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) { isAbsolute = true rootEnd = 3 } } let tail = rootEnd < len ? normalizeString(path.substring(rootEnd), !isAbsolute, '\\', isWindowsPathSeparator) : '' if (tail.length === 0 && !isAbsolute) { tail = '.' } if (tail.length > 0 && isWindowsPathSeparator(path.charCodeAt(len - 1))) { tail += '\\' } if (device === undefined) { return isAbsolute ? `\\${tail}` : tail } return isAbsolute ? `${device}\\${tail}` : `${device}${tail}` } exports.isAbsolute = function isAbsolute(path) { const len = path.length if (len === 0) return false const code = path.charCodeAt(0) return ( isWindowsPathSeparator(code) || (len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isWindowsPathSeparator(path.charCodeAt(2))) ) } exports.join = function join(...args) { if (args.length === 0) return '.' let joined let firstPart for (let i = 0; i < args.length; ++i) { const arg = args[i] if (arg.length > 0) { if (joined === undefined) joined = firstPart = arg else joined += `\\${arg}` } } if (joined === undefined) return '.' let needsReplace = true let slashCount = 0 if (isWindowsPathSeparator(firstPart.charCodeAt(0))) { ++slashCount const firstLen = firstPart.length if (firstLen > 1 && isWindowsPathSeparator(firstPart.charCodeAt(1))) { ++slashCount if (firstLen > 2) { if (isWindowsPathSeparator(firstPart.charCodeAt(2))) { ++slashCount } else { needsReplace = false } } } } if (needsReplace) { while (slashCount < joined.length && isWindowsPathSeparator(joined.charCodeAt(slashCount))) { slashCount++ } if (slashCount >= 2) { joined = `\\${joined.substring(slashCount)}` } } return exports.normalize(joined) } exports.relative = function relative(from, to) { if (from === to) return '' const fromOrig = exports.resolve(from) const toOrig = exports.resolve(to) if (fromOrig === toOrig) return '' from = fromOrig.toLowerCase() to = toOrig.toLowerCase() if (from === to) return '' let fromStart = 0 while (fromStart < from.length && from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) { fromStart++ } let fromEnd = from.length while (fromEnd - 1 > fromStart && from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) { fromEnd-- } const fromLen = fromEnd - fromStart let toStart = 0 while (toStart < to.length && to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { toStart++ } let toEnd = to.length while (toEnd - 1 > toStart && to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) { toEnd-- } const toLen = toEnd - toStart const length = fromLen < toLen ? fromLen : toLen let lastCommonSep = -1 let i = 0 for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i) if (fromCode !== to.charCodeAt(toStart + i)) { break } else if (fromCode === CHAR_BACKWARD_SLASH) { lastCommonSep = i } } if (i !== length) { if (lastCommonSep === -1) return toOrig } else { if (toLen > length) { if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { return toOrig.substring(toStart + i + 1) } if (i === 2) { return toOrig.substring(toStart + i) } } if (fromLen > length) { if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { lastCommonSep = i } else if (i === 2) { lastCommonSep = 3 } } if (lastCommonSep === -1) lastCommonSep = 0 } let out = '' for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) { out += out.length === 0 ? '..' : '\\..' } } toStart += lastCommonSep if (out.length > 0) { return `${out}${toOrig.substring(toStart, toEnd)}` } if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { ++toStart } return toOrig.substring(toStart, toEnd) } exports.toNamespacedPath = function toNamespacedPath(path) { if (path.length === 0) return path const resolvedPath = exports.resolve(path) if (resolvedPath.length <= 2) return path if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { const code = resolvedPath.charCodeAt(2) if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { return `\\\\?\\UNC\\${resolvedPath.substring(2)}` } } } else if ( isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH ) { return `\\\\?\\${resolvedPath}` } return path } exports.dirname = function dirname(path) { const len = path.length if (len === 0) return '.' let rootEnd = -1 let offset = 0 const code = path.charCodeAt(0) if (len === 1) { return isWindowsPathSeparator(code) ? path : '.' } if (isWindowsPathSeparator(code)) { rootEnd = offset = 1 if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len) { return path } if (j !== last) { rootEnd = offset = j + 1 } } } } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { rootEnd = len > 2 && isWindowsPathSeparator(path.charCodeAt(2)) ? 3 : 2 offset = rootEnd } let end = -1 let matchedSlash = true for (let i = len - 1; i >= offset; --i) { if (isWindowsPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { end = i break } } else { matchedSlash = false } } if (end === -1) { if (rootEnd === -1) return '.' end = rootEnd } return path.substring(0, end) } exports.basename = function basename(path, suffix) { let start = 0 let end = -1 let matchedSlash = true if ( path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON ) { start = 2 } if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) return '' let extIdx = suffix.length - 1 let firstNonSlashEnd = -1 for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i) if (isWindowsPathSeparator(code)) { if (!matchedSlash) { start = i + 1 break } } else { if (firstNonSlashEnd === -1) { matchedSlash = false firstNonSlashEnd = i + 1 } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) { end = i } } else { extIdx = -1 end = firstNonSlashEnd } } } } if (start === end) end = firstNonSlashEnd else if (end === -1) end = path.length return path.substring(start, end) } for (let i = path.length - 1; i >= start; --i) { if (isWindowsPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { start = i + 1 break } } else if (end === -1) { matchedSlash = false end = i + 1 } } if (end === -1) return '' return path.substring(start, end) } exports.extname = function extname(path) { let start = 0 let startDot = -1 let startPart = 0 let end = -1 let matchedSlash = true let preDotState = 0 if ( path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0)) ) { start = startPart = 2 } for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i) if (isWindowsPathSeparator(code)) { if (!matchedSlash) { startPart = i + 1 break } continue } if (end === -1) { matchedSlash = false end = i + 1 } if (code === CHAR_DOT) { if (startDot === -1) startDot = i else if (preDotState !== 1) preDotState = 1 } else if (startDot !== -1) { preDotState = -1 } } if ( startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return '' } return path.substring(startDot, end) } { "name": "bare-path", "version": "3.0.1", "description": "Path manipulation library for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./posix": "./lib/posix.js", "./win32": "./lib/win32.js" }, "files": [ "index.js", "index.d.ts", "lib", "NOTICE" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-path.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-path/issues" }, "homepage": "https://github.com/holepunchto/bare-path#readme", "dependencies": { "bare-os": "^3.0.1" }, "devDependencies": { "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } const b4a = require('b4a') const stream = require('streamx') const { ReadableStream, WritableStream } = require('./web') const defaultEncoding = 'utf8' module.exports = exports = stream.Stream exports.pipeline = stream.pipeline exports.isStream = stream.isStream exports.isEnding = stream.isEnding exports.isEnded = stream.isEnded exports.isFinishing = stream.isFinishing exports.isFinished = stream.isFinished exports.isDisturbed = stream.isDisturbed exports.isErrored = function isErrored(stream) { return exports.getStreamError(stream) !== null } exports.isReadable = function isReadable(stream) { return stream.readable && !stream.destroying && !exports.isEnded(stream) } exports.isWritable = function isWritable(stream) { return stream.writable && !stream.destroying && !exports.isFinishing(stream) } exports.getStreamError = stream.getStreamError exports.addAbortSignal = function addAbortSignal(signal, stream) { function onAbort() { stream.destroy(signal.reason) } if (signal.aborted) onAbort() else signal.addEventListener('abort', onAbort) return stream } exports.Stream = exports exports.Readable = class Readable extends stream.Readable { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, map: null, mapReadable: null }) if (this._construct) this._open = this._construct if (this._read !== stream.Readable.prototype._read) { this._read = read.bind(this, this._read) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } get closed() { return !exports.isReadable(this) } get errored() { return stream.getStreamError(this) } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } static fromWeb(readableStream, opts = {}) { const stream = readableStream._stream if (opts.encoding) stream.setEncoding(opts.encoding) if (opts.signal) exports.addAbortSignal(opts.signal, stream) return stream } static toWeb(readable, opts = {}) { return new ReadableStream(readable, opts.strategy) } async [Symbol.asyncDispose]() { if (!this.destroyed) this.destroy() await new Promise((resolve) => exports.finished(this, resolve)) } } exports.Writable = class Writable extends stream.Writable { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthWritable, map: null, mapWritable: null }) if (this._construct) this._open = this._construct if (this._write !== stream.Writable.prototype._write) { this._write = write.bind(this, this._write) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } get closed() { return !exports.isWritable(this) } get errored() { return stream.getStreamError(this) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding || defaultEncoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } static fromWeb(writableStream, opts = {}) { const stream = writableStream._stream if (opts.signal) exports.addAbortSignal(opts.signal, stream) return stream } static toWeb(writable) { return new WritableStream(writable) } async [Symbol.asyncDispose]() { if (!this.destroyed) this.destroy() await new Promise((resolve) => exports.finished(this, resolve)) } } exports.Duplex = class Duplex extends stream.Duplex { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, byteLengthWritable, map: null, mapReadable: null, mapWritable: null }) if (this._construct) this._open = this._construct if (this._read !== stream.Readable.prototype._read) { this._read = read.bind(this, this._read) } if (this._write !== stream.Duplex.prototype._write) { this._write = write.bind(this, this._write) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } static fromWeb({ readable: readableStream, writable: writableStream }, opts) { const readable = exports.Readable.fromWeb(readableStream, opts) const writable = exports.Writable.fromWeb(writableStream, opts) const duplex = new exports.Duplex({ write(data, encoding, cb) { writable.write(data, encoding, cb) } }) readable .on('data', (data) => duplex.push(data)) .on('end', () => duplex.push(null)) .on('error', (err) => duplex.destroy(err)) writable.on('finish', () => duplex.end()).on('error', (err) => duplex.destroy(err)) return duplex } static toWeb(duplex) { const readableStream = exports.Readable.toWeb(duplex) const writableStream = exports.Writable.toWeb(duplex) return { readable: readableStream, writable: writableStream } } } class DuplexSide extends exports.Duplex { constructor(opts) { super(opts) this._otherSide = null this._cb = null } _read() { const cb = this._cb if (!cb) return this._cb = null cb() } _write(chunk, encoding, cb) { this._otherSide.push(chunk, encoding) this._otherSide._cb = cb } _final(cb) { this._otherSide.on('end', cb) this._otherSide.push(null) } } exports.duplexPair = function duplexPair(opts) { const sideA = new DuplexSide(opts) const sideB = new DuplexSide(opts) sideA._otherSide = sideB sideB._otherSide = sideA return [sideA, sideB] } exports.Transform = class Transform extends stream.Transform { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, byteLengthWritable, map: null, mapReadable: null, mapWritable: null }) if (this._transform !== stream.Transform.prototype._transform) { this._transform = transform.bind(this, this._transform) } else { this._transform = passthrough } } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } } exports.PassThrough = class PassThrough extends exports.Transform {} exports.finished = function finished(stream, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} const { cleanup = false } = opts const done = () => { cb(exports.getStreamError(stream, { all: true })) if (cleanup) detach() } const detach = () => { stream.off('close', done) stream.off('error', noop) } if (stream.destroyed) { done() } else { stream.on('close', done) stream.on('error', noop) } return detach } function read(read, cb) { read.call(this, 65536) cb(null) } function write(write, data, cb) { write.call(this, data.chunk, data.encoding, cb) } function transform(transform, data, cb) { transform.call(this, data.chunk, data.encoding, cb) } function destroy(destroy, cb) { destroy.call(this, exports.getStreamError(this), cb) } function passthrough(data, cb) { cb(null, data.chunk) } function byteLengthWritable(data) { return data.chunk.byteLength } function noop() {} { "name": "bare-stream", "version": "2.13.3", "description": "Streaming data for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./promises": "./promises.js", "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" } }, "files": [ "index.js", "index.d.ts", "promises.js", "web.js", "web.d.ts", "global.js", "global.d.ts" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-stream.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-stream/issues" }, "homepage": "https://github.com/holepunchto/bare-stream#readme", "dependencies": { "b4a": "^1.8.1", "streamx": "^2.25.0", "teex": "^1.0.1" }, "devDependencies": { "bare-abort-controller": "^1.1.0", "bare-buffer": "^3.0.0", "bare-events": "^2.5.4", "brittle": "^3.5.2", "lunte": "^1.6.0", "prettier": "^3.3.3", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "bare-abort-controller": "*", "bare-buffer": "*", "bare-events": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true }, "bare-buffer": { "optional": true }, "bare-events": { "optional": true } } } const { Readable, Writable, Transform, getStreamError, isStreamx, isDisturbed } = require('streamx') const tee = require('teex') const readableKind = Symbol.for('bare.stream.readable.kind') const writableKind = Symbol.for('bare.stream.writable.kind') const transformKind = Symbol.for('bare.stream.transform.kind') // https://streams.spec.whatwg.org/#readablestreamdefaultreader exports.ReadableStreamDefaultReader = class ReadableStreamDefaultReader { constructor(stream) { this._stream = stream this._stream._stream.once('close', onclose).once('error', onerror) const closed = Promise.withResolvers() // Avoid unhandled exceptions closed.promise.catch(noop) this._closed = closed function onclose() { closed.resolve() } function onerror(err) { closed.reject(err) } } get closed() { return this._closed.promise } read() { const stream = this._stream._stream return new Promise((resolve, reject) => { const err = getStreamError(stream) if (err) return reject(err) if (stream.destroyed) { return resolve({ value: undefined, done: true }) } const value = stream.read() if (value !== null) { return resolve({ value, done: false }) } stream.once('readable', onreadable).once('close', onclose).once('error', onerror) function onreadable() { const value = stream.read() ondone(null, value === null ? { value: undefined, done: true } : { value, done: false }) } function onclose() { ondone(null, { value: undefined, done: true }) } function onerror(err) { ondone(err, null) } function ondone(err, value) { stream.off('readable', onreadable).off('close', onclose).off('error', onerror) if (err) reject(err) else resolve(value) } }) } releaseLock() { this._closed.reject(new TypeError('Reader was released')) this._stream._releaseLock() this._stream = null } cancel(reason = new TypeError('Stream was cancelled')) { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).once('error', noop).destroy(reason) ) } } // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller exports.ReadableStreamDefaultController = class ReadableStreamDefaultController { constructor(stream) { this._stream = stream } get desiredSize() { const stream = this._stream._stream return stream._readableState.highWaterMark - stream._readableState.buffered } enqueue(data) { this._stream._stream.push(data) } close() { this._stream._stream.push(null) } error(err) { this._stream._stream.destroy(err) } } // https://streams.spec.whatwg.org/#readablestream class ReadableStream { static get [readableKind]() { return 0 // Compatibility version } static from(iterable) { return new ReadableStream(Readable.from(iterable)) } constructor(underlyingSource = {}, queuingStrategy) { if (isStreamx(underlyingSource)) { this._stream = underlyingSource } else { if (queuingStrategy === undefined) { queuingStrategy = new exports.CountQueuingStrategy() } const { start, pull, cancel } = underlyingSource const { highWaterMark = 1, size = defaultSize } = queuingStrategy this._stream = new Readable({ highWaterMark, byteLength: size }) const controller = new exports.ReadableStreamDefaultController(this) try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (pull) { this._stream._read = this._read.bind(this, starting, pull.bind(this, controller)) } if (cancel) { this._stream.once('error', cancel.bind(this)) } } catch (err) { controller.error(err) } } this._reader = null } get [readableKind]() { return ReadableStream[readableKind] } get locked() { return this._reader !== null } getReader() { if (this.locked) throw new TypeError('Stream is locked') this._reader = new exports.ReadableStreamDefaultReader(this) return this._reader } cancel(reason = new TypeError('Stream was cancelled')) { const stream = this._stream if (stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => stream.once('close', resolve).once('error', noop).destroy(reason) ) } tee() { const [a, b] = tee(this._stream) return [new ReadableStream(a), new ReadableStream(b)] } pipeTo(destination) { return new Promise((resolve, reject) => this._stream.pipe(destination._stream, (err) => { err ? reject(err) : resolve() }) ) } [Symbol.asyncIterator]() { return this._stream[Symbol.asyncIterator]() } _releaseLock() { this._reader = null } async _read(starting, pull, cb) { await starting let err = null try { await pull() } catch (e) { err = e } cb(err) } } function defaultSize() { return 1 } exports.ReadableStream = ReadableStream // https://streams.spec.whatwg.org/#countqueuingstrategy exports.CountQueuingStrategy = class CountQueuingStrategy { constructor(opts = {}) { const { highWaterMark = 1 } = opts this.highWaterMark = highWaterMark } size(chunk) { return 1 } } // https://streams.spec.whatwg.org/#bytelengthqueuingstrategy exports.ByteLengthQueuingStrategy = class ByteLengthQueuingStrategy { constructor(opts = {}) { const { highWaterMark = 16384 } = opts this.highWaterMark = highWaterMark } size(chunk) { return chunk.byteLength } } exports.isReadableStream = function isReadableStream(value) { if (value instanceof ReadableStream) return true return ( typeof value === 'object' && value !== null && value[readableKind] === ReadableStream[readableKind] ) } // https://streams.spec.whatwg.org/#readablestream-errored exports.isReadableStreamErrored = function isReadableStreamErrored(stream) { return getStreamError(stream._stream) !== null } // https://streams.spec.whatwg.org/#is-readable-stream-disturbed exports.isReadableStreamDisturbed = function isReadableStreamDisturbed(stream) { return isDisturbed(stream._stream) } // https://streams.spec.whatwg.org/#writablestreamdefaultwriter exports.WritableStreamDefaultWriter = class WritableStreamDefaultWriter { constructor(stream) { this._stream = stream this._stream._stream.once('close', onclose).once('error', onerror) const closed = Promise.withResolvers() // Avoid unhandled exceptions closed.promise.catch(noop) this._closed = closed function onclose() { closed.resolve() } function onerror(err) { closed.reject(err) } } get desiredSize() { const stream = this._stream._stream return stream._writableState.highWaterMark - stream._writableState.buffered } get closed() { return this._closed.promise } get ready() { const stream = this._stream._stream if (getStreamError(stream)) return Promise.reject() return Writable.drained(stream).then() } async write(chunk) { const stream = this._stream._stream let err = getStreamError(stream) if (err) return Promise.reject(err) stream.write(chunk) await Writable.drained(stream) err = getStreamError(stream) if (err) return Promise.reject(err) } releaseLock() { this._closed.reject(new TypeError('Writer was released')) this._stream._releaseLock() this._stream = null } close() { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).end()) } abort(reason = new TypeError('Stream was aborted')) { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).destroy(reason)) } } // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller exports.WritableStreamDefaultController = class WritableStreamDefaultController { constructor(stream) { this._stream = stream } error(err) { this._stream._stream.destroy(err) } } // https://streams.spec.whatwg.org/#writablestream class WritableStream { static get [writableKind]() { return 0 // Compatibility version } constructor(underlyingSink = {}, queuingStrategy = {}) { if (isStreamx(underlyingSink)) { this._stream = underlyingSink } else { if (queuingStrategy === undefined) { queuingStrategy = new exports.CountQueuingStrategy() } const { start, write, close, abort } = underlyingSink const { highWaterMark = 1, size = defaultSize } = queuingStrategy this._stream = new Writable({ highWaterMark, byteLength: size }) const controller = new exports.WritableStreamDefaultController(this) this._controller = controller try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (write) { this._stream._write = this._write.bind(this, starting, write.bind(this)) } if (close) { this._stream._destroy = this._destroy.bind(this, close.call(this)) } if (abort) { this._stream.once('error', abort.bind(this)) } } catch (err) { controller.error(err) } } this._writer = null } get [writableKind]() { return WritableStream[writableKind] } get locked() { return this._writer !== null } getWriter() { if (this.locked) throw new TypeError('Stream is locked') this._writer = new exports.WritableStreamDefaultWriter(this) return this._writer } abort(reason = new TypeError('Stream was aborted')) { if (this._stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => this._stream.once('close', resolve).destroy(reason)) } close() { if (this._stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => this._stream.once('close', resolve).end()) } _releaseLock() { this._writer = null } async _write(starting, write, data, cb) { await starting let err = null try { await write(data, this._controller) } catch (e) { err = e } cb(err) } async _destroy(closing, cb) { let err = null try { await closing } catch (e) { err = e } cb(err) } } exports.WritableStream = WritableStream exports.isWritableStream = function isWritableStream(value) { if (value instanceof WritableStream) return true return ( typeof value === 'object' && value !== null && value[writableKind] === WritableStream[writableKind] ) } // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller exports.TransformStreamDefaultController = class TransformStreamDefaultController { constructor(stream) { this._stream = stream } get desiredSize() { const stream = this._stream._stream return stream._readableState.highWaterMark - stream._readableState.buffered } enqueue(data) { this._stream._stream.push(data) } error(err) { this._stream._stream.destroy(err) } terminate() { const stream = this._stream._stream stream.push(null) stream.destroy(new TypeError('Stream has been terminated')) } } // https://streams.spec.whatwg.org/#transformstream class TransformStream { static get [transformKind]() { return 0 // Compatibility version } constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) { if (isStreamx(transformer)) { this._stream = transformer } else { const { start, transform, flush } = transformer this._stream = new Transform({ ...writableStrategy, ...readableStrategy }) const controller = new exports.TransformStreamDefaultController(this) this._controller = controller try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (transform) { this._stream._transform = this._transform.bind(this, starting, transform.bind(this)) } if (flush) { this._stream._flush = this._flush.bind(this, flush.call(this, this._controller)) } } catch (err) { controller.error(err) } } this._writable = new WritableStream(this._stream) this._readable = new ReadableStream(this._stream) } get [transformKind]() { return TransformStream[transformKind] } get writable() { return this._writable } get readable() { return this._readable } async _transform(starting, transform, data, cb) { await starting let err = null try { await transform(data, this._controller) } catch (e) { err = e } cb(err) } async _flush(flush, cb) { let err = null try { await flush } catch (e) { err = e } cb(err) } } exports.TransformStream = TransformStream exports.isTransformStream = function isTransformStream(value) { if (value instanceof TransformStream) return true return ( typeof value === 'object' && value !== null && value[transformKind] === TransformStream[transformKind] ) } async function forwardError(promise, controller) { try { await promise } catch (err) { controller.error(err) } } function noop() {} module.exports = require.addon() const binding = require('./binding') const t = binding.constants class Type { constructor(type) { this._type = type } isUndefined() { return this._type === t.UNDEFINED } isNull() { return this._type === t.NULL } isBoolean() { return this._type === t.BOOLEAN } isNumber() { return (this._type & 0xff) === t.NUMBER } isInt32() { return (this._type & (0xff | t.INT32)) === (t.NUMBER | t.INT32) } isUint32() { return (this._type & (0xff | t.UINT32)) === (t.NUMBER | t.UINT32) } isString() { return this._type === t.STRING } isSymbol() { return this._type === t.SYMBOL } isObject() { return (this._type & 0xff) === t.OBJECT } isArray() { return this._type === (t.OBJECT | t.ARRAY) } isArguments() { return this._type === (t.OBJECT | t.ARGUMENTS) } isDate() { return this._type === (t.OBJECT | t.DATE) } isRegExp() { return this._type === (t.OBJECT | t.REGEXP) } isError() { return this._type === (t.OBJECT | t.ERROR) } isPromise() { return this._type === (t.OBJECT | t.PROMISE) } isProxy() { return this._type === (t.OBJECT | t.PROXY) } isGenerator() { return this._type === (t.OBJECT | t.GENERATOR) } isMap() { return this._type === (t.OBJECT | t.MAP) } isSet() { return this._type === (t.OBJECT | t.SET) } isWeakMap() { return this._type === (t.OBJECT | t.WEAK_MAP) } isWeakSet() { return this._type === (t.OBJECT | t.WEAK_SET) } isWeakRef() { return this._type === (t.OBJECT | t.WEAK_REF) } isArrayBuffer() { return this._type === (t.OBJECT | t.ARRAYBUFFER) } isSharedArrayBuffer() { return this._type === (t.OBJECT | t.SHAREDARRAYBUFFER) } isTypedArray() { return (this._type & 0xffff) === (t.OBJECT | t.TYPEDARRAY) } isInt8Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT8ARRAY) } isUint8Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8ARRAY) } isUint8ClampedArray() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8CLAMPEDARRAY) } isInt16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT16ARRAY) } isUint16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT16ARRAY) } isInt32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT32ARRAY) } isUint32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT32ARRAY) } isFloat16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT16ARRAY) } isFloat32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT32ARRAY) } isFloat64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT64ARRAY) } isBigInt64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGINT64ARRAY) } isBigUint64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGUINT64ARRAY) } isDataView() { return this._type === (t.OBJECT | t.DATAVIEW) } isModuleNamespace() { return this._type === (t.OBJECT | t.MODULE_NAMESPACE) } isFunction() { return (this._type & 0xff) === t.FUNCTION } isAsyncFunction() { return ( (this._type & (0xff | t.ASYNC_FUNCTION)) === (t.FUNCTION | t.ASYNC_FUNCTION) ) } isGeneratorFunction() { return ( (this._type & (0xff | t.GENERATOR_FUNCTION)) === (t.FUNCTION | t.GENERATOR_FUNCTION) ) } isExternal() { return this._type === t.EXTERNAL } isBigInt() { return this._type === t.BIGINT } } module.exports = exports = function type(value) { switch (typeof value) { case 'undefined': return new Type(t.UNDEFINED) case 'boolean': return new Type(t.BOOLEAN) case 'number': return new Type( Number.isSafeInteger(value) ? binding.type(value) : t.NUMBER ) case 'string': return new Type(t.STRING) case 'symbol': return new Type(t.SYMBOL) case 'object': return new Type(value === null ? t.NULL : binding.type(value)) case 'function': return new Type(binding.type(value)) case 'bigint': return new Type(t.BIGINT) } } exports.createTag = function createTag(...components) { const tag = new Uint32Array(4) for (let i = 0; i < 4; i++) tag[i] = components[i] || 0 return tag } exports.addTag = function addTag(object, tag) { binding.addTag(object, tag) } exports.checkTag = function checkTag(object, tag) { return binding.checkTag(object, tag) } { "name": "bare-type", "version": "1.1.0", "description": "Cross-realm type predicates for Bare", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-type.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-type/issues" }, "homepage": "https://github.com/holepunchto/bare-type#readme", "engines": { "bare": ">=1.2.0" }, "devDependencies": { "brittle": "^3.4.0", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const path = require('bare-path') const binding = require('./binding') const errors = require('./lib/errors') const URLSearchParams = require('./lib/url-search-params') const kind = Symbol.for('bare.url.kind') const isWindows = Bare.platform === 'win32' class URL { static get [kind]() { return 0 // Compatibility version } constructor(input, base, opts = {}) { if (arguments.length === 0) throw errors.INVALID_URL() input = String(input) if (base !== undefined) base = String(base) this._components = new Uint32Array(8) this._parse(input, base, opts.throw !== false) if (this._href) this._params = new URLSearchParams(this.search, this) } get [kind]() { return URL[kind] } // https://url.spec.whatwg.org/#dom-url-href get href() { return this._href } set href(value) { this._update(value) this._params._parse(this.search) } // https://url.spec.whatwg.org/#dom-url-protocol get protocol() { return this._slice(0, this._components[0]) + ':' } set protocol(value) { this._update(this._replace(value.replace(/:+$/, ''), 0, this._components[0])) } // https://url.spec.whatwg.org/#dom-url-username get username() { return this._slice(this._components[0] + 3 /* :// */, this._components[1]) } set username(value) { if (cannotHaveCredentialsOrPort(this)) { return } if (this.username === '') value += '@' this._update(this._replace(value, this._components[0] + 3 /* :// */, this._components[1])) } // https://url.spec.whatwg.org/#dom-url-password get password() { return this._href.slice(this._components[1] + 1 /* : */, this._components[2] - 1 /* @ */) } set password(value) { if (cannotHaveCredentialsOrPort(this)) { return } let start = this._components[1] + 1 /* : */ let end = this._components[2] - 1 /* @ */ if (this.password === '') { value = ':' + value start-- } if (this.username === '') { value += '@' end++ } this._update(this._replace(value, start, end)) } // https://url.spec.whatwg.org/#dom-url-host get host() { return this._slice(this._components[2], this._components[5]) } set host(value) { if (hasOpaquePath(this)) { return } this._update( this._replace(value, this._components[2], this._components[value.includes(':') ? 5 : 3]) ) } // https://url.spec.whatwg.org/#dom-url-hostname get hostname() { return this._slice(this._components[2], this._components[3]) } set hostname(value) { if (hasOpaquePath(this)) { return } this._update(this._replace(value, this._components[2], this._components[3])) } // https://url.spec.whatwg.org/#dom-url-port get port() { return this._slice(this._components[3] + 1 /* : */, this._components[5]) } set port(value) { if (cannotHaveCredentialsOrPort(this)) { return } let start = this._components[3] + 1 /* : */ if (this.port === '') { value = ':' + value start-- } this._update(this._replace(value, start, this._components[5])) } // https://url.spec.whatwg.org/#dom-url-pathname get pathname() { return this._slice(this._components[5], this._components[6] - 1 /* ? */) } set pathname(value) { if (hasOpaquePath(this)) { return } if (value[0] !== '/' && value[0] !== '\\') { value = '/' + value } this._update(this._replace(value, this._components[5], this._components[6] - 1 /* ? */)) } // https://url.spec.whatwg.org/#dom-url-search get search() { return this._slice(this._components[6] - 1 /* ? */, this._components[7] - 1 /* # */) } set search(value) { if (value && value[0] !== '?') value = '?' + value this._update( this._replace(value, this._components[6] - 1 /* ? */, this._components[7] - 1 /* # */) ) this._params._parse(this.search) } // https://url.spec.whatwg.org/#dom-url-searchparams get searchParams() { return this._params } // https://url.spec.whatwg.org/#dom-url-hash get hash() { return this._slice(this._components[7] - 1 /* # */) } set hash(value) { if (value && value[0] !== '#') value = '#' + value this._update(this._replace(value, this._components[7] - 1 /* # */)) } toString() { return this._href } toJSON() { return this._href } [Symbol.for('bare.inspect')]() { return { __proto__: { constructor: URL }, href: this.href, protocol: this.protocol, username: this.username, password: this.password, host: this.host, hostname: this.hostname, port: this.port, pathname: this.pathname, search: this.search, searchParams: this.searchParams, hash: this.hash } } _slice(start, end = this._href.length) { return this._href.slice(start, end) } _replace(replacement, start, end = this._href.length) { return this._slice(0, start) + replacement + this._slice(end) } _parse(input, base, shouldThrow) { try { this._href = binding.parse( String(input), base ? String(base) : null, this._components, shouldThrow ) } catch (err) { if (err instanceof TypeError) throw err throw errors.INVALID_URL(`Invalid URL '${input}'`, input) } } _update(input) { try { this._parse(input, null, true) } catch (err) { if (err instanceof TypeError) throw err } } } module.exports = exports = URL // https://url.spec.whatwg.org/#url-opaque-path function hasOpaquePath(url) { return url.pathname[0] !== '/' } // https://url.spec.whatwg.org/#cannot-have-a-username-password-port function cannotHaveCredentialsOrPort(url) { return url.hostname === '' || url.protocol === 'file:' } exports.URL = URL exports.URLSearchParams = URLSearchParams exports.errors = errors exports.isURL = function isURL(value) { if (value instanceof URL) return true return typeof value === 'object' && value !== null && value[kind] === URL[kind] } exports.isURLSearchParams = URLSearchParams.isURLSearchParams // https://url.spec.whatwg.org/#dom-url-parse exports.parse = function parse(input, base) { const url = new URL(input, base, { throw: false }) return url._href ? url : null } // https://url.spec.whatwg.org/#dom-url-canparse exports.canParse = function canParse(input, base) { return binding.canParse(String(input), base ? String(base) : null) } exports.fileURLToPath = function fileURLToPath(url) { if (typeof url === 'string') { url = new URL(url) } if (url.protocol !== 'file:') { throw errors.INVALID_URL_SCHEME('The URL must use the file: protocol') } if (isWindows) { if (/%2f|%5c/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH( 'The file: URL path must not include encoded \\ or / characters' ) } } else { if (url.hostname) { throw errors.INVALID_FILE_URL_HOST("The file: URL host must be 'localhost' or empty") } if (/%2f/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must not include encoded / characters') } } if (/%00/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must not include encoded NUL characters') } const pathname = path.normalize(decodeURIComponent(url.pathname)) if (isWindows) { if (url.hostname) return '\\\\' + url.hostname + pathname const letter = pathname.charCodeAt(1) | 0x20 if (letter < 0x61 /* a */ || letter > 0x7a /* z */ || pathname.charCodeAt(2) !== 0x3a /* : */) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must be absolute') } return pathname.slice(1) } return pathname } exports.pathToFileURL = function pathToFileURL(pathname) { let resolved = path.resolve(pathname) if (pathname[pathname.length - 1] === '/') { resolved += '/' } else if (isWindows && pathname[pathname.length - 1] === '\\') { resolved += '\\' } resolved = resolved .replaceAll('%', '%25') // Must be first .replaceAll('#', '%23') .replaceAll('?', '%3f') .replaceAll('\n', '%0a') .replaceAll('\r', '%0d') .replaceAll('\t', '%09') if (!isWindows) { resolved = resolved.replaceAll('\\', '%5c') } return new URL('file:' + resolved) } exports.format = function format(parts) { const { protocol, auth, host, hostname, port, pathname, search, query, hash, slashes } = parts let result = '' if (typeof protocol === 'string') { result += protocol if (protocol[protocol.length - 1] !== ':') { result += ':' } if (slashes === true || /https?|ftp|gopher|file/.test(protocol)) { result += '//' } } if (typeof auth === 'string') { if (host || hostname) result += auth + '@' } if (typeof host === 'string') result += host else { result += hostname if (port) result += ':' + port } if (typeof pathname === 'string' && pathname !== '') { if (pathname[0] !== '/') result += '/' result += pathname } if (typeof search === 'string') { if (search[0] !== '?') result += '?' result += search } else if (typeof query === 'object' && query !== null) { result += '?' + new URLSearchParams(query) } if (typeof hash === 'string') { if (hash[0] !== '#') result += '#' result += hash } return result } module.exports = class URLError extends Error { constructor(msg, fn = URLError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) Error.captureStackTrace(this, fn) } get name() { return 'URLError' } static INVALID_URL(msg, input) { const err = new URLError(msg, URLError.INVALID_URL) err.input = input return err } static INVALID_URL_SCHEME(msg = 'Invalid URL') { return new URLError(msg, URLError.INVALID_URL_SCHEME) } static INVALID_FILE_URL_HOST(msg = 'Invalid file: URL host') { return new URLError(msg, URLError.INVALID_FILE_URL_HOST) } static INVALID_FILE_URL_PATH(msg = 'Invalid file: URL path') { return new URLError(msg, URLError.INVALID_FILE_URL_PATH) } } const kind = Symbol.for('bare.url.search-params.kind') class URLSearchParams { static _urls = new WeakMap() static get [kind]() { return 0 // Compatibility version } // https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams constructor(init, url = null) { this._params = new Map() if (url) URLSearchParams._urls.set(this, url) if (typeof init === 'string') { this._parse(init) } else if (init) { for (const [name, value] of typeof init[Symbol.iterator] === 'function' ? init : Object.entries(init)) { this.append(name, value) } } } get [kind]() { return URLSearchParams[kind] } // https://url.spec.whatwg.org/#dom-urlsearchparams-size get size() { return this._params.length } // https://url.spec.whatwg.org/#dom-urlsearchparams-append append(name, value = null) { if (value === null) return let list = this._params.get(name) if (list === undefined) { list = [] this._params.set(name, list) } list.push(value) this._update() } // https://url.spec.whatwg.org/#dom-urlsearchparams-delete delete(name, value = null) { if (value === null) this._params.delete(name) else { let list = this._params.get(name) if (list === undefined) return list = list.filter((found) => found !== value) if (list.length === 0) this._params.delete(name) else this._params.set(name, list) } this._update() } // https://url.spec.whatwg.org/#dom-urlsearchparams-get get(name) { const list = this._params.get(name) if (list === undefined) return null return list[0] } // https://url.spec.whatwg.org/#dom-urlsearchparams-getall getAll(name) { const list = this._params.get(name) if (list === undefined) return [] return Array.from(list) } // https://url.spec.whatwg.org/#dom-urlsearchparams-has has(name, value = null) { const list = this._params.get(name) if (list === undefined) return false if (value === null) return true return list.includes(value) } // https://url.spec.whatwg.org/#dom-urlsearchparams-set set(name, value = null) { if (value === null) this._params.delete(name) else this._params.set(name, [value]) this._update() } toString() { return this._serialize() } toJSON() { return [...this] } *[Symbol.iterator]() { for (const [name, values] of this._params) { for (const value of values) yield [name, value] } } [Symbol.for('bare.inspect')]() { const object = { __proto__: { constructor: URLSearchParams } } for (const [name, values] of this._params) { if (values.length === 1) object[name] = values[0] else object[name] = values } return object } // https://url.spec.whatwg.org/#concept-urlsearchparams-update _update() { const url = URLSearchParams._urls.get(this) if (url === undefined) return url.search = this._serialize() } // https://url.spec.whatwg.org/#concept-urlencoded-parser _parse(input) { if (input[0] === '?') input = input.substring(1) this._params = new Map() for (let sequence of input.split('&')) { if (sequence.length === 0) continue sequence = sequence.replace(/\+/g, ' ') let i = sequence.indexOf('=') if (i === -1) i = sequence.length const name = decodeURIComponent(sequence.substring(0, i)) const value = decodeURIComponent(sequence.substring(i + 1, sequence.length)) let list = this._params.get(name) if (list === undefined) { list = [] this._params.set(name, list) } list.push(value) } } // https://url.spec.whatwg.org/#concept-urlencoded-serializer _serialize() { let output = '' for (let [name, values] of this._params) { name = encodeURIComponent(name) for (const value of values) { if (output) output += '&' output += name + '=' + encodeURIComponent(value) } } return output } } module.exports = exports = URLSearchParams exports.isURLSearchParams = function isURLSearchParams(value) { if (value instanceof URLSearchParams) return true return typeof value === 'object' && value !== null && value[kind] === URLSearchParams[kind] } { "name": "bare-url", "version": "2.4.5", "description": "WHATWG URL implementation for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" } }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-url.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-url/issues" }, "homepage": "https://github.com/holepunchto/bare-url", "dependencies": { "bare-path": "^3.0.0" }, "devDependencies": { "brittle": "^3.3.2", "cmake-bare": "^1.1.6", "cmake-fetch": "^1.0.0", "lunte": "^1.6.0", "prettier": "^3.3.3", "prettier-config-holepunch": "^2.0.0" } } const LE = (exports.LE = new Uint8Array(new Uint16Array([0xff]).buffer)[0] === 0xff) exports.BE = !LE const b4a = require('b4a') const { BE } = require('./endian') exports.state = function (start = 0, end = 0, buffer = null) { return { start, end, buffer } } const raw = (exports.raw = require('./raw')) const uint = (exports.uint = { preencode(state, n) { state.end += n <= 0xfc ? 1 : n <= 0xffff ? 3 : n <= 0xffffffff ? 5 : 9 }, encode(state, n) { if (n <= 0xfc) uint8.encode(state, n) else if (n <= 0xffff) { state.buffer[state.start++] = 0xfd uint16.encode(state, n) } else if (n <= 0xffffffff) { state.buffer[state.start++] = 0xfe uint32.encode(state, n) } else { state.buffer[state.start++] = 0xff uint64.encode(state, n) } }, decode(state) { const a = uint8.decode(state) if (a <= 0xfc) return a if (a === 0xfd) return uint16.decode(state) if (a === 0xfe) return uint32.decode(state) return uint64.decode(state) } }) const uint8 = (exports.uint8 = { preencode(state, n) { state.end += 1 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n }, decode(state) { if (state.start >= state.end) throw new Error('Out of bounds') return state.buffer[state.start++] } }) const uint16 = (exports.uint16 = { preencode(state, n) { state.end += 2 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 }, decode(state) { if (state.end - state.start < 2) throw new Error('Out of bounds') return state.buffer[state.start++] + state.buffer[state.start++] * 0x100 } }) const uint24 = (exports.uint24 = { preencode(state, n) { state.end += 3 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n >>> 16 }, decode(state) { if (state.end - state.start < 3) throw new Error('Out of bounds') return ( state.buffer[state.start++] + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] * 0x10000 ) } }) const uint32 = (exports.uint32 = { preencode(state, n) { state.end += 4 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n >>> 16 state.buffer[state.start++] = n >>> 24 }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] * 0x10000 + state.buffer[state.start++] * 0x1000000 ) } }) const uint32be = (exports.uint32be = { preencode(state, n) { state.end += 4 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n >>> 24 state.buffer[state.start++] = n >>> 16 state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] * 0x1000000 + state.buffer[state.start++] * 0x10000 + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] ) } }) const uint40 = (exports.uint40 = { preencode(state, n) { state.end += 5 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100) uint8.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 5) throw new Error('Out of bounds') return uint8.decode(state) + 0x100 * uint32.decode(state) } }) const uint48 = (exports.uint48 = { preencode(state, n) { state.end += 6 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x10000) uint16.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 6) throw new Error('Out of bounds') return uint16.decode(state) + 0x10000 * uint32.decode(state) } }) const uint56 = (exports.uint56 = { preencode(state, n) { state.end += 7 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x1000000) uint24.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 7) throw new Error('Out of bounds') return uint24.decode(state) + 0x1000000 * uint32.decode(state) } }) const uint64 = (exports.uint64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100000000) uint32.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') return uint32.decode(state) + 0x100000000 * uint32.decode(state) } }) exports.uint64be = { preencode(state, n) { state.end += 8 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100000000) uint32be.encode(state, r) uint32be.encode(state, n) }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') return 0x100000000 * uint32be.decode(state) + uint32be.decode(state) } } const int = (exports.int = zigZagInt(uint)) exports.int8 = zigZagInt(uint8) exports.int16 = zigZagInt(uint16) exports.int24 = zigZagInt(uint24) exports.int32 = zigZagInt(uint32) exports.int40 = zigZagInt(uint40) exports.int48 = zigZagInt(uint48) exports.int56 = zigZagInt(uint56) exports.int64 = zigZagInt(uint64) const biguint64 = (exports.biguint64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) view.setBigUint64(0, n, true) // little endian state.start += 8 }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) const n = view.getBigUint64(0, true) // little endian state.start += 8 return n } }) exports.bigint64 = zigZagBigInt(biguint64) const biguint = (exports.biguint = { preencode(state, n) { let len = 0 for (let m = n; m; m = m >> 64n) len++ uint.preencode(state, len) state.end += 8 * len }, encode(state, n) { let len = 0 for (let m = n; m; m = m >> 64n) len++ uint.encode(state, len) const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len ) for (let m = n, i = 0; m; m = m >> 64n, i += 8) { view.setBigUint64(i, BigInt.asUintN(64, m), true) // little endian } state.start += 8 * len }, decode(state) { const len = uint.decode(state) if (state.end - state.start < 8 * len) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len ) let n = 0n for (let i = len - 1; i >= 0; i--) n = (n << 64n) + view.getBigUint64(i * 8, true) // little endian state.start += 8 * len return n } }) exports.bigint = zigZagBigInt(biguint) exports.lexint = require('./lexint') exports.float32 = { preencode(state, n) { state.end += 4 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 4 ) view.setFloat32(0, n, true) // little endian state.start += 4 }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 4 ) const float = view.getFloat32(0, true) // little endian state.start += 4 return float } } exports.float64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) view.setFloat64(0, n, true) // little endian state.start += 8 }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) const float = view.getFloat64(0, true) // little endian state.start += 8 return float } } const buffer = (exports.buffer = { preencode(state, b) { uint8array.preencode(state, b) }, encode(state, b) { uint8array.encode(state, b) }, decode(state) { const len = uint.decode(state) if (state.end - state.start < len) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += len)) } }) exports.optionalBuffer = { preencode(state, b) { if (b) uint8array.preencode(state, b) else state.end++ }, encode(state, b) { if (b) uint8array.encode(state, b) else state.buffer[state.start++] = 0 }, decode(state) { const len = uint.decode(state) if (len === 0) return null if (state.end - state.start < len) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += len)) } } exports.binary = { ...buffer, preencode(state, b) { if (typeof b === 'string') utf8.preencode(state, b) else buffer.preencode(state, b) }, encode(state, b) { if (typeof b === 'string') utf8.encode(state, b) else buffer.encode(state, b) } } exports.arraybuffer = { preencode(state, b) { uint.preencode(state, b.byteLength) state.end += b.byteLength }, encode(state, b) { uint.encode(state, b.byteLength) const view = new Uint8Array(b) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const len = uint.decode(state) const b = new ArrayBuffer(len) const view = new Uint8Array(b) view.set(state.buffer.subarray(state.start, (state.start += len))) return b } } function typedarray(TypedArray, swap) { const n = TypedArray.BYTES_PER_ELEMENT return { preencode(state, b) { uint.preencode(state, b.length) state.end += b.byteLength }, encode(state, b) { uint.encode(state, b.length) const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength) if (BE && swap) swap(view) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const len = uint.decode(state) let b = state.buffer.subarray(state.start, (state.start += len * n)) if (b.byteLength !== len * n) throw new Error('Out of bounds') if (b.byteOffset % n !== 0) b = new Uint8Array(b) if (BE && swap) swap(b) return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n) } } } const uint8array = (exports.uint8array = typedarray(Uint8Array)) exports.uint16array = typedarray(Uint16Array, b4a.swap16) exports.uint32array = typedarray(Uint32Array, b4a.swap32) exports.int8array = typedarray(Int8Array) exports.int16array = typedarray(Int16Array, b4a.swap16) exports.int32array = typedarray(Int32Array, b4a.swap32) exports.biguint64array = typedarray(BigUint64Array, b4a.swap64) exports.bigint64array = typedarray(BigInt64Array, b4a.swap64) exports.float32array = typedarray(Float32Array, b4a.swap32) exports.float64array = typedarray(Float64Array, b4a.swap64) function string(encoding) { return { preencode(state, s) { const len = b4a.byteLength(s, encoding) uint.preencode(state, len) state.end += len }, encode(state, s) { const len = b4a.byteLength(s, encoding) uint.encode(state, len) b4a.write(state.buffer, s, state.start, encoding) state.start += len }, decode(state) { const len = uint.decode(state) if (state.end - state.start < len) throw new Error('Out of bounds') return b4a.toString( state.buffer, encoding, state.start, (state.start += len) ) }, fixed(n) { return { preencode(state) { state.end += n }, encode(state, s) { b4a.write(state.buffer, s, state.start, n, encoding) state.start += n }, decode(state) { if (state.end - state.start < n) throw new Error('Out of bounds') return b4a.toString( state.buffer, encoding, state.start, (state.start += n) ) } } } } } const utf8 = (exports.string = exports.utf8 = string('utf-8')) exports.ascii = string('ascii') exports.hex = string('hex') exports.base64 = string('base64') exports.ucs2 = exports.utf16le = string('utf16le') exports.bool = { preencode(state, b) { state.end++ }, encode(state, b) { state.buffer[state.start++] = b ? 1 : 0 }, decode(state) { if (state.start >= state.end) throw Error('Out of bounds') return state.buffer[state.start++] === 1 } } const fixed = (exports.fixed = function fixed(n) { return { preencode(state, s) { if (s.byteLength !== n) throw new Error('Incorrect buffer size') state.end += n }, encode(state, s) { state.buffer.set(s, state.start) state.start += n }, decode(state) { if (state.end - state.start < n) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += n)) } } }) exports.fixed32 = fixed(32) exports.fixed64 = fixed(64) exports.array = function array(enc) { return { preencode(state, list) { uint.preencode(state, list.length) for (let i = 0; i < list.length; i++) enc.preencode(state, list[i]) }, encode(state, list) { uint.encode(state, list.length) for (let i = 0; i < list.length; i++) enc.encode(state, list[i]) }, decode(state) { const len = uint.decode(state) if (len > 0x100000) throw new Error('Array is too big') const arr = new Array(len) for (let i = 0; i < len; i++) arr[i] = enc.decode(state) return arr } } } exports.frame = function frame(enc) { const dummy = exports.state() return { preencode(state, m) { const end = state.end enc.preencode(state, m) uint.preencode(state, state.end - end) }, encode(state, m) { dummy.end = 0 enc.preencode(dummy, m) uint.encode(state, dummy.end) enc.encode(state, m) }, decode(state) { const end = state.end const len = uint.decode(state) state.end = state.start + len const m = enc.decode(state) state.start = state.end state.end = end return m } } } exports.date = { preencode(state, d) { int.preencode(state, d.getTime()) }, encode(state, d) { int.encode(state, d.getTime()) }, decode(state, d) { return new Date(int.decode(state)) } } exports.json = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v)) }, encode(state, v) { utf8.encode(state, JSON.stringify(v)) }, decode(state) { return JSON.parse(utf8.decode(state)) } } exports.ndjson = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v) + '\n') }, encode(state, v) { utf8.encode(state, JSON.stringify(v) + '\n') }, decode(state) { return JSON.parse(utf8.decode(state)) } } // simple helper for when you want to just express nothing exports.none = { preencode(state, n) { // do nothing }, encode(state, n) { // do nothing }, decode(state) { return null } } // "any" encoders here for helping just structure any object without schematising it const anyArray = { preencode(state, arr) { uint.preencode(state, arr.length) for (let i = 0; i < arr.length; i++) { any.preencode(state, arr[i]) } }, encode(state, arr) { uint.encode(state, arr.length) for (let i = 0; i < arr.length; i++) { any.encode(state, arr[i]) } }, decode(state) { const arr = [] let len = uint.decode(state) while (len-- > 0) { arr.push(any.decode(state)) } return arr } } const anyObject = { preencode(state, o) { const keys = Object.keys(o) uint.preencode(state, keys.length) for (const key of keys) { utf8.preencode(state, key) any.preencode(state, o[key]) } }, encode(state, o) { const keys = Object.keys(o) uint.encode(state, keys.length) for (const key of keys) { utf8.encode(state, key) any.encode(state, o[key]) } }, decode(state) { let len = uint.decode(state) const o = {} while (len-- > 0) { const key = utf8.decode(state) o[key] = any.decode(state) } return o } } const anyTypes = [ exports.none, exports.bool, exports.string, exports.buffer, exports.uint, exports.int, exports.float64, anyArray, anyObject, exports.date ] const any = (exports.any = { preencode(state, o) { const t = getType(o) uint.preencode(state, t) anyTypes[t].preencode(state, o) }, encode(state, o) { const t = getType(o) uint.encode(state, t) anyTypes[t].encode(state, o) }, decode(state) { const t = uint.decode(state) if (t >= anyTypes.length) throw new Error('Unknown type: ' + t) return anyTypes[t].decode(state) } }) const port = (exports.port = uint16) const address = (host, family) => { return { preencode(state, m) { host.preencode(state, m.host) port.preencode(state, m.port) }, encode(state, m) { host.encode(state, m.host) port.encode(state, m.port) }, decode(state) { return { host: host.decode(state), family, port: port.decode(state) } } } } const ipv4 = (exports.ipv4 = { preencode(state) { state.end += 4 }, encode(state, string) { const start = state.start const end = start + 4 let i = 0 while (i < string.length) { let n = 0 let c while ( i < string.length && (c = string.charCodeAt(i++)) !== /* . */ 0x2e ) { n = n * 10 + (c - /* 0 */ 0x30) } state.buffer[state.start++] = n } state.start = end }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] + '.' + state.buffer[state.start++] + '.' + state.buffer[state.start++] + '.' + state.buffer[state.start++] ) } }) exports.ipv4Address = address(ipv4, 4) const ipv6 = (exports.ipv6 = { preencode(state) { state.end += 16 }, encode(state, string) { const start = state.start const end = start + 16 let i = 0 let split = null while (i < string.length) { let n = 0 let c while ( i < string.length && (c = string.charCodeAt(i++)) !== /* : */ 0x3a ) { if (c >= 0x30 && c <= 0x39) n = n * 0x10 + (c - /* 0 */ 0x30) else if (c >= 0x41 && c <= 0x46) n = n * 0x10 + (c - /* A */ 0x41 + 10) else if (c >= 0x61 && c <= 0x66) n = n * 0x10 + (c - /* a */ 0x61 + 10) } state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n if (i < string.length && string.charCodeAt(i) === /* : */ 0x3a) { i++ split = state.start } } if (split !== null) { const offset = end - state.start state.buffer .copyWithin(split + offset, split) .fill(0, split, split + offset) } state.start = end }, decode(state) { if (state.end - state.start < 16) throw new Error('Out of bounds') return ( ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) ) } }) exports.ipv6Address = address(ipv6, 6) const ip = (exports.ip = { preencode(state, string) { const family = string.includes(':') ? 6 : 4 uint8.preencode(state, family) if (family === 4) ipv4.preencode(state) else ipv6.preencode(state) }, encode(state, string) { const family = string.includes(':') ? 6 : 4 uint8.encode(state, family) if (family === 4) ipv4.encode(state, string) else ipv6.encode(state, string) }, decode(state) { const family = uint8.decode(state) if (family === 4) return ipv4.decode(state) else return ipv6.decode(state) } }) exports.ipAddress = { preencode(state, m) { ip.preencode(state, m.host) port.preencode(state, m.port) }, encode(state, m) { ip.encode(state, m.host) port.encode(state, m.port) }, decode(state) { const family = uint8.decode(state) return { host: family === 4 ? ipv4.decode(state) : ipv6.decode(state), family, port: port.decode(state) } } } const record = (exports.record = function (keyEncoding, valueEncoding) { return { preencode(state, v) { const keys = Object.keys(v) uint.preencode(state, keys.length) for (const k of keys) { keyEncoding.preencode(state, k) valueEncoding.preencode(state, v[k]) } }, encode(state, v) { const keys = Object.keys(v) uint.encode(state, keys.length) for (const k of keys) { keyEncoding.encode(state, k) valueEncoding.encode(state, v[k]) } }, decode(state) { const out = Object.create(null) const keys = uint.decode(state) for (let i = 0; i < keys; i++) { out[keyEncoding.decode(state)] = valueEncoding.decode(state) } return out } } }) exports.stringRecord = record(utf8, utf8) function getType(o) { if (o === null || o === undefined) return 0 if (typeof o === 'boolean') return 1 if (typeof o === 'string') return 2 if (b4a.isBuffer(o)) return 3 if (typeof o === 'number') { if (Number.isInteger(o)) return o >= 0 ? 4 : 5 return 6 } if (Array.isArray(o)) return 7 if (o instanceof Date) return 9 if (typeof o === 'object') return 8 throw new Error('Unsupported type for ' + o) } exports.from = function from(enc) { if (typeof enc === 'string') return fromNamed(enc) if (enc.preencode) return enc if (enc.encodingLength) return fromAbstractEncoder(enc) return fromCodec(enc) } function fromNamed(enc) { switch (enc) { case 'ascii': return raw.ascii case 'utf-8': case 'utf8': return raw.utf8 case 'hex': return raw.hex case 'base64': return raw.base64 case 'utf16-le': case 'utf16le': case 'ucs-2': case 'ucs2': return raw.ucs2 case 'ndjson': return raw.ndjson case 'json': return raw.json case 'binary': default: return raw.binary } } function fromCodec(enc) { let tmpM = null let tmpBuf = null return { preencode(state, m) { tmpM = m tmpBuf = enc.encode(m) state.end += tmpBuf.byteLength }, encode(state, m) { raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m)) tmpM = tmpBuf = null }, decode(state) { return enc.decode(raw.decode(state)) } } } function fromAbstractEncoder(enc) { return { preencode(state, m) { state.end += enc.encodingLength(m) }, encode(state, m) { enc.encode(m, state.buffer, state.start) state.start += enc.encode.bytes }, decode(state) { const m = enc.decode(state.buffer, state.start, state.end) state.start += enc.decode.bytes return m } } } exports.encode = function encode(enc, m) { const state = exports.state() enc.preencode(state, m) state.buffer = b4a.allocUnsafe(state.end) enc.encode(state, m) return state.buffer } exports.decode = function decode(enc, buffer) { return enc.decode(exports.state(0, buffer.byteLength, buffer)) } function zigZagInt(enc) { return { preencode(state, n) { enc.preencode(state, zigZagEncodeInt(n)) }, encode(state, n) { enc.encode(state, zigZagEncodeInt(n)) }, decode(state) { return zigZagDecodeInt(enc.decode(state)) } } } function zigZagDecodeInt(n) { return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2 } function zigZagEncodeInt(n) { // 0, -1, 1, -2, 2, ... return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n } function zigZagBigInt(enc) { return { preencode(state, n) { enc.preencode(state, zigZagEncodeBigInt(n)) }, encode(state, n) { enc.encode(state, zigZagEncodeBigInt(n)) }, decode(state) { return zigZagDecodeBigInt(enc.decode(state)) } } } function zigZagDecodeBigInt(n) { return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n } function zigZagEncodeBigInt(n) { // 0, -1, 1, -2, 2, ... return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n } function validateUint(n) { if (n >= 0 === false /* Handles NaN as well */) throw new Error('uint must be positive') // Beyond this, Number arithmetic loses precision and silently corrupts the // encoding. The zig-zag int codecs route through here too, so this also // guards int values whose doubled magnitude exceeds the safe range. if (n > Number.MAX_SAFE_INTEGER) throw new Error( 'integer is greater than the maximum safe integer, use biguint/bigint' ) } module.exports = { preencode, encode, decode } function preencode(state, num) { if (num < 251) { state.end++ } else if (num < 256) { state.end += 2 } else if (num < 0x10000) { state.end += 3 } else if (num < 0x1000000) { state.end += 4 } else if (num < 0x100000000) { state.end += 5 } else { state.end++ const exp = Math.floor(Math.log(num) / Math.log(2)) - 32 preencode(state, exp) state.end += 6 } } function encode(state, num) { const max = 251 const x = num - max if (num < max) { state.buffer[state.start++] = num } else if (num < 256) { state.buffer[state.start++] = max state.buffer[state.start++] = x } else if (num < 0x10000) { state.buffer[state.start++] = max + 1 state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else if (num < 0x1000000) { state.buffer[state.start++] = max + 2 state.buffer[state.start++] = x >> 16 state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else if (num < 0x100000000) { state.buffer[state.start++] = max + 3 state.buffer[state.start++] = x >> 24 state.buffer[state.start++] = (x >> 16) & 0xff state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else { // need to use Math here as bitwise ops are 32 bit const exp = Math.floor(Math.log(x) / Math.log(2)) - 32 state.buffer[state.start++] = 0xff encode(state, exp) const rem = x / Math.pow(2, exp - 11) for (let i = 5; i >= 0; i--) { state.buffer[state.start++] = (rem / Math.pow(2, 8 * i)) & 0xff } } } function decode(state) { const max = 251 if (state.end - state.start < 1) throw new Error('Out of bounds') const flag = state.buffer[state.start++] if (flag < max) return flag if (state.end - state.start < flag - max + 1) { throw new Error('Out of bounds.') } if (flag < 252) { return state.buffer[state.start++] + max } if (flag < 253) { return ( (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } if (flag < 254) { return ( (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } // << 24 result may be interpreted as negative if (flag < 255) { return ( state.buffer[state.start++] * 0x1000000 + (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } const exp = decode(state) if (state.end - state.start < 6) throw new Error('Out of bounds') let rem = 0 for (let i = 5; i >= 0; i--) { rem += state.buffer[state.start++] * Math.pow(2, 8 * i) } return rem * Math.pow(2, exp - 11) + max } { "name": "compact-encoding", "version": "3.2.0", "description": "A series of compact encoding schemes for building small and fast parsers and serializers", "main": "index.js", "files": [ "endian.js", "index.js", "lexint.js", "raw.js" ], "dependencies": { "b4a": "^1.3.0" }, "devDependencies": { "brittle": "^3.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" }, "scripts": { "format": "prettier . --write", "test": "prettier . --check && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/compact-encoding.git" }, "author": "Mathias Buus (@mafintosh)", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/compact-encoding/issues" }, "homepage": "https://github.com/holepunchto/compact-encoding" } const b4a = require('b4a') const { BE } = require('./endian') exports = module.exports = { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { state.buffer.set(b, state.start) state.start += b.byteLength }, decode(state) { const b = state.buffer.subarray(state.start, state.end) state.start = state.end return b } } const buffer = (exports.buffer = { preencode(state, b) { uint8array.preencode(state, b) }, encode(state, b) { uint8array.encode(state, b) }, decode(state) { const b = state.buffer.subarray(state.start) state.start = state.end return b } }) exports.binary = { ...buffer, preencode(state, b) { if (typeof b === 'string') utf8.preencode(state, b) else buffer.preencode(state, b) }, encode(state, b) { if (typeof b === 'string') utf8.encode(state, b) else buffer.encode(state, b) } } exports.arraybuffer = { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { const view = new Uint8Array(b) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const b = new ArrayBuffer(state.end - state.start) const view = new Uint8Array(b) view.set(state.buffer.subarray(state.start)) state.start = state.end return b } } function typedarray(TypedArray, swap) { const n = TypedArray.BYTES_PER_ELEMENT return { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength) if (BE && swap) swap(view) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { let b = state.buffer.subarray(state.start) if (b.byteOffset % n !== 0) b = new Uint8Array(b) if (BE && swap) swap(b) state.start = state.end return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n) } } } const uint8array = (exports.uint8array = typedarray(Uint8Array)) exports.uint16array = typedarray(Uint16Array, b4a.swap16) exports.uint32array = typedarray(Uint32Array, b4a.swap32) exports.int8array = typedarray(Int8Array) exports.int16array = typedarray(Int16Array, b4a.swap16) exports.int32array = typedarray(Int32Array, b4a.swap32) exports.biguint64array = typedarray(BigUint64Array, b4a.swap64) exports.bigint64array = typedarray(BigInt64Array, b4a.swap64) exports.float32array = typedarray(Float32Array, b4a.swap32) exports.float64array = typedarray(Float64Array, b4a.swap64) function string(encoding) { return { preencode(state, s) { state.end += b4a.byteLength(s, encoding) }, encode(state, s) { state.start += b4a.write(state.buffer, s, state.start, encoding) }, decode(state) { const s = b4a.toString(state.buffer, encoding, state.start) state.start = state.end return s } } } const utf8 = (exports.string = exports.utf8 = string('utf-8')) exports.ascii = string('ascii') exports.hex = string('hex') exports.base64 = string('base64') exports.ucs2 = exports.utf16le = string('utf16le') exports.array = function array(enc) { return { preencode(state, list) { for (const value of list) enc.preencode(state, value) }, encode(state, list) { for (const value of list) enc.encode(state, value) }, decode(state) { const arr = [] while (state.start < state.end) arr.push(enc.decode(state)) return arr } } } exports.json = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v)) }, encode(state, v) { utf8.encode(state, JSON.stringify(v)) }, decode(state) { return JSON.parse(utf8.decode(state)) } } exports.ndjson = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v) + '\n') }, encode(state, v) { utf8.encode(state, JSON.stringify(v) + '\n') }, decode(state) { return JSON.parse(utf8.decode(state)) } } module.exports = require('bare-events') { "name": "events-universal", "version": "1.0.1", "description": "Universal wrapper for the Node.js events module", "exports": { "./package": "./package.json", ".": { "bare": "./bare.js", "react-native": "./react-native.js", "default": "./default.js" } }, "files": [ "index.js", "default.js", "bare.js", "react-native.js" ], "scripts": { "test": "prettier . --check" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/events-universal.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/events-universal/issues" }, "homepage": "https://github.com/holepunchto/events-universal#readme", "dependencies": { "bare-events": "^2.7.0" }, "devDependencies": { "prettier": "^3.4.2", "prettier-config-holepunch": "^1.0.0" } } module.exports = class FixedFIFO { constructor (hwm) { if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two') this.buffer = new Array(hwm) this.mask = hwm - 1 this.top = 0 this.btm = 0 this.next = null } clear () { this.top = this.btm = 0 this.next = null this.buffer.fill(undefined) } push (data) { if (this.buffer[this.top] !== undefined) return false this.buffer[this.top] = data this.top = (this.top + 1) & this.mask return true } shift () { const last = this.buffer[this.btm] if (last === undefined) return undefined this.buffer[this.btm] = undefined this.btm = (this.btm + 1) & this.mask return last } peek () { return this.buffer[this.btm] } isEmpty () { return this.buffer[this.btm] === undefined } } const FixedFIFO = require('./fixed-size') module.exports = class FastFIFO { constructor (hwm) { this.hwm = hwm || 16 this.head = new FixedFIFO(this.hwm) this.tail = this.head this.length = 0 } clear () { this.head = this.tail this.head.clear() this.length = 0 } push (val) { this.length++ if (!this.head.push(val)) { const prev = this.head this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length) this.head.push(val) } } shift () { if (this.length !== 0) this.length-- const val = this.tail.shift() if (val === undefined && this.tail.next) { const next = this.tail.next this.tail.next = null this.tail = next return this.tail.shift() } return val } peek () { const val = this.tail.peek() if (val === undefined && this.tail.next) return this.tail.next.peek() return val } isEmpty () { return this.length === 0 } } { "name": "fast-fifo", "version": "1.3.2", "description": "A fast fifo implementation similar to the one powering nextTick in Node.js core", "main": "index.js", "files": [ "./index.js", "./fixed-size.js" ], "dependencies": {}, "devDependencies": { "standard": "^17.1.0", "brittle": "^3.3.2" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/fast-fifo.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/fast-fifo/issues" }, "homepage": "https://github.com/mafintosh/fast-fifo" } const sodium = require('sodium-universal') const c = require('compact-encoding') const b4a = require('b4a') // https://en.wikipedia.org/wiki/Merkle_tree#Second_preimage_attack const LEAF_TYPE = b4a.from([0]) const PARENT_TYPE = b4a.from([1]) const ROOT_TYPE = b4a.from([2]) const HYPERCORE = b4a.from('hypercore') exports.keyPair = function (seed) { // key pairs might stay around for a while, so better not to use a default slab to avoid retaining it completely const slab = b4a.allocUnsafeSlow( sodium.crypto_sign_PUBLICKEYBYTES + sodium.crypto_sign_SECRETKEYBYTES ) const publicKey = slab.subarray(0, sodium.crypto_sign_PUBLICKEYBYTES) const secretKey = slab.subarray(sodium.crypto_sign_PUBLICKEYBYTES) if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed) else sodium.crypto_sign_keypair(publicKey, secretKey) return { publicKey, secretKey } } exports.validateKeyPair = function (keyPair) { const pk = b4a.allocUnsafe(sodium.crypto_sign_PUBLICKEYBYTES) sodium.crypto_sign_ed25519_sk_to_pk(pk, keyPair.secretKey) return b4a.equals(pk, keyPair.publicKey) } exports.sign = function (message, secretKey) { // Dedicated slab for the signature, to avoid retaining unneeded mem and for security const signature = b4a.allocUnsafeSlow(sodium.crypto_sign_BYTES) sodium.crypto_sign_detached(signature, message, secretKey) return signature } exports.verify = function (message, signature, publicKey) { if (signature.byteLength !== sodium.crypto_sign_BYTES) return false if (publicKey.byteLength !== sodium.crypto_sign_PUBLICKEYBYTES) return false return sodium.crypto_sign_verify_detached(signature, message, publicKey) } exports.encrypt = function (message, publicKey) { const ciphertext = b4a.alloc(message.byteLength + sodium.crypto_box_SEALBYTES) sodium.crypto_box_seal(ciphertext, message, publicKey) return ciphertext } exports.decrypt = function (ciphertext, keyPair) { if (ciphertext.byteLength < sodium.crypto_box_SEALBYTES) return null const plaintext = b4a.alloc(ciphertext.byteLength - sodium.crypto_box_SEALBYTES) if (!sodium.crypto_box_seal_open(plaintext, ciphertext, keyPair.publicKey, keyPair.secretKey)) { return null } return plaintext } exports.encryptionKeyPair = function (seed) { const publicKey = b4a.alloc(sodium.crypto_box_PUBLICKEYBYTES) const secretKey = b4a.alloc(sodium.crypto_box_SECRETKEYBYTES) if (seed) { sodium.crypto_box_seed_keypair(publicKey, secretKey, seed) } else { sodium.crypto_box_keypair(publicKey, secretKey) } return { publicKey, secretKey } } exports.data = function (data) { const out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, [LEAF_TYPE, c.encode(c.uint64, data.byteLength), data]) return out } exports.parent = function (a, b) { if (a.index > b.index) { const tmp = a a = b b = tmp } const out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, [ PARENT_TYPE, c.encode(c.uint64, a.size + b.size), a.hash, b.hash ]) return out } exports.tree = function (roots, out) { const buffers = new Array(3 * roots.length + 1) let j = 0 buffers[j++] = ROOT_TYPE for (let i = 0; i < roots.length; i++) { const r = roots[i] buffers[j++] = r.hash buffers[j++] = c.encode(c.uint64, r.index) buffers[j++] = c.encode(c.uint64, r.size) } if (!out) out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, buffers) return out } exports.hash = function (data, out) { if (!out) out = b4a.allocUnsafe(32) if (!Array.isArray(data)) data = [data] sodium.crypto_generichash_batch(out, data) return out } exports.randomBytes = function (n) { const buf = b4a.allocUnsafe(n) sodium.randombytes_buf(buf) return buf } exports.discoveryKey = function (key) { if (!key || key.byteLength !== 32) throw new Error('Must pass a 32 byte buffer') // Discovery keys might stay around for a while, so better not to use slab memory (for better gc) const digest = b4a.allocUnsafeSlow(32) sodium.crypto_generichash(digest, HYPERCORE, key) return digest } if (sodium.sodium_free) { exports.free = function (secureBuf) { if (secureBuf.secure) sodium.sodium_free(secureBuf) } } else { exports.free = function () {} } exports.namespace = function (name, count) { const ids = typeof count === 'number' ? range(count) : count // Namespaces are long-lived, so better to use a dedicated slab const buf = b4a.allocUnsafeSlow(32 * ids.length) const list = new Array(ids.length) // ns is ephemeral, so default slab const ns = b4a.allocUnsafe(33) sodium.crypto_generichash(ns.subarray(0, 32), typeof name === 'string' ? b4a.from(name) : name) for (let i = 0; i < list.length; i++) { list[i] = buf.subarray(32 * i, 32 * i + 32) ns[32] = ids[i] sodium.crypto_generichash(list[i], ns) } return list } function range(count) { const arr = new Array(count) for (let i = 0; i < count; i++) arr[i] = i return arr } { "name": "hypercore-crypto", "version": "3.7.0", "description": "The crypto primitives used in hypercore, extracted into a separate module", "main": "index.js", "files": [ "index.js" ], "dependencies": { "b4a": "^1.6.6", "compact-encoding": "^3.0.0", "sodium-universal": "^5.0.0" }, "devDependencies": { "brittle": "^3.5.0", "lunte": "^1.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/hypercore-crypto.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/hypercore-crypto/issues" }, "homepage": "https://github.com/mafintosh/hypercore-crypto" } module.exports = require.addon.bind(require) { "name": "require-addon", "version": "1.2.0", "description": "Import native addons across JavaScript runtimes", "exports": { "./package": "./package.json", ".": { "bare": "./lib/bare.js", "node": "./lib/node.js", "default": "./lib/default.js" } }, "imports": { "fs": { "bare": "bare-fs", "default": "fs" }, "path": { "bare": "bare-path", "default": "path" }, "url": { "bare": "bare-url", "default": "url" } }, "files": [ "lib" ], "scripts": { "test": "npm run lint && npm run test:bare && npm run test:node", "test:bare": "bare test.js", "test:node": "node test.js", "lint": "prettier --check .", "format": "prettier --write ." }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/require-addon.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/require-addon/issues" }, "homepage": "https://github.com/holepunchto/require-addon#readme", "engines": { "bare": ">=1.10.0" }, "dependencies": { "bare-addon-resolve": "^1.3.0" }, "devDependencies": { "bare-bundle": "^1.8.1", "bare-bundle-evaluate": "^1.1.0", "bare-fs": "^4.0.0", "bare-path": "^3.0.0", "bare-url": "^2.1.0", "brittle": "^3.7.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } require.addon = require('require-addon') module.exports = require.addon('.', __filename) const assert = require('assert') const binding = require('./binding') const { isNode } = require('which-runtime') const OPTIONAL = Buffer.from(new ArrayBuffer(0)) module.exports = exports = { ...binding } // memory exports.sodium_memzero = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') binding.sodium_memzero(buf) } exports.sodium_mlock = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') const res = binding.sodium_mlock(buf) if (res !== 0) throw new Error('memory lock failed') } exports.sodium_munlock = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') const res = binding.sodium_munlock(buf) if (res !== 0) throw new Error('memory unlock failed') } exports.sodium_malloc = function (size) { assert(size >= 0, 'invalid size') const buf = Buffer.from(binding.sodium_malloc(size)) buf.secure = true return buf } exports.sodium_free = function (buf) { if (!buf || !buf.secure) return binding.sodium_free(buf.buffer) } exports.sodium_mprotect_noaccess = function (buf) { const res = binding.sodium_mprotect_noaccess(buf.buffer) if (res !== 0) throw new Error('failed to lock buffer') } exports.sodium_mprotect_readonly = function (buf) { const res = binding.sodium_mprotect_readonly(buf.buffer) if (res !== 0) throw new Error('failed to unlock buffer') } exports.sodium_mprotect_readwrite = function (buf) { const res = binding.sodium_mprotect_readwrite(buf.buffer) if (res !== 0) throw new Error('failed to unlock buffer') } // crypto_randombytes exports.randombytes_buf = function (buffer) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') binding.randombytes_buf(buffer.buffer, buffer.byteOffset, buffer.byteLength) } exports.randombytes_buf_deterministic = function (buffer, seed) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( seed.byteLength === binding.randombytes_SEEDBYTES, "seed must be 'randombytes_SEEDBYTES' bytes" ) binding.randombytes_buf_deterministic( buffer.buffer, buffer.byteOffset, buffer.byteLength, seed.buffer, seed.byteOffset, seed.byteLength ) } // sodium_helpers exports.sodium_memcmp = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') return binding.sodium_memcmp(a, b) } exports.sodium_add = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') binding.sodium_add(a, b) } exports.sodium_sub = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') binding.sodium_sub(a, b) } exports.sodium_compare = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') return binding.sodium_compare(a, b) } exports.sodium_is_zero = function (buffer, length) { if (length === undefined) length = buffer.byteLength assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(length >= 0 && length <= buffer.byteLength, 'invalid length') return binding.sodium_is_zero(buffer, length) } exports.sodium_pad = function (buffer, unpaddedBuflen, blockSize) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(unpaddedBuflen <= buffer.byteLength, 'unpadded length cannot exceed buffer length') assert(blockSize <= buffer.byteLength, 'block size cannot exceed buffer length') assert(blockSize >= 1, 'block size must be at least 1 byte') assert( buffer.byteLength >= unpaddedBuflen + (blockSize - (unpaddedBuflen % blockSize)), 'buf not long enough' ) return binding.sodium_pad(buffer, unpaddedBuflen, blockSize) } exports.sodium_unpad = function (buffer, paddedBuflen, blockSize) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(paddedBuflen <= buffer.byteLength, 'unpadded length cannot exceed buffer length') assert(blockSize <= buffer.byteLength, 'block size cannot exceed buffer length') assert(blockSize >= 1, 'block size must be at least 1 byte') return binding.sodium_unpad(buffer, paddedBuflen, blockSize) } // crypto_sign exports.crypto_sign_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) assert( seed.byteLength === binding.crypto_sign_SEEDBYTES, "seed must be 'crypto_sign_SEEDBYTES' bytes" ) const res = binding.crypto_sign_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign = function (sm, m, sk) { assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sm.byteLength === binding.crypto_sign_BYTES + m.byteLength, "sm must be 'm.byteLength + crypto_sign_BYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign(sm, m, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_open = function (m, sm, pk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sm.byteLength >= binding.crypto_sign_BYTES, "sm must be at least 'crypto_sign_BYTES' bytes" ) assert( m.byteLength === sm.byteLength - binding.crypto_sign_BYTES, "m must be 'sm.byteLength - crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_open(m, sm, pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_open = function (m, sm, pk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sm.byteLength >= binding.crypto_sign_BYTES, "sm must be at least 'crypto_sign_BYTES' bytes" ) assert( m.byteLength === sm.byteLength - binding.crypto_sign_BYTES, "m must be 'sm.byteLength - crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) return binding.crypto_sign_open(m, sm, pk) } exports.crypto_sign_detached = function (sig, m, sk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(sig.byteLength === binding.crypto_sign_BYTES, "sig must be 'crypto_sign_BYTES' bytes") assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_detached(sig, m, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_verify_detached = function (sig, m, pk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sig.byteLength >= binding.crypto_sign_BYTES, "sig must be at least 'crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) return binding.crypto_sign_verify_detached( sig.buffer, sig.byteOffset, sig.byteLength, m.buffer, m.byteOffset, m.byteLength, pk.buffer, pk.byteOffset, pk.byteLength ) } exports.crypto_sign_ed25519_sk_to_pk = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_sk_to_pk(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_ed25519_pk_to_curve25519 = function (x25519pk, ed25519pk) { assert(ArrayBuffer.isView(x25519pk), 'x25519pk must be a typed array') assert(ArrayBuffer.isView(ed25519pk), 'ed25519pk must be a typed array') assert( x25519pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "x25519pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( ed25519pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "ed25519pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_pk_to_curve25519(x25519pk, ed25519pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_ed25519_sk_to_curve25519 = function (x25519sk, ed25519sk) { assert(ArrayBuffer.isView(x25519sk), 'x25519sk must be a typed array') assert(ArrayBuffer.isView(ed25519sk), 'ed25519sk must be a typed array') assert( x25519sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "x25519sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const edLen = ed25519sk.byteLength assert( edLen === binding.crypto_sign_SECRETKEYBYTES || edLen === binding.crypto_box_SECRETKEYBYTES, "ed25519sk must be 'crypto_sign_SECRETKEYBYTES' or 'crypto_sign_SECRETKEYBYTES - crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_sk_to_curve25519(x25519sk, ed25519sk) if (res !== 0) throw new Error('status: ' + res) } // crypto_box exports.crypto_box_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( seed.byteLength === binding.crypto_box_SEEDBYTES, "seed must be 'crypto_box_SEEDBYTES' bytes" ) const res = binding.crypto_box_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_easy = function (c, m, n, pk, sk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength === m.byteLength + exports.crypto_box_MACBYTES, "c must be 'm.byteLength + crypto_box_MACBYTES' bytes" ) assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_easy(c, m, n, pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_detached = function (c, mac, m, n, pk, sk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(mac.byteLength === exports.crypto_box_MACBYTES, "mac must be 'crypto_box_MACBYTES' bytes") assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_detached(c, mac, m, n, pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_open_easy = function (m, c, n, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength >= exports.crypto_box_MACBYTES, "c must be at least 'crypto_box_MACBYTES' bytes" ) assert( m.byteLength === c.byteLength - exports.crypto_box_MACBYTES, "m must be 'c.byteLength - crypto_box_MACBYTES' bytes" ) assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_open_easy(m, c, n, pk, sk) } exports.crypto_box_open_detached = function (m, c, mac, n, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(mac.byteLength === exports.crypto_box_MACBYTES, "mac must be 'crypto_box_MACBYTES' bytes") assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_open_detached(m, c, mac, n, pk, sk) } exports.crypto_box_seal = function (c, m, pk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( c.byteLength === m.byteLength + exports.crypto_box_SEALBYTES, "c must be 'm.byteLength + crypto_box_SEALBYTES' bytes" ) assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_box_seal(c, m, pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_seal_open = function (m, c, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength >= exports.crypto_box_SEALBYTES, "c must be at least 'crypto_box_SEALBYTES' bytes" ) assert( m.byteLength === c.byteLength - exports.crypto_box_SEALBYTES, "m must be 'c.byteLength - crypto_box_SEALBYTES' bytes" ) assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_seal_open( m.buffer, m.byteOffset, m.byteLength, c.buffer, c.byteOffset, c.byteLength, pk.buffer, pk.byteOffset, pk.byteLength, sk.buffer, sk.byteOffset, sk.byteLength ) } // crypto_secretbox exports.crypto_secretbox_easy = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_secretbox_MACBYTES, "c must be 'm.byteLength + crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) const res = binding.crypto_secretbox_easy(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretbox_open_easy = function (m, c, n, k) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( c.byteLength >= binding.crypto_secretbox_MACBYTES, "c must be at least 'crypto_secretbox_MACBYTES' bytes" ) assert( m.byteLength === c.byteLength - binding.crypto_secretbox_MACBYTES, "m must be 'c.byteLength - crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) return binding.crypto_secretbox_open_easy(m, c, n, k) } exports.crypto_secretbox_detached = function (c, mac, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( mac.byteLength === binding.crypto_secretbox_MACBYTES, "mac must be 'crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) const res = binding.crypto_secretbox_detached(c, mac, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretbox_open_detached = function (m, c, mac, n, k) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert( mac.byteLength === binding.crypto_secretbox_MACBYTES, "mac must be 'crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) return binding.crypto_secretbox_open_detached(m, c, mac, n, k) } // crypto_generichash exports.crypto_generichash = function (output, input, key) { if (!key) key = OPTIONAL assert(ArrayBuffer.isView(output), 'output must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( output.byteLength >= binding.crypto_generichash_BYTES_MIN && output.byteLength <= binding.crypto_generichash_BYTES_MAX, 'output must be between crypto_generichash_BYTES_MIN and crypto_generichash_BYTES_MAX bytes' ) if (key !== OPTIONAL) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert( key.byteLength >= binding.crypto_generichash_KEYBYTES_MIN && key.byteLength <= binding.crypto_generichash_KEYBYTES_MAX, 'key must be between crypto_generichash_KEYBYTES_MIN and crypto_generichash_KEYBYTES_MAX bytes' ) } const res = binding.crypto_generichash( output.buffer, output.byteOffset, output.byteLength, input.buffer, input.byteOffset, input.byteLength, key.buffer, key.byteOffset, key.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_batch = function (output, batch, key) { assert(ArrayBuffer.isView(output), 'output must be a typed array') if (isNode || batch.length < 4) { const res = binding.crypto_generichash_batch(output, batch, !!key, key || OPTIONAL) if (res !== 0) throw new Error('status: ' + res) } else { const state = Buffer.alloc(binding.crypto_generichash_STATEBYTES) exports.crypto_generichash_init(state, key, output.byteLength) for (const buf of batch) { exports.crypto_generichash_update(state, buf) } exports.crypto_generichash_final(state, output) } } exports.crypto_generichash_keygen = function (key) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert( key.byteLength === binding.crypto_generichash_KEYBYTES, "key must be 'crypto_generichash_KEYBYTES' bytes" ) const res = binding.crypto_generichash_keygen(key.buffer, key.byteOffset, key.byteLength) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_init = function (state, key, outputLength) { if (!key) key = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_init( state.buffer, state.byteOffset, state.byteLength, key.buffer, key.byteOffset, key.byteLength, outputLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_update( state.buffer, state.byteOffset, state.byteLength, input.buffer, input.byteOffset, input.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_final = function (state, output) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(output), 'output must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_final( state.buffer, state.byteOffset, state.byteLength, output.buffer, output.byteOffset, output.byteLength ) if (res !== 0) throw new Error('status: ' + res) } // secretstream exports.crypto_secretstream_xchacha20poly1305_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) binding.crypto_secretstream_xchacha20poly1305_keygen(k.buffer, k.byteOffset, k.byteLength) } exports.crypto_secretstream_xchacha20poly1305_init_push = function (state, header, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(header), 'header must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( header.byteLength === binding.crypto_secretstream_xchacha20poly1305_HEADERBYTES, "header must be 'crypto_secretstream_xchacha20poly1305_HEADERBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_init_push( state.buffer, state.byteOffset, state.byteLength, header.buffer, header.byteOffset, header.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretstream_xchacha20poly1305_init_pull = function (state, header, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(header), 'header must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( header.byteLength === binding.crypto_secretstream_xchacha20poly1305_HEADERBYTES, "header must be 'crypto_secretstream_xchacha20poly1305_HEADERBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_init_pull( state.buffer, state.byteOffset, state.byteLength, header.buffer, header.byteOffset, header.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretstream_xchacha20poly1305_push = function (state, c, m, ad, tag) { if (!ad) ad = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( c.byteLength === m.byteLength + binding.crypto_secretstream_xchacha20poly1305_ABYTES, "c must be 'm.byteLength + crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_push( state.buffer, state.byteOffset, state.byteLength, c.buffer, c.byteOffset, c.byteLength, m.buffer, m.byteOffset, m.byteLength, ad.buffer, ad.byteOffset, ad.byteLength, tag ) if (res < 0) throw new Error('push failed') return res } exports.crypto_secretstream_xchacha20poly1305_pull = function (state, m, tag, c, ad) { if (!ad) ad = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(tag), 'tag must be a typed array') assert(tag.byteLength === 1, 'tag must be 1 byte') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( c.byteLength >= binding.crypto_secretstream_xchacha20poly1305_ABYTES, "c must be at least 'crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_secretstream_xchacha20poly1305_ABYTES, "m must be 'c.byteLength - crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_pull( state.buffer, state.byteOffset, state.byteLength, m.buffer, m.byteOffset, m.byteLength, tag.buffer, tag.byteOffset, tag.byteLength, c.buffer, c.byteOffset, c.byteLength, ad.buffer, ad.byteOffset, ad.byteLength ) if (res < 0) throw new Error('pull failed') return res } exports.crypto_secretstream_xchacha20poly1305_rekey = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) binding.crypto_secretstream_xchacha20poly1305_rekey( state.buffer, state.byteOffset, state.byteLength ) } // crypto_stream exports.crypto_stream = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) const res = binding.crypto_stream(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) const res = binding.crypto_stream_xor( c.buffer, c.byteOffset, c.byteLength, m.buffer, m.byteOffset, m.byteLength, n.buffer, n.byteOffset, n.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } // crypto_auth exports.crypto_auth = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(out.byteLength === binding.crypto_auth_BYTES, "out must be 'crypto_auth_BYTES' bytes") assert(k.byteLength === binding.crypto_auth_KEYBYTES, "k must be 'crypto_auth_KEYBYTES' bytes") const res = binding.crypto_auth(out, input, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_auth_verify = function (h, input, k) { assert(ArrayBuffer.isView(h), 'h must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(h.byteLength === binding.crypto_auth_BYTES, "h must be 'crypto_auth_BYTES' bytes") assert(k.byteLength === binding.crypto_auth_KEYBYTES, "k must be 'crypto_auth_KEYBYTES' bytes") return binding.crypto_auth_verify(h, input, k) } // crypto_onetimeauth exports.crypto_onetimeauth = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( out.byteLength === binding.crypto_onetimeauth_BYTES, "out must be 'crypto_onetimeauth_BYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) const res = binding.crypto_onetimeauth(out, input, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_init = function (state, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) const res = binding.crypto_onetimeauth_init(state, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) const res = binding.crypto_onetimeauth_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) assert( out.byteLength === binding.crypto_onetimeauth_BYTES, "out must be 'crypto_onetimeauth_BYTES' bytes" ) const res = binding.crypto_onetimeauth_final(state, out) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_verify = function (h, input, k) { assert(ArrayBuffer.isView(h), 'h must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( h.byteLength === binding.crypto_onetimeauth_BYTES, "h must be 'crypto_onetimeauth_BYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) return binding.crypto_onetimeauth_verify(h, input, k) } // crypto_pwhash exports.crypto_pwhash = function (out, passwd, salt, opslimit, memlimit, alg) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_BYTES_MIN, "out must be at least 'crypto_pwhash_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_BYTES_MAX, "out must be at most 'crypto_pwhash_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_SALTBYTES, "salt must be 'crypto_pwhash_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) assert(alg >= 1 && alg <= 2, 'alg must be either Argon2i 1.3 or Argon2id 1.3') const res = binding.crypto_pwhash(out, passwd, salt, opslimit, memlimit, alg) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_async = function ( out, passwd, salt, opslimit, memlimit, alg, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_BYTES_MIN, "out must be at least 'crypto_pwhash_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_BYTES_MAX, "out must be at most 'crypto_pwhash_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_SALTBYTES, "salt must be 'crypto_pwhash_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) assert(alg >= 1 && alg <= 2, 'alg must be either Argon2i 1.3 or Argon2id 1.3') const [done, promise] = checkStatus(callback) binding.crypto_pwhash_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, opslimit, memlimit, alg, done ) return promise } exports.crypto_pwhash_str = function (out, passwd, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_STRBYTES, "out must be 'crypto_pwhash_STRBYTES' bytes" ) assert(typeof opslimit === 'number', 'opslimit must be a number') assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert(typeof memlimit === 'number', 'memlimit must be a number') assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_str(out, passwd, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_str_async = function (out, passwd, opslimit, memlimit, callback = undefined) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_STRBYTES, "out must be 'crypto_pwhash_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert(typeof opslimit === 'number', 'opslimit must be a number') assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert(typeof memlimit === 'number', 'memlimit must be a number') assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_str_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_str_verify = function (str, passwd) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) return binding.crypto_pwhash_str_verify(str, passwd) } exports.crypto_pwhash_str_verify_async = function (str, passwd, callback = undefined) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') const [done, promise] = checkStatus(callback, true) binding.crypto_pwhash_str_verify_async( str.buffer, str.byteOffset, str.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, done ) return promise } exports.crypto_pwhash_str_needs_rehash = function (str, opslimit, memlimit) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) return binding.crypto_pwhash_str_needs_rehash(str, opslimit, memlimit) } exports.crypto_pwhash_scryptsalsa208sha256 = function (out, passwd, salt, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN, "out must be at least 'crypto_pwhash_scryptsalsa208sha256_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX, "out must be at most 'crypto_pwhash_scryptsalsa208sha256_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_SALTBYTES, "salt must be 'crypto_pwhash_scryptsalsa208sha256_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_scryptsalsa208sha256(out, passwd, salt, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_scryptsalsa208sha256_async = function ( out, passwd, salt, opslimit, memlimit, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN, "out must be at least 'crypto_pwhash_scryptsalsa208sha256_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX, "out must be at most 'crypto_pwhash_scryptsalsa208sha256_BYTES_MAX' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( salt.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_SALTBYTES, "salt must be 'crypto_pwhash_scryptsalsa208sha256_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_scryptsalsa208sha256_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str_async = function ( out, passwd, opslimit, memlimit, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "out must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_scryptsalsa208sha256_str_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str = function (out, passwd, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "out must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_scryptsalsa208sha256_str(out, passwd, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_scryptsalsa208sha256_str_verify_async = function ( str, passwd, callback = undefined ) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') const [done, promise] = checkStatus(callback, true) binding.crypto_pwhash_scryptsalsa208sha256_str_verify_async( str.buffer, str.byteOffset, str.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str_verify = function (str, passwd) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') return binding.crypto_pwhash_scryptsalsa208sha256_str_verify(str, passwd) } exports.crypto_pwhash_scryptsalsa208sha256_str_needs_rehash = function (str, opslimit, memlimit) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) return binding.crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(str, opslimit, memlimit) } // crypto_kx exports.crypto_kx_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "pk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "sk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) const res = binding.crypto_kx_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( pk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "pk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "sk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( seed.byteLength === binding.crypto_kx_SEEDBYTES, "seed must be 'crypto_kx_SEEDBYTES' bytes" ) const res = binding.crypto_kx_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_client_session_keys = function (rx, tx, clientPk, clientSk, serverPk) { if (!rx) rx = undefined if (!tx) tx = undefined assert(rx || tx, 'at least one session key must be specified') if (rx) { assert(ArrayBuffer.isView(rx), 'rx must be a typed array') assert( rx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "rx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } if (tx) { assert(ArrayBuffer.isView(tx), 'tx must be a typed array') assert( tx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "tx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } assert(ArrayBuffer.isView(clientPk), 'clientPk must be a typed array') assert(ArrayBuffer.isView(clientSk), 'clientSk must be a typed array') assert(ArrayBuffer.isView(serverPk), 'serverPk must be a typed array') assert( clientPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "clientPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( clientSk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "clientSk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( serverPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "serverPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_kx_client_session_keys(rx, tx, clientPk, clientSk, serverPk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_server_session_keys = function (rx, tx, serverPk, serverSk, clientPk) { if (!rx) rx = undefined if (!tx) tx = undefined assert(rx || tx, 'at least one session key must be specified') if (rx) { assert(ArrayBuffer.isView(rx), 'rx must be a typed array') assert( rx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "rx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } if (tx) { assert(ArrayBuffer.isView(tx), 'tx must be a typed array') assert( tx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "tx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } assert(ArrayBuffer.isView(serverPk), 'serverPk must be a typed array') assert(ArrayBuffer.isView(serverSk), 'serverSk must be a typed array') assert(ArrayBuffer.isView(clientPk), 'clientPk must be a typed array') assert( serverPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "serverPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( serverSk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "serverSk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( clientPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "clientPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_kx_server_session_keys(rx, tx, serverPk, serverSk, clientPk) if (res !== 0) throw new Error('status: ' + res) } // crypto_scalarmult exports.crypto_scalarmult_base = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_BYTES, "q must be 'crypto_scalarmult_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_SCALARBYTES, "n must be 'crypto_scalarmult_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_base(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_BYTES, "q must be 'crypto_scalarmult_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_SCALARBYTES, "n must be 'crypto_scalarmult_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_BYTES, "p must be 'crypto_scalarmult_BYTES' bytes" ) const res = binding.crypto_scalarmult(q, n, p) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_base = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_base(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519 = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "p must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519(q, n, p) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_is_valid_point = function (p) { assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) return binding.crypto_core_ed25519_is_valid_point(p) } exports.crypto_core_ed25519_from_uniform = function (p, r) { assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_UNIFORMBYTES, "r must be 'crypto_core_ed25519_UNIFORMBYTES' bytes" ) const res = binding.crypto_core_ed25519_from_uniform(p, r) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_base_noclamp = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_base_noclamp(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_noclamp = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "p must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_noclamp(q, n, p) if (res !== 0) throw new Error('status: ' + res) } // crypto_core exports.crypto_core_ed25519_add = function (r, p, q) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_BYTES, "r must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_core_ed25519_BYTES, "q must be 'crypto_core_ed25519_BYTES' bytes" ) const res = binding.crypto_core_ed25519_add(r, p, q) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_sub = function (r, p, q) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_BYTES, "r must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_core_ed25519_BYTES, "q must be 'crypto_core_ed25519_BYTES' bytes" ) const res = binding.crypto_core_ed25519_sub(r, p, q) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_scalar_random = function (r) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "r must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_random(r) } exports.crypto_core_ed25519_scalar_reduce = function (r, s) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "r must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_NONREDUCEDSCALARBYTES, "s must be 'crypto_core_ed25519_NONREDUCEDSCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_reduce(r, s) } exports.crypto_core_ed25519_scalar_invert = function (recip, s) { assert(ArrayBuffer.isView(recip), 'recip must be a typed array') assert( recip.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "recip must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_invert(recip, s) } exports.crypto_core_ed25519_scalar_negate = function (neg, s) { assert(ArrayBuffer.isView(neg), 'neg must be a typed array') assert( neg.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "neg must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_negate(neg, s) } exports.crypto_core_ed25519_scalar_complement = function (comp, s) { assert(ArrayBuffer.isView(comp), 'comp must be a typed array') assert( comp.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "comp must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_complement(comp, s) } exports.crypto_core_ed25519_scalar_add = function (z, x, y) { assert(ArrayBuffer.isView(z), 'z must be a typed array') assert( z.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "z must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(x), 'x must be a typed array') assert( x.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "x must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(y), 'y must be a typed array') assert( y.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "y must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_add(z, x, y) } exports.crypto_core_ed25519_scalar_sub = function (z, x, y) { assert(ArrayBuffer.isView(z), 'z must be a typed array') assert( z.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "z must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(x), 'x must be a typed array') assert( x.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "x must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(y), 'y must be a typed array') assert( y.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "y must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_sub(z, x, y) } // crypto_shorthash exports.crypto_shorthash = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_shorthash_BYTES, "out must be 'crypto_shorthash_BYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_shorthash_KEYBYTES, "k must be 'crypto_shorthash_KEYBYTES' bytes" ) const res = binding.crypto_shorthash(out, input, k) if (res !== 0) throw new Error('status: ' + res) } // crypto_kdf exports.crypto_kdf_keygen = function (key) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert(key.byteLength === binding.crypto_kdf_KEYBYTES, "key must be 'crypto_kdf_KEYBYTES' bytes") binding.crypto_kdf_keygen(key) } exports.crypto_kdf_derive_from_key = function (subkey, subkeyId, ctx, key) { assert(ArrayBuffer.isView(subkey), 'subkey must be a typed array') assert( subkey.byteLength >= binding.crypto_kdf_BYTES_MIN, "subkey must be at least 'crypto_kdf_BYTES_MIN' bytes" ) assert( subkey.byteLength <= binding.crypto_kdf_BYTES_MAX, "subkey must be at most 'crypto_kdf_BYTES_MAX' bytes" ) assert(ArrayBuffer.isView(ctx), 'ctx must be a typed array') assert( ctx.byteLength === binding.crypto_kdf_CONTEXTBYTES, "ctx must be 'crypto_kdf_CONTEXTBYTES' bytes" ) assert(ArrayBuffer.isView(key), 'key must be a typed array') assert(key.byteLength === binding.crypto_kdf_KEYBYTES, "key must be 'crypto_kdf_KEYBYTES' bytes") const res = binding.crypto_kdf_derive_from_key(subkey, subkeyId, ctx, key) if (res !== 0) throw new Error('status: ' + res) } // crypto_hash exports.crypto_hash = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(out.byteLength === binding.crypto_hash_BYTES, "out must be 'crypto_hash_BYTES' bytes") const res = binding.crypto_hash(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256 = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_hash_sha256_BYTES, "out must be 'crypto_hash_sha256_BYTES' bytes" ) const res = binding.crypto_hash_sha256(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_init = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha256_init(state) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha256_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( out.byteLength === binding.crypto_hash_sha256_BYTES, "out must be 'crypto_hash_sha256_BYTES' bytes" ) const res = binding.crypto_hash_sha256_final(state, out) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512 = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_hash_sha512_BYTES, "out must be 'crypto_hash_sha512_BYTES' bytes" ) const res = binding.crypto_hash_sha512(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_init = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha512_init(state) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha512_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( out.byteLength === binding.crypto_hash_sha512_BYTES, "out must be 'crypto_hash_sha512_BYTES' bytes" ) const res = binding.crypto_hash_sha512_final(state, out) if (res !== 0) throw new Error('status: ' + res) } // crypto_aead exports.crypto_aead_xchacha20poly1305_ietf_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) binding.crypto_aead_xchacha20poly1305_ietf_keygen(k) } exports.crypto_aead_xchacha20poly1305_ietf_encrypt = function (c, m, ad, nsec, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "c must be 'm.byteLength + crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(c.byteLength <= 0xffffffff, 'c.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_encrypt(c, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_xchacha20poly1305_ietf_decrypt = function (m, nsec, c, ad, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "m must be 'c.byteLength - crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(m.byteLength <= 0xffffffff, 'm.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_decrypt(m, c, ad, npub, k) if (res < 0) throw new Error('could not verify data') return res } exports.crypto_aead_xchacha20poly1305_ietf_encrypt_detached = function ( c, mac, m, ad, nsec, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_encrypt_detached(c, mac, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_xchacha20poly1305_ietf_decrypt_detached = function ( m, nsec, c, mac, ad, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_decrypt_detached(m, c, mac, ad, npub, k) if (res !== 0) throw new Error('could not verify data') } exports.crypto_aead_chacha20poly1305_ietf_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) binding.crypto_aead_chacha20poly1305_ietf_keygen(k) } exports.crypto_aead_chacha20poly1305_ietf_encrypt = function (c, m, ad, nsec, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "c must be 'm.byteLength + crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(c.byteLength <= 0xffffffff, 'c.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_encrypt(c, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_chacha20poly1305_ietf_decrypt = function (m, nsec, c, ad, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "m must be 'c.byteLength - crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(m.byteLength <= 0xffffffff, 'm.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_decrypt(m, c, ad, npub, k) if (res < 0) throw new Error('could not verify data') return res } exports.crypto_aead_chacha20poly1305_ietf_encrypt_detached = function ( c, mac, m, ad, nsec, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_encrypt_detached(c, mac, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_chacha20poly1305_ietf_decrypt_detached = function ( m, nsec, c, mac, ad, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_decrypt_detached(m, c, mac, ad, npub, k) if (res !== 0) throw new Error('could not verify data') } // crypto_stream exports.crypto_stream_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) binding.crypto_stream_xor_wrap_init(state, n, k) } exports.crypto_stream_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_xor_wrap_update(state, c, m) } exports.crypto_stream_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) binding.crypto_stream_xor_wrap_final(state) } exports.crypto_stream_chacha20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) binding.crypto_stream_chacha20_xor_wrap_init(state, n, k) } exports.crypto_stream_chacha20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_chacha20_xor_wrap_update(state, c, m) } exports.crypto_stream_chacha20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) binding.crypto_stream_chacha20_xor_wrap_final(state) } exports.crypto_stream_chacha20_ietf_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) binding.crypto_stream_chacha20_ietf_xor_wrap_init(state, n, k) } exports.crypto_stream_chacha20_ietf_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_chacha20_ietf_xor_wrap_update(state, c, m) } exports.crypto_stream_chacha20_ietf_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) binding.crypto_stream_chacha20_ietf_xor_wrap_final(state) } exports.crypto_stream_xchacha20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) binding.crypto_stream_xchacha20_xor_wrap_init(state, n, k) } exports.crypto_stream_xchacha20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_xchacha20_xor_wrap_update(state, c, m) } exports.crypto_stream_xchacha20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) binding.crypto_stream_xchacha20_xor_wrap_final(state) } exports.crypto_stream_salsa20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) binding.crypto_stream_salsa20_xor_wrap_init(state, n, k) } exports.crypto_stream_salsa20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_salsa20_xor_wrap_update(state, c, m) } exports.crypto_stream_salsa20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) binding.crypto_stream_salsa20_xor_wrap_final(state) } // experimental exports.extension_tweak_ed25519_base = function (n, p, ns) { assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.extension_tweak_ed25519_BYTES, "p must be 'extension_tweak_ed25519_BYTES' bytes" ) binding.extension_tweak_ed25519_base(n, p, ns) } exports.extension_tweak_ed25519_sign_detached = function (sig, m, scalar, pk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(sig.byteLength === binding.crypto_sign_BYTES, "sig must be 'crypto_sign_BYTES' bytes") assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) if (pk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) } const res = binding.extension_tweak_ed25519_sign_detached(sig, m, scalar, pk) if (res !== 0) throw new Error('failed to compute signature') } exports.extension_tweak_ed25519_sk_to_scalar = function (n, sk) { assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) binding.extension_tweak_ed25519_sk_to_scalar(n, sk) } exports.extension_tweak_ed25519_scalar = function (scalarOut, scalar, ns) { assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_scalar(scalarOut, scalar, ns) } exports.extension_tweak_ed25519_pk = function (tpk, pk, ns) { assert(ArrayBuffer.isView(tpk), 'tpk must be a typed array') assert( tpk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "tpk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.extension_tweak_ed25519_pk(tpk, pk, ns) if (res !== 0) throw new Error('failed to tweak public key') } exports.extension_tweak_ed25519_keypair = function (pk, scalarOut, scalarIn, ns) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.extension_tweak_ed25519_BYTES, "pk must be 'extension_tweak_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalarIn), 'scalarIn must be a typed array') assert( scalarIn.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarIn must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_keypair(pk, scalarOut, scalarIn, ns) } exports.extension_tweak_ed25519_scalar_add = function (scalarOut, scalar, n) { assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_scalar_add(scalarOut, scalar, n) } exports.extension_tweak_ed25519_pk_add = function (tpk, pk, p) { assert(ArrayBuffer.isView(tpk), 'tpk must be a typed array') assert( tpk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "tpk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "p must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.extension_tweak_ed25519_pk_add(tpk, pk, p) if (res !== 0) throw new Error('failed to add tweak to public key') } exports.extension_tweak_ed25519_keypair_add = function (pk, scalarOut, scalarIn, tweak) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.extension_tweak_ed25519_BYTES, "pk must be 'extension_tweak_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalarIn), 'scalarIn must be a typed array') assert( scalarIn.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarIn must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(tweak), 'tweak must be a typed array') assert( tweak.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "tweak must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) const res = binding.extension_tweak_ed25519_keypair_add(pk, scalarOut, scalarIn, tweak) if (res !== 0) throw new Error('failed to add tweak to keypair') } exports.extension_pbkdf2_sha512_async = function (out, passwd, salt, iter, outlen, callback) { assert( iter >= binding.extension_pbkdf2_sha512_ITERATIONS_MIN, "iter must be at least 'extension_pbkdf2_sha512_ITERATIONS_MIN'" ) assert( outlen <= binding.extension_pbkdf2_sha512_BYTES_MAX, "outlen must be at most 'extension_pbkdf2_sha512_BYTES_MAX'" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(out.byteLength >= outlen, "out must be at least 'outlen' bytes") assert(out.byteLength > 0, 'out must not be empty') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(passwd.byteLength > 0, 'passwd must not be empty') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert(salt.byteLength > 0, 'salt must not be empty') const [done, promise] = checkStatus(callback) binding.extension_pbkdf2_sha512_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, iter, outlen, done ) return promise } exports.extension_pbkdf2_sha512 = function (out, passwd, salt, iter, outlen) { assert( iter >= binding.extension_pbkdf2_sha512_ITERATIONS_MIN, "iter must be at least 'extension_pbkdf2_sha512_ITERATIONS_MIN'" ) assert( outlen <= binding.extension_pbkdf2_sha512_BYTES_MAX, "outlen must be at most 'extension_pbkdf2_sha512_BYTES_MAX'" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(out.byteLength >= outlen, "out must be at least 'outlen' bytes") assert(out.byteLength > 0, 'out must not be empty') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(passwd.byteLength > 0, 'passwd must not be empty') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert(salt.byteLength > 0, 'salt must not be empty') const res = binding.extension_pbkdf2_sha512(out, passwd, salt, iter, outlen) if (res !== 0) throw new Error('failed to add tweak to public key') } function checkStatus(callback, booleanResult = false) { let done, promise if (typeof callback === 'function') { done = function (status) { if (booleanResult) callback(null, status === 0) else if (status === 0) callback(null) else callback(new Error('status: ' + status)) } } else { promise = new Promise(function (resolve, reject) { done = function (status) { if (booleanResult) resolve(status === 0) else if (status === 0) resolve() else reject(new Error('status: ' + status)) } }) } return [done, promise] } { "name": "sodium-native", "version": "5.1.0", "description": "Low level bindings for libsodium", "main": "index.js", "files": [ "index.js", "binding.cc", "binding.js", "extensions", "prebuilds", "CMakeLists.txt" ], "imports": { "assert": { "bare": "bare-assert", "node": "assert" } }, "addon": true, "dependencies": { "bare-assert": "^1.2.0", "require-addon": "^1.1.0", "which-runtime": "^1.2.1" }, "devDependencies": { "bare-compat-napi": "^1.3.5", "brittle": "^3.16.2", "cmake-bare": "^1.6.1", "cmake-fetch": "^1.4.3", "cmake-napi": "^1.2.1", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "test": "prettier . --check && npm run test:node && npm run test:bare", "test:node": "node test/all.js", "test:bare": "bare test/all.js" }, "standard": { "ignore": [ "/test/fixtures/*.js" ] }, "engines": { "bare": ">=1.16.0" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/sodium-native.git" }, "contributors": [ "Emil Bay (http://bayes.dk)", "Mathias Buus (https://mafinto.sh)", "Christophe Diederichs " ], "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/sodium-native/issues" }, "homepage": "https://github.com/holepunchto/sodium-native" } module.exports = require('sodium-native') { "name": "sodium-universal", "version": "5.0.1", "description": "Universal wrapper for sodium-javascript and sodium-native working in Node.js and the Browser", "main": "index.js", "dependencies": { "sodium-native": "^5.0.1" }, "peerDependencies": { "sodium-javascript": "~0.8.0" }, "peerDependenciesMeta": { "sodium-javascript": { "optional": true } }, "scripts": { "prepublish": "./build-scripts/generate.js" }, "browser": { "sodium-native": "sodium-javascript" }, "browserify": { "transform": [ "./build-scripts/transform.js" ] }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/sodium-universal.git" }, "keywords": [ "libsodium", "sodium", "sodium-native", "sodium-javascript", "browserify" ], "contributors": [ "Emil Bay (http://bayes.dk)", "Mathias Buus (https://mafinto.sh)", "Christophe Diederichs " ], "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/sodium-universal/issues" }, "homepage": "https://github.com/holepunchto/sodium-universal#readme" } const { EventEmitter } = require('events-universal') const FIFO = require('fast-fifo') const TextDecoder = require('text-decoder') const StreamError = require('./lib/errors.js') // if we do a future major, expect queue microtask to be there always, for now a bit defensive const qmt = typeof queueMicrotask === 'undefined' ? (fn) => global.process.nextTick(fn) : queueMicrotask // 29 bits used total (4 from shared, 14 from read, and 11 from write) const MAX = (1 << 29) - 1 // Shared state const OPENING = 0b0001 const PREDESTROYING = 0b0010 const DESTROYING = 0b0100 const DESTROYED = 0b1000 const NOT_OPENING = MAX ^ OPENING const NOT_PREDESTROYING = MAX ^ PREDESTROYING // Read state (4 bit offset from shared state) const READ_ACTIVE = 0b00000000000001 << 4 const READ_UPDATING = 0b00000000000010 << 4 const READ_PRIMARY = 0b00000000000100 << 4 const READ_QUEUED = 0b00000000001000 << 4 const READ_RESUMED = 0b00000000010000 << 4 const READ_PIPE_DRAINED = 0b00000000100000 << 4 const READ_ENDING = 0b00000001000000 << 4 const READ_EMIT_DATA = 0b00000010000000 << 4 const READ_EMIT_READABLE = 0b00000100000000 << 4 const READ_EMITTED_READABLE = 0b00001000000000 << 4 const READ_DONE = 0b00010000000000 << 4 const READ_NEXT_TICK = 0b00100000000000 << 4 const READ_NEEDS_PUSH = 0b01000000000000 << 4 const READ_READ_AHEAD = 0b10000000000000 << 4 // Combined read state const READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED const READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH const READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE const READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED const READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD const READ_NOT_ACTIVE = MAX ^ READ_ACTIVE const READ_NON_PRIMARY = MAX ^ READ_PRIMARY const READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH) const READ_PUSHED = MAX ^ READ_NEEDS_PUSH const READ_PAUSED = MAX ^ READ_RESUMED const READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE) const READ_NOT_ENDING = MAX ^ READ_ENDING const READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING const READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK const READ_NOT_UPDATING = MAX ^ READ_UPDATING const READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD const READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD // Write state (18 bit offset, 4 bit offset from shared state and 14 from read state) const WRITE_ACTIVE = 0b00000000001 << 18 const WRITE_UPDATING = 0b00000000010 << 18 const WRITE_PRIMARY = 0b00000000100 << 18 const WRITE_QUEUED = 0b00000001000 << 18 const WRITE_UNDRAINED = 0b00000010000 << 18 const WRITE_DONE = 0b00000100000 << 18 const WRITE_EMIT_DRAIN = 0b00001000000 << 18 const WRITE_NEXT_TICK = 0b00010000000 << 18 const WRITE_WRITING = 0b00100000000 << 18 const WRITE_FINISHING = 0b01000000000 << 18 const WRITE_CORKED = 0b10000000000 << 18 const WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING) const WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY const WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING) const WRITE_DRAINED = MAX ^ WRITE_UNDRAINED const WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED const WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK const WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING const WRITE_NOT_CORKED = MAX ^ WRITE_CORKED // Combined shared state const ACTIVE = READ_ACTIVE | WRITE_ACTIVE const NOT_ACTIVE = MAX ^ ACTIVE const DONE = READ_DONE | WRITE_DONE const DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING const OPEN_STATUS = DESTROY_STATUS | OPENING const AUTO_DESTROY = DESTROY_STATUS | DONE const NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY const ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK const TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE const IS_OPENING = OPEN_STATUS | TICKING // Combined shared state and read state const READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE const READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED const READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED const READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE const SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD const READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE const READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY const READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING // Combined write state const WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE const WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED const WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE const WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE const WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED const WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE const WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING const WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE const WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE const WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY const WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS const asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator') class WritableState { constructor( stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {} ) { this.stream = stream this.queue = new FIFO() this.highWaterMark = highWaterMark this.buffered = 0 this.error = null this.pipeline = null this.drains = null // if we add more seldomly used helpers we might them into a subobject so its a single ptr this.byteLength = byteLengthWritable || byteLength || defaultByteLength this.map = mapWritable || map this.afterWrite = afterWrite.bind(this) this.afterUpdateNextTick = updateWriteNT.bind(this) } get ending() { return (this.stream._duplexState & WRITE_FINISHING) !== 0 } get ended() { return (this.stream._duplexState & WRITE_DONE) !== 0 } push(data) { if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false if (this.map !== null) data = this.map(data) this.buffered += this.byteLength(data) this.queue.push(data) if (this.buffered < this.highWaterMark) { this.stream._duplexState |= WRITE_QUEUED return true } this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED return false } shift() { const data = this.queue.shift() this.buffered -= this.byteLength(data) if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED return data } end(data) { if (typeof data === 'function') { this.stream.once('finish', data) } else if (data !== undefined && data !== null) { this.push(data) } this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY } autoBatch(data, cb) { const buffer = [] const stream = this.stream buffer.push(data) while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) { buffer.push(stream._writableState.shift()) } if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null) stream._writev(buffer, cb) } update() { const stream = this.stream stream._duplexState |= WRITE_UPDATING do { while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) { const data = this.shift() stream._duplexState |= WRITE_ACTIVE_AND_WRITING stream._write(data, this.afterWrite) } if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary() } while (this.continueUpdate() === true) stream._duplexState &= WRITE_NOT_UPDATING } updateNonPrimary() { const stream = this.stream if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) { stream._duplexState = stream._duplexState | WRITE_ACTIVE stream._final(afterFinal.bind(this)) return } if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { stream._duplexState |= ACTIVE stream._destroy(afterDestroy.bind(this)) } return } if ((stream._duplexState & IS_OPENING) === OPENING) { stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING stream._open(afterOpen.bind(this)) } } continueUpdate() { if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false this.stream._duplexState &= WRITE_NOT_NEXT_TICK return true } updateCallback() { if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) { this.update() } else { this.updateNextTick() } } updateNextTick() { if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return this.stream._duplexState |= WRITE_NEXT_TICK if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick) } } class ReadableState { constructor( stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {} ) { this.stream = stream this.queue = new FIFO() this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark this.buffered = 0 this.readAhead = highWaterMark > 0 this.error = null this.pipeline = null this.byteLength = byteLengthReadable || byteLength || defaultByteLength this.map = mapReadable || map this.pipeTo = null this.afterRead = afterRead.bind(this) this.afterUpdateNextTick = updateReadNT.bind(this) } get ending() { return (this.stream._duplexState & READ_ENDING) !== 0 } get ended() { return (this.stream._duplexState & READ_DONE) !== 0 } pipe(pipeTo, cb) { if (this.pipeTo !== null) throw StreamError.BAD_ARGUMENT('Can only pipe to one destination') if (typeof cb !== 'function') cb = null this.stream._duplexState |= READ_PIPE_DRAINED this.pipeTo = pipeTo this.pipeline = new Pipeline(this.stream, pipeTo, cb) if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes if (isStreamx(pipeTo)) { pipeTo._writableState.pipeline = this.pipeline if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself } else { const onerror = this.pipeline.done.bind(this.pipeline, pipeTo) const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool arg pipeTo.on('error', onerror) pipeTo.on('close', onclose) pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) } pipeTo.on('drain', afterDrain.bind(this)) this.stream.emit('piping', pipeTo) pipeTo.emit('pipe', this.stream) } push(data) { const stream = this.stream if (data === null) { this.highWaterMark = 0 stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED return false } if (this.map !== null) { data = this.map(data) if (data === null) { stream._duplexState &= READ_PUSHED return this.buffered < this.highWaterMark } } this.buffered += this.byteLength(data) this.queue.push(data) stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED return this.buffered < this.highWaterMark } shift() { const data = this.queue.shift() this.buffered -= this.byteLength(data) if (this.buffered === 0) { this.stream._duplexState &= READ_NOT_QUEUED } return data } unshift(data) { const pending = [this.map !== null ? this.map(data) : data] while (this.buffered > 0) pending.push(this.shift()) for (let i = 0; i < pending.length - 1; i++) { const data = pending[i] this.buffered += this.byteLength(data) this.queue.push(data) } this.push(pending[pending.length - 1]) } read() { const stream = this.stream if ((stream._duplexState & READ_STATUS) === READ_QUEUED) { const data = this.shift() if (this.pipeTo !== null && this.pipeTo.write(data) === false) { stream._duplexState &= READ_PIPE_NOT_DRAINED } if ((stream._duplexState & READ_EMIT_DATA) !== 0) { stream.emit('data', data) } return data } if (this.readAhead === false) { stream._duplexState |= READ_READ_AHEAD this.updateNextTick() } return null } drain() { const stream = this.stream while ( (stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0 ) { const data = this.shift() if (this.pipeTo !== null && this.pipeTo.write(data) === false) { stream._duplexState &= READ_PIPE_NOT_DRAINED } if ((stream._duplexState & READ_EMIT_DATA) !== 0) { stream.emit('data', data) } } } update() { const stream = this.stream stream._duplexState |= READ_UPDATING do { this.drain() while ( this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD ) { stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH stream._read(this.afterRead) this.drain() } if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) { stream._duplexState |= READ_EMITTED_READABLE stream.emit('readable') } if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) { this.updateNonPrimary() } } while (this.continueUpdate() === true) stream._duplexState &= READ_NOT_UPDATING } updateNonPrimary() { const stream = this.stream if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) { stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING stream.emit('end') if ((stream._duplexState & AUTO_DESTROY) === DONE) { stream._duplexState |= DESTROYING } if (this.pipeTo !== null) { this.pipeTo.end() } } if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { stream._duplexState |= ACTIVE stream._destroy(afterDestroy.bind(this)) } return } if ((stream._duplexState & IS_OPENING) === OPENING) { stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING stream._open(afterOpen.bind(this)) } } continueUpdate() { if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false this.stream._duplexState &= READ_NOT_NEXT_TICK return true } updateCallback() { if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) { this.update() } else { this.updateNextTick() } } updateNextTickIfOpen() { if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return this.stream._duplexState |= READ_NEXT_TICK if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick) } updateNextTick() { if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return this.stream._duplexState |= READ_NEXT_TICK if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick) } } class TransformState { constructor(stream) { this.data = null this.afterTransform = afterTransform.bind(stream) this.afterFinal = null } } class Pipeline { constructor(src, dst, cb) { this.from = src this.to = dst this.afterPipe = cb this.error = null this.pipeToFinished = false } finished() { this.pipeToFinished = true } done(stream, err) { if (err) this.error = err if (stream === this.to) { this.to = null if (this.from !== null) { if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) { this.from.destroy(this.error || StreamError.PREMATURE_CLOSE('Writable stream closed')) } return } } if (stream === this.from) { this.from = null if (this.to !== null) { if ((stream._duplexState & READ_DONE) === 0) { this.to.destroy(this.error || StreamError.PREMATURE_CLOSE('Readable stream closed')) } return } } if (this.afterPipe !== null) this.afterPipe(this.error) this.to = this.from = this.afterPipe = null } } function afterDrain() { this.stream._duplexState |= READ_PIPE_DRAINED this.updateCallback() } function afterFinal(err) { const stream = this.stream if (err) stream.destroy(err) if ((stream._duplexState & DESTROY_STATUS) === 0) { stream._duplexState |= WRITE_DONE stream.emit('finish') } if ((stream._duplexState & AUTO_DESTROY) === DONE) { stream._duplexState |= DESTROYING } stream._duplexState &= WRITE_NOT_FINISHING // no need to wait the extra tick here, so we short circuit that if ((stream._duplexState & WRITE_UPDATING) === 0) { this.update() } else { this.updateNextTick() } } function afterDestroy(err) { const stream = this.stream if (!err && !StreamError.isStreamDestroyed(this.error)) err = this.error if (err) stream.emit('error', err) stream._duplexState |= DESTROYED stream.emit('close') const rs = stream._readableState const ws = stream._writableState if (rs !== null && rs.pipeline !== null) { rs.pipeline.done(stream, err) } if (ws !== null) { while (ws.drains !== null && ws.drains.length > 0) { ws.drains.shift().resolve(false) } if (ws.pipeline !== null) { ws.pipeline.done(stream, err) } } } function afterWrite(err) { const stream = this.stream if (err) stream.destroy(err) stream._duplexState &= WRITE_NOT_ACTIVE if (this.drains !== null) tickDrains(this.drains) if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) { stream._duplexState &= WRITE_DRAINED if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) { stream.emit('drain') } } this.updateCallback() } function afterRead(err) { if (err) this.stream.destroy(err) this.stream._duplexState &= READ_NOT_ACTIVE if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) { this.stream._duplexState &= READ_NO_READ_AHEAD } this.updateCallback() } function updateReadNT() { if ((this.stream._duplexState & READ_UPDATING) === 0) { this.stream._duplexState &= READ_NOT_NEXT_TICK this.update() } } function updateWriteNT() { if ((this.stream._duplexState & WRITE_UPDATING) === 0) { this.stream._duplexState &= WRITE_NOT_NEXT_TICK this.update() } } function tickDrains(drains) { for (let i = 0; i < drains.length; i++) { // drains.writes are monotonic, so if one is 0 its always the first one if (--drains[i].writes === 0) { drains.shift().resolve(true) i-- } } } function afterOpen(err) { const stream = this.stream if (err) stream.destroy(err) if ((stream._duplexState & DESTROYING) === 0) { if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) { stream._duplexState |= READ_PRIMARY } if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) { stream._duplexState |= WRITE_PRIMARY } stream.emit('open') } stream._duplexState &= NOT_ACTIVE if (stream._writableState !== null) { stream._writableState.updateCallback() } if (stream._readableState !== null) { stream._readableState.updateCallback() } } function afterTransform(err, data) { if (data !== undefined && data !== null) this.push(data) this._writableState.afterWrite(err) } function newListener(name) { if (this._readableState !== null) { if (name === 'data') { this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD this._readableState.updateNextTick() } if (name === 'readable') { this._duplexState |= READ_EMIT_READABLE this._readableState.updateNextTick() } } if (this._writableState !== null) { if (name === 'drain') { this._duplexState |= WRITE_EMIT_DRAIN this._writableState.updateNextTick() } } } class Stream extends EventEmitter { constructor(opts) { super() this._duplexState = 0 this._readableState = null this._writableState = null if (opts) { if (opts.open) this._open = opts.open if (opts.destroy) this._destroy = opts.destroy if (opts.predestroy) this._predestroy = opts.predestroy if (opts.signal) opts.signal.addEventListener('abort', abort.bind(this)) } this.on('newListener', newListener) } _open(cb) { cb(null) } _destroy(cb) { cb(null) } _predestroy() { // does nothing } get readable() { return this._readableState !== null ? true : undefined } get writable() { return this._writableState !== null ? true : undefined } get destroyed() { return (this._duplexState & DESTROYED) !== 0 } get destroying() { return (this._duplexState & DESTROY_STATUS) !== 0 } destroy(err) { if ((this._duplexState & DESTROY_STATUS) === 0) { if (!err) err = StreamError.STREAM_DESTROYED() this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY if (this._readableState !== null) { this._readableState.highWaterMark = 0 this._readableState.error = err } if (this._writableState !== null) { this._writableState.highWaterMark = 0 this._writableState.error = err } this._duplexState |= PREDESTROYING this._predestroy() this._duplexState &= NOT_PREDESTROYING if (this._readableState !== null) { this._readableState.updateNextTick() } if (this._writableState !== null) { this._writableState.updateNextTick() } } } } class Readable extends Stream { constructor(opts) { super(opts) this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD this._readableState = new ReadableState(this, opts) if (opts) { if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD if (opts.read) this._read = opts.read if (opts.eagerOpen) this._readableState.updateNextTick() if (opts.encoding) this.setEncoding(opts.encoding) } } static deferred(fn, opts) { const out = new PassThrough(opts) fn() .then((src) => { if (src === null) return out.end() if (out.destroying) return pipeline(src, out, noop) }) .catch((err) => out.destroy(err)) return out } setEncoding(encoding) { const dec = new TextDecoder(encoding) const map = this._readableState.map || echo this._readableState.map = mapOrSkip return this function mapOrSkip(data) { const next = dec.push(data) return next === '' && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next) } } _read(cb) { cb(null) } pipe(dest, cb) { this._readableState.updateNextTick() this._readableState.pipe(dest, cb) return dest } read() { this._readableState.updateNextTick() return this._readableState.read() } push(data) { this._readableState.updateNextTickIfOpen() return this._readableState.push(data) } unshift(data) { this._readableState.updateNextTickIfOpen() return this._readableState.unshift(data) } resume() { this._duplexState |= READ_RESUMED_READ_AHEAD this._readableState.updateNextTick() return this } pause() { this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED return this } static _fromAsyncIterator(ite, opts) { let destroy const rs = new Readable({ ...opts, read(cb) { ite.next().then(push).then(cb.bind(null, null)).catch(cb) }, predestroy() { destroy = ite.return() }, destroy(cb) { if (!destroy) return cb(null) destroy.then(cb.bind(null, null)).catch(cb) } }) return rs function push(data) { if (data.done) rs.push(null) else rs.push(data.value) } } static from(data, opts) { if (isReadStreamx(data)) return data if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts) if (!Array.isArray(data)) data = data === undefined ? [] : [data] let i = 0 return new Readable({ ...opts, read(cb) { this.push(i === data.length ? null : data[i++]) cb(null) } }) } static isBackpressured(rs) { return ( (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark ) } static isPaused(rs) { return (rs._duplexState & READ_RESUMED) === 0 } [asyncIterator]() { const stream = this let error = null let promiseResolve = null let promiseReject = null this.on('error', (err) => { error = err }) this.on('readable', onreadable) this.on('close', onclose) return { [asyncIterator]() { return this }, next() { return new Promise(function (resolve, reject) { promiseResolve = resolve promiseReject = reject const data = stream.read() if (data !== null) ondata(data) else if ((stream._duplexState & DESTROYED) !== 0) ondata(null) }) }, return() { return destroy(null) }, throw(err) { return destroy(err) } } function onreadable() { if (promiseResolve !== null) ondata(stream.read()) } function onclose() { if (promiseResolve !== null) ondata(null) } function ondata(data) { if (promiseReject === null) return if (error) { promiseReject(error) } else if (data === null && (stream._duplexState & READ_DONE) === 0) { promiseReject(StreamError.STREAM_DESTROYED()) } else { promiseResolve({ value: data, done: data === null }) } promiseReject = promiseResolve = null } function destroy(err) { stream.destroy(err) return new Promise((resolve, reject) => { if (stream._duplexState & DESTROYED) return resolve({ value: undefined, done: true }) stream.once('close', function () { if (err) reject(err) else resolve({ value: undefined, done: true }) }) }) } } } class Writable extends Stream { constructor(opts) { super(opts) this._duplexState |= OPENING | READ_DONE this._writableState = new WritableState(this, opts) if (opts) { if (opts.writev) this._writev = opts.writev if (opts.write) this._write = opts.write if (opts.final) this._final = opts.final if (opts.eagerOpen) this._writableState.updateNextTick() } } cork() { this._duplexState |= WRITE_CORKED } uncork() { this._duplexState &= WRITE_NOT_CORKED this._writableState.updateNextTick() } _writev(batch, cb) { cb(null) } _write(data, cb) { this._writableState.autoBatch(data, cb) } _final(cb) { cb(null) } static isBackpressured(ws) { return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0 } static drained(ws) { if (ws.destroyed) return Promise.resolve(false) const state = ws._writableState const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0) if (writes === 0) return Promise.resolve(true) if (state.drains === null) state.drains = [] return new Promise((resolve) => { state.drains.push({ writes, resolve }) }) } write(data) { this._writableState.updateNextTick() return this._writableState.push(data) } end(data) { this._writableState.updateNextTick() this._writableState.end(data) return this } } class Duplex extends Readable { // and Writable constructor(opts) { super(opts) this._duplexState = OPENING | (this._duplexState & READ_READ_AHEAD) this._writableState = new WritableState(this, opts) if (opts) { if (opts.writev) this._writev = opts.writev if (opts.write) this._write = opts.write if (opts.final) this._final = opts.final } } cork() { this._duplexState |= WRITE_CORKED } uncork() { this._duplexState &= WRITE_NOT_CORKED this._writableState.updateNextTick() } _writev(batch, cb) { cb(null) } _write(data, cb) { this._writableState.autoBatch(data, cb) } _final(cb) { cb(null) } write(data) { this._writableState.updateNextTick() return this._writableState.push(data) } end(data) { this._writableState.updateNextTick() this._writableState.end(data) return this } } class Transform extends Duplex { constructor(opts) { super(opts) this._transformState = new TransformState(this) if (opts) { if (opts.transform) this._transform = opts.transform if (opts.flush) this._flush = opts.flush } } _write(data, cb) { if (this._readableState.buffered >= this._readableState.highWaterMark) { this._transformState.data = data } else { this._transform(data, this._transformState.afterTransform) } } _read(cb) { if (this._transformState.data !== null) { const data = this._transformState.data this._transformState.data = null cb(null) this._transform(data, this._transformState.afterTransform) } else { cb(null) } } destroy(err) { super.destroy(err) if (this._transformState.data !== null) { this._transformState.data = null this._transformState.afterTransform() } } _transform(data, cb) { cb(null, data) } _flush(cb) { cb(null) } _final(cb) { this._transformState.afterFinal = cb this._flush(transformAfterFlush.bind(this)) } } class PassThrough extends Transform {} function transformAfterFlush(err, data) { const cb = this._transformState.afterFinal if (err) return cb(err) if (data !== null && data !== undefined) this.push(data) this.push(null) cb(null) } function pipelinePromise(...streams) { return new Promise((resolve, reject) => { return pipeline(...streams, (err) => { if (err) return reject(err) resolve() }) }) } function pipeline(stream, ...streams) { const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams] const done = all.length && typeof all[all.length - 1] === 'function' ? all.pop() : null if (all.length < 2) throw StreamError.BAD_ARGUMENT('Pipeline requires at least 2 streams') let src = all[0] let dest = null let error = null for (let i = 1; i < all.length; i++) { dest = all[i] if (isStreamx(src)) { src.pipe(dest, onerror) } else { errorHandle(src, true, i > 1, onerror) src.pipe(dest) } src = dest } if (done) { let fin = false const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy) dest.on('error', (err) => { if (error === null) error = err }) dest.on('finish', () => { fin = true if (!autoDestroy) done(error) }) if (autoDestroy) { dest.on('close', () => done(error || (fin ? null : StreamError.PREMATURE_CLOSE()))) } } return dest function errorHandle(s, rd, wr, onerror) { s.on('error', onerror) s.on('close', onclose) function onclose() { if (rd && s._readableState && !s._readableState.ended) { return onerror(StreamError.PREMATURE_CLOSE()) } if (wr && s._writableState && !s._writableState.ended) { return onerror(StreamError.PREMATURE_CLOSE()) } } } function onerror(err) { if (!err || error) return error = err for (const s of all) { s.destroy(err) } } } function echo(s) { return s } function isStream(stream) { return !!stream._readableState || !!stream._writableState } function isStreamx(stream) { return typeof stream._duplexState === 'number' && isStream(stream) } function isEnding(stream) { return !!stream._readableState && stream._readableState.ending } function isEnded(stream) { return !!stream._readableState && stream._readableState.ended } function isFinishing(stream) { return !!stream._writableState && stream._writableState.ending } function isFinished(stream) { return !!stream._writableState && stream._writableState.ended } function getStreamError(stream, opts = {}) { const err = (stream._readableState && stream._readableState.error) || (stream._writableState && stream._writableState.error) // avoid implicit errors by default return !opts.all && StreamError.isStreamDestroyed(err) ? null : err } function isReadStreamx(stream) { return isStreamx(stream) && stream.readable } function isDisturbed(stream) { return ( (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0 ) } function isTypedArray(data) { return typeof data === 'object' && data !== null && typeof data.byteLength === 'number' } function defaultByteLength(data) { return isTypedArray(data) ? data.byteLength : 1024 } function noop() {} function abort() { this.destroy(StreamError.ABORTED()) } function isWritev(s) { return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev } module.exports = { pipeline, pipelinePromise, isStream, isStreamx, isEnding, isEnded, isFinishing, isFinished, isDisturbed, getStreamError, Stream, Writable, Readable, Duplex, Transform, // Export PassThrough for compatibility with Node.js core's stream module PassThrough } module.exports = class StreamError extends Error { constructor(msg, code, fn = StreamError) { super(msg) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } static isStreamDestroyed(err) { return err && err.code === 'STREAM_DESTROYED' } static isPrematureClose(err) { return err && err.code === 'PREMATURE_CLOSE' } static isAborted(err) { return err && err.code === 'ABORTED' } static isBadArgument(err) { return err && err.code === 'BAD_ARGUMENT' } get name() { return 'StreamError' } static STREAM_DESTROYED() { return new StreamError('Stream was destroyed', 'STREAM_DESTROYED', StreamError.STREAM_DESTROYED) } static PREMATURE_CLOSE(msg = 'Premature close') { return new StreamError(msg, 'PREMATURE_CLOSE', StreamError.PREMATURE_CLOSE) } static ABORTED() { return new StreamError('Stream aborted', 'ABORTED', StreamError.ABORTED) } static BAD_ARGUMENT(msg = 'Bad argument') { return new StreamError(msg, 'BAD_ARGUMENT', StreamError.BAD_ARGUMENT) } } { "name": "streamx", "version": "2.28.0", "description": "An iteration of the Node.js core streams with a series of improvements", "main": "index.js", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors" } }, "dependencies": { "events-universal": "^1.0.0", "fast-fifo": "^1.3.2", "text-decoder": "^1.1.0" }, "devDependencies": { "b4a": "^1.6.6", "brittle": "^3.1.1", "end-of-stream": "^1.4.4", "lunte": "^1.8.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "files": [ "index.js", "index.d.ts", "runtime.d.ts", "lib" ], "scripts": { "format": "prettier . --write", "test": "brittle test/all.js && brittle-bare test/all.js", "lint": "prettier . --check && lunte" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/streamx.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/streamx/issues" }, "homepage": "https://github.com/mafintosh/streamx" } const { Readable } = require('streamx') module.exports = function (s, forks = 2) { const streams = new Array(forks) const status = new Array(forks).fill(true) let ended = false for (let i = 0; i < forks; i++) { streams[i] = new Readable({ read (cb) { const check = !status[i] status[i] = true if (check && allReadable()) s.resume() cb(null) } }) } s.on('end', function () { ended = true for (const stream of streams) stream.push(null) }) s.on('error', function (err) { for (const stream of streams) stream.destroy(err) }) s.on('close', function () { if (ended) return for (const stream of streams) stream.destroy() }) s.on('data', function (data) { let needsPause = false for (let i = 0; i < streams.length; i++) { if (!(status[i] = streams[i].push(data))) { needsPause = true } } if (needsPause) s.pause() }) return streams function allReadable () { for (let j = 0; j < status.length; j++) { if (!status[j]) return false } return true } } { "name": "teex", "version": "1.0.1", "description": "Turn a readable stream into multiple readable streamx streams", "main": "index.js", "dependencies": { "streamx": "^2.12.5" }, "devDependencies": { "standard": "^14.3.4", "tape": "^5.0.1" }, "scripts": { "test": "standard && tape test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/teex.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/teex/issues" }, "homepage": "https://github.com/mafintosh/teex" } const PassThroughDecoder = require('./lib/pass-through-decoder') const UTF8Decoder = require('./lib/utf8-decoder') module.exports = class TextDecoder { constructor(encoding = 'utf8') { this.encoding = normalizeEncoding(encoding) switch (this.encoding) { case 'utf8': this.decoder = new UTF8Decoder() break case 'utf16le': case 'base64': throw new Error('Unsupported encoding: ' + this.encoding) default: this.decoder = new PassThroughDecoder(this.encoding) } } get remaining() { return this.decoder.remaining } push(data) { if (typeof data === 'string') return data return this.decoder.decode(data) } // For Node.js compatibility write(data) { return this.push(data) } end(data) { let result = '' if (data) result = this.push(data) result += this.decoder.flush() return result } } function normalizeEncoding(encoding) { encoding = encoding.toLowerCase() switch (encoding) { case 'utf8': case 'utf-8': return 'utf8' case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return 'utf16le' case 'latin1': case 'binary': return 'latin1' case 'base64': case 'ascii': case 'hex': return encoding default: throw new Error('Unknown encoding: ' + encoding) } } const b4a = require('b4a') module.exports = class PassThroughDecoder { constructor(encoding) { this.encoding = encoding } get remaining() { return 0 } decode(data) { return b4a.toString(data, this.encoding) } flush() { return '' } } const b4a = require('b4a') /** * https://encoding.spec.whatwg.org/#utf-8-decoder */ module.exports = class UTF8Decoder { constructor() { this._reset() } get remaining() { return this.bytesSeen } decode(data) { if (data.byteLength === 0) return '' if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) { this.bytesSeen = trailingBytesSeen(data) return b4a.toString(data, 'utf8') } let result = '' let start = 0 if (this.bytesNeeded > 0) { while (start < data.byteLength) { const byte = data[start] if (byte < this.lowerBoundary || byte > this.upperBoundary) { result += '\ufffd' this._reset() break } this.lowerBoundary = 0x80 this.upperBoundary = 0xbf this.codePoint = (this.codePoint << 6) | (byte & 0x3f) this.bytesSeen++ start++ if (this.bytesSeen === this.bytesNeeded) { result += String.fromCodePoint(this.codePoint) this._reset() break } } if (this.bytesNeeded > 0) return result } const trailing = trailingIncomplete(data, start) const end = data.byteLength - trailing if (end > start) result += b4a.toString(data, 'utf8', start, end) for (let i = end; i < data.byteLength; i++) { const byte = data[i] if (this.bytesNeeded === 0) { if (byte <= 0x7f) { this.bytesSeen = 0 result += String.fromCharCode(byte) } else if (byte >= 0xc2 && byte <= 0xdf) { this.bytesNeeded = 2 this.bytesSeen = 1 this.codePoint = byte & 0x1f } else if (byte >= 0xe0 && byte <= 0xef) { if (byte === 0xe0) this.lowerBoundary = 0xa0 else if (byte === 0xed) this.upperBoundary = 0x9f this.bytesNeeded = 3 this.bytesSeen = 1 this.codePoint = byte & 0xf } else if (byte >= 0xf0 && byte <= 0xf4) { if (byte === 0xf0) this.lowerBoundary = 0x90 else if (byte === 0xf4) this.upperBoundary = 0x8f this.bytesNeeded = 4 this.bytesSeen = 1 this.codePoint = byte & 0x7 } else { this.bytesSeen = 1 result += '\ufffd' } continue } if (byte < this.lowerBoundary || byte > this.upperBoundary) { result += '\ufffd' i-- this._reset() continue } this.lowerBoundary = 0x80 this.upperBoundary = 0xbf this.codePoint = (this.codePoint << 6) | (byte & 0x3f) this.bytesSeen++ if (this.bytesSeen === this.bytesNeeded) { result += String.fromCodePoint(this.codePoint) this._reset() } } return result } flush() { const result = this.bytesNeeded > 0 ? '\ufffd' : '' this._reset() return result } _reset() { this.codePoint = 0 this.bytesNeeded = 0 this.bytesSeen = 0 this.lowerBoundary = 0x80 this.upperBoundary = 0xbf } } function trailingIncomplete(data, start) { const len = data.byteLength if (len <= start) return 0 const limit = Math.max(start, len - 4) let i = len - 1 while (i > limit && (data[i] & 0xc0) === 0x80) i-- if (i < start) return 0 const byte = data[i] let needed if (byte <= 0x7f) return 0 if (byte >= 0xc2 && byte <= 0xdf) needed = 2 else if (byte >= 0xe0 && byte <= 0xef) needed = 3 else if (byte >= 0xf0 && byte <= 0xf4) needed = 4 else return 0 const available = len - i return available < needed ? available : 0 } function trailingBytesSeen(data) { const len = data.byteLength if (len === 0) return 0 const last = data[len - 1] if (last <= 0x7f) return 0 if ((last & 0xc0) !== 0x80) return 1 const limit = Math.max(0, len - 4) let i = len - 2 while (i >= limit && (data[i] & 0xc0) === 0x80) i-- if (i < 0) return 1 const first = data[i] let needed if (first >= 0xc2 && first <= 0xdf) needed = 2 else if (first >= 0xe0 && first <= 0xef) needed = 3 else if (first >= 0xf0 && first <= 0xf4) needed = 4 else return 1 if (len - i !== needed) return 1 if (needed >= 3) { const second = data[i + 1] if (first === 0xe0 && second < 0xa0) return 1 if (first === 0xed && second > 0x9f) return 1 if (first === 0xf0 && second < 0x90) return 1 if (first === 0xf4 && second > 0x8f) return 1 } return 0 } { "name": "text-decoder", "version": "1.2.7", "description": "Streaming text decoder that preserves multibyte Unicode characters", "exports": { "./package": "./package.json", ".": "./index.js" }, "files": [ "index.js", "lib" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/text-decoder.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/text-decoder/issues" }, "homepage": "https://github.com/holepunchto/text-decoder#readme", "dependencies": { "b4a": "^1.6.4" }, "devDependencies": { "brittle": "^3.3.2", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" } } const { runtime, platform, arch, version } = typeof Bare !== 'undefined' ? { runtime: 'bare', platform: global.Bare.platform, arch: global.Bare.arch, version: global.Bare.version } : typeof process !== 'undefined' ? { runtime: 'node', platform: global.process.platform, arch: global.process.arch, version: global.process.version } : typeof Window !== 'undefined' ? { runtime: 'browser', platform: 'unknown', arch: 'unknown', version: 'unknown' } : { runtime: 'unknown', platform: 'unknown', arch: 'unknown', version: 'unknown' } exports.runtime = runtime exports.version = version exports.platform = platform exports.arch = arch exports.isBare = runtime === 'bare' exports.isBareKit = exports.isBare && typeof BareKit !== 'undefined' exports.isPear = typeof Pear !== 'undefined' exports.isNode = runtime === 'node' exports.isBrowser = runtime === 'browser' exports.isWindows = platform === 'win32' exports.isLinux = platform === 'linux' exports.isMac = platform === 'darwin' exports.isIOS = platform === 'ios' || platform === 'ios-simulator' exports.isAndroid = platform === 'android' exports.isElectron = typeof process !== 'undefined' && !!global.process.versions?.electron exports.isElectronRenderer = exports.isElectron && global.process.type === 'renderer' exports.isElectronWorker = exports.isElectron && global.process.type === 'worker' { "name": "which-runtime", "version": "1.4.0", "description": "Detect if you are in Bare or Node and which os etc", "main": "index.js", "files": [ "index.js" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte .", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/which-runtime.git" }, "author": "Holepunch Inc.", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/which-runtime/issues" }, "homepage": "https://github.com/holepunchto/which-runtime", "devDependencies": { "brittle": "^3.0.0", "lunte": "^1.4.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } { "name": "hyper-overlay", "version": "0.3.13", "description": "Content-addressed P2P file distribution over Protomux — FastCDC chunking, multi-source fetch, resumable transfers, zero blob duplication. Files live on disk; the overlay is a thin index and transfer protocol.", "type": "module", "main": "index.js", "imports": { "#fs": { "bare": "bare-fs", "default": "fs" }, "#path": { "bare": "bare-path", "default": "path" }, "#os": { "bare": "bare-os", "default": "os" }, "#zlib": { "bare": "bare-zlib", "default": "zlib" } }, "exports": { ".": "./index.js", "./overlay": "./lib/overlay.js", "./protocol": "./lib/protocol.js", "./messages": "./lib/messages.js", "./chunker": "./lib/chunker.js", "./chunk-scheduler": "./lib/chunk-scheduler.js", "./transfer": "./lib/transfer.js", "./file-index": "./lib/file-index.js", "./sync-engine": "./lib/sync-engine.js", "./tree": "./lib/tree.js", "./pointer": "./lib/pointer.js", "./ignore": "./lib/ignore.js", "./manifest": "./lib/manifest.js", "./package.json": "./package.json" }, "scripts": { "test": "brittle-bare test/*.test.js test/integration/*.test.js", "test:node": "brittle-node test/*.test.js" }, "engines": { "bare": ">=1.16.0" }, "license": "AGPL-3.0", "keywords": [ "p2p", "hypercore", "hyperbee", "protomux", "overlay", "content-addressed", "deduplication", "file-transfer", "fastcdc", "chunking", "multi-source", "resumable", "bare" ], "dependencies": { "b4a": "^1.0.0", "bare-fs": "^4.7.2", "bare-os": "^3.8.7", "bare-path": "^3.0.0", "bare-zlib": "^1.3.3", "compact-encoding": "^3.2.0", "corestore": "^7.0.0", "hyperbee": "^2.0.0", "hypercore-crypto": "^3.0.0", "protomux": "^3.0.0", "ready-resource": "^1.0.0", "sodium-universal": "^5.0.1", "streamx": "^2.0.0" }, "devDependencies": { "brittle": "^3.0.0", "hyperswarm": "^4.0.0", "@hyperswarm/testnet": "^3.1.4" } } { "name": "pgh-runtime", "version": "0.1.4", "description": "Per-app OTA updater for pgh-installed apps — polls a release source, materializes new trees into the pgh store", "type": "module", "main": "index.js", "exports": { ".": "./index.js" }, "imports": { "#node:events": { "bare": "bare-events", "default": "events" } }, "scripts": { "test": "brittle test/*.test.js" }, "license": "AGPL-3.0", "dependencies": { "bare-events": "^2.0.0", "hyper-overlay": "file:../hyper-overlay" }, "devDependencies": { "brittle": "^3.0.0", "hypercore-crypto": "^3.0.0" }, "overrides": { "bare-fs": "^4.7.2" } } /** * NetworkFetcher — Hyperswarm-backed { getTree, getContent, getLatestRelease } * * Phase 0.5 follow-on. Lives between pgh-runtime / installTree (which * expect a fetcher shape) and the wire (Hyperswarm + OverlayProtocol * tree-request / content-request messages, plus chunk flow for content). * * Server side: hyper-deploy's DeployServer (0.5b + enableTrees) attaches * OverlayProtocol to each incoming connection and has trees + * contentHashPaths pre-populated. The client just needs to connect on * the same topic and open a protomux channel. * * Usage: * const fetcher = new NetworkFetcher({ topic: '...hex...', timeout: 15000 }) * await fetcher.ready() * const tree = await fetcher.getTree(rootHash) * const content = await fetcher.getContent(contentHash) * await fetcher.close() * * Limitations (scope boundary — further refinement tracked separately): * - getLatestRelease currently reads from the LOCAL ReleaseRegistry. * Replication of the publisher's remote registry is a follow-on. * - Content transfer uses the existing chunk flow triggered by the * server's _onContentRequest handler — getContent awaits the next * transferComplete that lands locally. */ import fs from '#node:fs' import path from '#node:path' import { homedir, tmpdir as osTmpdir } from '#node:os' import b4a from 'b4a' import Hyperswarm from 'hyperswarm' import Protomux from 'protomux' import Corestore from 'corestore' import crypto from 'hypercore-crypto' import { FileIndex } from 'hyper-overlay/file-index' import { TransferManager } from 'hyper-overlay/transfer' import { OverlayProtocol } from 'hyper-overlay/protocol' import { computeTreeHash } from 'hyper-overlay/tree' import { ReleaseRegistry } from './release-registry.js' const DEFAULT_TIMEOUT = 30000 const DEFAULT_LOCAL_REGISTRY = path.join(homedir(), '.config', 'pgh', 'release-registry') export class NetworkFetcher { /** * @param {object} opts * @param {string|Buffer} opts.topic — 32-byte discovery key * @param {number} [opts.timeout] — per-request timeout (ms) * @param {string} [opts.storeDir] — temp corestore path * @param {Hyperswarm} [opts.swarm] — reuse an existing swarm * @param {string} [opts.localRegistryDir] — for getLatestRelease (local lookup) * @param {string} [opts.destDir] — where content chunks land; default tmp */ constructor (opts = {}) { if (!opts.topic) throw new Error('NetworkFetcher requires opts.topic') this.topic = typeof opts.topic === 'string' ? b4a.from(opts.topic, 'hex') : opts.topic this.timeout = opts.timeout || DEFAULT_TIMEOUT this.localRegistryDir = opts.localRegistryDir || DEFAULT_LOCAL_REGISTRY this.swarm = opts.swarm || null this._ownSwarm = !this.swarm this._storeDir = opts.storeDir || null this._destDir = opts.destDir || null this._store = null this._fileIndex = null this._transferManager = null this._protocol = null this._peers = [] // all peers discovered on the topic (in connection order) this._peerResolve = null this._pendingContent = new Map() // contentHash → { resolve, reject, timer, diskPath } this._ready = false // Per-peer timeouts for individual requests. Tree lookups are small // RPCs — if a peer doesn't respond in a few seconds it doesn't have // the tree. Content is an actual chunk stream, so it legitimately // takes longer; we keep that timeout at the full request budget. // The big speedup comes from `_markPeerGood` promoting responsive // peers to the front of the list after their first success. this._perPeerTreeTimeout = Math.min(opts.perPeerTreeTimeout || 5000, this.timeout) this._perPeerContentTimeout = opts.perPeerContentTimeout || this.timeout // Silent-peer watchdog: how long an in-flight content request can go // without ANY chunk arrival before we declare the peer silent and // fail the request. Companion to fail-fast-on-disconnect (which only // catches outright connection death). 30s is enough to ride out // brief mux contention; longer than that and the peer is stuck. this._idleTimeout = opts.idleTimeout || 30000 } // Back-compat: _peer was the first peer; expose the first peer for callers // that reference it (tests, diagnostics). Real tree/content requests walk // _peers so they survive stale DHT advertisements. get _peer () { return this._peers[0] || null } /** * Promote a peer to the front of our peer list after a successful * request. This is the key to fast multi-peer handling: once we know * a peer responds with real data, subsequent calls try it FIRST * instead of burning per-peer timeouts on dead peers every call. */ _markPeerGood (peer) { const idx = this._peers.indexOf(peer) if (idx > 0) { this._peers.splice(idx, 1) this._peers.unshift(peer) } } async ready () { if (this._ready) return // Memoize the in-flight promise. Without this, concurrent callers // (e.g. server.js's fire-and-forget `fetcher.ready().then(...)` AND // pgh-runtime's `installTree` → `getTree` → `await this.ready()`) // each run `new Corestore(this._storeDir)` on the same path. The // device-file FDLock admits only one; the loser throws "File // descriptor could not be locked" and leaves `_store` in a closed // state, so subsequent reads fail with "Corestore is closed". if (this._readyPromise) return this._readyPromise this._readyPromise = this._doReady() try { await this._readyPromise } catch (err) { this._readyPromise = null throw err } } async _doReady () { if (!this._storeDir) { this._storeDir = fs.mkdtempSync(path.join(osTmpdir(), 'pgh-fetcher-')) } if (!this._destDir) { this._destDir = fs.mkdtempSync(path.join(osTmpdir(), 'pgh-fetcher-dest-')) } this._store = new Corestore(this._storeDir) await this._store.ready() this._fileIndex = new FileIndex(this._store) await this._fileIndex.ready() this._transferManager = new TransferManager(this._fileIndex) const stubSyncEngine = { _fileIndex: this._fileIndex, feedKey: '0'.repeat(64), feed: { length: 0, async get () { return null } }, async markSynced () {}, async logPut () {} } this._protocol = new OverlayProtocol( stubSyncEngine, this._transferManager, { key: this.topic, autoSync: false, // Fires when the client-side chunk flow finalizes a file. // We use it to resolve getContent promises keyed by synthetic path. onSynced: (info) => this._onSynced(info), // Fires for EVERY chunk arrival. We reset the per-pending idle // timer so a peer that connects then goes silent mid-stream is // detected within `_idleTimeout` ms (not the 5-min global cap). onChunkProgress: (info) => this._onChunkProgress(info) } ) if (!this.swarm) this.swarm = new Hyperswarm() this.swarm.on('connection', (conn) => this._onConnection(conn)) this.swarm.join(this.topic, { server: false, client: true }) await this.swarm.flush() // Wait for at least one peer before resolving if (this._peers.length === 0) { await Promise.race([ new Promise((resolve) => { this._peerResolve = resolve }), new Promise((_, reject) => setTimeout( () => reject(new Error('NetworkFetcher: no peer within ' + this.timeout + 'ms')), this.timeout )) ]) } this._ready = true } _onConnection (conn) { const mux = Protomux.from(conn) const peer = this._protocol.attach(mux) if (!peer) return // Track ALL peers on the topic. The DHT may return multiple peers // (stale advertisements, other seeds, etc.) and only SOME have the // tree/content we're looking for. requestTree + requestContent // iterate this list until a peer returns non-empty data. this._peers.push(peer) // Connection-death handling. Without this, a peer that disconnects // mid-chunk-stream leaves _pendingContent entries waiting on the // 5-min global timeout — the user sees this as a "stall" (chunks // streaming, then nothing). 2026-05-13 observed: // tabertron logs `deploy-server error (non-fatal) [ECONNRESET]` // stortron's getContent just sits there waiting for transferComplete // Listen for the underlying conn close + fail any pending requests // that were tied to this peer. Caller retries fast on next peer. const handleClose = () => { this._peers = this._peers.filter(p => p !== peer) for (const pending of this._pendingContent.values()) { if (pending.peer === peer) { pending.finish(new Error('peer disconnected mid-stream (' + pending.contentHash.slice(0, 12) + ')')) } } } // Hyperswarm streams emit 'close' on disconnect; protomux mux also // emits 'close' when the underlying stream dies. Attach to both for // belt-and-suspenders. conn.on('close', handleClose) conn.on('error', (err) => { // Errors here are typically wire-level (ECONNRESET, ETIMEDOUT). // We don't fail-fast on error alone — wait for the matching // 'close' event so we don't double-fire. The on-error listener // exists just to keep Node from crashing. }) if (this._peerResolve) { this._peerResolve(peer); this._peerResolve = null } } async close () { for (const pending of this._pendingContent.values()) { clearTimeout(pending.timer) pending.reject(new Error('NetworkFetcher closing')) } this._pendingContent.clear() if (this._protocol) { try { this._protocol.destroy() } catch {} this._protocol = null } if (this._fileIndex) { try { await this._fileIndex.close() } catch {} } if (this._store) { try { await this._store.close() } catch {} } if (this._ownSwarm && this.swarm) { try { await this.swarm.destroy() } catch {} this.swarm = null } this._ready = false } /** * Fetch a tree by its hash, walking all known peers until one returns * a non-empty response. * * hyper-overlay's `_onTreeRequest` (server side) replies with * `entries: []` on lookup miss. Combined with DHT promiscuity — the * same topic may have multiple advertised peers, some stale/unrelated, * some with data — a single-peer fetch is unreliable: whichever peer * happens to connect first might not have the tree. * * Strategy: try peers in connection order. First peer to return * non-empty entries wins. If all peers return empty, treat as * not-found (throw) — the caller knows the tree SHOULD have content * (it's in a lockfile) so empty is a failure signal, not a genuinely * empty directory. * * @param {string} hash * @returns {Promise<{ entries, size }>} */ async getTree (hash) { if (!this._ready) await this.ready() if (this._peers.length === 0) throw new Error('NetworkFetcher: no peer available') // Walk peers, accept the first VERIFIED response. hyper-overlay's // protocol returns `entries: []` when a peer doesn't have a tree — // that's a valid negative response ("try elsewhere"), not "this // tree is empty." Content-address verification distinguishes: // computeTreeHash(entries) must equal the requested hash. let lastErr = null const tried = new Set() for (let round = 0; round < 2; round++) { for (const peer of this._peers) { if (tried.has(peer)) continue tried.add(peer) try { const entries = await this._protocol.requestTree(peer, hash, { timeout: this._perPeerTreeTimeout }) const actual = computeTreeHash(entries || []) if (actual === hash) { this._markPeerGood(peer) const size = entries.reduce((a, e) => a + (e.size || 0), 0) return { entries, size } } // Hash mismatch → this peer doesn't have it. Try next. } catch (err) { lastErr = err } } // Second round: wait for additional peers to arrive, then retry // any new ones (plus the old ones if they haven't been tried yet). if (round === 0) { await new Promise(r => setTimeout(r, 2000)) tried.clear() } } throw new Error('NetworkFetcher: tree ' + hash.slice(0, 12) + '… not found on any of ' + this._peers.length + ' peer(s)' + (lastErr ? ' (last err: ' + lastErr.message + ')' : '')) } /** * Fetch a file's content by its content hash. * * Uses the synthetic-path convention in hyper-overlay/v2 content-request: * server responds with chunkHashes whose `path` is * `"content:" + contentHash`. Client pre-registers its target disk * path under that key in `_filePaths` so the chunk flow writes to * our destination; then resolves when transferComplete arrives with * the matching synthetic path. * * @param {string} contentHash — hex blake2b hash of the file content * @returns {Promise} */ async getContent (contentHash) { if (!this._ready) await this.ready() if (this._peers.length === 0) throw new Error('NetworkFetcher: no peer available') // Multi-source: fan the request out to ALL peers at once via the // ChunkScheduler (hyper-overlay `fetchContent`). It assigns distinct // chunks per peer, fails over on disconnect, and hash-verifies every // chunk — pulling one blob from many seeders in parallel (the torrent // path) instead of the legacy one-peer-at-a-time failover in // `_getContentFromPeer`. Proven by hyper-overlay's // overlay-v2-fetch.test.js ("chunks fetched from MULTIPLE peers"). // Retry once to pick up peers that arrive late on the topic. const destPath = path.join(this._destDir, 'blob-' + contentHash + '-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8)) let lastErr = null for (let round = 0; round < 2; round++) { const peers = this._peers.slice() if (peers.length > 0) { try { await this._protocol.fetchContent(contentHash, peers, { destPath, timeout: this._perPeerContentTimeout }) // The chunk flow verifies each chunk; verify the full // concatenation against the advertised content hash here so no // caller of getContent ever sees un-verified bytes. const data = fs.readFileSync(destPath) const actual = crypto.data(data).toString('hex') if (actual !== contentHash) { throw Object.assign( new Error('content-hash mismatch: expected ' + contentHash.slice(0, 12) + '…, got ' + actual.slice(0, 12) + '…'), { code: 'EHASHMISMATCH', expected: contentHash, actual } ) } try { fs.unlinkSync(destPath) } catch {} return data } catch (err) { lastErr = err try { fs.unlinkSync(destPath) } catch {} } } // Wait briefly for additional peers to arrive on the topic, then retry. if (round === 0) await new Promise(r => setTimeout(r, 2000)) } throw new Error('NetworkFetcher: content ' + contentHash.slice(0, 12) + '… not found on any of ' + this._peers.length + ' peer(s)' + (lastErr ? ' (last err: ' + lastErr.message + ')' : '')) } async _getContentFromPeer (peer, contentHash) { const syntheticPath = 'content:' + contentHash // Per-peer destPath so concurrent attempts don't clobber each other. const destPath = path.join(this._destDir, 'blob-' + contentHash + '-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8)) // Pre-register destination so _onChunkHashes + chunk-data handlers // write to the right place when chunks arrive. this._protocol._filePaths.set(syntheticPath, destPath) return new Promise((resolve, reject) => { let settled = false const finish = (err, result) => { if (settled) return settled = true clearTimeout(timer) clearTimeout(pending.idleTimer) this._pendingContent.delete(contentHash) if (err) reject(err); else resolve(result) } const timer = setTimeout(() => { finish(new Error('content request timed out on peer: ' + contentHash.slice(0, 12))) }, this._perPeerContentTimeout) // Silent-peer watchdog: reset on each chunk arrival via // _onChunkProgress. If no chunk arrives within _idleTimeout the // request fails fast and getContent moves on to the next peer. const idleFire = () => { finish(new Error('peer went silent mid-stream after ' + (pending.bytesReceived || 0) + ' byte(s): ' + contentHash.slice(0, 12))) } const pending = { syntheticPath, destPath, finish, timer, peer, contentHash, bytesReceived: 0, idleTimer: setTimeout(idleFire, this._idleTimeout), idleFire } // Tag the pending entry with the peer it was sent to. _onConnection's // close handler uses this to fail-fast any pending requests when the // connection dies (the dominant LAN-stall pattern observed // 2026-05-13: tabertron pushed 7 chunks, ECONNRESET, stortron sat // waiting on the 5-min global timeout). this._pendingContent.set(contentHash, pending) this._protocol.requestContent(peer, contentHash, null) }) } /** * Reset the idle timer for any pending content request matching the * synthetic path of the arriving chunk. Companion to fail-fast on * disconnect: this fires when the peer is alive but silent. */ _onChunkProgress (info) { if (!info || !info.path || !info.path.startsWith('content:')) return const contentHash = info.path.slice('content:'.length) const pending = this._pendingContent.get(contentHash) if (!pending) return pending.bytesReceived += (info.bytes || 0) clearTimeout(pending.idleTimer) pending.idleTimer = setTimeout(pending.idleFire, this._idleTimeout) } /** * Called by OverlayProtocol when a file completes on the receiver * side (direction === 'pull'). Resolves any pending getContent whose * synthetic path matches — AFTER content-address verification. * * hyper-overlay's chunk flow doesn't verify the final concatenation * against the advertised hash (that's the caller's responsibility in * this protocol). We do it here so no caller of getContent ever sees * un-verified bytes. */ _onSynced (info) { if (info.direction !== 'pull') return if (!info.path || !info.path.startsWith('content:')) return const contentHash = info.path.slice('content:'.length) const pending = this._pendingContent.get(contentHash) if (!pending) return try { const data = fs.readFileSync(pending.destPath) const actual = crypto.data(data).toString('hex') if (actual !== contentHash) { pending.finish(Object.assign( new Error('content-hash mismatch: expected ' + contentHash.slice(0, 12) + '…, got ' + actual.slice(0, 12) + '…'), { code: 'EHASHMISMATCH', expected: contentHash, actual } )) return } pending.finish(null, data) } catch (err) { pending.finish(err) } } /** * Look up the latest release for an app name. * * MVP: reads from the LOCAL ReleaseRegistry. Remote replication of * the publisher's registry is follow-on work — until then, callers * that want network-side release lookup need to ship the registry * core key separately (e.g. via peer config). * * @param {string} name * @returns {Promise} */ async getLatestRelease (name) { if (!fs.existsSync(this.localRegistryDir)) return null const store = new Corestore(this.localRegistryDir) const reg = new ReleaseRegistry(store) try { await reg.ready() return await reg.latest(name) } finally { try { await reg.close() } catch {} try { await store.close() } catch {} } } } /** * ReleaseRegistry — Autobase-backed index of published releases. * * Multi-writer. Each publisher runs a registry; linked devices (or * explicitly added writers) all append to the same logical registry. * Clients replicate the registry by its bootstrap key over Hyperswarm * to resolve app names → tree hashes + deploy locators. * * Autobase shape (follows hyperident's IdentityRegistry pattern): * - Base: autobase keyed by the first writer's hypercore * - Writers: append op records (JSON-encoded) * - Apply: single apply function translates ops → Hyperbee view * - View: Hyperbee with the same keyspace as the earlier single-writer * implementation so downstream readers (getLatest, list, etc.) don't * change * * Ops: * { type: 'add-release', entry } — append a release record * { type: 'remove-release', name, version } * { type: 'add-writer', publicKey } — grant another device write * * Entry schema (unchanged): * name, version, treeHash, serverKey, upgrade, deps, publishedAt, * publisherDevicePubkey, sig?, acceptedConflicts? * * Hyperbee view keys (unchanged): * release:: → entry * latest: → { version, publishedAt } * by-tree: → { name, version } */ import Autobase from 'autobase' import Hyperbee from 'hyperbee' import crypto from 'hypercore-crypto' import b4a from 'b4a' import sodium from 'sodium-native' export const OP_ADD_RELEASE = 'add-release' export const OP_REMOVE_RELEASE = 'remove-release' export const OP_ADD_WRITER = 'add-writer' export class ReleaseRegistry { /** * @param {Corestore} corestore * @param {object} [opts] * @param {string} [opts.namespace='release-registry'] — corestore sub-namespace * @param {Buffer|string} [opts.bootstrap] — hex or Buffer autobase key. If * omitted, creates a NEW registry * and this node becomes the * first writer. */ constructor (corestore, opts = {}) { this._store = corestore.namespace(opts.namespace || 'release-registry') this._bootstrap = opts.bootstrap ? (Buffer.isBuffer(opts.bootstrap) ? opts.bootstrap : b4a.from(opts.bootstrap, 'hex')) : null this._base = null this._view = null this._ready = false } async ready () { if (this._ready) return const apply = async (nodes, view, base) => { for (const node of nodes) { let op try { op = JSON.parse(node.value.toString()) } catch { continue } if (op.type === OP_ADD_RELEASE) { const e = op.entry if (!e || !e.name || !e.version || !e.treeHash) continue await view.put('release:' + e.name + ':' + e.version, e) // Update latest pointer if this entry is newer const latestKey = 'latest:' + e.name const existing = await view.get(latestKey) if (!existing || compareTimestamps(e.publishedAt, existing.value.publishedAt) > 0) { await view.put(latestKey, { version: e.version, publishedAt: e.publishedAt }) } await view.put('by-tree:' + e.treeHash, { name: e.name, version: e.version }) } if (op.type === OP_REMOVE_RELEASE) { const key = 'release:' + op.name + ':' + op.version await view.del(key) const latestKey = 'latest:' + op.name const latest = await view.get(latestKey) if (latest && latest.value.version === op.version) { // Roll back to the next most recent release for this name let fallback = null const prefix = 'release:' + op.name + ':' for await (const e of view.createReadStream({ gt: prefix, lt: prefix + '\xff' })) { if (!fallback || compareTimestamps(e.value.publishedAt, fallback.publishedAt) > 0) { fallback = e.value } } if (fallback) { await view.put(latestKey, { version: fallback.version, publishedAt: fallback.publishedAt }) } else { await view.del(latestKey) } } } if (op.type === OP_ADD_WRITER && op.publicKey) { try { await base.addWriter(b4a.from(op.publicKey, 'hex')) } catch { // autobase throws if already a writer — safe to ignore } } } } this._base = new Autobase(this._store, this._bootstrap, { apply, open: (store) => new Hyperbee(store.get({ name: 'releases', valueEncoding: 'json' }), { keyEncoding: 'utf-8', valueEncoding: 'json' }), valueEncoding: 'binary', // Canonical keet multi-writer opts. Single-writer (the common // publisher case) ignores these — they only matter once a publisher // adds a mirror/linked-device writer, at which point optimistic // append + periodic ack keeps the writers converging (per the keet // pattern in multi-writer-autobase memory). Harmless before then. optimistic: true, ackInterval: 1000, ackThreshold: 4 }) await this._base.ready() this._view = this._base.view this._ready = true } async close () { if (this._base) await this._base.close() this._ready = false } // ── Keys / identity ───────────────────────────────────────── get key () { return this._base && this._base.key } get keyHex () { const k = this.key return k ? b4a.toString(k, 'hex') : null } get localWriterKey () { return this._base && this._base.local && this._base.local.key } get isWriter () { return !!(this._base && this._base.writable) } // ── Ops (writer-only) ──────────────────────────────────────── async add (entry) { if (!this._ready) await this.ready() if (!this.isWriter) throw new Error('not a writer on this registry') if (!entry || !entry.name || !entry.version || !entry.treeHash) { throw new Error('release entry requires name, version, treeHash') } const normalized = { name: entry.name, version: entry.version, // runtime drives the materializer (node vs godot vs bare→node alias) // and the launcher shebang at install time. Drop-on-store would // make installers fall back to 'node' and produce wrong launchers // (e.g. `exec node` for a bare app → require.addon throws). runtime: entry.runtime || 'node', treeHash: entry.treeHash, serverKey: entry.serverKey || null, upgrade: entry.upgrade || null, deps: entry.deps || [], publishedAt: entry.publishedAt || new Date().toISOString(), publisherDevicePubkey: entry.publisherDevicePubkey || null, // MUST be carried: `sig` covers every field except itself, so a field // dropped here is a field the stored entry no longer hashes to and the // signature stops verifying. Anything added to the signed entry has to // be added to this list too (org #144). publisherChain: entry.publisherChain || null, sig: entry.sig || null, acceptedConflicts: entry.acceptedConflicts || null } await this._base.append(JSON.stringify({ type: OP_ADD_RELEASE, entry: normalized })) await this._base.update() return normalized } async remove (name, version) { if (!this._ready) await this.ready() if (!this.isWriter) throw new Error('not a writer on this registry') await this._base.append(JSON.stringify({ type: OP_REMOVE_RELEASE, name, version })) await this._base.update() } async addWriter (publicKey) { if (!this._ready) await this.ready() if (!this.isWriter) throw new Error('not a writer on this registry') const hex = Buffer.isBuffer(publicKey) ? publicKey.toString('hex') : publicKey await this._base.append(JSON.stringify({ type: OP_ADD_WRITER, publicKey: hex })) await this._base.update() } // ── Queries (readable by anyone with the registry key) ─────── async get (name, version) { if (!this._ready) await this.ready() const entry = await this._view.get('release:' + name + ':' + version) if (!entry) return null assertEntryIntegrity(entry.value) return entry.value } async latest (name) { if (!this._ready) await this.ready() const latest = await this._view.get('latest:' + name) if (!latest) return null return this.get(name, latest.value.version) } async lookupByTree (treeHash) { if (!this._ready) await this.ready() const ref = await this._view.get('by-tree:' + treeHash) if (!ref) return null return this.get(ref.value.name, ref.value.version) } async list (nameFilter) { if (!this._ready) await this.ready() const prefix = nameFilter ? 'release:' + nameFilter + ':' : 'release:' const out = [] for await (const entry of this._view.createReadStream({ gt: prefix, lt: prefix + '\xff' })) { out.push(entry.value) } return out } // ── Replication handle ─────────────────────────────────────── replicate (stream) { return this._base.replicate(stream) } /** * Pull updates from the network (call after the underlying cores * have replicated new blocks). */ async update () { if (!this._ready) await this.ready() return this._base.update() } } // ── Canonical signing (unchanged) ────────────────────────────── export function canonicalBytes (entry) { const { sig, ...rest } = entry // eslint-disable-line no-unused-vars const keys = Object.keys(rest).sort() const ordered = {} for (const k of keys) ordered[k] = rest[k] return Buffer.from(JSON.stringify(ordered)) } export function signEntry (entry, secretKey) { const sig = Buffer.alloc(64) sodium.crypto_sign_detached(sig, canonicalBytes(entry), secretKey) return { ...entry, sig: sig.toString('hex') } } /** * Verify a release entry's signature against the device key it names. * * Transitional by design (org #144): an entry with NO `sig` passes. Every * release published before signing was wired carries `sig: null`, and * refusing those would make every installed app un-updatable and every * existing release uninstallable. What this closes is the case that actually * matters now — an entry that carries a signature which does not verify. * * Enforcement (refuse unsigned) is a later flip, once publishers have * re-published. Until then this is a tamper check, not an authenticity * guarantee: an attacker who can write to the registry can still simply omit * the signature. * * @returns {{ ok: boolean, signed: boolean, reason?: string }} */ export function verifyReleaseEntry (entry) { if (!entry) return { ok: false, signed: false, reason: 'no entry' } if (!entry.sig) return { ok: true, signed: false } const pubkey = entry.publisherDevicePubkey if (!pubkey) { return { ok: false, signed: true, reason: 'entry is signed but names no publisherDevicePubkey' } } let ok = false try { ok = verifyEntry(entry, pubkey) } catch (err) { return { ok: false, signed: true, reason: 'signature check threw: ' + err.message } } if (!ok) { return { ok: false, signed: true, reason: 'signature does not verify against publisherDevicePubkey ' + String(pubkey).slice(0, 12) + '…' } } return { ok: true, signed: true } } /** * Throwing form, used on every read path so no call site can forget it. A * signed entry that fails verification is not a release, it is a tamper — and * a loud failure degrades to "not found" in callers that catch, which is the * safe direction. */ export function assertEntryIntegrity (entry) { const v = verifyReleaseEntry(entry) if (!v.ok) { throw Object.assign( new Error( 'release ' + (entry && entry.name) + '@' + (entry && entry.version) + ' failed verification: ' + v.reason ), { code: 'EBADRELEASESIG', entry } ) } return entry } export function verifyEntry (entry, publisherPublicKey) { if (!entry.sig) return false const sig = b4a.from(entry.sig, 'hex') const pubkey = Buffer.isBuffer(publisherPublicKey) ? publisherPublicKey : b4a.from(publisherPublicKey, 'hex') return sodium.crypto_sign_verify_detached(sig, canonicalBytes(entry), pubkey) } function compareTimestamps (a, b) { if (a === b) return 0 return a > b ? 1 : -1 } /** * resolveRelease — "what is the latest release of ?", with or without a * pgh-sidecar on this machine. * * Extracted verbatim in behaviour from commands/app.js, where it was the install * path's private helper. It is here because it is the missing half of embedded * OTA: NetworkFetcher's own header says * * getLatestRelease currently reads from the LOCAL ReleaseRegistry. * Replication of the publisher's remote registry is a follow-on. * * and that follow-on turned out to already exist — as this function, reachable * only from `pgh app install`. A standalone app (no sidecar, no CLI) could fetch * trees and content over Hyperswarm but had no way to learn WHICH tree to fetch. * * TWO ORDERED PATHS, and the order is not a preference: * * 1. the sidecar's live replica, when ~/.pgh/svc.sock exists; * 2. otherwise replicate the publisher's registry directly by its bootstrap * key, over Hyperswarm. * * The sidecar goes first because BOTH paths open the same * ~/.config/pgh/registries/ Corestore, and that store takes an EXCLUSIVE * FD-LOCK. On a machine where the sidecar is also re-opening it (its in-process * autoupdate does), a direct open loses the race and dies with "File descriptor * could not be locked". runtime-factory's createRuntime routes getLatestRelease * through the sidecar for exactly this reason. Path 2 is for machines that have * no sidecar at all — which is every standalone install, and every Windows one. * * THE CALLER OWNS THE CLEANUP. `cleanup()` closes registry, swarm AND store, in * that order. ReleaseRegistry.close() closes only the autobase, so dropping the * handle without calling this orphans the store's fd-lock for the life of the * process and every later resolve in it fails. */ import process from '#node:process' // NOT a global under bare — process.env below needs it import fs from '#node:fs' import path from '#node:path' import { homedir } from '#node:os' import b4a from 'b4a' import { Client } from 'hyper-svc' import { ReleaseRegistry } from './release-registry.js' const SIDECAR_SOCK = process.env.PGH_SIDECAR_SOCK || path.join(homedir(), '.pgh', 'svc.sock') /** Where a directly-replicated registry's corestore lives. */ export function registryStoreDir (registryKeyHex) { return path.join(homedir(), '.config', 'pgh', 'registries', registryKeyHex.slice(0, 16)) } /** * @param {object} opts * @param {string} opts.registryKeyHex 64-char registry (autobase bootstrap) key * @param {string} opts.name app name * @param {string} [opts.version] exact version; omitted = latest * @param {boolean} [opts.preferSidecar=true] try the sidecar's replica first * @param {number} [opts.settleMs=500] post-flush settle before reading the view * @param {string} [opts.storeDir] where to keep the registry replica. Defaults to a path under * the home directory, which does not exist on Android — an embedder must pass its own. * @returns {Promise<{ entry: object|null, via: string, cleanup: function }>} */ export async function resolveRelease (opts = {}) { const { registryKeyHex, name, version } = opts if (!registryKeyHex || registryKeyHex.length !== 64) { throw new Error('resolveRelease requires a 64-char registryKeyHex') } if (!name) throw new Error('resolveRelease requires a name') const preferSidecar = opts.preferSidecar !== false const settleMs = opts.settleMs != null ? opts.settleMs : 500 const noop = async () => {} let entry = null if (preferSidecar && fs.existsSync(SIDECAR_SOCK)) { let c = null try { c = await Client.connectUds(SIDECAR_SOCK) const res = await c.call('resolve-release', { registryKey: registryKeyHex, name, version: version || undefined }) if (res && res.found && res.entry) entry = res.entry } catch { // Sidecar present but unhelpful (down mid-restart, older build without the // RPC). Fall through and replicate directly — worst case that fails on the // fd-lock, which is a clearer error than a silent miss. } finally { try { if (c) await c.close() } catch {} } if (entry) return { entry, via: 'sidecar', cleanup: noop } } const Corestore = (await import('corestore')).default const Hyperswarm = (await import('hyperswarm')).default let store = null let registry = null let swarm = null const cleanup = async () => { try { if (registry) await registry.close() } catch {} try { if (swarm) await swarm.destroy() } catch {} try { if (store) await store.close() } catch {} } // ⛔ CALLER-SUPPLIED OR THE DEFAULT, because the default assumes a HOME DIRECTORY and a phone has // none. On Android this resolved to a path that cannot be stat'd, so `resolveRelease` threw // ENOENT, `swarmFetcher` caught it, and OTA reported "no swarm fetcher — updates disabled this // boot" — a handset that could never update, with the reason visible nowhere until the app was // taught to report its own last OTA line. // // ⚠ Same class as a binary assumed on PATH and a vault assumed under ~: a library that picks a // path from the environment works everywhere the environment has one. An embedder knows where its // state goes; ask it. const dir = opts.storeDir || registryStoreDir(registryKeyHex) fs.mkdirSync(dir, { recursive: true }) store = new Corestore(dir) try { registry = new ReleaseRegistry(store, { bootstrap: b4a.from(registryKeyHex, 'hex') }) await registry.ready() swarm = new Hyperswarm() swarm.on('connection', (conn) => store.replicate(conn)) // client-only: we are reading someone else's registry, not serving ours. swarm.join(registry._base.discoveryKey, { server: false, client: true }) await swarm.flush() // The view is built by autobase's apply as blocks arrive; flush returns when // peers are connected, not when the log has caught up. await new Promise(r => setTimeout(r, settleMs)) await registry.update() entry = version ? await registry.get(name, version) : await registry.latest(name) } catch (err) { await cleanup() throw err } return { entry, via: 'replica', cleanup } } /** * A `getLatestRelease(name)` for pgh-runtime's fetcher shape, backed by the above. * * pgh-runtime polls, so this opens and CLOSES per call rather than holding the * store's fd-lock for the life of the app: an app that kept it would block the * sidecar, `pgh app install`, and its own next resolve. Polling is hourly by * default, so the reconnect cost is irrelevant beside that. */ /** * WATCH a registry for releases of one app, instead of asking it repeatedly. * * ⛔ WHY THIS EXISTS. `resolveRelease` opens a Corestore and a Hyperswarm, reads, and tears both * down — so nothing survives to emit anything, and every caller is forced to poll. Worse, a one-shot * read has to GUESS how long replication takes: the code above waits `settleMs` because, in its own * words, "flush returns when peers are connected, not when the log has caught up". That guess was * 500ms, which is correct for a warm replica and far too short for a cold one — measured on a * handset as `resolveRelease` returning null and OTA reporting "no published release with a * serverKey", which reads like a publishing failure and is not. * * ★ A held replica has no settle to guess. The view is built by autobase's apply as blocks arrive, * and autobase emits `update` when it does — so you are TOLD when the data lands, however long it * takes. That removes the entire class of "you did not wait long enough", rather than retuning it. * * Event-driven plus reconciliation, the same shape hyper-social #68 §2 landed for delivery: the * event sets the latency floor, and the initial read after flush is the reconciliation that covers * a replica which was already caught up before anyone subscribed. * * @returns {{ close: function, latest: function }} `latest()` is the last entry seen, or null. */ export async function watchLatestRelease (opts = {}) { const { registryKeyHex, name, onRelease = () => {} } = opts if (!registryKeyHex || registryKeyHex.length !== 64) { throw new Error('watchLatestRelease requires a 64-char registryKeyHex') } if (!name) throw new Error('watchLatestRelease requires a name') const Corestore = (await import('corestore')).default const Hyperswarm = (await import('hyperswarm')).default const dir = opts.storeDir || registryStoreDir(registryKeyHex) fs.mkdirSync(dir, { recursive: true }) const store = new Corestore(dir) const registry = new ReleaseRegistry(store, { bootstrap: b4a.from(registryKeyHex, 'hex') }) await registry.ready() const swarm = new Hyperswarm() swarm.on('connection', (conn) => store.replicate(conn)) // client-only: we are reading someone else's registry, not serving ours. swarm.join(registry._base.discoveryKey, { server: false, client: true }) let last = null let closed = false // ⚠ Reports only CHANGES. A view can update many times while one release replicates, and a caller // that rebuilt a fetcher on every tick would thrash for no reason. const reread = async () => { if (closed) return try { await registry.update() const entry = await registry.latest(name) if (!entry) return if (last && last.treeHash === entry.treeHash) return last = entry await onRelease(entry) } catch { /* a registry that cannot be read right now is not an error; the next update retries */ } } registry._base.on('update', () => { reread().catch(() => {}) }) // Reconciliation: a replica already caught up before we subscribed emits nothing, so read once. // NOT awaited on the swarm — `flush()` can take as long as a DHT lookup, and a caller must not // block boot on it. The `update` event covers whatever arrives afterwards. swarm.flush().then(reread).catch(() => {}) await reread() return { latest: () => last, close: async () => { closed = true try { registry._base.removeAllListeners('update') } catch {} // ⛔ CLOSE WHAT WE OPENED, all of it. A swarm left running is a DHT node and a set of sockets // held awake by something the user switched off — the same leak shape that reached ~205k // sockets on stortron because the thing that created a handle was not the thing that owned it. try { await swarm.destroy() } catch {} try { await registry.close() } catch {} try { await store.close() } catch {} } } } export function makeGetLatestRelease ({ registryKeyHex, preferSidecar, settleMs, storeDir } = {}) { return async function getLatestRelease (name) { const { entry, cleanup } = await resolveRelease({ registryKeyHex, name, preferSidecar, settleMs, storeDir }) try { return entry } finally { await cleanup() } } } const { Pull, Push, HEADERBYTES, KEYBYTES, ABYTES } = require('sodium-secretstream') const sodium = require('sodium-universal') const crypto = require('hypercore-crypto') const { Duplex, Writable, getStreamError } = require('streamx') const b4a = require('b4a') const Timeout = require('timeout-refresh') const unslab = require('unslab') const Bridge = require('./lib/bridge') const Handshake = require('./lib/handshake') const IDHEADERBYTES = HEADERBYTES + 32 const [NS_INITIATOR, NS_RESPONDER, NS_SEND] = crypto.namespace('hyperswarm/secret-stream', 3) const MAX_ATOMIC_WRITE = 256 * 256 * 256 - 1 module.exports = class NoiseSecretStream extends Duplex { constructor(isInitiator, rawStream, opts = {}) { super({ mapWritable: toBuffer }) if (typeof isInitiator !== 'boolean') { throw new Error('isInitiator should be a boolean') } this.noiseStream = this this.isInitiator = isInitiator this.rawStream = null this.publicKey = opts.publicKey || null this.remotePublicKey = opts.remotePublicKey || null this.handshakeHash = null this.connected = false this.keepAlive = opts.keepAlive || 0 this.timeout = 0 this.enableSend = opts.enableSend !== false // pointer for upstream to set data here if they want this.userData = null let openedDone = null this.opened = new Promise((resolve) => { openedDone = resolve }) this.rawBytesWritten = 0 this.rawBytesRead = 0 // metadata used by 'hyperdht' this.relay = null this.puncher = null // unwrapped raw stream this._rawStream = null // handshake state this._handshake = null this._handshakePattern = opts.pattern || null this._handshakeDone = null // message parsing state this._state = 0 this._len = 0 this._tmp = 1 this._message = null this._openedDone = openedDone this._startDone = null this._drainDone = null this._outgoingPlain = null this._outgoingWrapped = null this._utp = null this._setup = true this._ended = 2 this._encrypt = null this._decrypt = null this._timeoutTimer = null this._keepAliveTimer = null this._sendState = null if (opts.autoStart !== false) this.start(rawStream, opts) // wiggle it to trigger open immediately (TODO add streamx option for this) this.resume() this.pause() } static keyPair(seed) { return Handshake.keyPair(seed) } static id(handshakeHash, isInitiator, id) { return streamId(handshakeHash, isInitiator, id) } setTimeout(ms) { if (!ms) ms = 0 this._clearTimeout() this.timeout = ms if (!ms || this.rawStream === null) return this._timeoutTimer = Timeout.once(ms, destroyTimeout, this) this._timeoutTimer.unref() } setKeepAlive(ms) { if (!ms) ms = 0 this._clearKeepAlive() this.keepAlive = ms if (!ms || this.rawStream === null) return this._keepAliveTimer = Timeout.on(ms, sendKeepAlive, this) this._keepAliveTimer.unref() } sendKeepAlive() { const empty = this.alloc(0) this.write(empty) } start(rawStream, opts = {}) { if (rawStream) { this.rawStream = rawStream this._rawStream = rawStream if (typeof this.rawStream.setContentSize === 'function') { this._utp = rawStream } } else { this.rawStream = new Bridge(this) this._rawStream = this.rawStream.reverse } this.rawStream.on('error', this._onrawerror.bind(this)) this.rawStream.on('close', this._onrawclose.bind(this)) this._startHandshake(opts.handshake, opts.keyPair || null) this._continueOpen(null) if (this.destroying) return if (opts.data) this._onrawdata(opts.data) if (opts.ended) this._onrawend() if (this.keepAlive > 0 && this._keepAliveTimer === null) { this.setKeepAlive(this.keepAlive) } if (this.timeout > 0 && this._timeoutTimer === null) { this.setTimeout(this.timeout) } } async flush() { if ((await this.opened) === false) return false if ((await Writable.drained(this)) === false) return false if (this.destroying) return false if (this.rawStream !== null && this.rawStream.flush) { return await this.rawStream.flush() } return true } _continueOpen(err) { if (err) this.destroy(err) if (this._startDone === null) return const done = this._startDone this._startDone = null this._open(done) } _onkeypairpromise(p) { const self = this const cont = this._continueOpen.bind(this) p.then(onkeypair, cont) function onkeypair(kp) { self._onkeypair(kp) cont(null) } } _onkeypair(keyPair) { const pattern = this._handshakePattern || 'XX' const remotePublicKey = this.remotePublicKey this._handshake = new Handshake(this.isInitiator, keyPair, remotePublicKey, pattern) this.publicKey = this._handshake.keyPair.publicKey } _startHandshake(handshake, keyPair) { if (handshake) { const { tx, rx, hash, publicKey, remotePublicKey } = handshake this._setupSecretStream(tx, rx, hash, publicKey, remotePublicKey) return } if (!keyPair) keyPair = Handshake.keyPair() if (typeof keyPair.then === 'function') { this._onkeypairpromise(keyPair) } else { this._onkeypair(keyPair) } } _onrawerror(err) { this.destroy(err) } _onrawclose() { if (this._ended !== 0) this.destroy() } _onrawdata(data) { let offset = 0 if (this._timeoutTimer !== null) { this._timeoutTimer.refresh() } do { switch (this._state) { case 0: { while (this._tmp !== 0x1000000 && offset < data.byteLength) { const v = data[offset++] this._len += this._tmp * v this._tmp *= 256 } if (this._tmp === 0x1000000) { this._tmp = 0 this._state = 1 const unprocessed = data.byteLength - offset if (unprocessed < this._len && this._utp !== null) this._utp.setContentSize(this._len - unprocessed) } break } case 1: { const missing = this._len - this._tmp const end = missing + offset if (this._message === null && end <= data.byteLength) { this._message = data.subarray(offset, end) offset += missing this._incoming() break } const unprocessed = data.byteLength - offset if (this._message === null) { this._message = b4a.allocUnsafe(this._len) } b4a.copy(data, this._message, this._tmp, offset) this._tmp += unprocessed if (end <= data.byteLength) { offset += missing this._incoming() } else { offset += unprocessed } break } } } while (offset < data.byteLength && !this.destroying) } _onrawend() { this._ended-- this.push(null) } _onrawdrain() { const drain = this._drainDone if (drain === null) return this._drainDone = null drain() } _read(cb) { this.rawStream.resume() cb(null) } _incoming() { const message = this._message this._state = 0 this._len = 0 this._tmp = 1 this._message = null if (this._setup === true) { if (this._handshake) { this._onhandshakert(this._handshake.recv(message)) } else { if (message.byteLength !== IDHEADERBYTES) { this.destroy(new Error('Invalid header message received')) return } const remoteId = message.subarray(0, 32) const expectedId = streamId(this.handshakeHash, !this.isInitiator) const header = message.subarray(32) if (!b4a.equals(expectedId, remoteId)) { this.destroy(new Error('Invalid header received')) return } this._decrypt.init(header) this._setup = false // setup is now done } return } if (message.byteLength < ABYTES) { this.destroy(new Error('Invalid message received')) return } this.rawBytesRead += message.byteLength const plain = message.subarray(1, message.byteLength - ABYTES + 1) try { this._decrypt.next(message, plain) } catch (err) { this.destroy(err) return } // If keep alive is selective, eat the empty buffers (ie assume the other side has it enabled also) if (plain.byteLength === 0 && this.keepAlive !== 0) return if (this.push(plain) === false) { this.rawStream.pause() } } _onhandshakert(h) { if (this._handshakeDone === null) return if (h !== null) { if (h.data) this._rawStream.write(h.data) if (!h.tx) return } const done = this._handshakeDone const publicKey = this._handshake.keyPair.publicKey this._handshakeDone = null this._handshake = null if (h === null) return done(new Error('Noise handshake failed')) this._setupSecretStream(h.tx, h.rx, h.hash, publicKey, h.remotePublicKey) this._resolveOpened(true) done(null) } _setupSecretStream(tx, rx, handshakeHash, publicKey, remotePublicKey) { const buf = b4a.allocUnsafeSlow(3 + IDHEADERBYTES) writeUint24le(IDHEADERBYTES, buf) this._encrypt = new Push(unslab(tx.subarray(0, KEYBYTES)), undefined, buf.subarray(3 + 32)) this._decrypt = new Pull(unslab(rx.subarray(0, KEYBYTES))) this.publicKey = publicKey this.remotePublicKey = remotePublicKey this.handshakeHash = handshakeHash const id = buf.subarray(3, 3 + 32) streamId(handshakeHash, this.isInitiator, id) // initialize secretbox state for unordered messages this._setupSecretSend(handshakeHash) this.emit('handshake') // if rawStream is a bridge, also emit it there if (this.rawStream !== this._rawStream) this.rawStream.emit('handshake') if (this.destroying) return this._rawStream.write(buf) } _setupSecretSend(handshakeHash) { this._sendState = b4a.allocUnsafeSlow(32 + 32 + 8 + 8) const encrypt = this._sendState.subarray(0, 32) // secrets const decrypt = this._sendState.subarray(32, 64) const counter = this._sendState.subarray(64, 72) // nonce const initial = this._sendState.subarray(72) const inputs = this.isInitiator ? [ [NS_INITIATOR, NS_SEND], [NS_RESPONDER, NS_SEND] ] : [ [NS_RESPONDER, NS_SEND], [NS_INITIATOR, NS_SEND] ] sodium.crypto_generichash_batch(encrypt, inputs[0], handshakeHash) sodium.crypto_generichash_batch(decrypt, inputs[1], handshakeHash) sodium.randombytes_buf(initial) counter.set(initial) } _open(cb) { // no autostart or no handshake yet if (this._rawStream === null || (this._handshake === null && this._encrypt === null)) { this._startDone = cb return } this._rawStream.on('data', this._onrawdata.bind(this)) this._rawStream.on('end', this._onrawend.bind(this)) this._rawStream.on('drain', this._onrawdrain.bind(this)) if (this.enableSend) this._rawStream.on('message', this._onmessage.bind(this)) if (this._encrypt !== null) { this._resolveOpened(true) return cb(null) } this._handshakeDone = cb if (this.isInitiator) this._onhandshakert(this._handshake.send()) } _predestroy() { if (this.rawStream) { const error = getStreamError(this) this.rawStream.destroy(error) } if (this._startDone !== null) { const done = this._startDone this._startDone = null done(new Error('Stream destroyed')) } if (this._handshakeDone !== null) { const done = this._handshakeDone this._handshakeDone = null done(new Error('Stream destroyed')) } if (this._drainDone !== null) { const done = this._drainDone this._drainDone = null done(new Error('Stream destroyed')) } } _write(data, cb) { let wrapped = this._outgoingWrapped if (data !== this._outgoingPlain) { wrapped = b4a.allocUnsafe(data.byteLength + 3 + ABYTES) wrapped.set(data, 4) } else { this._outgoingWrapped = this._outgoingPlain = null } if (wrapped.byteLength - 3 > MAX_ATOMIC_WRITE) { return cb( new Error( 'Message is too large for an atomic write. Max size is ' + MAX_ATOMIC_WRITE + ' bytes.' ) ) } this.rawBytesWritten += wrapped.byteLength writeUint24le(wrapped.byteLength - 3, wrapped) // offset 4 so we can do it in-place this._encrypt.next(wrapped.subarray(4, 4 + data.byteLength), wrapped.subarray(3)) if (this._keepAliveTimer !== null) this._keepAliveTimer.refresh() if (this._rawStream.write(wrapped) === false) { this._drainDone = cb } else { cb(null) } } _final(cb) { this._clearKeepAlive() this._ended-- this._rawStream.end() cb(null) } _resolveOpened(val) { if (this._openedDone === null) return const opened = this._openedDone this._openedDone = null opened(val) if (!val) return this.connected = true this.emit('connect') } _clearTimeout() { if (this._timeoutTimer === null) return this._timeoutTimer.destroy() this._timeoutTimer = null this.timeout = 0 } _clearKeepAlive() { if (this._keepAliveTimer === null) return this._keepAliveTimer.destroy() this._keepAliveTimer = null this.keepAlive = 0 } _destroy(cb) { this._clearKeepAlive() this._clearTimeout() this._resolveOpened(false) cb(null) } _boxMessage(buffer) { const MB = sodium.crypto_secretbox_MACBYTES // 16 const NB = sodium.crypto_secretbox_NONCEBYTES // 24 const counter = this._sendState.subarray(64, 72) sodium.sodium_increment(counter) if (b4a.equals(counter, this._sendState.subarray(72))) { this.destroy(new Error('udp send nonce exchausted')) return } const secret = this._sendState.subarray(0, 32) const envelope = b4a.allocUnsafe(8 + MB + buffer.byteLength) const nonce = envelope.subarray(0, NB) const ciphertext = envelope.subarray(8) b4a.fill(nonce, 0) // pad suffix nonce.set(counter) sodium.crypto_secretbox_easy(ciphertext, buffer, nonce, secret) return envelope } send(buffer) { if (!this._sendState) return if (!this.rawStream?.send) return // udx-stream expected const message = this._boxMessage(buffer) return this.rawStream.send(message) } trySend(buffer) { if (!this._sendState) return if (!this.rawStream?.trySend) return // udx-stream expected const message = this._boxMessage(buffer) this.rawStream.trySend(message) } _onmessage(buffer) { if (!this._sendState) return // messages before handshake are dropped const MB = sodium.crypto_secretbox_MACBYTES // 16 const NB = sodium.crypto_secretbox_NONCEBYTES // 24 if (buffer.byteLength < NB) return // Invalid message const nonce = b4a.allocUnsafe(NB) b4a.fill(nonce, 0) nonce.set(buffer.subarray(0, 8)) const secret = this._sendState.subarray(32, 64) const ciphertext = buffer.subarray(8) const plain = buffer.subarray(8, buffer.byteLength - MB) if (ciphertext.byteLength < MB) return // invalid message const success = sodium.crypto_secretbox_open_easy(plain, ciphertext, nonce, secret) if (success) this.emit('message', plain) } alloc(len) { const buf = b4a.allocUnsafe(len + 3 + ABYTES) this._outgoingWrapped = buf this._outgoingPlain = buf.subarray(4, buf.byteLength - ABYTES + 1) return this._outgoingPlain } toJSON() { return { isInitiator: this.isInitiator, publicKey: this.publicKey && b4a.toString(this.publicKey, 'hex'), remotePublicKey: this.remotePublicKey && b4a.toString(this.remotePublicKey, 'hex'), connected: this.connected, destroying: this.destroying, destroyed: this.destroyed, rawStream: this.rawStream && this.rawStream.toJSON ? this.rawStream.toJSON() : null } } } function writeUint24le(n, buf) { buf[0] = n & 255 buf[1] = (n >>> 8) & 255 buf[2] = (n >>> 16) & 255 } function streamId(handshakeHash, isInitiator, out = b4a.allocUnsafe(32)) { sodium.crypto_generichash(out, isInitiator ? NS_INITIATOR : NS_RESPONDER, handshakeHash) return out } function toBuffer(data) { return typeof data === 'string' ? b4a.from(data) : data } function destroyTimeout() { this.destroy(new Error('Stream timed out')) } function sendKeepAlive() { const empty = this.alloc(0) this.write(empty) } const { Duplex, Writable } = require('streamx') class ReversePassThrough extends Duplex { constructor(s) { super() this._stream = s this._ondrain = null } _write(data, cb) { if (this._stream.push(data) === false) { this._stream._ondrain = cb } else { cb(null) } } _final(cb) { this._stream.push(null) cb(null) } _read(cb) { const ondrain = this._ondrain this._ondrain = null if (ondrain) ondrain() cb(null) } } module.exports = class Bridge extends Duplex { constructor(noiseStream) { super() this.noiseStream = noiseStream this._ondrain = null this.reverse = new ReversePassThrough(this) } get publicKey() { return this.noiseStream.publicKey } get remotePublicKey() { return this.noiseStream.remotePublicKey } get handshakeHash() { return this.noiseStream.handshakeHash } flush() { return Writable.drained(this) } _read(cb) { const ondrain = this._ondrain this._ondrain = null if (ondrain) ondrain() cb(null) } _write(data, cb) { if (this.reverse.push(data) === false) { this.reverse._ondrain = cb } else { cb(null) } } _final(cb) { this.reverse.push(null) cb(null) } } const sodium = require('sodium-universal') const curve = require('noise-curve-ed') const Noise = require('noise-handshake') const b4a = require('b4a') const EMPTY = b4a.alloc(0) module.exports = class Handshake { constructor(isInitiator, keyPair, remotePublicKey, pattern) { this.isInitiator = isInitiator this.keyPair = keyPair this.noise = new Noise(pattern, isInitiator, keyPair, { curve }) this.noise.initialise(EMPTY, remotePublicKey) this.destroyed = false } static keyPair(seed) { const publicKey = b4a.alloc(32) const secretKey = b4a.alloc(64) if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed) else sodium.crypto_sign_keypair(publicKey, secretKey) return { publicKey, secretKey } } recv(data) { try { this.noise.recv(data) if (this.noise.complete) return this._return(null) return this.send() } catch { this.destroy() return null } } // note that the data returned here is framed so we don't have to do an extra copy // when sending it... send() { try { const data = this.noise.send() const wrap = b4a.allocUnsafe(data.byteLength + 3) writeUint24le(data.byteLength, wrap) wrap.set(data, 3) return this._return(wrap) } catch { this.destroy() return null } } destroy() { if (this.destroyed) return this.destroyed = true } _return(data) { const tx = this.noise.complete ? b4a.toBuffer(this.noise.tx) : null const rx = this.noise.complete ? b4a.toBuffer(this.noise.rx) : null const hash = this.noise.complete ? b4a.toBuffer(this.noise.hash) : null const remotePublicKey = this.noise.complete ? b4a.toBuffer(this.noise.rs) : null return { data, remotePublicKey, hash, tx, rx } } } function writeUint24le(n, buf) { buf[0] = n & 255 buf[1] = (n >>> 8) & 255 buf[2] = (n >>> 16) & 255 } { "name": "@hyperswarm/secret-stream", "version": "6.9.1", "description": "Secret stream backed by Noise and libsodium's secretstream", "main": "index.js", "files": [ "index.js", "lib/**.js" ], "dependencies": { "b4a": "^1.1.0", "hypercore-crypto": "^3.3.1", "noise-curve-ed": "^2.0.1", "noise-handshake": "^4.0.0", "sodium-secretstream": "^1.1.0", "sodium-universal": "^5.0.0", "streamx": "^2.14.0", "timeout-refresh": "^2.0.0", "unslab": "^1.3.0" }, "devDependencies": { "brittle": "^3.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "udx-native": "^1.13.2" }, "scripts": { "format": "prettier --write .", "lint": "prettier --check .", "test": "brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/hyperswarm-secret-stream.git" }, "author": "Mathias Buus (@mafintosh)", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/hyperswarm-secret-stream/issues" }, "homepage": "https://github.com/holepunchto/hyperswarm-secret-stream" } const Cache = require('xache') module.exports = class AdaptiveTimeout { constructor(opts = {}) { this._cache = new Cache({ maxSize: opts.maxSize || 65536, maxAge: opts.maxAge || 10 * 60 * 1000 // 10 minutes }) this._fallback = opts.fallback || AdaptiveTimeout.TimeoutExponential this._min = opts.min ?? 300 this._max = opts.max || 4000 this._jitter = opts.jitter ?? 256 } // Default - aggressive ramp static TimeoutAggressive = [500, 750, 1000, 1500, 2000] // Linear - steady increase static TimeoutLinear = [500, 1000, 1500, 2000, 2500] // Exponential - slow start, rapid backoff static TimeoutExponential = [250, 500, 1000, 2000, 4000] // Gentle - conservative, patient static TimeoutGentle = [1000, 1250, 1500, 1750, 2000] // Fast - rapid fire retries static TimeoutFast = [200, 400, 600, 800, 1000] // U-shape - long, short, long static TimeoutUShape = [1500, 750, 500, 750, 1500] // Inverse U - short, long, short static TimeoutInverseU = [500, 1000, 1500, 1000, 500] // Sawtooth - alternating fast/slow static TimeoutSawtooth = [500, 1500, 500, 1500, 500] // Plateau - quick ramp then steady static TimeoutPlateau = [500, 1000, 2000, 2000, 2000] // Logarithmic - diminishing increases static TimeoutLogarithmic = [500, 1000, 1300, 1500, 1600] getValue(key) { return this._cache.get(key) } put(key, value) { let p = this._cache.get(key) if (!p) { p = { avg: value, variance: value >> 1 } } else { // blend 75% old + 25% new deviation p.variance += (Math.abs(p.avg - value) - p.variance) >> 2 // blend 87.5% old + 12.5% new sample p.avg += (value - p.avg) >> 3 } this._cache.set(key, p) return p } get(key, attempt = 1) { const p = this._cache.get(key) const jitter = (Math.random() * this._jitter) | 0 if (p) { // known - use adaptive with linear backoff const base = p.avg + (p.variance << 1) const backoff = base * attempt return Math.min(Math.max(backoff + jitter, this._min), this._max) } else { // unknown - use aggressive fallback const base = this._fallback[Math.min(attempt - 1, this._fallback.length - 1)] return base + jitter } } has(key) { return this._cache.has(key) } delete(key) { return this._cache.delete(key) } clear() { this._cache.clear() } } { "name": "adaptive-timeout", "version": "1.0.1", "description": "adaptive-timeout", "main": "index.js", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" } }, "files": [ "package.json", "index.js", "index.d.ts" ], "devDependencies": { "brittle": "^3.19.0", "lunte": "^1.2.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "format": "prettier . --write", "test": "prettier . --check && lunte && brittle-bare test/index.js", "lint": "lunte" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/adaptive-timeout.git" }, "author": "Holepunch Inc", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/adaptive-timeout/issues" }, "homepage": "https://github.com/holepunchto/adaptive-timeout", "dependencies": { "xache": "^1.2.1" } } const c = require('compact-encoding') const IndexEncoder = require('index-encoder') const Checkout = { preencode(state, m) { c.fixed32.preencode(state, m.key) c.uint.preencode(state, m.length) }, encode(state, m) { c.fixed32.encode(state, m.key) c.uint.encode(state, m.length) }, decode(state) { return { key: c.fixed32.decode(state), length: c.uint.decode(state) } } } const Clock = c.array(Checkout) const IndexCheckpoint = { preencode(state, m) { c.fixed64.preencode(state, m.signature) c.uint.preencode(state, m.length) }, encode(state, m) { c.fixed64.encode(state, m.signature) c.uint.encode(state, m.length) }, decode(state) { return { signature: c.fixed64.decode(state), length: c.uint.decode(state) } } } const KeyV0 = { preencode(state, m) { c.fixed32.preencode(state, m.key) }, encode(state, m) { c.fixed32.encode(state, m.key) }, decode(state) { return { key: c.fixed32.decode(state), length: -1 } } } const KeysV0 = c.array(KeyV0) const WakeupV0 = { preencode(state, m) { c.uint.preencode(state, 0) // version c.uint.preencode(state, m.type) if (m.type === 1) { KeysV0.preencode(state, m.writers) } }, encode(state, m) { c.uint.encode(state, 0) // version c.uint.encode(state, m.type) if (m.type === 1) { KeysV0.encode(state, m.writers) } }, decode(state) { const v = c.uint.decode(state) if (v !== 0) throw new Error('Unsupported version: ' + v) const type = c.uint.decode(state) const m = { version: 0, type, writers: null } if (m.type === 1) { m.writers = KeysV0.decode(state) } return m } } const Wakeup = { preencode(state, m) { if (m.version === 0) return WakeupV0.preencode(state, m) c.uint.preencode(state, 1) // version c.uint.preencode(state, m.type) if (m.type === 1) { Clock.preencode(state, m.writers) } }, encode(state, m) { if (m.version === 0) return WakeupV0.encode(state, m) c.uint.encode(state, 1) // version c.uint.encode(state, m.type) if (m.type === 1) { Clock.encode(state, m.writers) } }, decode(state) { const start = state.start const v = c.uint.decode(state) if (v > 1) throw new Error('Unsupported version: ' + v) if (v === 0) { state.start = start return WakeupV0.decode(state) } const type = c.uint.decode(state) const m = { version: 1, type, writers: null } if (m.type === 1) { m.writers = Clock.decode(state) } return m } } const BootRecordV0 = { preencode() { throw new Error('version 0 records cannot be encoded') }, encode() { throw new Error('version 0 records cannot be encoded') }, decode(state) { c.uint.decode(state) const indexed = Checkout.decode(state) const heads = Clock.decode(state) // one cause initial recover is not ff recovery return { version: 0, key: indexed.key, systemLength: indexed.length, indexersUpdated: false, fastForwarding: false, recoveries: 1, migrating: false, heads } } } const Checkpointer = { preencode(state, idx) { c.uint.preencode(state, idx.checkpointer) if (idx.checkpoint !== null) IndexCheckpoint.preencode(state, idx.checkpoint) }, encode(state, idx) { c.uint.encode(state, idx.checkpointer) if (idx.checkpoint !== null) IndexCheckpoint.encode(state, idx.checkpoint) }, decode(state) { const checkpointer = c.uint.decode(state) const checkpoint = checkpointer ? null : IndexCheckpoint.decode(state) return { checkpointer, checkpoint } } } const CheckpointerArray = c.array(Checkpointer) const Indexer = { preencode(state, m) { c.uint.preencode(state, m.signature) c.fixed32.preencode(state, m.namespace) c.fixed32.preencode(state, m.publicKey) }, encode(state, m) { c.uint.encode(state, m.signature) c.fixed32.encode(state, m.namespace) c.fixed32.encode(state, m.publicKey) }, decode(state) { return { signature: c.uint.decode(state), namespace: c.fixed32.decode(state), publicKey: c.fixed32.decode(state) } } } const Indexers = c.array(Indexer) const DigestV0 = { preencode(state, m) { c.uint.preencode(state, m.pointer) if (m.pointer === 0) { Indexers.preencode(state, m.indexers) } }, encode(state, m) { c.uint.encode(state, m.pointer) if (m.pointer === 0) { Indexers.encode(state, m.indexers) } }, decode(state) { const pointer = c.uint.decode(state) return { pointer, indexers: pointer === 0 ? Indexers.decode(state) : null } } } const Digest = { preencode(state, m) { c.uint.preencode(state, m.pointer) if (m.pointer === 0) { c.fixed32.preencode(state, m.key) } }, encode(state, m) { c.uint.encode(state, m.pointer) if (m.pointer === 0) { c.fixed32.encode(state, m.key) } }, decode(state) { const pointer = c.uint.decode(state) return { pointer, key: pointer === 0 ? c.fixed32.decode(state) : null } } } const Node = { preencode(state, m) { Clock.preencode(state, m.heads) c.uint.preencode(state, m.batch) c.optionalBuffer.preencode(state, m.value) }, encode(state, m) { Clock.encode(state, m.heads) c.uint.encode(state, m.batch) c.optionalBuffer.encode(state, m.value) }, decode(state, m) { return { heads: Clock.decode(state), batch: c.uint.decode(state), value: c.optionalBuffer.decode(state) } } } const Additional = { preencode(state, m) { c.uint.preencode(state, m.pointer) if (m.pointer === 0) { AdditionalData.preencode(state, m.data) } }, encode(state, m) { c.uint.encode(state, m.pointer) if (m.pointer === 0) { AdditionalData.encode(state, m.data) } }, decode(state) { const pointer = c.uint.decode(state) return { pointer, data: pointer === 0 ? AdditionalData.decode(state) : null } } } const AdditionalData = { preencode(state, m) { c.uint.preencode(state, 0) }, encode(state, m) { c.uint.encode(state, 0) // empty for now, for the future }, decode(state) { const flags = c.uint.decode(state) return { encryptionId: flags & 1 ? c.fixed32.decode(state) : null, // to help validate the encryption key used abi: flags & 2 ? c.uint.decode(state) : 0 } } } const OplogMessageV1 = { preencode(state, m) { throw new Error('Encoding not supported') }, encode(state, m) { throw new Error('Encoding not supported') }, decode(state) { c.uint.decode(state) // version const maxSupportedVersion = c.uint.decode(state) const flags = c.uint.decode(state) const isCheckpointer = (flags & 1) !== 0 const chk = isCheckpointer ? CheckpointerArray.decode(state) : null const digest = isCheckpointer ? Digest.decode(state) : null const node = Node.decode(state) return { version: 1, maxSupportedVersion, digest, checkpoint: chk ? { system: chk[0], encryption: null, user: chk.slice(1) } : null, optimistic: (flags & 2) !== 0, node } } } const OplogMessageV0 = { preencode(state, m) { throw new Error('Encoding not supported') }, encode(state, m) { throw new Error('Encoding not supported') }, decode(state) { c.uint.decode(state) // version const flags = c.uint.decode(state) const isCheckpointer = (flags & 1) !== 0 if (isCheckpointer) DigestV0.decode(state) const chk = isCheckpointer ? CheckpointerArray.decode(state) : null const node = Node.decode(state) Additional.decode(state) const maxSupportedVersion = state.start < state.end ? c.uint.decode(state) : 0 return { version: 0, maxSupportedVersion, digest: null, checkpoint: chk ? { system: chk[0], encryption: null, user: chk.slice(1) } : null, optimistic: null, node } } } // prefix 0 is reserved for future manifest const LINEARIZER_PREFIX = 1 const LinearizerKey = { preencode(state, seq) { IndexEncoder.UINT.preencode(state, LINEARIZER_PREFIX) IndexEncoder.UINT.preencode(state, seq) }, encode(state, seq) { IndexEncoder.UINT.encode(state, LINEARIZER_PREFIX) IndexEncoder.UINT.encode(state, seq) }, decode(state) { IndexEncoder.UINT.decode(state) return IndexEncoder.UINT.decode(state) } } function infoLegacyMap(info) { return { version: info.version, members: info.members, pendingIndexers: info.pendingIndexers, indexers: info.indexers, heads: info.heads, views: info.views, encryptionLength: 0, entropy: null } } module.exports = { Wakeup, BootRecordV0, OplogMessageV0, OplogMessageV1, LinearizerKey, infoLegacyMap } // This file is autogenerated by the hyperschema compiler // Schema Version: 1 /* eslint-disable camelcase */ /* eslint-disable quotes */ /* eslint-disable space-before-function-paren */ const { c } = require('hyperschema/runtime') const external0 = require('../../legacy.js') const VERSION = 1 // eslint-disable-next-line no-unused-vars let version = VERSION // @autobase/checkout const encoding0 = { preencode(state, m) { c.fixed32.preencode(state, m.key) c.uint.preencode(state, m.length) }, encode(state, m) { c.fixed32.encode(state, m.key) c.uint.encode(state, m.length) }, decode(state) { const r0 = c.fixed32.decode(state) const r1 = c.uint.decode(state) return { key: r0, length: r1 } } } // @autobase/clock const encoding1 = c.array(encoding0) // @autobase/index-checkpoint const encoding2 = { preencode(state, m) { c.fixed64.preencode(state, m.signature) c.uint.preencode(state, m.length) }, encode(state, m) { c.fixed64.encode(state, m.signature) c.uint.encode(state, m.length) }, decode(state) { const r0 = c.fixed64.decode(state) const r1 = c.uint.decode(state) return { signature: r0, length: r1 } } } const encoding3 = external0.Wakeup const encoding4 = external0.BootRecordV0 // @autobase/boot-record-raw const encoding5 = { preencode(state, m) { c.fixed32.preencode(state, m.key) c.uint.preencode(state, m.systemLength) state.end++ // max flag is 4 so always one byte if (m.recoveries) c.uint.preencode(state, m.recoveries) }, encode(state, m) { const flags = (m.indexersUpdated ? 1 : 0) | (m.fastForwarding ? 2 : 0) | (m.recoveries ? 4 : 0) c.fixed32.encode(state, m.key) c.uint.encode(state, m.systemLength) c.uint.encode(state, flags) if (m.recoveries) c.uint.encode(state, m.recoveries) }, decode(state) { const v = c.uint.decode(state) const r0 = c.fixed32.decode(state) const r1 = c.uint.decode(state) const flags = c.uint.decode(state) return { version: v, key: r0, systemLength: r1, indexersUpdated: (flags & 1) !== 0, fastForwarding: (flags & 2) !== 0, recoveries: (flags & 4) !== 0 ? c.uint.decode(state) : 0 } } } // @autobase/boot-record const encoding6 = { preencode(state, m) { c.uint.preencode(state, m.version) switch (m.version) { case 0: encoding4.preencode(state, m) break case 1: case 2: case 3: encoding5.preencode(state, m) break default: throw new Error('Unsupported version') } }, encode(state, m) { c.uint.encode(state, m.version) switch (m.version) { case 0: encoding4.encode(state, m) break case 1: case 2: case 3: encoding5.encode(state, m) break default: throw new Error('Unsupported version') } }, decode(state) { const start = state.start const v = c.uint.decode(state) state.start = start switch (v) { case 0: { const decoded = encoding4.decode(state) return decoded } case 1: case 2: case 3: { const decoded = encoding5.decode(state) return decoded } default: throw new Error('Unsupported version') } } } // @autobase/checkpointer const encoding7 = { preencode(state, m) { state.end++ // flags are fixed size if (m.checkpointer) c.uint.preencode(state, m.checkpointer) if (m.checkpoint) encoding2.preencode(state, m.checkpoint) }, encode(state, m) { const flags = (m.checkpointer ? 1 : 0) | (m.checkpoint ? 2 : 0) c.uint8.encode(state, flags) if (m.checkpointer) c.uint.encode(state, m.checkpointer) if (m.checkpoint) encoding2.encode(state, m.checkpoint) }, decode(state) { const flags = c.uint8.decode(state) return { checkpointer: (flags & 1) !== 0 ? c.uint.decode(state) : 0, checkpoint: (flags & 2) !== 0 ? encoding2.decode(state) : null } } } // @autobase/checkpoint.user const encoding8_2 = c.array(encoding7) // @autobase/checkpoint const encoding8 = { preencode(state, m) { state.end++ // max flag is 4 so always one byte if (m.system) encoding7.preencode(state, m.system) if (m.encryption) encoding7.preencode(state, m.encryption) if (m.user) encoding8_2.preencode(state, m.user) }, encode(state, m) { const flags = (m.system ? 1 : 0) | (m.encryption ? 2 : 0) | (m.user ? 4 : 0) c.uint.encode(state, flags) if (m.system) encoding7.encode(state, m.system) if (m.encryption) encoding7.encode(state, m.encryption) if (m.user) encoding8_2.encode(state, m.user) }, decode(state) { const flags = c.uint.decode(state) return { system: (flags & 1) !== 0 ? encoding7.decode(state) : null, encryption: (flags & 2) !== 0 ? encoding7.decode(state) : null, user: (flags & 4) !== 0 ? encoding8_2.decode(state) : null } } } // @autobase/digest const encoding9 = { preencode(state, m) { state.end++ // max flag is 2 so always one byte if (m.pointer) c.uint.preencode(state, m.pointer) if (m.key) c.fixed32.preencode(state, m.key) }, encode(state, m) { const flags = (m.pointer ? 1 : 0) | (m.key ? 2 : 0) c.uint.encode(state, flags) if (m.pointer) c.uint.encode(state, m.pointer) if (m.key) c.fixed32.encode(state, m.key) }, decode(state) { const flags = c.uint.decode(state) return { pointer: (flags & 1) !== 0 ? c.uint.decode(state) : 0, key: (flags & 2) !== 0 ? c.fixed32.decode(state) : null } } } // @autobase/node const encoding10 = { preencode(state, m) { encoding1.preencode(state, m.heads) c.uint.preencode(state, m.batch) c.optionalBuffer.preencode(state, m.value) }, encode(state, m) { encoding1.encode(state, m.heads) c.uint.encode(state, m.batch) c.optionalBuffer.encode(state, m.value) }, decode(state) { const r0 = encoding1.decode(state) const r1 = c.uint.decode(state) const r2 = c.optionalBuffer.decode(state) return { heads: r0, batch: r1, value: r2 } } } // @autobase/user-view-trace.blocks const encoding11_1 = c.array(c.uint) // @autobase/user-view-trace const encoding11 = { preencode(state, m) { c.uint.preencode(state, m.view) encoding11_1.preencode(state, m.blocks) }, encode(state, m) { c.uint.encode(state, m.view) encoding11_1.encode(state, m.blocks) }, decode(state) { const r0 = c.uint.decode(state) const r1 = encoding11_1.decode(state) return { view: r0, blocks: r1 } } } // @autobase/trace.system const encoding12_0 = encoding11_1 // @autobase/trace.encryption const encoding12_1 = encoding11_1 // @autobase/trace.user const encoding12_2 = c.array(encoding11) // @autobase/trace const encoding12 = { preencode(state, m) { encoding12_0.preencode(state, m.system) encoding12_1.preencode(state, m.encryption) encoding12_2.preencode(state, m.user) }, encode(state, m) { encoding12_0.encode(state, m.system) encoding12_1.encode(state, m.encryption) encoding12_2.encode(state, m.user) }, decode(state) { const r0 = encoding12_0.decode(state) const r1 = encoding12_1.decode(state) const r2 = encoding12_2.decode(state) return { system: r0, encryption: r1, user: r2 } } } const encoding13 = external0.OplogMessageV0 const encoding14 = external0.OplogMessageV1 // @autobase/oplog-message-v2.checkpoint const encoding15_1 = c.frame(encoding8) // @autobase/oplog-message-v2.digest const encoding15_2 = c.frame(encoding9) // @autobase/oplog-message-v2.trace const encoding15_4 = c.frame(encoding12) // @autobase/oplog-message-v2 const encoding15 = { preencode(state, m) { encoding10.preencode(state, m.node) state.end++ // max flag is 8 so always one byte if (m.checkpoint) encoding15_1.preencode(state, m.checkpoint) if (m.digest) encoding15_2.preencode(state, m.digest) if (m.trace) encoding15_4.preencode(state, m.trace) }, encode(state, m) { const flags = (m.checkpoint ? 1 : 0) | (m.digest ? 2 : 0) | (m.optimistic ? 4 : 0) | (m.trace ? 8 : 0) encoding10.encode(state, m.node) c.uint.encode(state, flags) if (m.checkpoint) encoding15_1.encode(state, m.checkpoint) if (m.digest) encoding15_2.encode(state, m.digest) if (m.trace) encoding15_4.encode(state, m.trace) }, decode(state) { const v = c.uint.decode(state) const r0 = encoding10.decode(state) const flags = c.uint.decode(state) return { version: v, node: r0, checkpoint: (flags & 1) !== 0 ? encoding15_1.decode(state) : null, digest: (flags & 2) !== 0 ? encoding15_2.decode(state) : null, optimistic: (flags & 4) !== 0, trace: (flags & 8) !== 0 ? encoding15_4.decode(state) : null } } } // @autobase/oplog-message const encoding16 = { preencode(state, m) { c.uint.preencode(state, m.version) switch (m.version) { case 0: encoding13.preencode(state, m) break case 1: encoding14.preencode(state, m) break case 2: encoding15.preencode(state, m) break default: throw new Error('Unsupported version') } }, encode(state, m) { c.uint.encode(state, m.version) switch (m.version) { case 0: encoding13.encode(state, m) break case 1: encoding14.encode(state, m) break case 2: encoding15.encode(state, m) break default: throw new Error('Unsupported version') } }, decode(state) { const start = state.start const v = c.uint.decode(state) state.start = start switch (v) { case 0: { const decoded = encoding13.decode(state) return decoded } case 1: { const decoded = encoding14.decode(state) return decoded } case 2: { const decoded = encoding15.decode(state) return decoded } default: throw new Error('Unsupported version') } } } // @autobase/info-v1.pendingIndexers const encoding17_1 = c.array(c.fixed32) // @autobase/info-v1 const encoding17 = { preencode(state, m) { c.uint.preencode(state, m.members) encoding17_1.preencode(state, m.pendingIndexers) encoding1.preencode(state, m.indexers) encoding1.preencode(state, m.heads) encoding1.preencode(state, m.views) }, encode(state, m) { c.uint.encode(state, m.members) encoding17_1.encode(state, m.pendingIndexers) encoding1.encode(state, m.indexers) encoding1.encode(state, m.heads) encoding1.encode(state, m.views) }, decode(state) { const v = c.uint.decode(state) const r0 = c.uint.decode(state) const r1 = encoding17_1.decode(state) const r2 = encoding1.decode(state) const r3 = encoding1.decode(state) const r4 = encoding1.decode(state) return { version: v, members: r0, pendingIndexers: r1, indexers: r2, heads: r3, views: r4 } } } // @autobase/info-v2.pendingIndexers const encoding18_1 = encoding17_1 // @autobase/info-v2 const encoding18 = { preencode(state, m) { c.uint.preencode(state, m.members) encoding18_1.preencode(state, m.pendingIndexers) encoding1.preencode(state, m.indexers) encoding1.preencode(state, m.heads) encoding1.preencode(state, m.views) c.uint.preencode(state, m.encryptionLength) state.end++ // max flag is 1 so always one byte if (m.entropy) c.fixed32.preencode(state, m.entropy) }, encode(state, m) { const flags = m.entropy ? 1 : 0 c.uint.encode(state, m.members) encoding18_1.encode(state, m.pendingIndexers) encoding1.encode(state, m.indexers) encoding1.encode(state, m.heads) encoding1.encode(state, m.views) c.uint.encode(state, m.encryptionLength) c.uint.encode(state, flags) if (m.entropy) c.fixed32.encode(state, m.entropy) }, decode(state) { const v = c.uint.decode(state) const r0 = c.uint.decode(state) const r1 = encoding18_1.decode(state) const r2 = encoding1.decode(state) const r3 = encoding1.decode(state) const r4 = encoding1.decode(state) const r5 = c.uint.decode(state) const flags = c.uint.decode(state) return { version: v, members: r0, pendingIndexers: r1, indexers: r2, heads: r3, views: r4, encryptionLength: r5, entropy: (flags & 1) !== 0 ? c.fixed32.decode(state) : null } } } // @autobase/info const encoding19 = { preencode(state, m) { c.uint.preencode(state, m.version) switch (m.version) { case 0: case 1: encoding17.preencode(state, m) break case 2: encoding18.preencode(state, m) break default: throw new Error('Unsupported version') } }, encode(state, m) { c.uint.encode(state, m.version) switch (m.version) { case 0: case 1: encoding17.encode(state, m) break case 2: encoding18.encode(state, m) break default: throw new Error('Unsupported version') } }, decode(state) { const start = state.start const v = c.uint.decode(state) state.start = start switch (v) { case 0: case 1: { const decoded = encoding17.decode(state) const map = external0.infoLegacyMap return map(decoded) } case 2: { const decoded = encoding18.decode(state) return decoded } default: throw new Error('Unsupported version') } } } // @autobase/member const encoding20 = { preencode(state, m) { state.end++ // max flag is 2 so always one byte c.uint.preencode(state, m.length) }, encode(state, m) { const flags = (m.isIndexer ? 1 : 0) | (m.isRemoved ? 2 : 0) c.uint.encode(state, flags) c.uint.encode(state, m.length) }, decode(state) { const flags = c.uint.decode(state) return { isIndexer: (flags & 1) !== 0, isRemoved: (flags & 2) !== 0, length: c.uint.decode(state) } } } const encoding21 = external0.LinearizerKey // @autobase/linearizer-update const encoding22 = { preencode(state, m) { c.fixed32.preencode(state, m.key) c.uint.preencode(state, m.length) c.uint.preencode(state, m.batch) c.uint.preencode(state, m.systemLength) state.end++ // max flag is 1 so always one byte }, encode(state, m) { const flags = m.indexers ? 1 : 0 c.fixed32.encode(state, m.key) c.uint.encode(state, m.length) c.uint.encode(state, m.batch) c.uint.encode(state, m.systemLength) c.uint.encode(state, flags) }, decode(state) { const r0 = c.fixed32.decode(state) const r1 = c.uint.decode(state) const r2 = c.uint.decode(state) const r3 = c.uint.decode(state) const flags = c.uint.decode(state) return { key: r0, length: r1, batch: r2, systemLength: r3, indexers: (flags & 1) !== 0 } } } // @autobase/encryption-descriptor const encoding23 = { preencode(state, m) { c.uint.preencode(state, m.type) c.optionalBuffer.preencode(state, m.payload) }, encode(state, m) { c.uint.encode(state, m.type) c.optionalBuffer.encode(state, m.payload) }, decode(state) { const r0 = c.uint.decode(state) const r1 = c.optionalBuffer.decode(state) return { type: r0, payload: r1 } } } // @autobase/manifest-data const encoding24 = { preencode(state, m) { c.uint.preencode(state, m.version) state.end++ // max flag is 2 so always one byte if (m.legacyBlocks) c.uint.preencode(state, m.legacyBlocks) if (m.namespace) c.fixed32.preencode(state, m.namespace) }, encode(state, m) { const flags = (m.legacyBlocks ? 1 : 0) | (m.namespace ? 2 : 0) c.uint.encode(state, m.version) c.uint.encode(state, flags) if (m.legacyBlocks) c.uint.encode(state, m.legacyBlocks) if (m.namespace) c.fixed32.encode(state, m.namespace) }, decode(state) { const r0 = c.uint.decode(state) const flags = c.uint.decode(state) return { version: r0, legacyBlocks: (flags & 1) !== 0 ? c.uint.decode(state) : 0, namespace: (flags & 2) !== 0 ? c.fixed32.decode(state) : null } } } function setVersion(v) { version = v } function encode(name, value, v = VERSION) { version = v return c.encode(getEncoding(name), value) } function decode(name, buffer, v = VERSION) { version = v return c.decode(getEncoding(name), buffer) } function getEnum(name) { switch (name) { default: throw new Error('Enum not found ' + name) } } function getEncoding(name) { switch (name) { case '@autobase/checkout': return encoding0 case '@autobase/clock': return encoding1 case '@autobase/index-checkpoint': return encoding2 case '@autobase/wakeup': return encoding3 case '@autobase/boot-record-v0': return encoding4 case '@autobase/boot-record-raw': return encoding5 case '@autobase/boot-record': return encoding6 case '@autobase/checkpointer': return encoding7 case '@autobase/checkpoint': return encoding8 case '@autobase/digest': return encoding9 case '@autobase/node': return encoding10 case '@autobase/user-view-trace': return encoding11 case '@autobase/trace': return encoding12 case '@autobase/oplog-message-v0': return encoding13 case '@autobase/oplog-message-v1': return encoding14 case '@autobase/oplog-message-v2': return encoding15 case '@autobase/oplog-message': return encoding16 case '@autobase/info-v1': return encoding17 case '@autobase/info-v2': return encoding18 case '@autobase/info': return encoding19 case '@autobase/member': return encoding20 case '@autobase/linearizer-key': return encoding21 case '@autobase/linearizer-update': return encoding22 case '@autobase/encryption-descriptor': return encoding23 case '@autobase/manifest-data': return encoding24 default: throw new Error('Encoder not found ' + name) } } function getStruct(name, v = VERSION) { const enc = getEncoding(name) return { preencode(state, m) { version = v enc.preencode(state, m) }, encode(state, m) { version = v enc.encode(state, m) }, decode(state) { version = v return enc.decode(state) } } } const resolveStruct = getStruct // compat module.exports = { resolveStruct, getStruct, getEnum, getEncoding, encode, decode, setVersion, version } const b4a = require('b4a') const ReadyResource = require('ready-resource') const debounceify = require('debounceify') const c = require('compact-encoding') const safetyCatch = require('safety-catch') const hypercoreId = require('hypercore-id-encoding') const assert = require('nanoassert') const SignalPromise = require('signal-promise') const CoreCoupler = require('core-coupler') const ProtomuxWakeup = require('protomux-wakeup') const rrp = require('resolve-reject-promise') const Hypercore = require('hypercore') const ScopeLock = require('scope-lock') const encryptionEncoding = require('encryption-encoding') const LocalState = require('./lib/local-state.js') const Linearizer = require('./lib/linearizer.js') const SystemView = require('./lib/system.js') const { EncryptionView } = require('./lib/encryption.js') const UpdateChanges = require('./lib/updates.js') const messages = require('./lib/messages.js') const Timer = require('./lib/timer.js') const Writer = require('./lib/writer.js') const { encodeValue, decodeValue } = require('./lib/values.js') const ActiveWriters = require('./lib/active-writers.js') const AutoWakeup = require('./lib/wakeup.js') const FastForward = require('./lib/fast-forward.js') const AutoStore = require('./lib/store.js') const ApplyState = require('./lib/apply-state.js') const AppendBatch = require('./lib/append-batch.js') const { PublicApplyCalls } = require('./lib/apply-calls.js') const boot = require('./lib/boot.js') const { MAX_AUTOBASE_VERSION, BOOT_RECORD_VERSION } = require('./lib/caps.js') const inspect = Symbol.for('nodejs.util.inspect.custom') const INTERRUPT = new Error('Apply interrupted') const BINARY_ENCODING = c.from('binary') const RECOVERIES = 3 // default is to automatically ack const DEFAULT_ACK_INTERVAL = 10_000 const DEFAULT_ACK_THRESHOLD = 4 const REMOTE_ADD_BATCH = 64 const REMOTE_ADD_BATCH_SANITY = 4096 const MIN_FF_WAIT = 300_000 // wait at least 5min before attempting to ff again after failure class WakeupHandler { constructor(base, discoveryKey) { this.active = true this.discoveryKey = discoveryKey this.base = base } onpeeractive(peer, session) { this.base._bumpWakeupPeer(peer) } onlookup(req, peer, session) { const wakeup = this.base._getWakeup() if (wakeup.length === 0) return session.announce(peer, wakeup) } onannounce(wakeup, peer, session) { if (this.base.isFastForwarding()) { this.base._needsWakeupRequest = true return } this.base.hintWakeup(wakeup) } } module.exports = class Autobase extends ReadyResource { constructor(store, bootstrap, handlers = {}) { if (Array.isArray(bootstrap)) bootstrap = bootstrap[0] // TODO: just a quick compat, lets remove soon if (bootstrap && typeof bootstrap !== 'string' && !b4a.isBuffer(bootstrap)) { handlers = bootstrap bootstrap = null } super() const key = bootstrap ? toKey(bootstrap) : null this.id = null this.key = key this.discoveryKey = null this.backoff = handlers.backoff || null this.keyPair = null this.valueEncoding = c.from(handlers.valueEncoding || 'binary') this.store = store this.globalCache = store.globalCache || null this.migrated = false this.encrypted = handlers.encrypted || !!handlers.encryptionKey this.encrypt = !!handlers.encrypt this.encryptionKey = null this.encryption = null this.blindEncryption = handlers.blindEncryption || null this.activeBatch = null // maintained by the append-batch this.local = null this.localWriter = null this.isIndexer = false this.activeWriters = new ActiveWriters() this.linearizer = null this.updating = false this.nukeTip = !!handlers.nukeTip this.wakeupOwner = !handlers.wakeup this.wakeupCapability = null this.wakeupProtocol = handlers.wakeup || new ProtomuxWakeup() this.wakeupSession = null this._primaryBootstrap = null this.fastForwardEnabled = handlers.fastForward !== false this.fastForwarding = null this.fastForwardTo = null this.fastForwardFailedAt = 0 this.fastForwardMinimum = FastForward.MINIMUM this.bigBatches = !!handlers.bigBatches this._bootstrapWriters = [] // might contain dups, but thats ok this._bootstrapWritersChanged = false this._flushSignal = new SignalPromise() this._flushing = 0 this._checkWriters = [] this._optimistic = -1 this._appended = 0 this._appending = null this._wakeup = new AutoWakeup(this) this._wakeupHints = new Map() this._wakeupPeerBound = this._wakeupPeer.bind(this) this._coupler = null this._updateLocalCore = null this._lock = new ScopeLock() this._needsWakeupRequest = false this._needsWakeup = true this._needsWakeupHeads = true this._updates = [] this._handlers = handlers || {} this._warn = emitWarning.bind(this) this._lastError = null this._draining = false this._writable = null this._advancing = null this._interrupting = false this._caughtup = false this.paused = false this._bump = debounceify(() => { this._advancing = this._advance() return this._advancing }) this._onremotewriterchangeBound = this._onremotewriterchange.bind(this) this._onlocalwriterchangeBound = this._onlocalwriterchange.bind(this) this._preopen = null this._hasOpen = !!this._handlers.open this._hasApply = !!this._handlers.apply this._hasOptimisticApply = !!this._handlers.optimistic this._hasUpdate = !!this._handlers.update this._hasClose = !!this._handlers.close this._viewStore = new AutoStore(this) this._applyState = null this.view = null this.core = null this.version = -1 this.interrupted = null this.recoveries = RECOVERIES const { ackInterval = DEFAULT_ACK_INTERVAL, ackThreshold = DEFAULT_ACK_THRESHOLD } = handlers this._ackInterval = ackInterval this._ackThreshold = ackThreshold this._ackTickThreshold = ackThreshold this._ackTick = 0 this._ackTimer = null this._acking = false this._waiting = new SignalPromise() this.view = this._hasOpen ? this._handlers.open(this._viewStore, new PublicApplyCalls(this)) : null this.core = this._viewStore.get({ name: '_system' }) if (this.fastForwardEnabled && isObject(handlers.fastForward)) { this._runFastForward( new FastForward(this, handlers.fastForward.key, { verified: false }) ).catch(noop) } this.ready().catch(safetyCatch) } [inspect](depth, opts) { let indent = '' if (typeof opts.indentationLvl === 'number') { while (indent.length < opts.indentationLvl) indent += ' ' } return indent + 'Autobase { ... }' } // just compat, use .key get bootstrap() { return this.key } // TODO: compat, will be removed get bootstraps() { return [this.bootstrap] } get appending() { return this._appending !== null && this._appending.length > 0 } get writable() { return this.localWriter !== null && !this.localWriter.isRemoved } get ackable() { return this.localWriter !== null && this.localWriter.isActiveIndexer } get signedLength() { return this.core.signedLength } get indexedLength() { return this._applyState ? this._applyState.indexedLength : 0 } get length() { return this.core.length } get flushing() { return this._flushing > 0 } hash() { return this.core.treeHash() } // deprecated, use .core.key getSystemKey() { return this.core.key } get system() { return this._applyState && this._applyState.system } // deprecated async getIndexedInfo() { if (this.opened === false) await this.ready() return ( this._applyState && this._applyState.system.getIndexedInfo(this._applyState.indexedLength) ) } _isActiveIndexer() { return this.localWriter ? this.localWriter.isActiveIndexer : false } replicate(isInitiator, opts) { const stream = this.store.replicate(isInitiator, opts) this.wakeupProtocol.addStream(stream) return stream } heads() { if (!this._applyState || !this._applyState.opened) return [] const nodes = new Array(this._applyState.system.heads.length) for (let i = 0; i < this._applyState.system.heads.length; i++) nodes[i] = this._applyState.system.heads[i] return nodes.sort(compareNodes) } async export() { const exporting = [this.store.storage.export(this.local.discoveryKey), this._viewStore.export()] const [local, views] = await Promise.all(exporting) return { local, views } } hintWakeup(hints) { if (!Array.isArray(hints)) hints = [hints] for (const { key, length } of hints) { const hex = b4a.toString(key, 'hex') const prev = this._wakeupHints.get(hex) if (!prev || length === -1 || prev < length) this._wakeupHints.set(hex, length) } this._queueBump() } setBigBatches(bool = true) { this.bigBatches = bool } _queueBump() { this._bump().catch(safetyCatch) } async _runPreOpen() { if (this._handlers.wait) await this._handlers.wait() await this.store.ready() this.keyPair = (await this._handlers.keyPair) || null if (this._handlers.encryptionKey !== null) { this.encryptionKey = await this._handlers.encryptionKey } const result = await boot(this.store, this.key, { encryptionKey: this.encryptionKey, encrypt: this.encrypt, keyPair: this.keyPair, blindEncryption: this.blindEncryption }) this._primaryBootstrap = result.bootstrap this.local = result.local this.key = result.bootstrap.key this.discoveryKey = result.bootstrap.discoveryKey this.id = result.bootstrap.id this.encryptionKey = result.encryptionKey if (this.encrypted) { assert(this.encryptionKey !== null, 'Encryption key is expected') } if (this.encryptionKey) { this.encryption = new EncryptionView(this, null) this.local.setEncryption(this.getWriterEncryption()) this._primaryBootstrap.setEncryption(this.getWriterEncryption()) } if (this.nukeTip) await this._nukeTip() this.local.on('append', this._onlocalwriterchangeBound) this.wakeupCapability = (await this._handlers.wakeupCapability) || { key: this.key, discoveryKey: this.discoveryKey } this.setWakeup(this.wakeupCapability.key, this.wakeupCapability.discoveryKey) } async _nukeTipBatch(key, length) { const core = this.store.get({ key, active: false }) await core.ready() const batch = core.session({ name: 'batch' }) await batch.ready() if (batch.length > length) await batch.truncate(length) await batch.close() await core.close() } // TODO: not atomic atm, so more of a (very useful) debug helper async _nukeTip() { const pointer = await this.local.getUserData('autobase/boot') if (!pointer) return const boot = c.decode(messages.BootRecord, pointer) await LocalState.clear(this.local) await this._nukeTipBatch(boot.key, boot.systemLength) const core = this.store.get({ key: boot.key, active: false, encryption: null }) const encCore = await EncryptionView.setSystemEncryption(this, core) const batch = core.session({ name: 'batch' }) await batch.ready() const info = await SystemView.getIndexedInfo(batch, boot.systemLength) await batch.close() for (const view of info.views) { // ensure any views ref'ed by system are consistent as well await this._nukeTipBatch(view.key, view.length) } if (boot.heads) this.hintWakeup(boot.heads) if (this.local.length) this.hintWakeup([{ key: this.local.key, length: this.local.length }]) await core.close() if (encCore) await encCore.close() } _bumpWakeupPeer(peer) { if (this._coupler) this._coupler.update(peer.stream) } async _rotateLocalWriter(newLocal) { assert(!this.appending, 'Cannot rotate a newLocal writer if an append is in progress') const oldLocal = this.local if (this._applyState) await this._applyState.close() this.local = newLocal this.local.on('append', this._onlocalwriterchangeBound) this.localWriter = null this._updateLocalCore = null const store = this._viewStore.atomize() const local = store.getLocal() await local.ready() await LocalState.moveTo(oldLocal, local) await local.setUserData('referrer', this.key) if (this.encryptionKey) { if (this.blindEncryption) { const encrypted = await encryptionEncoding.encrypt( this.encryptionKey, this.blindEncryption.encrypt ) await local.setUserData('autobase/blind-encryption', encrypted) } else { await local.setUserData('autobase/encryption', this.encryptionKey) } } await store.flush() await store.close() await this._primaryBootstrap.setUserData('autobase/local', local.key) await this._clearWriters() await oldLocal.close() // done, soft reboot await this._viewStore.updateLocal() await this._clearWriters() this._applyState = new ApplyState(this) await this._applyState.ready() await this._makeLinearizerFromViewState() this._caughtup = false this._rebooted() this.emit('rotate-local-writer') } async setLocal(key, { keyPair } = {}) { if (!this.opened) await this.ready() const manifest = keyPair ? { version: this.store.manifestVersion, signers: [{ publicKey: keyPair.publicKey }] } : null if (!key) key = Hypercore.key(manifest) // If the keys are the same, no need to rotate if (b4a.equals(key, this.local.key)) return const encryption = this.encryptionKey ? this.getWriterEncryption() : null const local = this.store.get({ key, manifest, active: false, exclusive: true, encryption, valueEncoding: messages.OplogMessage }) await local.ready() this._updateLocalCore = local let runs = 0 while (!this._interrupting && this.appending && runs++ < 16) await this.update() await this._bump() } setWakeup(cap, discoveryKey) { if (this.wakeupSession) this.wakeupSession.destroy() if (!discoveryKey && b4a.equals(cap, this.key)) discoveryKey = this.discoveryKey this.wakeupSession = this.wakeupProtocol.session( cap, new WakeupHandler(this, discoveryKey || null) ) // incase this session has active peers already, bump the coupler for (const peer of this.wakeupSession.peers) { if (peer.active) this._bumpWakeupPeer(peer) } } async _getMigrationPointer(key, length) { const core = this.store.get({ key, active: false, encryption: null }) const encCore = await EncryptionView.setSystemEncryption(this, core) const min = core.manifest && core.manifest.prologue ? core.manifest.prologue.length : 0 for (let i = length - 1; i >= min; i--) { if (!(await core.has(i))) continue const sys = new SystemView(core, { checkout: i + 1 }) await sys.ready() let good = true for (const v of sys.views) { const vc = this.store.get({ key: v.key, active: false }) await vc.ready() if (vc.length < v.length) good = false await vc.close() } await sys.close() if (!good) continue return i + 1 } await core.close() if (encCore) await encCore.close() return min } // migrating from 6 -> latest async _migrate6(key, length) { const core = this.store.get({ key, active: false }) await core.ready() const batch = core.session({ name: 'batch', overwrite: true, checkout: length }) await batch.ready() await batch.close() await core.close() } // called by view-store for bootstrapping async _getSystemInfo() { const boot = await this._getBootRecord() if (!boot.key) return null const migrated = !!boot.heads const indexedLength = boot.systemLength if (migrated) { // ensure system batch is consistent on initial migration await this._migrate6(boot.key, indexedLength) } const core = this.store.get({ key: boot.key, encryption: null, active: false }) await core.ready() const batch = core.session({ name: 'batch' }) const encCore = await EncryptionView.setSystemEncryption(this, batch) await batch.ready() if (encCore) await encCore.ready() const info = await SystemView.getIndexedInfo(batch, indexedLength) if (encCore) await encCore.close() await batch.close() await core.close() if (info.version > MAX_AUTOBASE_VERSION) { throw new Error('Autobase upgrade required.') } // just compat if (migrated) { this.migrated = true for (const view of info.views) { // ensure any views ref'ed by system are consistent as well await this._migrate6(view.key, view.length) } if (boot.heads) this.hintWakeup(boot.heads) if (this.local.length) this.hintWakeup([{ key: this.local.key, length: this.local.length }]) } return { key: boot.key, indexers: info.indexers, views: info.views, entropy: info.entropy } } // called by the apply state for bootstrapping async _getBootRecord() { await this._preopen const pointer = await this.local.getUserData('autobase/boot') const boot = pointer ? c.decode(messages.BootRecord, pointer) : { version: BOOT_RECORD_VERSION, key: null, systemLength: 0, indexersUpdated: false, fastForwarding: false, recoveries: RECOVERIES, heads: null } if (boot.heads) { const len = await this._getMigrationPointer(boot.key, boot.systemLength) if (len !== boot.systemLength) this._warn( new Error( 'Invalid pointer in migration, correcting (' + len + ' vs ' + boot.systemLength + ')' ) ) boot.systemLength = len } return boot } static async getBootRecord(store, key) { const result = await boot(store, key, { exclusive: false }) await result.bootstrap.close() await result.local.close() return result.boot } _interrupt(reason) { assert(!!this._applyState.applying, 'Interrupt is only allowed in apply') this._interrupting = true if (reason) this.interrupted = reason throw INTERRUPT } async flush() { if (this._flushing === 0) return return this._flushSignal.wait() } async advance() { if (this.opened === false) await this.ready() await this._advancing } recouple() { if (this._coupler) this._coupler.destroy() const core = this._viewStore.getSystemCore() this._coupler = new CoreCoupler(core, this._wakeupPeerBound) } _updateBootstrapWriters() { const writers = this.linearizer.getBootstrapWriters() // first clear all, but without applying it for churn reasons for (const writer of this._bootstrapWriters) { writer.isBootstrap = false writer.isCoupled = false } // all passed are bootstraps for (const writer of writers) { writer.isCoupled = true writer.setBootstrap(true) } // reset activity on old ones, all should be in sync now for (const writer of this._bootstrapWriters) { if (writer.isBootstrap === false) writer.setBootstrap(false) } this._bootstrapWriters = writers this._bootstrapWritersChanged = false } async _openLinearizer() { if (this._applyState.system.bootstrapping) { await this._makeLinearizer(null) this._bootstrapLinearizer() return } await this._makeLinearizerFromViewState() } async _catchupApplyState() { if (await this._applyState.shouldMigrate()) { await this._migrate() } else if (!(await this._applyState.catchup(this.linearizer))) { return false } this._caughtup = true return true } async _open() { this._preopen = this._runPreOpen() await this._preopen if (this.closing) return this._applyState = new ApplyState(this) try { await this._applyState.ready() } catch (err) { if (this.closing) return try { await this._applyState.close() } catch {} try { await this.core.ready() } catch {} this._applyState = null if (this.closing) return throw err } try { await this._openLinearizer() await this.core.ready() await this._wakeup.ready() } catch (err) { if (this.closing) return throw err } if (this.core.length - this._applyState.indexedLength > this._ackTickThreshold) { this._ackTick = this._ackTickThreshold } if (this.localWriter && this._ackInterval) { this._startAckTimer() } this._updateBootstrapWriters() this.recouple() this._queueFastForward() // queue a full bump that handles wakeup etc (not legal to wait for that here) this._queueBump() } async _close() { await this.flush() // flush all pending non network io this._interrupting = true await Promise.resolve() // defer one tick if (this.wakeupSession) this.wakeupSession.destroy() if (this.wakeupOwner) this.wakeupProtocol.destroy() if (this.fastForwarding) await this.fastForwarding.close() if (this._coupler) this._coupler.destroy() this._coupler = null this._waiting.notify(null) await this.activeWriters.clear() const closing = this._advancing ? this._advancing.catch(safetyCatch) : null await this._clearWriters() if (this._primaryBootstrap) await this._primaryBootstrap.close() await this.local.close() if (this._ackTimer) { this._ackTimer.stop() await this._ackTimer.flush() } await this._wakeup.close() if (this._hasClose) await this._handlers.close(this.view) if (this._applyState) await this._applyState.close() await this._viewStore.close() await this.core.close() await this.store.close() if (this._writable) this._writable.resolve(false) await closing } getLastError() { return this._lastError } _onError(err) { if (this.closing) return this._lastError = err if (err === INTERRUPT) { this.emit('interrupt', this.interrupted) this.emit('update') return } this.close().catch(safetyCatch) // if no one is listening we should crash! we cannot rely on the EE here // as this is wrapped in a promise so instead of nextTick throw it if (ReadyResource.listenerCount(this, 'error') === 0) { crashSoon(err) return } this.emit('error', err) } async _closeWriter(w) { this.activeWriters.delete(w) await w.close() } async _gcWriters() { // just return early, why not if (this._checkWriters.length === 0) return while (this._checkWriters.length > 0) { const w = this._checkWriters.pop() // doesnt hurt w.updateActivity() if (!w.flushed()) continue const unqueued = this._wakeup.unqueue(w.core.key, w.core.length) if (!unqueued || w.isActiveIndexer) continue if (this.localWriter === w) continue await this._closeWriter(w) } await this._wakeup.flush() } _startAckTimer() { if (this._ackTimer) return this._ackTimer = new Timer(this._backgroundAck.bind(this), this._ackInterval) this._bumpAckTimer() } _bumpAckTimer() { if (!this._ackTimer) return this._ackTimer.bump() } async update() { if (this.opened === false) await this.ready() try { await this._bump() if (this._acking) await this._bump() // if acking just rebump incase it was triggered from above... } catch (err) { if (this._interrupting) return throw err } } // runs in bg, not allowed to throw // TODO: refactor so this only moves the writer affected to a updated set async _onremotewriterchange() { this._bumpAckTimer() try { await this._bump() } catch {} } _onlocalwriterchange() { if (!this.localWriter || this.localWriter.isRemoved) this._queueBump() } _onwakeup() { this._needsWakeup = true this._queueBump() } isFastForwarding() { if (this.fastForwardTo !== null) return true return this.fastForwardEnabled && this.fastForwarding !== null } _backgroundAck() { return this.ack(true) } async ack(bg = false) { if (this.opened === false) await this.ready() if (this.localWriter === null || this._acking || this._interrupting || this._appending !== null) return if (this._applyState === null) { try { await this._bump() } catch {} if (this._applyState === null || this._interrupting) return } const applyState = this._applyState if (applyState.opened === false) await applyState.ready() const isPendingIndexer = applyState.isLocalPendingIndexer() // if no one is waiting for our index manifest, wait for FF before pushing an ack if ((!isPendingIndexer && this.isFastForwarding()) || this._interrupting) return const isIndexer = applyState.isLocalIndexer() || isPendingIndexer if (!isIndexer) return this._acking = true try { await this._bump() } catch (err) { if (!this._interrupting) throw err } if (this._interrupting || !this.localWriter || this.localWriter.closed) { this._acking = false return } // avoid lumping acks together due to the bump wait here if (this._ackTimer && bg) await this._ackTimer.asapStandalone() if (this._interrupting || applyState.closing) { this._acking = false return } const alwaysWrite = isPendingIndexer || (await applyState.shouldWrite()) if (this._interrupting || applyState.closing) { this._acking = false return } const hasPendingIndexers = applyState.system.indexers.length > this.linearizer.indexers.length if (alwaysWrite || this.linearizer.shouldAck(this.localWriter, hasPendingIndexers)) { try { if (this.localWriter && !this.localWriter.closed) await this.append(null) } catch (err) { if (!this._interrupting) throw err } } if (!this._interrupting) { this._updateAckThreshold() this._bumpAckTimer() } this._acking = false } views() { if (this._applyState) return this._applyState.store.listViews() return this._viewStore.listViews() } batch() { return new AppendBatch(this) } async append(value, opts) { if (this.opened === false) await this.ready() if (this._advancing !== null) await this._advancing while (this.activeBatch) await this.activeBatch.flushed() return this._appendBatch(value, opts) } async _appendBatch(value, opts) { if (this._interrupting) throw new Error('Autobase is closing') if (value && this.valueEncoding !== BINARY_ENCODING) value = normalize(this.valueEncoding, value) const optimistic = !!opts && !!opts.optimistic && !!value // we wanna allow acks so interdexers can flush if ( !optimistic && (this.localWriter === null || (this.localWriter.isRemoved && value !== null)) ) { throw new Error('Not writable') } if (this._appending === null) this._appending = [] let len = 0 if (Array.isArray(value)) { for (const v of value) len = this._append(v) } else { len = this._append(value) } const localLength = this.local.length if (optimistic) this._optimistic = this._appending.length - 1 const target = this._appended + this._appending.length // await in case append is in current tick if (this._advancing) await this._advancing let runs = 0 // bump until we've flushed the nodes while (this._appended < target && !this._interrupting) { await this._bump() // safety if (runs++ >= 16 && this.localWriter && this.localWriter.idle()) break } if (this._advancing) await this._advancing if (this._interrupting) throw new Error('Autobase is closing') return localLength + len } _append(value) { // if prev value is an ack that hasnt been flushed, skip it if (this._appending.length > 0) { if (value === null) return this._appending.length if (this._appending[this._appending.length - 1] === null) { this._appending.pop() } } return this._appending.push(value) } static decodeValue(value, opts) { return decodeValue(value, opts) } static encodeValue(value, opts) { return encodeValue(value, opts) } static async getLocalKey(store, opts = {}) { const core = opts.keyPair ? store.get({ ...opts, active: false }) : store.get({ ...opts, name: 'local', active: false }) await core.ready() const key = core.key await core.close() return key } static getLocalCore(store, handlers, encryptionKey) { const encryption = !encryptionKey ? null : { key: encryptionKey } const opts = { ...handlers, compat: false, active: false, exclusive: true, valueEncoding: messages.OplogMessage, encryption } return opts.keyPair ? store.get(opts) : store.get({ ...opts, name: 'local' }) } static async getUserData(core) { const view = await core.getUserData('autobase/view') return { referrer: await core.getUserData('referrer'), view: view ? b4a.toString(view) : null } } static async isAutobase(core, opts = {}) { const block = await core.get(0, opts) if (!block) throw new Error('Core is empty.') if (!b4a.isBuffer(block)) return isAutobaseMessage(block) try { const m = c.decode(messages.OplogMessage, block) return isAutobaseMessage(m) } catch { return false } } // no guarantees where the user data is stored, just that its associated with the base async setUserData(key, val) { await this._preopen const core = this._primaryBootstrap === null ? this.local : this._primaryBootstrap await core.setUserData(key, val) } async getUserData(key) { await this._preopen const core = this._primaryBootstrap === null ? this.local : this._primaryBootstrap return await core.getUserData(key) } _needsLocalWriter() { return this.localWriter === null || this.localWriter.closed } // no guarantees about writer.isActiveIndexer property here async _getWriterByKey(key, len, seen, allowGC, isAdded, system) { assert(this._draining === true || (this.opening && !this.opened) || this._optimistic > -1) await this._lock.lock() if (this._interrupting) { this._lock.unlock() throw new Error('Autobase is closing') } try { let w = this.activeWriters.get(key) const alreadyActive = !!w const sys = system || this._applyState.system const writerInfo = await sys.get(key) if (len === -1) { if (!allowGC && writerInfo === null) { if (w) w.isRemoved = !isAdded return null } len = writerInfo === null ? 0 : writerInfo.length } const isActive = writerInfo !== null && (isAdded || !writerInfo.isRemoved) const isRemoved = !isActive if (w) { w.isRemoved = isRemoved } else { w = this._makeWriter(key, len, isActive, isRemoved) if (!w) return null } if (isRemoved && sys.bootstrapping && b4a.equals(w.core.key, this.key)) { w.isRemoved = false } if (this._isLocalCore(w.core) && this._needsLocalWriter()) { this._setLocalWriter(w) } w.seen(seen) if (alreadyActive) return w await w.ready() if (this._isLocalCore(w.core) && this._needsLocalWriter()) { this._setLocalWriter(w) } if (allowGC && w.flushed()) { this._wakeup.unqueue(key, len) if (w !== this.localWriter) { await w.close() return w } } this.activeWriters.add(w) this._checkWriters.push(w) assert(w.opened) assert(!w.closed) w.updateActivity() return w } finally { this._lock.unlock() } } _updateAll() { const p = [] for (const w of this.activeWriters) p.push(w.update(null).catch(safetyCatch)) return Promise.all(p) } getWriterEncryption() { if (!this.encryptionKey) return null return this.encryption.getWriterEncryption() } _makeWriterCore(key) { if (this.closing) throw new Error('Autobase is closing') if (this._interrupting) throw INTERRUPT() const local = b4a.equals(key, this.local.key) const encryption = this.getWriterEncryption() const core = local ? this.local.session({ valueEncoding: messages.OplogMessage, encryption, active: false }) : this.store.get({ key, compat: false, writable: false, valueEncoding: messages.OplogMessage, encryption, active: false }) return core } _makeWriter(key, length, isActive, isRemoved) { const core = this._makeWriterCore(key) const w = new Writer(this, core, length, isRemoved) if (this._isLocalCore(core)) { if (isActive) this._setLocalWriter(w) // only set active writer return w } core.on('append', this._onremotewriterchangeBound) core.on('download', this._onremotewriterchangeBound) core.on('manifest', this._onremotewriterchangeBound) return w } _updateLinearizer(indexers, heads) { // only current active indexers are reset to true below for (const w of this.activeWriters) w.isActiveIndexer = false if (this.localWriter) this.localWriter.isActiveIndexer = false for (const writer of indexers) writer.isActiveIndexer = true if (this._isActiveIndexer() && !this.isIndexer) { this._setLocalIndexer() } else if (!this._isActiveIndexer() && this.isIndexer) { this._clearLocalIndexer() } this.linearizer = new Linearizer(indexers, { heads, writers: this.activeWriters }) this._updateAckThreshold() } async _updateLocalWriter(sys) { if (this.localWriter !== null && !this.localWriter.closed) return await this._getWriterByKey(this.local.key, -1, 0, true, false, sys) } async _bootstrapLinearizer() { const bootstrap = this._makeWriter(this.key, 0, true, false) this.activeWriters.add(bootstrap) this._checkWriters.push(bootstrap) await bootstrap.ready() this._ensureWakeup(bootstrap) this._updateLinearizer([bootstrap], []) } async _makeLinearizer(sys) { if (sys === null) { return this._bootstrapLinearizer() } if (this.opened || (await sys.hasLocal(this.local.key))) { await this._updateLocalWriter(sys) } const indexers = [] for (const head of sys.indexers) { const writer = await this._getWriterByKey(head.key, head.length, 0, false, false, sys) indexers.push(writer) } if (!this._isActiveIndexer()) { for (const key of sys.pendingIndexers) { if (b4a.equals(key, this.local.key)) { this._setLocalIndexer() break } } } this._updateLinearizer(indexers, sys.heads) for (const { key, length } of sys.heads) { await this._getWriterByKey(key, length, 0, false, false, sys) } } async _clearWriters() { await this.activeWriters.clear() if (this.localWriter !== null) await this.localWriter.close() this._checkWriters = [] } async _moveTo() { assert(this._applyState.closed) for (const ref of this._viewStore.byName.values()) { if (!ref.moveTo) continue const [batch, next] = ref.moveTo ref.moveTo = null await ref.batch.state.moveTo(batch, batch.length) await batch.close() ref.migrated(this, next) } } async _makeLinearizerFromViewState() { const sys = await this._applyState.getIndexedSystem() await this._makeLinearizer(sys) await sys.close() } async _runForceFastForward() { await this.core.ready() if (this.closing) return const rec = this._applyState ? await this._applyState.recoverAt() : null await this._runFastForward( new FastForward(this, this.core.key, { force: true, length: rec ? rec.length : 0 }) ) } // general repair method for trying to recover async repair() { await this.forceFastForward() } async forceFastForward() { if (this.isFastForwarding()) return await this._runForceFastForward() await this.update() } async _applyFastForward() { if ( !this.fastForwardTo.force && this.fastForwardTo.length < this.core.length + this.fastForwardTo.minimum ) { this.fastForwardTo = null this._updateActivity() // still not worth it return } const changes = this._hasUpdate ? new UpdateChanges(this) : null if (changes) changes.track(this._applyState) // close existing state if (this._applyState) await this._applyState.close() const { key, length, views, indexers, manifestVersion, entropy } = this.fastForwardTo const from = this.core.signedLength const ffed = new Set() this._flushing++ try { const store = this._viewStore.atomize() const systemRef = await this._viewStore.findViewByKey(key, indexers, manifestVersion, entropy) const migrated = !b4a.equals(key, systemRef.core.key) ffed.add(systemRef) if (migrated) { await this._applyFastForwardMigration(systemRef, { key, length }) } else { await systemRef.catchup(store.atom, length) } for (const v of views) { const ref = await this._viewStore.findViewByKey(v.key, indexers, manifestVersion, entropy) if (!ref) continue // unknown, view ignored const migrated = !b4a.equals(ref.core.key, v.key) ffed.add(ref) if (migrated) { await this._applyFastForwardMigration(ref, v) } else { await ref.catchup(store.atom, v.length) } } if (ffed.size !== store.getViewCount()) { for (const ref of store.getViews()) { if (ffed.has(ref)) continue await ref.catchup(store.atom, 0) // its gone } } // migrate zero length cores if (migrated) { const manifests = await this._viewStore.getIndexerManifests(indexers) for (const [name, ref] of this._viewStore.byName) { if (ffed.has(ref)) continue await this._migrateView(manifests, null, name, 0, manifestVersion, entropy, [], null) } } const value = c.encode(messages.BootRecord, { version: BOOT_RECORD_VERSION, key, systemLength: length, indexersUpdated: false, fastForwarding: true, recoveries: RECOVERIES }) const local = store.getLocal() await local.ready() await local.setUserData('autobase/boot', value) await LocalState.clear(local) await store.flush() await store.close() } finally { if (--this._flushing === 0) this._flushSignal.notify() } for (const ref of this._viewStore.byName.values()) await ref.release() this.recoveries = RECOVERIES this.fastForwardTo = null this._queueFastForward() await this._clearWriters() await this._moveTo() const to = this.core.signedLength if (changes) changes.finalise() this._applyState = new ApplyState(this) await this._applyState.ready() if (changes) await this._handlers.update(this._applyState.view, changes) if (await this._applyState.shouldMigrate()) { await this._migrate() } else { await this._makeLinearizerFromViewState() await this._applyState.catchup(this.linearizer) } if (!this.localWriter || this.localWriter.closed) { await this._updateLocalWriter(this._applyState.system) } this._caughtup = true this._rebooted() this.emit('fast-forward', to, from) } // TODO: not atomic in regards to the ff, fix that async _applyFastForwardMigration(ref, v) { await ref.batch.ready() const next = this.store.get(v.key) await next.ready() const prologue = next.manifest && next.manifest.prologue if (prologue && prologue.length > 0 && ref.core.length >= prologue.length) { try { await next.core.copyPrologue(ref.core.state) } catch { // we might be missing some nodes for this, just ignore, only an optimisation } } const batch = next.session({ name: 'batch', overwrite: true, checkout: v.length }) await batch.ready() // remake the batch, reset from our prologue in case it replicated inbetween // TODO: we should really have an HC function for this ref.moveTo = [batch, next] } async _migrateView( indexerManifests, source, name, indexedLength, manifestVersion, entropy, linked, manifestData ) { const ref = this._viewStore.byName.get(name) await ref.batch.ready() const prologue = indexedLength === 0 ? null : { length: indexedLength, hash: await source.treeHash(indexedLength) } if (manifestData === null && ref.core.manifest.userData !== null) { manifestData = ref.core.manifest.userData } const next = this._viewStore.getViewCore( indexerManifests, name, prologue, manifestVersion, entropy, linked, manifestData ) await next.ready() if (indexedLength > 0) { await next.core.copyPrologue(source.state) } // remake the batch, reset from our prologue in case it replicated inbetween // TODO: we should really have an HC function for this const batch = next.session({ name: 'batch', overwrite: true, checkout: indexedLength }) await batch.ready() if (source !== null) { while (batch.length < source.length) { await batch.append(await source.get(batch.length)) } } ref.moveTo = [batch, next] return ref } async _premigrate() { this._flushing++ try { const length = this._applyState.indexedLength const system = this._applyState.system const info = await system.getIndexedInfo(length) const indexerManifests = await this._viewStore.getIndexerManifests(info.indexers) const { views, systemView, encryptionView } = this._applyState const manifestVersion = this._applyState.system.core.manifest.version for (const view of views) { const v = this._applyState.getViewFromSystem(view, info) const indexedLength = v ? v.length : 0 const ref = this._viewStore.getViewByName(view.name) const source = ref.getCore() await source.ready() await this._migrateView( indexerManifests, source, view.name, indexedLength, manifestVersion, info.entropy, null, null ) } const source = encryptionView.ref.getCore() await source.ready() const enc = await this._migrateView( indexerManifests, source, '_encryption', info.encryptionLength, manifestVersion, info.entropy, null, null ) const linked = [enc.core.key] const sysCore = systemView.ref.getCore() const ref = await this._migrateView( indexerManifests, sysCore, '_system', length, manifestVersion, info.entropy, linked, null, null ) const sysKey = ref.getNextKey() if (sysKey === null) { throw new Error('Migration failed, expected core to be moved') } return sysKey } finally { if (--this._flushing === 0) this._flushSignal.notify() } } async _migrate() { return this._reboot(await this._premigrate()) } async _reboot(key) { await this._clearWriters() await this._makeLinearizerFromViewState() await this._applyState.finalize(key) await this._moveTo() this._applyState = new ApplyState(this) await this._applyState.ready() await this._applyState.catchup(this.linearizer) // end soft shutdown this._queueFastForward() this._rebooted() } _rebooted() { this.recouple() this._updateActivity() this.emit('reboot') // ensure we re-evalute our state this._bootstrapWritersChanged = true this._needsWakeup = true this.updating = true this._queueBump() } _setLocalWriter(w) { this.localWriter = w if (this._ackInterval) this._startAckTimer() } _unsetLocalWriter() { if (!this.localWriter) return this._closeWriter(this.localWriter) if (this.localWriter.isActiveIndexer) this._clearLocalIndexer() this.localWriter = null } _setLocalIndexer() { assert(this.localWriter !== null) this.isIndexer = true this.emit('is-indexer') } _clearLocalIndexer() { assert(this.localWriter !== null) if (this._ackTimer) this._ackTimer.stop() this.isIndexer = false this._ackTimer = null this.emit('is-non-indexer') } _isLocalCore(core) { return core.writable && core.id === this.local.id } _addLocalHeads() { // not writable atm, will prop be writable in a subsequent bump tho if (!this.localWriter || this.localWriter.closed) return null // safety, localwriter is still processing, should prop be an assertion if (!this.localWriter.idle()) return null const length = this._optimistic === -1 ? this._appending.length : this._optimistic || 1 const nodes = new Array(length) for (let i = 0; i < length; i++) { const heads = this.linearizer.getHeads() const deps = new Set(this.linearizer.heads) const batch = length - i const value = this._appending[i] const node = this.localWriter.append(value, heads, batch, deps, this._optimistic === 0) this.linearizer.addHead(node) nodes[i] = node } return nodes } _flushLocalHeads(length) { this._appending = length === this._appending.length ? null : this._appending.slice(length) this._appended += length if (this._optimistic > -1 && this._optimistic < length) this._optimistic = -1 } async _addRemoteHeads() { let added = 0 while ( added < REMOTE_ADD_BATCH || (this.bigBatches && !this._indexersIdle() && added < REMOTE_ADD_BATCH_SANITY) ) { await this._updateAll() let advanced = 0 for (const w of this.activeWriters) { let node = w.advance() if (node === null) continue advanced += node.batch while (true) { this.linearizer.addHead(node) if (node.batch === 1) break node = w.advance() } } if (advanced === 0) { if (this.bigBatches && !this._indexersIdle() && (await this._waitForIndexers())) continue break } added += advanced } return added } async _waitForIndexers() { const promises = [] for (const w of this.linearizer.indexers) { if (w.idle()) continue if (await w.core.has(w.length)) continue promises.push(w.core.get(w.length, { timeout: 3000 })) } for (const result of await Promise.allSettled(promises)) { if (result.status !== 'rejected') return true } return false } _indexersIdle() { for (const w of this.linearizer.indexers) { if (!w.idle()) return false } return true } async _drain() { const writable = this.writable while (!this._interrupting && !this.paused) { if (this.local.recovering) { try { await this.local.recover() } catch { await this._runForceFastForward() } continue } if (this.fastForwardTo !== null) { await this._applyFastForward() continue // revaluate conditions... } // we defer this to post ready so its not blocking reading the views if (this._caughtup === false) { // if the catchup fails, just force ff it to recover, less user pain if (!(await this._catchupApplyState())) { await this._runForceFastForward() } continue } const remoteAdded = await this._addRemoteHeads() const localNodes = this._appending !== null ? this._addLocalHeads() : null if (this._interrupting) return if (remoteAdded > 0 || localNodes !== null) { this.updating = true } const u = this.linearizer.update() const update = u ? await this._applyState.update(u, localNodes) : { reboot: false, migrated: false } if (localNodes) this._flushLocalHeads(localNodes.length) if (!update.reboot) { if (this._applyState.shouldFlush()) { await this._applyState.flush() this.updating = true } if (this._checkWriters.length > 0) { await this._gcWriters() continue // rerun the update loop as a writer might have been added } if (remoteAdded >= REMOTE_ADD_BATCH) continue break } await this._gcWriters() await this._reboot(this._applyState.key) } // emit state changes post drain if (writable !== this.writable) { if (this.writable && this._writable) this._writable.resolve(true) this.emit(writable ? 'unwritable' : 'writable') } } _wakeupPeer(stream) { if (!this.wakeupSession) return const wakeup = this._getWakeup() if (wakeup.length === 0) return this.wakeupSession.announceByStream(stream, wakeup) } _getWakeup() { const writers = [] for (const w of this.activeWriters) { if (w.isActiveIndexer || w.flushed()) continue writers.push({ key: w.core.key, length: w.length }) } return writers } async _wakeupWriter(key, length) { this._ensureWakeup(await this._getWriterByKey(key, -1, length, true, false, null)) } // ensure wakeup on an existing writer (the writer calls this in addition to above) _ensureWakeup(w) { if (w === null || w.isBootstrap === true) return w.setBootstrap(true) // even if turn false at end of drain, hypercore makes them linger a bit so no churn this._bootstrapWriters.push(w) this._bootstrapWritersChanged = true } async _drainWakeup() { const promises = [] // warmup all the below gets if (this._needsWakeup) { for (const { key, length } of this._wakeup) { const w = this.activeWriters.get(key) if (w) { if (w.length < length) w.seen(length) continue } promises.push(this._applyState.system.get(key)) } if (this._needsWakeupHeads) { for (const { key } of await this._applyState.system.heads) { if (this.activeWriters.has(key)) continue promises.push(this._applyState.system.get(key)) } } } for (const [hex, length] of this._wakeupHints) { const key = b4a.from(hex, 'hex') if (length !== -1) { const w = this.activeWriters.get(key) if (w) { if (w.length < length) w.seen(length) continue } } promises.push(this._applyState.system.get(key)) } await Promise.allSettled(promises) if (this._needsWakeup === true) { this._needsWakeup = false for (const { key, length } of this._wakeup) { if (this.activeWriters.has(key)) continue await this._wakeupWriter(key, length) } if (this._needsWakeupHeads === true) { this._needsWakeupHeads = false for (const { key } of await this._applyState.system.heads) { if (this.activeWriters.has(key)) continue await this._wakeupWriter(key, 0) } } } for (const [hex, length] of this._wakeupHints) { const key = b4a.from(hex, 'hex') if (this.activeWriters.has(key)) continue if (length !== -1) { const info = await this._applyState.system.get(key) if (info && length <= info.length) continue // stale hint } await this._wakeupWriter(key, length === -1 ? 0 : length) } this._wakeupHints.clear() } pause() { this.paused = true } resume() { this.paused = false this._queueBump() } waitForWritable() { if (this.writable) return Promise.resolve(true) if (!this._writable) this._writable = rrp() return this._writable.promise } async _drainWithInterupt() { while (true) { try { await this._drain() return } catch (err) { if (this.closing || !this.fastForwardTo) throw err if (Date.now() - this.fastForwardFailedAt < MIN_FF_WAIT) throw err this.fastForwardFailedAt = Date.now() // if an FF is enabled retry } } } async _advance() { if (this.opened === false) await this.ready() if (this.paused || this._interrupting) return this._draining = true if (this._updateLocalCore !== null) { await this._rotateLocalWriter(this._updateLocalCore) } const local = this.local.length try { await this._drainWithInterupt() // must run post drain so the linearizer is caught up if (this._caughtup && (this._needsWakeup === true || this._wakeupHints.size > 0)) await this._drainWakeup() // check if we should update local writer if (!this.localWriter || this.localWriter.closed) { await this._updateLocalWriter(this._applyState.system) } this._draining = false } catch (err) { this._onError(err) return } if (this._interrupting) return if (this.localWriter && !this.localWriter.closed) { if (this._applyState.isLocalPendingIndexer()) this.ack().catch(noop) else if (this._triggerAckAsap()) this._ackTimer.asap() } // keep bootstraps in sync with linearizer if (this.updating === true || this._bootstrapWritersChanged === true) { this._updateBootstrapWriters() } if (this.updating === true) { this.updating = false if (local !== this.local.length) this._resetAckTick() else this._ackTick++ if (!this._interrupting) this.emit('update') this._waiting.notify(null) } if (!this._interrupting) await this._gcWriters() } _triggerAckAsap() { if (!this._ackTimer) return false // flush if threshold is reached and we are not already acking if (this._ackTickThreshold && !this._acking && this._ackTick >= this._ackTickThreshold) { if (this._ackTimer) { for (const w of this.linearizer.indexers) { if (w.core.length > w.length) return false // wait for the normal ack cycle in this case } } return true } return false } _queueFastForward() { if (!this.core.opened) return // should have a better way to get this const latestSignedLength = this.core.core.state.length if (!this.fastForwardEnabled || this.fastForwarding !== null || this._interrupting) return if (latestSignedLength - this.core.length < this.fastForwardMinimum) return if (this.fastForwardTo !== null) return if (Date.now() - this.fastForwardFailedAt < MIN_FF_WAIT) return this._runFastForward( new FastForward(this, this.core.key, { minimum: this.fastForwardMinimum }) ).catch(noop) } _queueStaticFastForward(key) { if (!this.fastForwardEnabled || this.fastForwarding !== null || this._interrupting) return if (this.fastForwardTo !== null) return if (Date.now() - this.fastForwardFailedAt < MIN_FF_WAIT) return this._runFastForward(new FastForward(this, key, { verified: false })).catch(noop) } _updateActivity() { this.activeWriters.updateActivity() if (this._applyState) { if (this.isFastForwarding()) this._applyState.pause() else this._applyState.resume() } // in case we ignored wakeups case we were fast forwarding, request them now if not if (this._needsWakeupRequest && !this.isFastForwarding() && this.wakeupSession) { this._needsWakeupRequest = false this.wakeupSession.broadcastLookup({}) } } _preferFastForward() { this.fastForwardMinimum = 1 this._queueFastForward() } _postApply() { this.fastForwardMinimum = FastForward.MINIMUM } async _runFastForward(ff) { this.fastForwarding = ff this._updateActivity() const result = await ff.upgrade() await ff.close() if (this.fastForwarding === ff) this.fastForwarding = null if (!result) { if (ff.failed) this.fastForwardFailedAt = Date.now() else this._queueFastForward() this._updateActivity() return } this.fastForwardFailedAt = 0 this.fastForwardTo = result if (this._applyState && this._applyState.applying && this.fastForwardMinimum === 1) { await this._applyState.close() } this._bumpAckTimer() this._queueBump() } // triggered from apply async _addWriter(key, sys) { // just compat for old version assert(!!this._applyState.applying, 'System changes are only allowed in apply') const writer = (await this._getWriterByKey(key, -1, 0, false, true, sys)) || this._makeWriter(key, 0, true, false) await writer.ready() if (!this.activeWriters.has(key)) { this.activeWriters.add(writer) this._checkWriters.push(writer) this._ensureWakeup(writer) } // fetch any nodes needed for dependents this._queueBump() } // triggered from apply _removeWriter(key) { // just compat for old version const w = this.activeWriters.get(key) if (w) w.isRemoved = true this._queueBump() } removeable(key) { return this._applyState ? this._applyState.removeable(key) : false } _updateAckThreshold() { if (this._ackThreshold === 0) return if (this._ackTimer) this._ackTimer.bau() this._ackTick = 0 this._ackTickThreshold = random2over1(this.linearizer.indexers.length * this._ackThreshold) } _resetAckTick() { this._ackTick = 0 if (this._ackTimer) this._ackTimer.bau() } _shiftWriter(w) { w.shift() if (w.flushed()) this._checkWriters.push(w) } } function toKey(k) { return b4a.isBuffer(k) ? k : hypercoreId.decode(k) } function isAutobaseMessage(msg) { return msg.checkpoint ? msg.checkpoint.length > 0 : msg.checkpoint === null } function compareNodes(a, b) { return b4a.compare(a.key, b.key) } function random2over1(n) { return Math.floor(n + Math.random() * n) } function noop() {} function crashSoon(err) { queueMicrotask(() => { throw err }) throw err } function isObject(obj) { return typeof obj === 'object' && obj !== null } function emitWarning(err) { safetyCatch(err) this.emit('warning', err) } function normalize(valueEncoding, value) { const state = { buffer: null, start: 0, end: 0 } valueEncoding.preencode(state, value) state.buffer = b4a.allocUnsafe(state.end) valueEncoding.encode(state, value) state.start = 0 return valueEncoding.decode(state) } const b4a = require('b4a') module.exports = class ActiveWriters { constructor() { this.map = new Map() } get size() { return this.map.size } [Symbol.iterator]() { return this.map.values() } get(key) { return this.map.get(b4a.toString(key, 'hex')) || null } has(key) { return this.get(key) !== null } add(writer) { this.map.set(b4a.toString(writer.core.key, 'hex'), writer) } delete(writer) { this.map.delete(b4a.toString(writer.core.key, 'hex')) } updateActivity() { for (const w of this.map.values()) w.updateActivity() } clear() { const p = [] for (const w of this.map.values()) p.push(w.close()) this.map.clear() return Promise.all(p) } } const SignalPromise = require('signal-promise') module.exports = class AppendBatch { constructor(base) { this.base = base this.blocks = [] this.closed = false this.flushing = false this._flushed = null } async _acquire() { while (this.base.activeBatch !== null && this.base.activeBatch !== this) await this.base.activeBatch.flushed() this.base.activeBatch = this } async append(value) { if (this.base.opened === false) await this.base.ready() if (this.base._advancing !== null) await this.base._advancing if (this.closed) throw new Error('Batch is closed') if (this.base.activeBatch !== this) await this._acquire() if (this.closed) throw new Error('Batch is closed') this.blocks.push(value) return this.base.local.length + this.blocks.length } async flush() { if (this.closed) throw new Error('Batch is closed') if (this.flushing) return this.flushed() this.flushing = true if (this.blocks.length) await this.base._appendBatch(this.blocks) return this.close() } flushed() { if (this.closed) return Promise.resolve() if (this._flushed) return this._flushed.wait() this._flushed = new SignalPromise() return this._flushed.wait() } close() { if (this.base.activeBatch !== this) return this.base.activeBatch = null this.closed = true if (this._flushed) this._flushed.notify(null) } } class PublicApplyCalls { constructor(base) { this.base = base this.internal = false } get discoveryKey() { return this.base.discoveryKey } get key() { return this.base.key } get id() { return this.base.id } async addWriter() { throw new Error('Not allowed on the public view') } async ackWriter() { throw new Error('Not allowed on the public view') } async removeWriter() { throw new Error('Not allowed on the public view') } preferFastForward() { throw new Error('Not allowed on the public view') } interrupt() { throw new Error('Not allowed on the public view') } removeable() { throw new Error('Not allowed on the public view') } fork() { throw new Error('Not allowed on the public view') } anchor() { throw new Error('Not allowed on the public view') } } class PrivateApplyCalls extends PublicApplyCalls { constructor(state) { super(state.base) this.state = state this.internal = true } get system() { return this.state.system } async addWriter(key, { indexer = true, isIndexer = indexer } = {}) { // just compat for old version await this.state.system.add(key, { isIndexer }) await this.base._addWriter(key, this.state.system) } async ackWriter(key) { await this.state.system.ack(key) } async removeWriter(key) { // just compat for old version if (!this.state.removeable(key)) { throw new Error('Not allowed to remove the last indexer') } await this.state.system.remove(key) this.base._removeWriter(key) } preferFastForward() { this.base._preferFastForward() } interrupt(reason) { this.base._interrupt(reason) } removeable(key) { return this.state.removeable(key) } async fork(indexerKeys, system) { if (!(await this.state.validateFork(indexerKeys, system))) return false const indexers = indexerKeys.map(toIndexer) this.state.pendingFork = { indexers, length: system.length } return true } async createAnchor() { return await this.state.createAnchor() } } module.exports = { PublicApplyCalls, PrivateApplyCalls } function toIndexer(key) { return { key, length: 0 } // length is not used, just for api compat } const ReadyResource = require('ready-resource') const assert = require('nanoassert') const c = require('compact-encoding') const crypto = require('hypercore-crypto') const b4a = require('b4a') const safetyCatch = require('safety-catch') const Hypercore = require('hypercore') const { partialSignature } = require('hypercore/lib/multisig.js') const SystemView = require('./system.js') const { AutobaseEncryption, EncryptionView } = require('./encryption.js') const UpdateChanges = require('./updates.js') const messages = require('./messages.js') const { PrivateApplyCalls } = require('./apply-calls.js') const { encodeValue } = require('./values.js') const Fork = require('./fork.js') const LocalState = require('./local-state.js') const { OPLOG_VERSION, BOOT_RECORD_VERSION } = require('./caps.js') // todo: expose this as an option const SHOULD_SIGN_THRESHOLD = 0 class CheckpointCore { constructor(view, core, signer, paused) { this.view = view this.core = core this.signer = signer this.length = 0 this.digest = null this.signatures = { system: null, encryption: null, user: [] } this.closed = false this.paused = paused } pause() { this.paused = true } resume() { if (!this.paused) return this.paused = false this.updateBackground() } async update() { if (await this.updateCheckpoints()) await this.view.maybeSigned() } async updateCheckpoints() { if (this.core.length <= this.length || this.closed || this.paused) return false const length = this.core.length const value = await this.core.get(length - 1) if (length <= this.length || this.closed || !value.digest || this.paused) return false const [digest, checkpoints] = await Promise.all([ this._inflateDigest(length, value.digest), this._inflateAllCheckpoints(length, value.checkpoint) ]) if (length <= this.length || this.closed || !digest || !checkpoints || this.paused) return false for (let i = 0; i < checkpoints.length; i++) { if (checkpoints[i] === null) return false } this.length = length this.digest = digest this.signatures = checkpoints return true } updateBackground() { return this.update().catch(safetyCatch) } updateInternalSignatures(length, signatures) { this.signatures.system = updateSignature(length, signatures.system, this.signatures.system) this.signatures.encryption = updateSignature( length, signatures.encryption, this.signatures.encryption ) } updateUserSignatures(length, signatures) { this.signatures.user = updateSignatures(length, signatures, this.signatures.user) } makeCheckpoints(length) { return { system: makeCheckpoint(length, this.signatures.system), encryption: makeCheckpoint(length, this.signatures.encryption), user: makeCheckpoints(length, this.signatures.user) } } makeDigest(length, key) { if (this.digest && (this.digest.key === key || b4a.equals(this.digest.key, key))) { return { key: null, pointer: length - this.digest.at } } this.digest = { key, at: length } return { key, pointer: 0 } } async ready() { await this.core.ready() this.core.on('append', this.updateBackground.bind(this)) if (this.core.writable) await this.updateCheckpoints() this.updateBackground() } signedLength() { return this.signatures.system ? this.signatures.system.length : 0 } close() { this.closed = true return this.core.close() } async _inflateDigest(length, dig) { if (!dig) return null if (dig.pointer === 0) { return { key: dig.key, at: length } } const len = length - dig.pointer if (this.digest && len === this.digest.at) return this.digest if (len <= 0) return null const { digest } = await this.core.get(len - 1) if (!digest || !digest.key) return null return { key: digest.key, at: len } } _sameSignatures(b, a) { return ( sameSignature(a.system, b.system) && sameSignature(a.encryption, b.encryption) && sameSignatures(a.user, b.user) ) } async _inflateAllCheckpoints(length, checkpoints) { if (!checkpoints) return { system: null, encryption: null, user: [] } if (this._sameSignatures(checkpoints, this.signatures)) return this.signatures const system = this._inflateSystemCheckpoint(checkpoints.system, length) const encryption = this._inflateEncryptionCheckpoint(checkpoints.encryption, length) const user = checkpoints.user ? new Array(checkpoints.user.length) : [] for (let i = 0; i < user.length; i++) { const chk = checkpoints.user[i] user[i] = this._inflateUserCheckpoint(chk, i, length) } const [systemCheckpoint, encryptionCheckpoint, userCheckpoints] = await Promise.all([ system, encryption, Promise.all(user) ]) return { system: systemCheckpoint, encryption: encryptionCheckpoint, user: userCheckpoints } } async _inflateSystemCheckpoint(chk, coreLength) { if (chk.checkpoint) { const { signature, length } = chk.checkpoint return { signature, length, at: coreLength } } const len = coreLength - chk.checkpointer if (this.signatures.system && this.signatures.system.at === len) { return this.signatures.system } if (len <= 0) return null const { checkpoint } = await this.core.get(len - 1) if (!checkpoint || !checkpoint.system || !checkpoint.system.checkpoint) return null const { signature, length } = checkpoint.system.checkpoint return { signature, length, at: len } } async _inflateEncryptionCheckpoint(chk, coreLength) { if (!chk) return { length: 0, signature: null, at: 0 } if (chk.checkpoint) { const { signature, length } = chk.checkpoint return { signature, length, at: coreLength } } const len = coreLength - chk.checkpointer if (this.signatures.encryption && this.signatures.encryption.at === len) { return this.signatures.encryption } if (len <= 0) return null const { checkpoint } = await this.core.get(len - 1) if (!checkpoint || !checkpoint.encryption || !checkpoint.encryption.checkpoint) return null const { signature, length } = checkpoint.encryption.checkpoint return { signature, length, at: len } } async _inflateUserCheckpoint(chk, i, coreLength) { if (chk.checkpoint) { const { signature, length } = chk.checkpoint return { signature, length, at: coreLength } } const len = coreLength - chk.checkpointer if (i < this.signatures.user.length && this.signatures.user[i].at === len) { return this.signatures.user[i] } if (len <= 0) return null const { checkpoint } = await this.core.get(len - 1) if (!checkpoint || i >= checkpoint.user.length || !checkpoint.user[i].checkpoint) return null const { signature, length } = checkpoint.user[i].checkpoint return { signature, length, at: len } } } module.exports = class ApplyState extends ReadyResource { constructor(base) { super() this.base = base this.encryption = this.base.encryption this.valueEncoding = base.valueEncoding this.store = base._viewStore.atomize() this.key = null this.system = null this.view = null this.views = [] this.systemView = null this.encryptionView = null this.hostcalls = null this.changes = base._hasUpdate ? new UpdateChanges(base) : null this.updates = [] this.local = null this.localState = null this.fastForwarding = false this.indexersUpdated = false this.quorum = 0 this.needsIndexedLengthUpdate = false this.interrupted = false this.applying = null this.applyBatch = null this.localCheckpoint = null this.localIndexer = false this.systemUpgrade = null this.checkpoints = [] this.pendingViews = null this.pendingFork = null this.dirty = false } shouldFlush() { return this.dirty } async shouldWrite() { if (!this.localIndexer || !this.localCheckpoint || !this.localCheckpoint.core.opened) { return false } const info = await this.system.getIndexedInfo(this.indexedLength) if (!info.views.length) return false const { encryption, user } = this.localCheckpoint.signatures // todo: does this condition hold for soft-fork? if (info.views.length > user.length) return true for (let i = 0; i < info.views.length; i++) { if (user[i].length + SHOULD_SIGN_THRESHOLD < info.views[i].length) return true } // always flush encryption signature if (info.encryptionLength !== 0) { if (!encryption || encryption.length < info.encryptionLength) return true } return false } get indexedLength() { return this.systemView ? this.systemView.indexedLength : 0 } get systemRef() { return this.systemView ? this.systemView.ref : null } async validateFork(indexerKeys, system) { if (!b4a.equals(system.key, this.system.core.key)) return false if (this.pendingIndexedLength() < system.length) return false for (const key of indexerKeys) { const info = await this.system.get(key) // writer should be active and we need manifest if (!info || !info.length || info.isRemoved) return false } return true } async shouldMigrate() { if (!this.fastForwarding && !this.indexersUpdated) return false if (this.system.indexers.length === 0) return false // genesis // sanity, prefer migration if (!this.system.core.manifest || !this.system.core.manifest.signers) return true // easy mode if (this.system.indexers.length !== this.system.core.manifest.signers.length) { return true } const manifests = await this.store.getIndexerManifests(this.system.indexers) for (let i = 0; i < this.system.core.manifest.signers.length; i++) { const { publicKey } = this.system.core.manifest.signers[i] if (!b4a.equals(publicKey, manifests[i].signers[0].publicKey)) return true } return false } isLocalPendingIndexer() { if (this.system.pendingIndexers.length === 0) return false const key = this.base.local.key for (const k of this.system.pendingIndexers) { if (b4a.equals(k, key)) return !b4a.equals(this.base.key, key) && this.base.local.length === 0 } return false } removeable(key) { if (this.system.indexers.length !== 1) return true return !b4a.equals(this.system.indexers[0].key, key) } isLocalIndexer() { return !!this.localCheckpoint } _createCheckpointCore(key, active, signer, paused) { const encryption = this.base.getWriterEncryption(key) const session = this.base.store.get({ key, valueEncoding: messages.OplogMessage, encryption, active }) return new CheckpointCore(this, session, signer, paused) } async _openInternalView(name, indexedLength) { const core = this.store.get({ name }) await core.ready() await core.setUserData('referrer', this.base.key) await core.setUserData('autobase/view', b4a.from(name)) const ref = this.store.getViewByName(name) return { ref, core, indexedLength } } async _open() { try { await this._boot() } catch (err) { if (isViewCorruption(err)) { for (const v of this.store.opened) { await v.core.ready() await v.core.state.storage.deleteSessions() } if (this.systemView) { const core = this.systemView.ref.core await core.ready() await core.state.storage.deleteSessions() } if (this.encryptionView) { const core = this.encryptionView.ref.core await core.ready() await core.state.storage.deleteSessions() } await LocalState.clear(this.base.local) } await this._free() throw err } } async _boot() { const boot = await this.base._getBootRecord() this.systemView = await this._openInternalView('_system', boot.systemLength) this.encryptionView = await this._openInternalView('_encryption', -1) const sysCore = this.systemView.core if (sysCore.manifest.version >= 2) { if (this.encryption !== null) await this.encryption.reload(this.encryptionView.core) } const system = new SystemView(sysCore) await system.ready() // reset so we dont track _system or _encryption this.store.opened = [] this.hostcalls = new PrivateApplyCalls(this) const view = this.base._hasOpen ? this.base._handlers.open(this.store, this.hostcalls) : null this.view = view this.system = system // ensure all are ready for (const v of this.store.opened) await v.atomicBatch.ready() this.key = system.core.key this.fastForwarding = boot.fastForwarding this.indexersUpdated = boot.indexersUpdated this.quorum = sysCore.manifest ? sysCore.manifest.quorum : 0 const added = new Set() for (let i = 0; i < system.views.length; i++) { const { key, length } = system.views[i] const v = await this.store.findViewByKey( key, system.indexers, sysCore.manifest.version, system.entropy ) if (v === null) { this.views.push({ name: null, key, length, core: null, ref: null, mappedIndex: i }) continue } await v.atomicBatch.ready() await v.core.setUserData('referrer', this.base.key) await v.core.setUserData('autobase/view', b4a.from(v.name)) this.views.push({ name: v.name, key, length, core: v.atomicBatch, ref: v, mappedIndex: i }) added.add(v) } for (const v of this.store.opened) { if (added.has(v)) continue const core = v.atomicBatch this.views.push({ name: v.name, key: core.key, length: core.length, core, ref: v, mappedIndex: -1 }) } this.local = this.store.getLocal() await this.local.ready() this.localState = new LocalState(this.local) let isLocalIndexer = false const paused = this.base.isFastForwarding() const inf = await this.system.getIndexedInfo() for (let i = 0; i < inf.indexers.length; i++) { const idx = inf.indexers[i] const chk = this._createCheckpointCore(idx.key, true, i, paused) await chk.ready() this.checkpoints.push(chk) if (b4a.equals(idx.key, this.base.local.key)) isLocalIndexer = true } const shouldSign = this.quorum > 0 && isLocalIndexer if (shouldSign) { this.localIndexer = true await this._startLocalCheckpoint() } await this._refreshWriters() // deferred this.maybeSigned().catch(noop) } async _startLocalCheckpoint() { for (const chk of this.checkpoints) { if (chk.core.id === this.base.local.id) { this.localCheckpoint = chk return } } this.localCheckpoint = this._createCheckpointCore(this.base.local.key, false, 0, false) await this.localCheckpoint.ready() } interrupt() { this.interrupted = true this.pause() } pause() { for (const chk of this.checkpoints) { if (chk !== this.localCheckpoint) chk.pause() } } resume() { for (const chk of this.checkpoints) { if (chk !== this.localCheckpoint) chk.resume() } } _checkSystemUpgrade() { if (this.systemUpgrade) return const tally = new Map() for (const chk of this.checkpoints) { if (chk.signedLength() <= this.system.core.signedLength) continue if (!chk.digest) continue const id = b4a.toString(chk.digest.key, 'hex') const cnt = (tally.get(id) || 0) + 1 if (cnt >= this.quorum) { this.systemUpgrade = chk.digest.key this.base._queueStaticFastForward(this.systemUpgrade) return } tally.set(id, cnt) } } mapIndexToView(index) { for (const { mappedIndex, ref } of this.views) { if (mappedIndex === index) return ref } } async maybeSigned() { if (this.opened === false) await this.ready() if (this.interrupted) return const thres = this.checkpoints.length - this.quorum if (thres < 0 || this.checkpoints.length <= thres) return this.checkpoints.sort(cmpCheckpoints) const signableLength = this.checkpoints[thres].signedLength() if (signableLength <= this.system.core.signedLength) return const expected = this.system.core.key if (signableLength > this.indexedLength) { if (!b4a.equals(expected, this.checkpoints[thres].digest.key)) this._checkSystemUpgrade() this.needsIndexedLengthUpdate = true return } for (let i = thres; i < this.checkpoints.length; i++) { const chk = this.checkpoints[i] // we must agree on what the system is obvs if (!b4a.equals(expected, chk.digest.key)) { this._checkSystemUpgrade() return } // if we dont have the indexed state ourself, then no way for us to verify / patch if (!chk.signatures.system || chk.signatures.system.length > this.indexedLength) { this.needsIndexedLengthUpdate = true return } } this.needsIndexedLengthUpdate = false const chk = [] for (let i = thres; i < this.checkpoints.length; i++) { chk.push({ signer: this.checkpoints[i].signer, signatures: this.checkpoints[i].signatures }) } const { system } = this.checkpoints[thres].signatures await this._assembleMultisig(system.length, chk) } async _assembleMultisig(signableLength, checkpoints) { const views = new Array(this.views.length + 2) // +2 is system + encryption const sys = await this.system.getIndexedInfo(signableLength) if (this.interrupted) return if (this.pendingViews && this.pendingViews[0].length >= signableLength) { return } views[0] = createCheckpointSignature(signableLength, this.systemView, checkpoints.length) if (sys.encryptionLength) { views[1] = createCheckpointSignature( sys.encryptionLength, this.encryptionView, checkpoints.length ) } const offset = 2 // system + encryption for (let i = offset; i < views.length; i++) { const view = this.views[i - offset] const core = view.core const v = this.getViewFromSystem(view, sys) const length = v ? v.length : 0 if (!core || length <= core.signedLength) continue const viewIndex = view.mappedIndex + offset views[viewIndex] = createCheckpointSignature(length, view, checkpoints.length) } for (let i = 0; i < checkpoints.length; i++) { addCheckpointSignatures(views, checkpoints, i) } const promises = [] for (const view of views) { if (!view) continue for (let i = 0; i < view.signatures.length; i++) { promises.push(setPartialSignature(view, i)) } } await Promise.all(promises) // check that the state still looks good, couple replicate inbetween... for (const v of views) { if (!v) continue for (let i = 0; i < v.signatures.length; i++) { if (!v.partials[i]) return } } if (this.interrupted) return if (this.pendingViews && this.pendingViews[0].length >= signableLength) { return } // skipped system for whatever reason... if (!views[0]) return this.pendingViews = views this.dirty = true // TODO: only needed if not updating, wont crash so keeping for now, just less efficient this.base._queueBump() } _close() { if (this.interrupted) return return this._free() } async _free() { this.interrupted = true if (this.applying) this._postApply() for (const chk of this.checkpoints) await chk.close() if (this.localCheckpoint) await this.localCheckpoint.close() if (this.view && this.base._hasClose) await this.base._handlers.close(this.view) if (this.system) await this.system.close() const promises = [] for (const v of this.views) { if (v.ref) promises.push(v.ref.release()) } if (this.systemView) promises.push(this.systemView.ref.release()) if (this.encryptionView) promises.push(this.encryptionView.ref.release()) await Promise.all(promises) await this.store.close() } _pushUpdate(u) { u.version = 1 u.seq = this.updates.length === 0 ? 0 : this.updates[this.updates.length - 1].seq + 1 u.systemLength = this.systemView.core.length this.updates.push(u) this.localState.insertUpdate(u) } async catchup(linearizer) { if (!this.opened) await this.ready() if (!this.system.heads.length) return true const writers = new Map() // load linearizer... const updates = await this.localState.listUpdates() const sys = await this.system.checkout(this.indexedLength) for (const node of updates) { const hex = b4a.toString(node.key, 'hex') let w = writers.get(hex) if (w === undefined) { // TODO: we actually have all the writer info already but our current methods make it hard to reuse that w = await this.base._getWriterByKey(node.key, -1, 0, true, false, sys) writers.set(hex, w) } if (w.length >= node.length) { this.base._warn(new Error('Update expects writer to be consumed here')) return false } while (w.length < node.length) { await w.update(sys) const next = w.advance() if (!next) { this.base._warn(new Error('Node must exist for catchup')) return false } linearizer.addHead(next) } } await sys.close() this.updates = updates if (this.indexersUpdated) { this.indexersUpdated = false // if we updated the indexers, invalidate all the internal state and reapply it await this.truncate(this.indexedLength) await this._rollbackViews() if (this.tx === null) this.tx = this.local.state.storage.write() while ( this.updates.length > 0 && this.updates[this.updates.length - 1].systemLength >= this.indexedLength ) { const u = this.updates.pop() this.localState.deleteUpdate(u) } } else { // otherwise we know the internal state is correct, so we carry on linearizer.update() } // must refresh the writers here so isRemoved is up to date await this._refreshWriters() return true } async getIndexedSystem() { if (this.opened === false) await this.ready() const indexedLength = this.pendingFork ? this.pendingFork.length : this.indexedLength const sys = await this.system.checkout(indexedLength) await sys.ready() return sys } getViewFromSystem(view, sys = this.system) { if (view.mappedIndex === -1 || view.mappedIndex >= sys.views.length) return null return sys.views[view.mappedIndex] } async recoverAt() { if (!this.systemRef) await this.ready() await this.systemRef.core.ready() const lt = this.systemRef.core.core.state.length for await (const { length, info } of SystemView.flushes(this.systemRef.core.session(), { reverse: true, lt })) { let consistent = true for (let i = 0; i < info.views.length; i++) { if (i >= this.views.length) continue if (!b4a.equals(info.views[i].key, this.views[i].key)) continue if (info.views[i].length > this.views[i].core.core.state.length) { consistent = false break } } if (consistent) { return { length, force: true, key: this.system.core.key, indexers: info.indexers, views: info.views } } } return null } bootstrap() { return this.system.add(this.base.key, { isIndexer: true, isPending: false }) } async undo(popped) { if (!popped) return let indexersUpdated = false while (popped > 0) { const u = this.updates.pop() this.localState.deleteUpdate(u) popped -= u.batch if (u.indexers) indexersUpdated = true } const u = this.updates.length === 0 ? null : this.updates[this.updates.length - 1] const systemLength = u ? u.systemLength : this.indexedLength await this.truncate(systemLength) if (indexersUpdated) await this._rollbackViews() } async truncate(systemLength) { if (this.opened === false) await this.ready() if (systemLength === this.system.core.length) return await this.system.core.truncate(systemLength) const migrated = await this.system.update() if (this.encryptionView.core.length !== this.system.encryptionLength) { await this.encryptionView.core.truncate(this.system.encryptionLength) } for (const view of this.views) { if (!view.core) continue const v = this.getViewFromSystem(view) if (v && view.core.length === v.length) continue if (v === null) view.mappedIndex = -1 // unmap await view.core.truncate(v ? v.length : 0) } if (!migrated) return await this._refreshWriters() await this._rollbackViews() } async _refreshWriters() { // TODO: add the seq at which we updated the state to the writer instance. // then we know if it was truncated out without the lookup, meaning faster truncations for (const w of this.base.activeWriters) { const data = await this.system.get(w.core.key) const bootstrapper = this.system.core.length === 0 && b4a.equals(w.core.key, this.base.key) const isRemoved = data ? data.isRemoved : !bootstrapper w.isRemoved = isRemoved } } async _updateSystem() { if (!(await this.system.update())) return await this._refreshWriters() await this._rollbackViews() } async _signViewCore(core, length) { const s = await core.signable(length, 0) const signature = crypto.sign(s, this.base.local.keyPair.secretKey) return { signature, length } } async _signInternalViewCores(sys) { return { system: await this._signViewCore(this.systemView.core, this.systemView.indexedLength), encryption: await this._signViewCore(this.encryptionView.core, sys.encryptionLength) } } async _signUserViewCores(sys) { const promises = new Array(sys.views.length) for (let i = 0; i < this.views.length; i++) { const view = this.views[i] const v = this.getViewFromSystem(view, sys) const indexedLength = v ? v.length : 0 if (!indexedLength) continue const viewIndex = view.mappedIndex promises[viewIndex] = this._signViewCore(view.ref.atomicBatch, indexedLength) } return Promise.all(promises) } async finalize(key) { this.localState.setBootRecord({ version: BOOT_RECORD_VERSION, key, systemLength: this.systemView.indexedLength, indexersUpdated: true, fastForwarding: false, recoveries: this.base.recoveries }) await this.localState.flush() await this.store.flush() await this.close() } async _flush(localNodes) { if (localNodes) await this._appendLocalNodes(localNodes) if (this.localCheckpoint) { // we have to flush here so the chkpoint can update // could run the checkpoint on the batch but also no big dead // as the "should we sign" check is rerun on boot... await this.store.flush() await this.localCheckpoint.update() } this.localState.setBootRecord({ version: BOOT_RECORD_VERSION, key: this.key, systemLength: this.systemView.indexedLength, indexersUpdated: false, fastForwarding: false, recoveries: this.base.recoveries }) await this.localState.flush() if (this.pendingViews) { const views = this.pendingViews this.pendingViews = null for (let i = views.length - 1; i >= 0; i--) { const v = views[i] if (!v || v.length <= v.core.signedLength) continue const signature = v.core.core.verifier.assemble(v.partials) try { await v.ref.commit(this.store.atom, v.length, signature) } catch (err) { if (isAssertion(err)) { throw err } // TODO: we should prevalidate all signatures instead of during commit so it can be all or nothing, just slighly // friendlier ux. missing hc api for that if (!this.base.closing) this.base._warn(err) break } } } await this.store.flush() this.fastForwarding = false if (this.pendingViews === null) this.dirty = false } _indexUpdates(indexed) { let shift = 0 while (indexed > 0) indexed -= this.updates[shift++].batch const last = this.updates[shift - 1] this.systemView.indexedLength = last.systemLength for (let i = 0; i < shift; i++) this.localState.deleteUpdate(this.updates[i]) this.updates.splice(0, shift) if (!this.needsIndexedLengthUpdate) return this.maybeSigned().catch(noop) } pendingIndexedLength() { let indexed = this.applying.indexed.length if (!this.applying || !this.updates.length || !indexed) return this.indexedLength let pos = 0 while (indexed > 0 && pos < this.updates.length) { indexed -= this.updates[pos++].batch } const last = this.updates[pos - 1] return last.systemLength } async _assertNode(node, batch) { // helpful dag helper, so kept here const v = (await this.system.get(node.writer.core.key)) || { length: 0, isRemoved: false } const expected = v.length + batch if (node.length === expected) return console.trace( 'INVALID_INSERTION', 'length=', node.length, 'key=', node.writer.core.key, 'local=', node.writer.core.writable, 'batch=', batch, 'dag=', v ) process.exit(1) } _postApply() { this.applyBatch = this.applying = null this.base._postApply() } async _optimisticApply(u, node, indexed) { const checkpoint = this.system.checkpoint() this.system.addHead(node) const applyBatch = [] const key = node.writer.core.key applyBatch.push({ indexed, optimistic: true, from: node.writer.core, length: node.length, value: node.value, heads: node.actualHeads }) const pre = await this.system.get(key) const preLength = pre ? pre.length : 0 let failed = false this.applying = u this.applyBatch = applyBatch try { await this.base._handlers.apply(applyBatch, this.view, this.hostcalls) } catch (err) { if (this.base.closing) throw err failed = true } this._postApply() if (!failed) { const post = await this.system.get(key) // check if acked by addWriter/removeWriter/ackWriter if (!post || preLength === post.length) failed = true } if (!failed) { // technically we only need to to this is the writer was removed, but hey, tricky logic await this._refreshWriters() return true } // it failed! rollback... this.system.applyCheckpoint(checkpoint) if (this.encryptionView.core.length !== this.system.encryptionLength) { await this.encryptionView.core.truncate(this.system.encryptionLength) } for (const view of this.views) { const viewLength = view.core ? view.core.length : view.length const viewLookup = this.getViewFromSystem(view) const viewSystemLength = viewLookup ? viewLookup.length : 0 if (viewSystemLength === viewLength) continue await view.core.truncate(viewSystemLength) } await this._refreshWriters() await this._rollbackViews() return false } _startTrace(node) { this.systemRef.tracer.start() this.encryptionView.ref.tracer.start() for (let i = 0; i < this.views.length; i++) this.views[i].ref.tracer.start() } _endTrace(node) { const trace = { system: this.systemRef.tracer.end(), encryption: this.encryptionView.ref.tracer.end(), user: [] } for (let i = 0; i < this.views.length; i++) { const blocks = this.views[i].ref.tracer.end() if (blocks.length) trace.user.push({ view: i, blocks }) } if (trace.system.length || trace.encryption.length || trace.user.length) node.trace = trace } async update(u, localNodes) { if (this.changes !== null) this.changes.track(this) let batch = 0 let applyBatch = [] let indexersUpdated = 0 let j = 0 let i = 0 let forkedAt = -1 while (i < Math.min(u.indexed.length, u.shared)) { const node = u.indexed[i++] if (node.batch > 1) continue this.base._shiftWriter(node.writer) const update = this.updates[j++] if (update.indexers) { indexersUpdated = i break } } if (u.undo) await this.undo(u.undo) if (this.system.bootstrapping) await this.bootstrap() await this._updateSystem() // Organize by view const warmupSystemView = [] const warmupEncryptionView = [] const warmupUserView = new Array(this.views.length) for (let k = u.shared; k < u.length; k++) { const indexed = k < u.indexed.length const node = indexed ? u.indexed[k] : u.tip[k - u.indexed.length] if (!node.trace) continue if (node.trace.system.length) warmupSystemView.push(...node.trace.system) if (node.trace.encryption.length) warmupEncryptionView.push(...node.trace.encryption) for (const trace of node.trace.user) { // Assert (as warning) that trace view should only be currently indexed views if (trace.view >= this.views.length) { console.warn( 'Oplog block trace contains OOB view index', 'trace view', trace.view, 'views.length', this.views.length ) continue } warmupUserView[trace.view] = warmupUserView[trace.view] || [] warmupUserView[trace.view].push(...trace.blocks) } } // Request per view if (warmupSystemView.length) this.systemView.core.download({ blocks: warmupSystemView }) if (warmupEncryptionView.length) this.encryptionView.core.download({ blocks: warmupEncryptionView }) for (let k = 0; k < warmupUserView.length; k++) { const blocks = warmupUserView[k] if (!blocks) continue const view = this.views[k] view.core.download({ blocks }) } for (i = u.shared; i < u.length; i++) { if (this.base.backoff !== null && this.base.backoff.backoff()) await this.base.backoff.wait() const indexed = i < u.indexed.length const node = indexed ? u.indexed[i] : u.tip[i - u.indexed.length] batch++ if (node.writer.core.writable) this._startTrace(node) const optimist = node.writer.isRemoved && node.optimistic && batch === 1 && this.base._hasOptimisticApply === true && (await this._optimisticApply(u, node, indexed)) if (!optimist) { if (node.writer.isRemoved && !node.writer.isActiveIndexer) { if (node.batch > 1) continue // in case someone is linking this node and they are not removed const u = { seq: 0, key: node.writer.core.key, length: node.length, batch, systemLength: 0, indexers: false } this._pushUpdate(u) batch = 0 assert(applyBatch.length === 0, 'Apply batch should not have been modified') continue } // in prod we prop need to disable this assertion as its pretty expensive, // but it catches a lot of bugs, so here for debugs // await this._assertNode(node, batch) const deps = node.causalDependencies() // oldest -> newest for (let i = deps.length - 1; i >= 1; i--) { const d = deps[i] if (await this.system.linkable(d.writer.core.key, d.length)) { this.system.addHead(deps[i]) } } this.system.addHead(deps[0]) if (node.value !== null && !node.writer.isRemoved) { applyBatch.push({ indexed, optimistic: false, from: node.writer.core, length: node.length, value: node.value, heads: node.actualHeads }) } if (node.batch > 1) continue if (applyBatch.length && this.base._hasApply === true) { this.applying = u this.applyBatch = applyBatch await this.base._handlers.apply(applyBatch, this.view, this.hostcalls) if (forkedAt === -1 && this.pendingFork) forkedAt = i this._postApply() } } const update = { seq: 0, key: node.writer.core.key, length: node.length, batch, systemLength: 0, indexers: false } update.indexers = !!this.system.indexerUpdate if (this.system.indexerUpdate) await this._generateNextViews() await this.system.flush(this.views) await this.system.update() if (node.writer.core.writable) this._endTrace(node) batch = 0 applyBatch = [] this._pushUpdate(update) if (!indexed || indexersUpdated) continue this.base._shiftWriter(node.writer) if (update.indexers) { indexersUpdated = i + 1 } } if (this.pendingFork) { const pending = this.pendingFork if (pending.length > this.indexedLength) this._indexUpdates(u.indexed.length) const fork = new Fork(this.base, this.store, this, pending) const forked = await fork.upgrade() if (!forked) throw new Error('Fork failed') await this._flush(localNodes) return { reboot: true, migrated: false } } if (u.indexed.length) { this._indexUpdates(indexersUpdated || u.indexed.length) } const migrated = indexersUpdated !== 0 if (migrated) this.key = await this.base._premigrate() if (this.changes !== null) { this.changes.finalise() await this.base._handlers.update(this.view, this.changes) } await this._flush(localNodes) return { reboot: migrated, migrated } } flush() { return this._flush(null) } async _appendLocalNodes(localNodes) { if (localNodes.length === 0) return // just in case const blocks = new Array(localNodes.length) const local = this.local if (!local.opened) await local.ready() for (let i = 0; i < blocks.length; i++) { const { value, heads, batch, optimistic, trace } = localNodes[i] blocks[i] = { version: OPLOG_VERSION, maxSupportedVersion: this.base.maxSupportedVersion, checkpoint: null, digest: null, optimistic, node: { heads, batch, value: value === null ? null : c.encode(this.base.valueEncoding, value) }, trace } } if (this.localIndexer) { const signedLength = this.localCheckpoint.signedLength() const local = this.local let signedAt = 0 let internalSignatures = null let signatures = null if (this.indexedLength > signedLength) { const sys = await this.system.getIndexedInfo(this.indexedLength) internalSignatures = await this._signInternalViewCores(sys) signatures = await this._signUserViewCores(sys) signedAt = local.length + blocks.length } for (let i = 0; i < blocks.length; i++) { const length = local.length + i + 1 if (length === signedAt) { this.localCheckpoint.updateInternalSignatures(length, internalSignatures) this.localCheckpoint.updateUserSignatures(length, signatures) } const blk = blocks[i] blk.checkpoint = this.localCheckpoint.makeCheckpoints(length) blk.digest = this.localCheckpoint.makeDigest(length, this.key) } } else { if (!this.localCheckpoint) await this._startLocalCheckpoint() for (let i = 0; i < blocks.length; i++) { const length = local.length + i + 1 blocks[i].digest = this.localCheckpoint.makeDigest(length, this.key) } } await local.append(blocks) } async _rollbackViews() { // encryption view key is not in system so no need to handle here for (const view of this.views) { const v = this.getViewFromSystem(view) if (v) { view.key = v.key } else { await this._resetView(view) } } } async createAnchor() { const node = this.applyBatch[this.applyBatch.length - 1] const key = node.from.key const length = node.length const info = await this.system.get(key, { unflushed: true }) if (!info || info.length < length) throw new Error('Anchor node is not in system') const state = { start: 0, end: 40, buffer: b4a.alloc(40) } c.fixed32.encode(state, key) c.uint64.encode(state, length) const namespace = crypto.hash(state.buffer) const manifestData = c.encode(messages.ManifestData, { version: 0, legacyBlocks: 0, namespace }) const padding = this.encryption ? AutobaseEncryption.PADDING : 0 const block = encodeValue(null, { heads: [{ key, length }], padding }) if (this.encryption) await this.encryption.encryptAnchor(block, namespace) const root = { index: 0, size: block.byteLength, hash: crypto.data(block) } const hash = crypto.tree([root]) const prologue = { hash, length: 1 } const core = this.store.createAnchorCore(prologue, manifestData) await core.ready() if (core.length === 0) await core.append(block, { writable: true, maxLength: 1 }) await this.system.add(core.key, { isIndexer: false, length: 0 }) await this.base._addWriter(core.key, this.system) const anchor = { key: core.key, length: core.length } await core.close() await this.base.hintWakeup(anchor) return anchor } async _resetView(view) { const manifests = await this.store.getIndexerManifests(this.system.indexers) const manifestData = view.core ? view.core.manifest.userData : null view.key = await this.store.createView( manifests, view.name, null, this.system.core.manifest.version, this.system.entropy, null, manifestData ) // will never be system so no linked view.length = 0 } async _generateNextViews() { const sys = this.system // note, this is very state dependent so can ONLY be called at the exact time an indexer upgrade occurs const manifests = await this.store.getIndexerManifests(sys.indexers) const entropy = sys.version < 2 ? null : sys.getEntropy(sys.indexers, sys.flushLength()) for (const v of this.views) { const manifestData = v.core ? v.core.manifest.userData : null const prologue = await getPrologue(v) const key = await this.store.createView( manifests, v.name, prologue, sys.core.manifest.version, entropy, null, manifestData ) v.key = key } } } async function getPrologue(view) { const length = view.core ? view.core.length : view.length if (!length) return null const hash = await view.core.treeHash(length) return { hash, length } } function noop() {} function cmpCheckpoints(a, b) { return a.signedLength() - b.signedLength() } function sameSignature(a, b) { if (!a || !b) return a === b return a.length === b.length } function sameSignatures(a, b) { if (!a || !b) return a === b if (a.length !== b.length) return false for (let i = 0; i < a.length; i++) { if (a[i].length !== b[i].length) return false } return true } function createCheckpointSignature(length, view, checkpoints) { return { length, core: view.core, ref: view.ref, signatures: new Array(checkpoints), partials: new Array(checkpoints) } } function addCheckpointSignatures(pending, checkpoints, index) { const { signer, signatures } = checkpoints[index] pending[0].signatures[index] = { signature: signatures.system.signature, length: signatures.system.length, signer } if (pending[1]) { pending[1].signatures[index] = { signature: signatures.encryption.signature, length: signatures.encryption.length, signer } } for (let i = 2; i < pending.length; i++) { if (!pending[i]) continue const { length, signature } = signatures.user[i - 2] pending[i].signatures[index] = { signature, length, signer } } } async function setPartialSignature(view, index) { const sig = view.signatures[index] if (sig.length < view.length && sig.length > 0) await view.core.get(sig.length - 1) view.partials[index] = await partialSignature( view.core, sig.signer, view.length, sig.length, sig.signature ) } function updateSignature(length, sig, existing) { return sig ? { signature: sig.signature, length: sig.length, at: length } : existing } function updateSignatures(length, signatures, existing) { const updated = new Array(signatures.length) for (let i = 0; i < updated.length; i++) { updated[i] = updateSignature(length, signatures[i], i < existing.length ? existing[i] : null) } return updated } function makeCheckpoint(length, chk) { if (!chk) return null const checkpointer = length - chk.at return { checkpointer, checkpoint: checkpointer === 0 ? { signature: chk.signature, length: chk.length } : null } } function makeCheckpoints(length, signatures) { if (!signatures.length) return null const checkpoints = new Array(signatures.length) for (let i = 0; i < signatures.length; i++) { checkpoints[i] = makeCheckpoint(length, signatures[i]) } return checkpoints } function isViewCorruption(err) { return err.code === 'INVALID_OPERATION' } function isAssertion(err) { return err.code === 'ERR_ASSERTION' || err.name === 'AssertionError' } const c = require('compact-encoding') const encryptionEncoding = require('encryption-encoding') const messages = require('./messages.js') module.exports = async function boot( corestore, key, { encrypt, encryptionKey, keyPair, exclusive = true, blindEncryption } = {} ) { const result = { key: null, local: null, bootstrap: null, encryptionKey: null, boot: null } const manifest = keyPair ? { version: corestore.manifestVersion, signers: [{ publicKey: keyPair.publicKey }] } : null if (key) { result.key = key const bootstrap = corestore.get({ key, active: false, valueEncoding: messages.OplogMessage }) await bootstrap.ready() const localKey = await bootstrap.getUserData('autobase/local') if (keyPair) { result.local = corestore.get({ keyPair, active: false, exclusive, valueEncoding: messages.OplogMessage, manifest }) } else { if (bootstrap.writable && !localKey) { result.local = bootstrap.session({ active: false, exclusive, valueEncoding: messages.OplogMessage }) } else { const local = localKey ? corestore.get({ key: localKey, active: false, exclusive, valueEncoding: messages.OplogMessage }) : corestore.get({ name: 'local', active: false, exclusive, valueEncoding: messages.OplogMessage }) await local.ready() result.local = local } } result.bootstrap = bootstrap } else { result.local = keyPair ? corestore.get({ keyPair, manifest, active: false, exclusive, valueEncoding: messages.OplogMessage }) : corestore.get({ name: 'local', active: false, exclusive, valueEncoding: messages.OplogMessage }) await result.local.ready() const key = await result.local.getUserData('referrer') if (key) { result.key = key result.bootstrap = corestore.get({ key, active: false, valueEncoding: messages.OplogMessage }) await result.bootstrap.ready() } else { result.key = result.local.key result.bootstrap = result.local.session({ active: false, valueEncoding: messages.OplogMessage }) await result.bootstrap.setUserData('autobase/local', result.local.key) } } if (key || keyPair) { await result.bootstrap.setUserData('referrer', result.key) await result.bootstrap.setUserData('autobase/local', result.local.key) await result.local.setUserData('referrer', result.key) } const [encryptionKeyBuffer, encryptionKeyEncryptedBuffer, pointer] = await Promise.all([ result.local.getUserData('autobase/encryption'), result.local.getUserData('autobase/blind-encryption'), result.local.getUserData('autobase/boot') ]) if (pointer) { result.boot = c.decode(messages.BootRecord, pointer) } if (encryptionKeyBuffer) { // if not encoded, replace if (blindEncryption) { const encrypted = await encryptionEncoding.encrypt( encryptionKeyBuffer, blindEncryption.encrypt ) await result.local.setUserData('autobase/blind-encryption', encrypted) await result.local.setUserData('autobase/encryption', null) } result.encryptionKey = encryptionKeyBuffer } if (encryptionKeyEncryptedBuffer) { const { value, rotated } = await encryptionEncoding.decrypt( encryptionKeyEncryptedBuffer, blindEncryption.decrypt ) if (rotated) { const encrypted = await encryptionEncoding.encrypt(value, blindEncryption.encrypt) await result.local.setUserData('autobase/blind-encryption', encrypted) } result.encryptionKey = value } if (!result.encryptionKey && (encryptionKey || encrypt)) { if (!encryptionKey) { encryptionKey = (await corestore.createKeyPair('autobase/encryption')).secretKey.subarray( 0, 32 ) } if (blindEncryption) { const encrypted = await encryptionEncoding.encrypt(encryptionKey, blindEncryption.encrypt) await result.local.setUserData('autobase/blind-encryption', encrypted) } else { await result.bootstrap.setUserData('autobase/encryption', encryptionKey) // legacy support await result.local.setUserData('autobase/encryption', encryptionKey) } result.encryptionKey = encryptionKey } return result } const crypto = require('hypercore-crypto') const OPLOG_VERSION = 2 const DEFAULT_AUTOBASE_VERSION = 1 // default const MAX_AUTOBASE_VERSION = 2 // optional fork support const BOOT_RECORD_VERSION = 3 const [NS_SIGNER_NAMESPACE, NS_VIEW_BLOCK_KEY, NS_HASH_KEY, NS_ENCRYPTION] = crypto.namespace( 'autobase', 4 ) module.exports = { OPLOG_VERSION, DEFAULT_AUTOBASE_VERSION, MAX_AUTOBASE_VERSION, BOOT_RECORD_VERSION, NS_SIGNER_NAMESPACE, NS_VIEW_BLOCK_KEY, NS_HASH_KEY, NS_ENCRYPTION } const BufferMap = require('tiny-buffer-map') // This is basically just a Map atm, but leaving it as an abstraction for now // in case we wanna optimize it for our exact usecase module.exports = class Clock { constructor() { this.seen = new BufferMap() } get size() { return this.seen.size } has(key) { return this.seen.has(key) } includes(key, length) { return this.seen.has(key) && this.seen.get(key) >= length } get(key) { return this.seen.get(key) || 0 } set(key, len) { this.seen.set(key, len) return len } add(clock) { for (const [key, l] of clock) { if (this.get(key) < l) this.set(key, l) } } [Symbol.iterator]() { return this.seen[Symbol.iterator]() } } const BufferMap = require('tiny-buffer-map') const Clock = require('./clock.js') const UNSEEN = 0 const NEWER = 1 const ACKED = 2 // Consensus machine for Autobase. Sort DAG nodes using // vector clocks to determine a globally consistent view module.exports = class Consensus { constructor(indexers) { this.merges = new Set() this.majority = (indexers.length >>> 1) + 1 this.indexers = indexers this.removed = new Clock() this.updated = false this.writers = new BufferMap() for (const idx of this.indexers) { this.writers.set(idx.core.key, idx) } } addHead(node) { if (!node.writer.isActiveIndexer) return if (this._isMerge(node)) this.merges.add(node) this.updated = true return node } /* Indexer Only DAG methods */ _tails(node, tails) { const tailSet = new Set() for (const t of tails) { if (node.clock.includes(t.writer.core.key, t.length)) tailSet.add(t) } return tailSet } _tailsAndMerges(node, tails) { const all = this._tails(node, tails) for (const m of this.merges) { if (m !== node && node.clock.includes(m.writer.core.key, m.length)) { all.add(m) } } return all } _isMerge(node) { if (!node.writer.isActiveIndexer) return false const deps = [] for (const idx of this.indexers) { let seq = node.clock.get(idx.core.key) - 1 if (idx === node.writer) seq-- const head = idx.get(seq) if (!head || this.removed.includes(head.writer.core.key, head.length)) continue let isDep = true for (let i = 0; i < deps.length; i++) { const d = deps[i] if (d === head) continue if (d.clock.includes(head.writer.core.key, head.length)) { isDep = false break } if (head.clock.includes(d.writer.core.key, d.length)) { const popped = deps.pop() if (d === popped) continue deps[i--] = popped } } if (isDep) deps.push(head) } return deps.length > 1 } _indexerTails() { const tails = new Set() for (const idx of this.indexers) { const length = this.removed.has(idx.core.key) ? this.removed.get(idx.core.key) : idx.indexed const head = idx.get(length) if (!head || this.removed.includes(head.writer.core.key, head.length)) continue let isTail = true for (const t of tails) { if (head.clock.includes(t.writer.core.key, t.length)) { isTail = false break } if (t.clock.includes(head.writer.core.key, head.length)) { tails.delete(t) } } if (isTail) tails.add(head) } return tails } // parent is newer if for any node in parent's view, // either node can see object or object can see node _strictlyNewer(object, parent) { if (!parent.clock.includes(object.writer.core.key, object.length)) return false for (const [key, latest] of parent.clock) { const oldest = this.removed.get(key) if (latest <= oldest) continue // check quickly if we removed it // get the NEXT node from the writer from the objects pov, adjust if its removed let length = object.clock.get(key) if (length <= oldest) length = oldest // sanity check, likely not needed as someone has checked this before, but it's free if (latest < length) return false // if the same, they have both seen it, continue if (latest === length) continue const writer = this.writers.get(key) // might not be in the removed set but the writer can tell us if it was indexed... const next = writer && writer.get(length >= writer.indexed ? length : writer.indexed) // no next, its been indexed, both seen it if (!next) continue // if the NEXT node has seen the object its fine - newer if (next.clock.includes(object.writer.core.key, object.length)) continue // otherwise the parent must also NOT have seen the next node if (latest < next.length) continue return false } return true } _acks(target) { const acks = target.writer.isActiveIndexer ? [target] : [] // TODO: can be cached on the target node in future (ie if we add one we dont have to check it again) for (const idx of this.indexers) { if (idx === target.writer) continue let next = target.clock.get(idx.core.key) if (next < idx.nodes.offset) next = idx.nodes.offset const nextIndexNode = idx.get(next >= idx.indexed ? next : idx.indexed) // no node - no ack if (!nextIndexNode) continue // if the next index node does not see the target, no ack if (!nextIndexNode.clock.includes(target.writer.core.key, target.length)) continue // if the next index node is not strictly newer, skip to avoid ambig... if (!this._strictlyNewer(target, nextIndexNode)) continue acks.push(nextIndexNode) } return acks } acksFromNode(target, view) { const acks = new Set() if (!view || !view.clock.includes(target.writer.core.key, target.length)) return acks acks.add(view.writer) for (const idx of this.indexers) { if (idx === view.writer) continue const length = view.clock.get(idx.core.key) if (!length) continue if (target.clock.includes(idx.core.key, length)) continue const head = idx.get(length - 1) if (!head) continue if (head.clock.includes(target.writer.core.key, target.length)) { acks.add(idx) } } return acks } _ackedAt(acks, parent) { let seen = 0 let missing = acks.length for (const node of acks) { missing-- if (!parent.clock.includes(node.writer.core.key, node.length)) { if (seen + missing < this.majority) return false continue } if (++seen >= this.majority) return true } return false } confirms(indexer, target, acks, length) { if (!length || this.removed.get(indexer.core.key) >= length) return UNSEEN // def feels like there is a smarter way of doing this part // ie we just wanna find a node from the indexer that is strictly newer than target // and seens a maj of the acks - thats it let jump = true let newer = true for (let i = length - 1; i >= 0; i--) { const head = indexer.get(i) if (head === null) return UNSEEN let seen = 0 for (const node of acks) { // if (node.writer === indexer) continue if (!head.clock.includes(node.writer.core.key, node.length)) continue if (++seen >= this.majority) break } if (!newer && seen < this.majority) { break } if (!this._strictlyNewer(target, head)) { // all strictly newer nodes are clustered together so bisect until we find the cluster if (jump) { jump = false let t = length - 1 let b = 0 while (t > b) { const mid = (t + b) >>> 1 const node = indexer.get(mid) if ( node === null || !node.clock.includes(target.writer.core.key, target.length) || this._strictlyNewer(target, node) ) { b = mid + 1 } else { t = mid - 1 } } // + 2 in case we are off by one and the i--. its fine, just an optimisation if (b + 1 < i) i = b + 2 } newer = false continue } else if (seen < this.majority) { return NEWER } return ACKED } return UNSEEN } _isConfirmed(target, parent = null) { const acks = this._acks(target) const confs = new Set() if (acks.length < this.majority) return false let allNewer = true for (const indexer of this.indexers) { const length = parent ? parent.writer === indexer ? parent.length - 1 : parent.clock.get(indexer.core.key) : indexer.length const result = this.confirms(indexer, target, acks, length) if (result === ACKED) { confs.add(indexer) if (confs.size >= this.majority) { return true } } if (result === UNSEEN) allNewer = false } if (parent) return this._isConfirmableAt(target, parent, acks, confs) return allNewer } _isConfirmableAt(target, parent, acks, confs) { if (!this._ackedAt(acks, parent)) return false let potential = confs.size for (const indexer of this.indexers) { if (confs.has(indexer)) continue const length = parent.clock.get(indexer.core.key) const isSeen = target.clock.includes(indexer.core.key, length) // if the target has seen the latest node, it can freely be used to confirm the target later // otherwise, check if a newer node is strictly newer... if (!isSeen) { const head = indexer.get(length - 1) // the next indexer head HAS to be strictly newer - meaning the current one has to be also. if ( head && !this.removed.includes(head.writer.core.key, head.length) && !this._strictlyNewer(target, head) ) { continue } } if (++potential >= this.majority) return true } return false } // this can get called multiple times for same node remove(node) { this.merges.delete(node) this.removed.set(node.writer.core.key, node.length) return node } shift() { if (!this.updated) return [] const tails = this._indexerTails() for (const tail of tails) { if (this._isConfirmed(tail)) { return [this.remove(tail)] } } for (const merge of this.merges) { if (this._isConfirmed(merge)) { return this._yieldNext(merge, tails) } } this.updated = false return [] } // yields next indexer node _yieldNext(node, tails) { // only stop when we find a tail while (!tails.has(node)) { let next = null // for merges check if one fork is confirmed for (const t of this._tailsAndMerges(node, tails)) { if (this._isConfirmed(t, node)) { next = t break } } if (next) { node = next continue } // otherwise yield all tails const tailSet = [] for (const t of this._tails(node, tails)) { tailSet.push(this.remove(t)) } return tailSet } return [this.remove(node)] } shouldAck(writer) { for (const t of this._indexerTails()) { if (t.writer === writer) continue if (this._shouldAckNode(t, writer)) return true } return false } _shouldAckNode(target, writer) { const head = writer.head() const next = target.clock.get(writer.core.key) const nextIndexNode = writer.get(next >= writer.indexed ? next : writer.indexed) // if we have no next node and we didn't write target then ack if (!nextIndexNode && writer !== target.writer) return true // shortcuts if we have next node if (nextIndexNode) { // if the next node does not see the target, should ack if (!nextIndexNode.clock.includes(target.writer.core.key, target.length)) { return !head.clock.includes(target.writer.core.key, target.length) } // if the next node is not strictly newer, no point acking if (!this._strictlyNewer(target, nextIndexNode)) return false } // now check if we can double confirm const acks = this._acks(target) // need enough to double confirm if (acks.length >= this.majority) { return this.confirms(writer, target, acks, writer.length) === UNSEEN } return false } } const HypercoreEncryption = require('hypercore/lib/default-encryption.js') const sodium = require('sodium-universal') const crypto = require('hypercore-crypto') const c = require('compact-encoding') const b4a = require('b4a') const rrp = require('resolve-reject-promise') const ReadyResource = require('ready-resource') const SystemView = require('./system.js') const { EncryptionDescriptor, ManifestData } = require('./messages.js') const { NS_VIEW_BLOCK_KEY, NS_HASH_KEY, NS_ENCRYPTION } = require('./caps.js') const nonce = b4a.alloc(sodium.crypto_stream_NONCEBYTES) const hash = nonce.subarray(0, sodium.crypto_generichash_BYTES_MIN) class AutobaseEncryption { static PADDING = 8 constructor(encryption) { this.encryption = encryption this.compat = null this.keys = null this.keysById = new Map() } get id() { return this.keys ? this.keys.id : 0 } padding() { return AutobaseEncryption.PADDING } isCompat() { return false } load(keys) { if (this.keys === null) this.keys = keys } async update(ctx) { if (this.id !== 0 && this.id === this.encryption.id) return const keys = await this.get(this.encryption.id, ctx) if (keys) this.keys = keys } async get(id, ctx) { if (this.keysById.has(id)) return this.keysById.get(id) const keys = await this.getKeys(id, ctx) this.keysById.set(id, keys) return keys } async getKeys(id, ctx) { const entropy = await this.encryption.get(id) if (!entropy) return null const block = this.blockKey(entropy, ctx) const hash = crypto.hash([NS_HASH_KEY, block]) return { id, block, hash } } blockKey(entropy, ctx) { return this.encryption.blockKey(entropy, ctx) } async _ensureCompat(ctx) { if (!this.compat) this.compat = this.compatKeys(ctx) } compatKeys() { throw new Error('Compatibility method is not specified') } async encrypt(index, block, fork, ctx) { if (this.isCompat(ctx, index)) { this._ensureCompat(ctx) return HypercoreEncryption.encrypt( index, block, fork, this.compat.block, this.compat.blinding ) } await this.update(ctx) encryptBlock(index, block, this.keys.id, this.keys.block, this.keys.hash) } async decrypt(index, block, ctx) { if (this.isCompat(ctx, index)) { this._ensureCompat(ctx) return HypercoreEncryption.decrypt(index, block, this.compat.block) } const padding = block.subarray(0, AutobaseEncryption.PADDING) block = block.subarray(AutobaseEncryption.PADDING) const type = padding[0] switch (type) { case 0: return block // unencrypted case 1: break default: throw new Error('Unrecognised encryption type') } const id = c.uint32.decode({ start: 4, end: 8, buffer: padding }) const keys = await this.get(id, ctx) c.uint64.encode({ start: 0, end: 8, buffer: nonce }, index) nonce.set(padding, 8, 16) // Decrypt the block using the full nonce decrypt(block, nonce, keys.block) } } class ViewEncryption extends AutobaseEncryption { constructor(encryption, name) { super(encryption) this.name = name } isCompat(ctx, index) { if (ctx.manifest.version <= 1) return true if (!ctx.manifest.userData) return false const { legacyBlocks } = c.decode(ManifestData, ctx.manifest.userData) return index < legacyBlocks } compatKeys() { const { bootstrap, encryptionKey } = this.encryption.base const block = getCompatBlockKey(bootstrap, encryptionKey, this.name) return { block, blinding: crypto.hash(block) } } blockKey(entropy) { return getCompatBlockKey(this.encryption.base.bootstrap, entropy, this.name) } } class WriterEncryption extends AutobaseEncryption { isCompat(ctx) { return ctx.manifest.version <= 1 } compatKeys(ctx) { return HypercoreEncryption.deriveKeys(this.encryption.base.encryptionKey, ctx.key) } blockKey(entropy, ctx) { if (ctx.manifest.userData) { const userData = c.decode(ManifestData, ctx.manifest.userData) if (userData.namespace !== null) { return this.encryption.blockKey(entropy, { key: userData.namespace }) } } return this.encryption.blockKey(entropy, ctx) } } class EncryptionView extends ReadyResource { constructor(base, core) { super() this.base = base this.core = core || null this.sessions = new Map() this._initialising = null } async _open() { await this.initialised() await this.core.ready() } initialised() { if (this.core !== null) return this.core.ready() if (this._initialising) return this._initialising this._initialising = rrp() return this._initialising.promise } _close() { if (this._initialising) { this._initialising.reject(new Error('Encryption closed')) this._initialising = null } if (this.core) return this.core.close() } get bootstrapped() { return !!(this.core && this.core.length > 0) } get id() { return this.core ? this.core.length : 0 } _createPayload(key) { return key } async reload(core) { if (this.core) await this.core.close() this.core = core await this.core.ready() if (this._initialising) { this._initialising.resolve() this._initialising = null } } unpack(type, payload) { if (type > 0) throw new Error('Unsupported version') return payload } async update(key) { const payload = await this._createPayload(key) const desc = { type: 0, payload } await this.core.append(c.encode(EncryptionDescriptor, desc)) } async _preload() { await this.ready() return this.id() } getViewEncryption(name) { if (this.sessions.has(name)) return this.sessions.get(name) const encryption = new ViewEncryption(this, name) this.sessions.set(name, encryption) return encryption } getWriterEncryption() { return new WriterEncryption(this) } async encryptAnchor(block, namespace) { const entropy = await this.get(this.id) if (!entropy) return null const blockKey = this.blockKey(entropy, { key: namespace }) const hashKey = crypto.hash([NS_HASH_KEY, block]) encryptBlock(0, block, this.id, blockKey, hashKey) } blockKey(entropy, ctx) { return getBlockKey(this.base.bootstrap, this.base.encryptionKey, entropy, ctx.key) } async get(encryptionId) { if (encryptionId === 0) return SystemView.GENESIS_ENTROPY if (!this.core) await this.initialised() const index = encryptionId - 1 const desc = await this.core.get(index) const { type, payload } = c.decode(EncryptionDescriptor, desc) const key = this.unpack(type, payload) return key } getSystemEncryption() { return this.getViewEncryption('_system') } static namespace(entropy) { return crypto.hash([NS_ENCRYPTION, entropy]) } static getBlockKey(bootstrap, encryptionKey, entropy, hypercoreKey) { return getBlockKey(bootstrap, encryptionKey, entropy, hypercoreKey) } static getSystemEncryption(base, core) { const view = new EncryptionView(base, core) return view.getSystemEncryption() } static async setSystemEncryption(base, core, opts) { if (base.encryptionKey === null) return null await core.ready() if (core.manifest.version === 1) { const key = getCompatBlockKey(base.bootstrap, base.encryptionKey, '_system') return core.setEncryptionKey(key, { block: true }) } if (!core.manifest.linked.length) { throw new Error('System manifest does not link encryption view') } const enc = base.store.get({ key: core.manifest.linked[0], active: false }) const encryption = EncryptionView.getSystemEncryption(base, enc) await core.setEncryption(encryption, opts) return enc } } module.exports = { AutobaseEncryption, EncryptionView } function encrypt(block, nonce, key) { sodium.crypto_stream_xor(block, block, nonce, key) } function decrypt(block, nonce, key) { return encrypt(block, nonce, key) // symmetric } function getBlockKey(bootstrap, encryptionKey, entropy, hypercoreKey) { return ( encryptionKey && crypto.hash([NS_VIEW_BLOCK_KEY, bootstrap, encryptionKey, entropy, hypercoreKey]) ) } function getCompatBlockKey(bootstrap, encryptionKey, name) { if (typeof name === 'string') return getCompatBlockKey(bootstrap, encryptionKey, b4a.from(name)) return encryptionKey && crypto.hash([NS_VIEW_BLOCK_KEY, bootstrap, encryptionKey, name]) } function blockhash(block, padding, hashKey) { sodium.crypto_generichash(hash, block, hashKey) padding.set(hash.subarray(0, 8)) // copy first 8 bytes of hash hash.fill(0) // clear nonce buffer } function encryptBlock(index, block, id, blockKey, hashKey) { const padding = block.subarray(0, AutobaseEncryption.PADDING) block = block.subarray(AutobaseEncryption.PADDING) blockhash(block, padding, hashKey) c.uint32.encode({ start: 4, end: 8, buffer: padding }, id) c.uint64.encode({ start: 0, end: 8, buffer: nonce }, index) padding[0] = 1 // version in plaintext nonce.set(padding, 8, 16) // The combination of index, key id, fork id and block hash is very likely // to be unique for a given Hypercore and therefore our nonce is suitable encrypt(block, nonce, blockKey) } const rrp = require('resolve-reject-promise') const safetyCatch = require('safety-catch') const SystemView = require('./system.js') const { EncryptionView } = require('./encryption.js') const DEFAULT_OP_TIMEOUT = 5_000 const DEFAULT_MIN_FF = 16 module.exports = class FastForward { constructor( base, key, { timeout = DEFAULT_OP_TIMEOUT, verified = true, minimum = DEFAULT_MIN_FF, force = false, length = 0 } = {} ) { this.base = base this.key = key this.timeout = timeout this.force = force this.core = base.store.get({ key, active: true, encryption: null }) this.length = length this.views = [] this.encryption = null this.entropy = null this.indexers = [] this.minimum = minimum this.verified = verified this.waiting = new Set() this.cores = [this.core] this.system = null this.destroyed = false this.upgrading = null this.failed = false } static MINIMUM = DEFAULT_MIN_FF async upgrade() { try { if (!this.upgrading) this.upgrading = this._upgrade() if (!(await this.upgrading)) return null return { length: this.length, force: this.force, key: this.key, indexers: this.indexers, views: this.views, entropy: this.entropy, manifestVersion: this.core.manifest.version, minimum: this.minimum } } catch (err) { safetyCatch(err) this.failed = true return null } finally { await this.close() } } _waitForAppend(core) { if (core.length > 0) return Promise.resolve() const promise = rrp() const timeout = setTimeout(this.close.bind(this), this.timeout) const wait = { promise, timeout } this.waiting.add(wait) core.once('append', () => { this.waiting.delete(wait) clearTimeout(timeout) promise.resolve() }) return promise.promise } _minLength() { return this.base.core.length + this.minimum } async _upgrade() { await this.core.ready() if (!this.verified) await this._waitForAppend(this.core) if (this.destroyed) return false if (this.core.manifest.linked) { const appends = [] for (const key of this.core.manifest.linked) { const core = this.base.store.get({ key, active: true }) this.cores.push(core) await core.ready() appends.push(this._waitForAppend(core)) } await Promise.all(appends) } if (this.length === 0) this.length = this.core.length // note we use the persisted length here, as we might as well continue that work as thats ~ the same length if (!this.force && this.length < this._minLength()) return false if (this.length === 0) return false await this.core.get(this.length - 1, { timeout: this.timeout }) await this.base.ready() if (this.destroyed) return false if (this.base.encryptionKey && !(await this._ensureEncryption())) return false if (this.destroyed) return false this.system = new SystemView(this.core, { checkout: this.length }) await this.system.ready() if (this.destroyed) return false this.entropy = this.system.entropy if (this.core.manifest.version >= 2) { const linked = this.core.manifest.linked if (this.system.encryptionLength === 0 || linked === null || !linked.length) { return false } // technically diverges from system.views to include encryption here, but makes sense this.views.push({ key: linked[0], length: this.system.encryptionLength }) } const promises = [] // ensure local key is locally available always promises.push(this.system.get(this.base.local.key, { timeout: this.timeout })) if (this.encryption && this.encryption.core) { promises.push( this.encryption.core.get(this.system.encryptionLength - 1, { timeout: this.timeout }) ) } for (const v of this.system.views) { this.views.push(v) const core = this.base.store.get({ key: v.key, active: true }) this.cores.push(core) if (!v.length) continue // encryption view can be 0 length promises.push(core.get(v.length - 1, { timeout: this.timeout })) } for (const idx of this.system.indexers) { this.indexers.push(idx) if (idx.length === 0) continue // need to make sure we have manifest... const core = this.base.store.get({ key: idx.key, active: true }) this.cores.push(core) promises.push(core.get(idx.length - 1, { timeout: this.timeout })) promises.push(this.system.get(idx.key, { timeout: this.timeout })) } for (const head of this.system.heads) { promises.push(this.system.get(head.key, { timeout: this.timeout })) } await Promise.all(promises) if (this.destroyed) return false return true } async _ensureEncryption() { // only need encryption if we migrated if (this.core.encryption !== null) return true const encCore = this.core.manifest.version <= 1 ? null : this.cores[1] // expects internal views to be loaded in order this.encryption = new EncryptionView(this.base, encCore) const encryption = this.encryption.getViewEncryption('_system') await this.core.setEncryption(encryption) return true } async close() { this.destroyed = true for (const { promise, timeout } of this.waiting) { clearTimeout(timeout) promise.resolve() // silently bail } if (this.system) await this.system.close() if (this.encryption) await this.encryption.close() for (const core of this.cores) await core.close() await this.core.close() } } const c = require('compact-encoding') const SystemView = require('./system.js') const { EncryptionView } = require('./encryption.js') const { ManifestData } = require('./messages.js') module.exports = class Fork { constructor(base, store, state, fork) { this.base = base this.store = store this.state = state this.indexers = fork.indexers this.length = fork.length this.system = null this.encryption = null this.manifests = null this.cores = [] } async upgrade() { try { await this._upgrade() return true } catch { return false } finally { await this.close() } } async _upgrade() { this.manifests = await this.store.getIndexerManifests(this.indexers) this.system = new SystemView(await this._get('_system', this.length)) this.encryption = new EncryptionView(this, await this._get('_encryption', -1)) await this.system.ready() await this.encryption.ready() this.entropy = this.system.getEntropy(this.indexers, this.length) this.manifestVersion = Math.max(this.system.core.manifest.version, 2) // >= 2 to signal new encryption const views = [] for (const view of this.state.views) { const v = this.getViewFromSystem(view, this.system) const indexedLength = v ? v.length : 0 const session = await this._get(view.name, indexedLength) await session.ready() const next = await this.createView(view.name, session, null) await next.ready() await this._migrate(view.ref, next, view.core, indexedLength) // update key views.push({ key: next.key, length: indexedLength }) } // internal views are explicitly migrated const entropy = EncryptionView.namespace(this.entropy) await this.encryption.update(entropy) const system = this.store.getViewByName('_system') const encryption = this.store.getViewByName('_encryption') const enc = await this.createView('_encryption', this.encryption.core, null) await enc.ready() await this._migrate(encryption, enc, this.encryption.core, this.encryption.core.length) await this.system.fork(this.indexers, this.manifests, this.encryption.core.length, views) const sys = await this.createView('_system', this.system.core, [enc.key]) await sys.ready() await this._migrate(system, sys, this.system.core, this.system.core.length) } async createView(name, core, linked) { const prologue = await getPrologue(core) const manifestData = this._manifestData(core) return this.store.getViewCore( this.manifests, name, prologue, this.manifestVersion, this.entropy, linked, manifestData ) } async _get(name, length) { const core = this.store.get({ name }) this.cores.push(core) if (length !== -1) await core.truncate(length) return core } getViewFromSystem(view) { if (view.mappedIndex === -1 || view.mappedIndex >= this.system.views.length) return null return this.system.views[view.mappedIndex] } _manifestData(session) { if (session.manifest.version > 1) return session.manifest.userData return c.encode(ManifestData, { version: 0, legacyBlocks: session.length }) } async _migrate(ref, next, source, length) { if (length > 0) { await next.core.copyPrologue(source.state) } // remake the batch, reset from our prologue in case it replicated inbetween // TODO: we should really have an HC function for this const batch = next.session({ name: 'batch', overwrite: true, checkout: length }) await batch.ready() if (source !== null) { while (batch.length < source.length) { await batch.append(await source.get(batch.length)) } } ref.moveTo = [batch, next] } async close() { this.destroyed = true if (this.system) await this.system.close() if (this.encryption) await this.encryption.close() for (const core of this.cores) await core.close() } } async function getPrologue(core) { if (!core.length) return null return { hash: await core.treeHash(), length: core.length } } const b4a = require('b4a') const assert = require('nanoassert') const Clock = require('./clock.js') const Consensus = require('./consensus.js') const Topolist = require('./topolist.js') class Node { constructor(writer, length, value, heads, batch, dependencies, optimistic, trace) { this.writer = writer this.length = length this.value = value this.heads = heads this.actualHeads = heads.slice(0) // TODO: we should remove this and just not mutate heads... this.dependents = new Set() this.dependencies = dependencies this.index = 0 // used by topolist this.optimistic = optimistic && batch === 1 && !!value this.batch = batch this.dropped = 0 this.trace = trace this.clock = new Clock() this.yielded = false this.yielding = false } isTail() { return this.dependencies.size === this.dropped } causalDependencies(idx) { const order = [this] const stack = [this] let visited = null while (stack.length > 0) { const node = stack.pop() for (const dep of node.dependencies) { if (!dep.writer.isRemoved || dep.writer.isActiveIndexer) continue // TODO: replace with "coloring" but ok for now, tiny set if (visited === null) visited = new Set() if (visited.has(dep)) continue visited.add(dep) stack.push(dep) order.push(dep) } } return order } clear() { this.clock = null this.dependents = null return this } reset() { this.yielded = false this.yielding = false for (const dep of this.dependents) dep.dependencies.add(this) this.dependents.clear() } active() { for (const dep of this.dependencies) { if (dep.yielded) { this.dependencies.delete(dep) // nodes might be yielded during buffering } else { dep.dependents.add(this) this.clock.add(dep.clock) } } if (this.writer.isActiveIndexer) this.clock.set(this.writer.core.key, this.length) } tieBreak(node) { return tieBreak(this, node) } hasDependency(dep) { for (const h of this.actualHeads) { if (sameNode(h, dep)) return true } return false } get ref() { return this.writer.core.key.toString('hex').slice(0, 2) + ':' + this.length } } module.exports = class Linearizer { constructor(indexers, { heads = [], writers = new Map() } = {}) { this.heads = new Set() this.tails = new Set() this.tip = new Topolist() this.size = 0 // useful for debugging this.updated = false this.indexersUpdated = false this.writers = writers this.consensus = new Consensus(indexers) this._initialHeads = heads.slice(0) this._strictlyAdded = null for (const { key, length } of heads) { this.consensus.removed.set(key, length) } } get indexers() { return this.consensus.indexers } static createNode(writer, length, value, heads, batch, dependencies, optimistic, trace) { return new Node(writer, length, value, heads, batch, dependencies, optimistic, trace) } // returns the global links of the dag, use this to link against the current state of the dag // TODO: rename to heads() and move the sets to _ props getHeads() { const heads = this._initialHeads.slice(0) for (const node of this.heads) heads.push({ key: node.writer.core.key, length: node.length }) return heads } // TODO: might contain dups atm, nbd for how we use it, returns an array of writers you can "pull" // to get the full dag view at any time getBootstrapWriters() { const writers = [] for (const head of this.heads) writers.push(head.writer) for (let i = 0; i < this.consensus.indexers.length; i++) writers.push(this.consensus.indexers[i]) return writers } addHead(node) { node.active() // 99.99% of the time _initialHeads is empty... if (this._initialHeads.length > 0) this._updateInitialHeads(node) if (node.isTail()) { this.tails.add(node) } for (const head of this.heads) { if (node.hasDependency(head)) { this.heads.delete(head) } } this.tip.add(node) if (node.writer.isActiveIndexer) this.consensus.addHead(node) this.size++ this.heads.add(node) this.updated = true return node } update() { if (!this.updated) return null this.updated = false // get the indexed nodes const indexed = [] while (true) { const nodes = this.consensus.shift() if (!nodes.length) break this._yield(nodes, indexed) } return this.tip.flush(indexed) } _updateInitialHeads(node) { for (const head of node.actualHeads) { for (let i = 0; i < this._initialHeads.length; i++) { const { key, length } = this._initialHeads[i] if (length !== head.length || !b4a.equals(key, head.key)) continue this._initialHeads.splice(i--, 1) } } } /* Ack methods */ shouldAck(writer, pending = false) { if (!writer || !writer.isActiveIndexer) return false // all indexers have to flushed to the dag before we ack as a quick "debounce" for (const w of this.indexers) { if (w.length !== w.available) return false } let isHead = false // if ANY head is not an indexer ack for (const head of this.heads) { if (!head.writer.isActiveIndexer) return true if (head.writer === writer) isHead = true } if (this.heads.size === 1 && isHead) { return false // never self-ack! } const visited = new Set() // check if there is non-null value let valueCheck = false for (const tail of this.tails) { if (pending || this._nonNull(tail, visited)) { valueCheck = true break } } if (!valueCheck) return false if (this.consensus.shouldAck(writer)) return true return this._shouldAckHeads(writer, pending) } // check if there is any value above this node _nonNull(target, visited) { const stack = [target] while (stack.length) { const node = stack.pop() if (visited.has(node)) continue if (node.value !== null) return true visited.add(node) for (const dep of node.dependents) { stack.push(dep) } } return false } // ack if any head is closer to confirming a value _shouldAckHeads(writer, pending) { const prev = writer.head() for (const head of this.heads) { // only check other writers heads if (head.writer === writer) continue const stack = [head] const visited = new Set() while (stack.length) { const node = stack.pop() if (visited.has(node)) continue visited.add(node) if (pending || node.value !== null) { const acks = this.consensus.acksFromNode(node, head) const prevAcks = this.consensus.acksFromNode(node, prev) // head sees more acks if (acks.size > prevAcks.size) return true for (const idx of acks) { // head sees acks that writer does not if (!prevAcks.has(idx)) return true } // both seen, no point going any further down if (prevAcks.size && acks.size) continue } stack.push(...node.dependencies) } } return false } /* Full DAG methods */ _yield(nodes, indexed = []) { const offset = indexed.length const tails = [] // determine which nodes are yielded while (nodes.length) { const node = nodes.pop() if (node.yielding) continue node.yielding = true if (node.isTail()) tails.push(node) nodes.push(...node.dependencies) } while (tails.length) { let tail = tails.pop() for (tail of this._removeBatch(tail)) { Topolist.add(tail, indexed, offset) } for (const dep of tail.dependents) { if (dep.isTail() && dep.yielding) tails.push(dep) } } return indexed } _isFutureTail(node) { let dropped = node.dropped // a tail has no unyielded dependencies for (const dep of node.dependencies) { if (dep.yielded) continue if (dropped === 0) return false dropped-- } return true } _removeNode(node) { this.tails.delete(node) this.heads.delete(node) this.consensus.remove(node) // update the tailset for (const d of node.dependents) { if (d.yielding && d.dependencies.has(node)) d.dropped++ // keep links for the indexed batch else d.dependencies.delete(node) if (this._isFutureTail(d)) this.tails.add(d) } node.yielded = true this.size-- if (this.heads.size === 0) { // in case of a single writer the dag might drain immediately... this._initialHeads.push({ key: node.writer.core.key, length: node.length }) } return node } _removeBatch(node) { const batch = [this._removeNode(node)] while (node.batch !== 1) { // its a batch! if (node.dependents.size === 0) { // bad batch node, auto correct const next = node.writer.get(node.length) if (next && next.batch === node.batch - 1) node.dependents.add(next) } assert(node.dependents.size === 1, 'Batch is linked partially, which is not allowed') node = getFirst(node.dependents) batch.push(this._removeNode(node)) } return batch } } function tieBreak(a, b) { return Topolist.compare(a, b) < 0 // lowest key wis } function getFirst(set) { return set[Symbol.iterator]().next().value } function sameNode(a, b) { return b4a.equals(a.key, b.writer.core.key) && a.length === b.length } const c = require('compact-encoding') const b4a = require('b4a') const messages = require('./messages.js') const GTE = b4a.from([messages.LINEARIZER_PREFIX]) const LT = b4a.from([messages.LINEARIZER_PREFIX + 1]) module.exports = class LocalState { constructor(core) { this.core = core this.tx = null } static clear(core) { const tx = core.state.storage.write() tx.deleteLocalRange(GTE, LT) return tx.flush() } static async moveTo(src, dst) { const boot = await src.getUserData('autobase/boot') const tx = dst.state.storage.write() tx.deleteLocalRange(GTE, LT) for await (const data of src.state.storage.createLocalStream({ gte: GTE, lt: LT })) { tx.putLocal(data.key, data.value) } tx.putUserData('autobase/boot', boot) await tx.flush() } setBootRecord(boot) { if (this.tx === null) this.tx = this.core.state.storage.write() this.tx.putUserData('autobase/boot', c.encode(messages.BootRecord, boot)) } async listUpdates() { const updates = [] for await (const data of this.core.state.storage.createLocalStream({ gte: GTE, lt: LT })) { const update = c.decode(messages.LinearizerUpdate, data.value) const seq = c.decode(messages.LinearizerKey, data.key) update.seq = seq updates.push(update) } return updates } clearUpdates() { if (this.tx === null) this.tx = this.core.state.storage.write() this.tx.deleteLocalRange(GTE, LT) } deleteUpdate(update) { if (this.tx === null) this.tx = this.core.state.storage.write() this.tx.deleteLocal(c.encode(messages.LinearizerKey, update.seq)) } insertUpdate(update) { if (this.tx === null) this.tx = this.core.state.storage.write() this.tx.putLocal( c.encode(messages.LinearizerKey, update.seq), c.encode(messages.LinearizerUpdate, update) ) } flush() { if (!this.tx) return Promise.resolve() const flushing = this.tx.flush() this.tx = null return flushing } } const schema = require('../encoding/spec/autobase') module.exports = { Wakeup: schema.resolveStruct('@autobase/wakeup'), Clock: schema.resolveStruct('@autobase/clock'), Checkout: schema.resolveStruct('@autobase/checkout'), BootRecord: schema.resolveStruct('@autobase/boot-record'), OplogMessage: schema.resolveStruct('@autobase/oplog-message'), Checkpoint: schema.resolveStruct('@autobase/checkpoint'), Info: schema.resolveStruct('@autobase/info'), Member: schema.resolveStruct('@autobase/member'), ManifestData: schema.resolveStruct('@autobase/manifest-data'), LINEARIZER_PREFIX: 1, LinearizerKey: schema.resolveStruct('@autobase/linearizer-key'), LinearizerUpdate: schema.resolveStruct('@autobase/linearizer-update'), EncryptionDescriptor: schema.resolveStruct('@autobase/encryption-descriptor') } const DEFAULT_SIZE = 32 module.exports = class NodeBuffer { constructor(offset, hwm) { this.hwm = hwm || DEFAULT_SIZE this.defaultHwm = this.hwm this.mask = this.hwm - 1 this.top = 0 this.btm = 0 this.buffer = new Array(this.hwm) this.offset = offset || 0 this.length = this.offset } get size() { return this.length - this.offset } isEmpty() { return this.length === this.offset } isFull() { return this.size === this.buffer.length } grow() { this.hwm <<= 1 const size = this.size const buffer = new Array(this.hwm) const mask = this.hwm - 1 for (let i = 0; i < size; i++) { buffer[i] = this.buffer[(this.btm + i) & this.mask] } this.mask = mask this.top = size this.btm = 0 this.buffer = buffer } push(data) { if (this.isFull()) this.grow() this.buffer[this.top] = data this.top = (this.top + 1) & this.mask return this.length++ } shift() { if (this.isEmpty()) return null const last = this.buffer[this.btm] this.buffer[this.btm] = undefined this.btm = (this.btm + 1) & this.mask this.offset++ // reset on empty if (this.isEmpty() && this.hwm !== this.defaultHwm) { this.buffer = new Array(this.defaultHwm) this.hwm = this.buffer.length this.mask = this.hwm - 1 this.top = this.btm = 0 } return last } get(seq) { if (seq < this.offset || seq >= this.length) return null return this.buffer[(this.btm + (seq - this.offset)) & this.mask] } } const b4a = require('b4a') const c = require('compact-encoding') const crypto = require('hypercore-crypto') const Hypercore = require('hypercore') const messages = require('./messages.js') const DEFAULT_MANIFEST_VERSION = 1 const INDEX_VERSION = 1 const MAX_TRACE_PER_VIEW = 256 const EMPTY = b4a.alloc(0) const [NS_SIGNER_NAMESPACE] = crypto.namespace('autobase', 1) class ViewCore { constructor(name, core, base) { this.name = name this.core = null this.batch = null this.atomicBatch = null this.moveTo = null this.tracer = new Tracer() this.shared = 0 this.ontruncate = (length) => { this.shared = Math.min(this.shared, length) } this.migrated(base, core) } getCore() { return this.atomicBatch || this.batch || this.core } migrated(base, core) { // TODO: close old core if present, for now we just close when the autobase is closed indirectly // atm its unsafe to do as moveTo has a bug due to a missing read lock in hc this.core = core if (this.name === '_system') { const ff = base._queueFastForward.bind(base) this.core.on('append', ff) this.core.ready().then(ff, ff) } } async matchesKey(key) { if (!this.core.opened) await this.core.ready() return b4a.equals(this.core.key, key) } async matchesNamespace(target) { if (!this.core.opened) await this.core.ready() if (this.core.manifest && this.core.manifest.signers.length > 0) { const ns = this.core.manifest.signers[0].namespace if (b4a.equals(ns, target)) return true } return false } getNextKey() { return this.moveTo ? this.moveTo[0].key : null } async commit(atom, length, signature) { // TODO: is this how its supposed be done atomic wise? await this.core.commit(this._getAtomicBatch(atom), { length, signature }) } async release() { if (!this.atomicBatch) return await this.atomicBatch.ready() while (this.atomicBatch.state.sessions.length) { await this.atomicBatch.state.sessions[0].close() } await this.atomicBatch.close() this.atomicBatch = null } _getAtomicBatch(atom) { if (this.atomicBatch === null) { this.atomicBatch = this.batch.session({ atom, writable: true }) this.atomicBatch.on('truncate', this.ontruncate) } return this.atomicBatch } async catchup(atom, length) { await this.release() const batch = this._getAtomicBatch(atom) await batch.ready() await batch.state.catchup(length) } createSession(atom, valueEncoding) { if (this.batch === null) { this.batch = this.core.session({ name: 'batch', writable: true }) this.batch.on('truncate', this.ontruncate) } const s = atom ? this._getAtomicBatch(atom).session({ valueEncoding, writable: true, onseq: this.tracer.onseq.bind(this.tracer) }) : this.batch.session({ valueEncoding, writable: false }) return s } } class Tracer { constructor() { this.enabled = false this.seen = new Set() } start() { this.enabled = true this.seen.clear() } end() { this.enabled = false return [...this.seen.values()] } onseq(seq, core) { if (!this.enabled) return if (this.seen.size >= MAX_TRACE_PER_VIEW) return if (seq >= core.signedLength) return this.seen.add(seq) } } class AutoStore { constructor(base, byName) { this.base = base this.store = base.store this.byName = byName || new Map() this.opened = [] this.atom = null this.local = null } async close() { if (this.local) await this.local.close() for (const v of this.byName.values()) { await v.release() } if (this.atom) return for (const v of this.byName.values()) { if (v.core) await v.core.close() if (v.batch) await v.batch.close() } } async export() { const views = [] for (const [name, value] of this.byName) { const core = await this.store.storage.export(value.core.discoveryKey, { batches: true }) views.push({ name, core }) } return views } atomize() { const store = new AutoStore(this.base, this.byName) store.atom = this.store.storage.createAtom() return store } async updateLocal() { if (!this.local) return await this.local.close() this.local = null } flush() { return this.atom ? this.atom.flush() : Promise.resolve() } get(opts, moreOpts) { if (typeof opts === 'string') opts = { name: opts } if (moreOpts) opts = { ...opts, ...moreOpts } const { name, valueEncoding = null } = opts if (!name) throw new Error('name is required') return this.getViewByName(name).createSession(this.atom, valueEncoding) } getViewByName(name) { let view = this.byName.get(name) if (!view) { const preload = this._preload(name) const core = this.base.store.get({ preload }) view = new ViewCore(name, core, this.base) this.byName.set(name, view) } if (this.opened.indexOf(view) === -1) { this.opened.push(view) } return view } getLocal() { if (this.local !== null) return this.local this.local = this.base.local.session({ atom: this.atom, valueEncoding: messages.OplogMessage, encryption: this.base.getWriterEncryption(this.base.local.key), active: false }) return this.local } getViews() { return [...this.byName.values()] } getViewCount() { return this.byName.size } getSystemView() { return this.getViewByName('_system') } getSystemCore() { return this.getSystemView().core } getEncryption(name) { if (!this.base.encryptionKey) return null if (name === '_encryption') return null return this.base.encryption.getViewEncryption(name) } async getIndexerManifests(entries) { const manifests = [] for (const { key } of entries) { const core = this.store.get({ key, active: false }) await core.ready() if (!core.manifest) continue // danger but only for bootstrapping... manifests.push(core.manifest) await core.close() } return manifests } getViewCore(indexerManifests, name, prologue, manifestVersion, entropy, linked, manifestData) { const manifest = this._createManifest( indexerManifests, name, prologue, manifestVersion, entropy, linked, manifestData ) return this.base.store.get({ manifest, exclusive: false, encryption: this.getEncryption(name) }) } listViews() { const views = [] for (const [name, ref] of this.byName) { const core = ref.batch || ref.core views.push({ name, key: core.key, length: core.length, signedLength: core.signedLength }) } return views } createAnchorCore(prologue, manifestData) { const manifest = { version: 2, hash: 'blake2b', prologue, allowPatch: false, quorum: 0, signers: [], userData: manifestData, linked: null } const core = this.store.get({ manifest, active: false }) return core } async createView( indexerManifests, name, prologue, manifestVersion, entropy, linked, manifestData ) { const manifest = this._createManifest( indexerManifests, name, prologue, manifestVersion, entropy, linked, manifestData ) const core = this.store.get({ key: Hypercore.key(manifest), manifest, active: false }) await core.ready() const key = core.key await core.close() return key } async _preload(name) { await Promise.resolve() if (!this.base.opening) throw new Error('Autobase failed to open') await this.base._preopen const boot = (await this.base._getSystemInfo()) || { key: this.getBootstrapSystemKey(), indexers: [], views: [], entropy: null } const indexerManifests = await this.getIndexerManifests(boot.indexers) // no system, everything is fresh if (boot.indexers.length === 0) { return this._freshCorePreload(indexerManifests, name, boot.entropy) } // asking for the system, just return it, easy if (name === '_system') { return { key: boot.key, exclusive: false, encryption: this.getEncryption(name) } } if (name === '_encryption') { const core = this.getSystemCore() await core.ready() if (!core.manifest.linked) { return this._freshCorePreload(indexerManifests, name, boot.entropy) } return { key: core.manifest.linked[0], exclusive: false, encryption: null } } // infer which view const v = await this.findViewByName(indexerManifests, boot.views, name, boot.entropy) // new view, fresh if (v === null) { return this._freshCorePreload(indexerManifests, name, boot.entropy) } return { key: v.key, exclusive: false, encryption: this.getEncryption(name) } } _freshCorePreload(indexerManifests, name, entropy) { if (name === '_system') return this._freshSystemPreload(indexerManifests, entropy) return { manifest: this._createManifest( indexerManifests, name, null, DEFAULT_MANIFEST_VERSION, entropy, [], null ), exclusive: true, encryption: this.getEncryption(name) } } _freshSystemPreload(indexerManifests, entropy) { return { manifest: this._createSystemManifest( indexerManifests, null, DEFAULT_MANIFEST_VERSION, entropy, null ), exclusive: true, encryption: this.getEncryption('_system') } } _deriveStaticHash(name) { // key doesnt matter... return crypto.hash([this.base.key, b4a.from(name)]) } _deriveNamespace(name, entropy) { const encryptionId = crypto.hash(this.base.encryptionKey || EMPTY) const version = c.encode(c.uint, INDEX_VERSION) const bootstrap = this.base.key return crypto.hash([ NS_SIGNER_NAMESPACE, version, bootstrap, encryptionId, entropy, b4a.from(name) ]) } async _getCoreManifest(key) { const core = this.store.get({ key, active: false }) await core.ready() const manifest = core.manifest await core.close() return manifest } getBootstrapSystemKey() { return Hypercore.key(this._createSystemManifest([], null, DEFAULT_MANIFEST_VERSION, null)) } async findViewByKey(key, indexers, manifestVersion, entropy) { for (const v of this.byName.values()) { if (await v.matchesKey(key)) return v } const manifest = await this._getCoreManifest(key) const target = manifest && manifest.signers.length ? manifest.signers[0].namespace : null if (target) { for (const v of this.byName.values()) { if (await v.matchesNamespace(target)) return v } } const indexerManifests = await this.getIndexerManifests(indexers) if (entropy === null) { entropy = indexerManifests[0].signers[0].namespace } if (target) { for (const v of this.byName.values()) { const namespace = this._deriveNamespace(v.name, entropy) if (b4a.equals(namespace, target)) return v } } // prob the empty prologue, we dont have manifest for those in FF if len=0 for (const v of this.byName.values()) { const manifestData = v.core ? v.core.manifest.userData : null const manifest = this._createManifest( indexerManifests, v.name, null, manifestVersion, entropy, [], manifestData ) const manifestKey = Hypercore.key(manifest) if (!b4a.equals(manifestKey, key)) continue // we didnt have the core! this is because it is empty, ensure its on disk const core = this.store.get({ key: manifestKey, manifest, active: false }) await core.ready() await core.close() return v } return null } async findViewByName(indexerManifests, views, name, entropy) { if (indexerManifests.length === 0) return null if (entropy === null) entropy = indexerManifests[0].signers[0].namespace const namespace = this._deriveNamespace(name, entropy) for (const v of views) { const manifest = await this._getCoreManifest(v.key) if (manifest.signers.length === 0) continue const signer = manifest.signers[0] if (b4a.equals(signer.namespace, namespace)) return v } return null } _createManifest(indexerManifests, name, prologue, version, entropy, linked, manifestData) { if (!indexerManifests.length) { prologue = { hash: this._deriveStaticHash(name), length: 0 } } else if (prologue && prologue.length === 0) { // just in case prologue = null } const signers = [] if (indexerManifests.length && entropy === null) { entropy = indexerManifests[0].signers[0].namespace } for (const manifest of indexerManifests) { const signer = manifest.signers[0] signers.push({ namespace: this._deriveNamespace(name, entropy), signature: 'ed25519', publicKey: signer.publicKey }) } return { version, hash: 'blake2b', prologue, allowPatch: true, quorum: Math.min(signers.length, (signers.length >> 1) + 1), signers, userData: manifestData, linked: version > 1 ? linked : null } } _createSystemManifest(indexerManifests, prologue, version, entropy, manifestData) { if (prologue !== null) throw new Error('Can only derive fresh system core') const linked = [] if (version > DEFAULT_MANIFEST_VERSION) { const encManifest = this._createManifest( indexerManifests, '_encryption', null, version, entropy, [], manifestData ) linked.push(Hypercore.key(encManifest)) } return this._createManifest( indexerManifests, '_system', null, version, entropy, linked, manifestData ) } } module.exports = AutoStore const Hyperbee = require('hyperbee') const SubEncoder = require('sub-encoder') const ReadyResource = require('ready-resource') const b4a = require('b4a') const c = require('compact-encoding') const crypto = require('hypercore-crypto') const { Info, Member } = require('./messages.js') const { DEFAULT_AUTOBASE_VERSION } = require('./caps.js') const subs = new SubEncoder() const DIGEST = subs.sub(b4a.from([0])) const MEMBERS = subs.sub(b4a.from([1])) const INFO_KEY = DIGEST.encode('info') const [GENESIS_ENTROPY, NS_ENTROPY] = crypto.namespace('autobase/entropy', 2) module.exports = class SystemView extends ReadyResource { constructor(core, { checkout = 0, empty = false } = {}) { super() this.core = core // sessions is a workaround for batches not having sessions atm... this.db = new Hyperbee(core, { keyEncoding: 'binary', extension: false, checkout, sessions: typeof core.session === 'function' }) this.version = DEFAULT_AUTOBASE_VERSION this.members = 0 this.pendingIndexers = [] this.indexers = [] this.heads = [] this.views = [] this.encryptionLength = 0 this.entropy = null this.indexerUpdate = false this._empty = empty this._fork = 0 this._length = 0 this._changes = [] this._indexerMap = new Map() this._clockUpdates = new Map() } static GENESIS_ENTROPY = GENESIS_ENTROPY static async getIndexedInfo(core, length) { const sys = new this(core.session()) try { return await sys.getIndexedInfo(length) } finally { await sys.close() } } static async *flushes(core, { reverse, lt = core.length, gte = 0, wait = true } = {}) { if (lt <= 0) return // ensure block await core.get(lt - 1) const sys = new SystemView(core) try { for await (const data of sys.db.createHistoryStream({ lt, gte, wait, reverse: true })) { if (!b4a.equals(data.key, INFO_KEY)) continue const info = c.decode(Info, data.value) yield { length: data.seq + 1, info } } } finally { await sys.close() } } get bootstrapping() { return this.members === 0 } async checkout(length) { const checkout = new SystemView(this.core.session(), { checkout: length, empty: length === 0 }) await checkout.ready() return checkout } async _open() { // this should NEVER fail, if so we have a bug elsewhere (should always be consistent) const info = this._empty ? null : await this.db.get('info', { valueEncoding: Info, keyEncoding: DIGEST, update: false, wait: false }) await this._reset(info) } async _close() { await this.db.close() } async getIndexedInfo(length = this.core.signedLength) { if (this.opened === false) await this.ready() if (length === this.core.length) { return { version: this.version, members: this.members, pendingIndexers: this.pendingIndexers, indexers: this.indexers, heads: this.heads, views: this.views, encryptionLength: this.encryptionLength, entropy: this.entropy } } const node = length === 0 ? null : await this.db.getBySeq(length - 1) if (node === null) { return { version: DEFAULT_AUTOBASE_VERSION, members: 0, pendingIndexers: [], indexers: [], heads: [], views: [], encryptionLength: 0, entropy: null } } return c.decode(Info, node.value) } static sameIndexers(a, b) { if (a.length !== b.length) return false for (let i = 0; i < a.length; i++) { if (!b4a.equals(a[i].key, b[i].core.key)) return false } return true } sameIndexers(indexers) { return SystemView.sameIndexers(this.indexers, indexers) } async history(since) { const checkout = this.db.checkout(since) const seen = new Map() const nodes = [] const updates = [] const checkoutNode = since === 0 ? null : await this.db.getBySeq(since - 1) let prevInfo = checkoutNode === null ? null : c.decode(Info, checkoutNode.value) let updateBatch = 0 for await (const data of this.db.createHistoryStream({ gte: since })) { if (b4a.equals(data.key, INFO_KEY)) { const info = c.decode(Info, data.value) updates.push({ batch: updateBatch, indexers: prevInfo === null || !sameIndexers(info, prevInfo), systemLength: data.seq + 1 }) prevInfo = info updateBatch = 0 continue } const key = data.key.subarray(2) const hex = b4a.toString(key, 'hex') const len = c.decode(Member, data.value).length if (!seen.has(hex)) { const node = await checkout.get(data.key) if (node === null) { seen.set(hex, 0) } else { const { length } = c.decode(Member, node.value) seen.set(hex, length) } } const prev = seen.get(hex) const batch = len - prev seen.set(hex, len) if (batch === 0) continue updateBatch += batch if (nodes.length > 0) { const top = nodes[nodes.length - 1] if (b4a.equals(top.key, key)) { top.length = len top.batch += batch continue } } nodes.push({ key, length: len, batch }) } await checkout.close() return { updates, nodes } } async update() { if (this.opened === false) await this.ready() if (this._fork === this.core.fork && this._length === this.core.length) return false await this._reset( this._empty ? null : await this.db.get('info', { valueEncoding: Info, keyEncoding: DIGEST }) ) return true } async _reset(info) { this.version = info === null ? DEFAULT_AUTOBASE_VERSION : info.value.version this.members = info === null ? 0 : info.value.members this.pendingIndexers = info === null ? [] : info.value.pendingIndexers this.indexers = info === null ? [] : info.value.indexers this.heads = info === null ? [] : info.value.heads this.views = info === null ? [] : info.value.views this.encryptionLength = info === null ? 0 : info.value.encryptionLength this.entropy = info === null ? null : info.value.entropy this.indexerUpdate = false this._indexerMap.clear() this._clockUpdates.clear() this._length = this.core.length this._fork = this.core.fork this._changes = [] for (const idx of this.indexers) { this._indexerMap.set(b4a.toString(idx.key, 'hex'), idx) } } // helper used by apply-state flushLength() { const header = this.core.length ? 0 : 1 // account for header let updates = this._changes.length + this._clockUpdates.size for (const { key } of this._changes) { const hex = b4a.toString(key, 'hex') if (this._clockUpdates.has(hex)) updates-- // shared are skipped } return header + this.core.length + updates + 1 } async flush(views) { const batch = this.db.batch({ update: false }) for (let i = 0; i < this._changes.length; i++) { const c = this._changes[i] if (this._clockUpdates.has(b4a.toString(c.key, 'hex'))) continue await batch.put(c.key, c.value, { valueEncoding: Member, keyEncoding: MEMBERS }) } for (const [hex, length] of this._clockUpdates) { const isIndexer = this._indexerMap.get(hex) !== undefined const key = b4a.from(hex, 'hex') const info = await this._get(key, 0) const value = { isIndexer, isRemoved: info ? info.isRemoved : true, length } await batch.put(key, value, { valueEncoding: Member, keyEncoding: MEMBERS }) } if (this.indexerUpdate) { this._refreshEntropy(this.core.length + batch.length + 1) } this._clockUpdates.clear() let maxIndex = -1 for (const view of views) { if (view.mappedIndex > maxIndex) maxIndex = view.mappedIndex } while (this.views.length > maxIndex + 1) this.views.pop() for (const view of views) { const length = view.core ? view.core.length : view.length if (!length) continue const v = { key: view.key, length } if (view.mappedIndex !== -1) { this.views[view.mappedIndex] = v } else { view.mappedIndex = this.views.push(v) - 1 } } const info = { version: this.version, members: this.members, pendingIndexers: this.pendingIndexers, indexers: this.indexers, heads: this.heads, views: this.views, encryptionLength: this.encryptionLength, entropy: this.entropy } await batch.put('info', info, { valueEncoding: Info, keyEncoding: DIGEST }) await batch.flush() this._length = this.core.length // should be ok this._changes = [] if (this.indexerUpdate) this.indexerUpdate = false } getEntropy(indexers, length) { return generateEntropy(indexers, length, this.entropy) } _refreshEntropy(length) { if (this.version < 2) return this.entropy = this.getEntropy(this.indexers, length) } checkpoint() { return { version: this.version, members: this.members, pendingIndexers: this.pendingIndexers.slice(0), indexers: cloneNodes(this.indexers), heads: cloneNodes(this.heads), views: cloneNodes(this.views), indexerUpdate: this.indexerUpdate, encryptionLength: this.encryptionLength, entropy: this.entropy ? b4a.from(this.entropy) : null, changes: this._changes.slice(0), clockUpdates: new Map([...this._clockUpdates]) } } applyCheckpoint(checkpoint) { this.version = checkpoint.version this.members = checkpoint.members this.pendingIndexers = checkpoint.pendingIndexers this.indexers = checkpoint.indexers this.heads = checkpoint.heads this.views = checkpoint.views this.indexerUpdate = checkpoint.indexerUpdate this.encryptionLength = checkpoint.encryptionLength this.entropy = checkpoint.entropy this._changes = checkpoint.changes this._clockUpdates = checkpoint.clockUpdates this._indexerMap = new Map() for (const idx of this.indexers) { this._indexerMap.set(b4a.toString(idx.key, 'hex'), idx) } } addHead(node) { const h = { key: node.writer.core.key, length: node.length } for (let i = 0; i < this.heads.length; i++) { const head = this.heads[i] if (!hasDependency(node, head)) { if (!b4a.equals(node.writer.core.key, head.key)) continue // todo: remove in next major because bug was fixed here: // https://github.com/holepunchto/autobase-next/pull/237 // filter out any bad heads introduced by a bug to // prevent inconsistencies being written to the oplog if (head.length > h.length) return false } const popped = this.heads.pop() if (popped !== head) this.heads[i--] = popped } this.heads.push(h) const hex = b4a.toString(h.key, 'hex') this._clockUpdates.set(hex, h.length) if (this.pendingIndexers.length > 0) { for (let i = 0; i < this.pendingIndexers.length; i++) { if (!b4a.equals(this.pendingIndexers[i], h.key)) continue this._updateIndexer(h.key, h.length, true, i) return true } } const idx = this._indexerMap.get(hex) if (idx !== undefined) { idx.length = h.length } return false } _updateIndexer(key, length, isIndexer, i) { const hex = b4a.toString(key, 'hex') if (!isIndexer) { const existing = this._indexerMap.get(hex) if (existing) { this.indexerUpdate = true this.indexers.splice(this.indexers.indexOf(existing), 1) this._indexerMap.delete(hex) } return } for (; i < this.pendingIndexers.length; i++) { if (b4a.equals(this.pendingIndexers[i], key)) { break } } if (length === 0) { if (i >= this.pendingIndexers.length) this.pendingIndexers.push(key) return } if (i < this.pendingIndexers.length) { const top = this.pendingIndexers.pop() if (i < this.pendingIndexers.length) this.pendingIndexers[i] = top } const idx = this._indexerMap.get(hex) if (idx === undefined) { const newIdx = { key, length } this._indexerMap.set(hex, newIdx) this.indexers.push(newIdx) // bootstrap is "silently" added so that initial views have no prologue if (!this.bootstrapping) this.indexerUpdate = true } else { idx.length = length } } _seenLength(key) { return this._clockUpdates.get(b4a.toString(key, 'hex')) || 0 } async ack(key) { const value = await this._get(key, 0) const length = this._seenLength(key) if (value && value.length === length) return const isIndexer = value ? value.isIndexer : false const isRemoved = value ? value.isRemoved : true this._changes.push({ key, value: { isIndexer, isRemoved, length } }) } async add(key, { isIndexer = false, length = this._seenLength(key) } = {}) { let value = null let found = false let changed = true for (let i = this._changes.length - 1; i >= 0; i--) { const c = this._changes[i] if (b4a.equals(key, c.key)) { value = c.value found = true break } } if (!found) { const node = await this.db.get(key, { valueEncoding: Member, keyEncoding: MEMBERS }) if (node) { value = node.value found = true } } let wasTracked = false let wasIndexer = false if (found) { if (!value.isRemoved) wasTracked = true if (value.isIndexer) wasIndexer = true if (length < value.length) length = value.length if (value.length === length && value.isIndexer === isIndexer && value.isRemoved === false) changed = false } if (changed) { this._changes.push({ key, value: { isIndexer, isRemoved: false, length } }) } if (!wasTracked) this.members++ if (wasIndexer || isIndexer) this._updateIndexer(key, length, isIndexer, 0) } async remove(key) { let isIndexer = false for (const idx of this.indexers) { isIndexer = b4a.equals(idx.key, key) if (isIndexer) break } if (isIndexer) this._updateIndexer(key, null, false, 0) let value = null let found = false for (let i = this._changes.length - 1; i >= 0; i--) { const c = this._changes[i] if (b4a.equals(key, c.key)) { value = c.value found = true break } } if (!found) { const node = await this.db.get(key, { valueEncoding: Member, keyEncoding: MEMBERS }) if (node) { value = node.value found = true } } const changed = !found || !value.isRemoved const wasTracked = found && !value.isRemoved const length = found ? value.length : 0 if (changed) { this._changes.push({ key, value: { isIndexer: false, isRemoved: true, length } }) } if (wasTracked) this.members-- return isIndexer } async linkable(key, length) { const len = this._seenLength(key) if (len > 0) return length > len const info = await this._get(key, 0) const prevLength = info ? info.length : 0 return length > prevLength } async has(key, opts) { // could be optimised... return (await this.get(key, opts)) !== null } async _get(key, timeout) { let value = null let found = false for (let i = this._changes.length - 1; i >= 0; i--) { const c = this._changes[i] if (b4a.equals(key, c.key)) { value = c.value found = true break } } if (!found) { const node = await this.db.get(key, { timeout, valueEncoding: Member, keyEncoding: MEMBERS }) if (node) { value = node.value found = true } } return found ? value : null } async get(key, opts = {}) { if (this._empty) return null let value = await this._get(key, opts.timeout || 0) if (opts.unflushed) { const hex = b4a.toString(key, 'hex') for (let i = this._changes.length - 1; i >= 0; i--) { const c = this._changes[i] if (b4a.equals(c.key, key)) value = c.value } if (this._clockUpdates.has(hex)) value.length = this._clockUpdates.get(hex) } return opts.onlyActive !== false || !value.isRemoved ? value : null } async hasLocal(key) { if (this._empty) return false try { const node = await this.db.get(key, { valueEncoding: Member, keyEncoding: MEMBERS, update: false, wait: false }) return node !== null } catch { return false } } async getLocalLength(key) { if (this._empty) return 0 try { const node = await this.db.get(key, { valueEncoding: Member, keyEncoding: MEMBERS, update: false, wait: false }) return node === null ? 0 : node.value.length } catch { return 0 } } list() { // note, NOT safe to use during apply atm return this.db.createReadStream({ valueEncoding: Member, keyEncoding: MEMBERS }) } async isIndexed(key, length) { const co = this.db.checkout(this.core.indexedLength) try { const node = await co.get(key, { valueEncoding: Member, keyEncoding: MEMBERS }) return node !== null && node.value.length >= length } finally { await co.close() } } async fork(indexers, manifests, encryptionLength, views) { this.indexers = [] this.pendingIndexers = [] this.views = views if (this.version < 2) this.version = 2 // bump to enable entropy for (const { key } of indexers) { // todo: probably need to check isRemoved etc const { length } = await this.get(key) this.indexers.push({ key, length }) } this._refreshEntropy(this.core.length) const blocks = [] // truncate needs to respect hypercore batch let truncate = this.core.length - 1 for await (const data of this.db.createHistoryStream({ lt: truncate, reverse: true })) { if (b4a.equals(data.key, INFO_KEY)) { truncate = data.seq + 1 break } blocks.push(data) } await this.core.truncate(truncate, this.core.fork) const batch = this.db.batch({ update: false }) await batch.ready() for (const { key, value } of blocks) { await batch.put(key, value) } const info = { version: this.version, members: this.members, pendingIndexers: this.pendingIndexers, indexers: this.indexers, heads: this.heads, views: this.views, encryptionLength, entropy: this.entropy } await batch.put('info', info, { valueEncoding: Info, keyEncoding: DIGEST }) await batch.flush() await this._reset(await this.db.get('info', { valueEncoding: Info, keyEncoding: DIGEST })) return truncate } } function hasDependency(node, dep) { for (const h of node.actualHeads) { if (sameNode(h, dep)) return true } return false } function sameNode(a, b) { return b4a.equals(a.key, b.key) && a.length === b.length } function sameIndexers(a, b) { if (a.views.length > 0 && b.views.length > 0) return b4a.equals(a.views[0].key, b.views[0].key) if (a.indexers.length !== b.indexers.length) return false for (let i = 0; i < a.indexers.length; i++) { if (!b4a.equals(a.indexers[i].key, b.indexers[i].key)) return false } return true } function cloneNodes(arr) { const c = [] for (let i = 0; i < arr.length; i++) { c.push({ key: arr[i].key, length: arr[i].length }) } return c } function generateEntropy(indexers, length, entropy) { const buffer = b4a.alloc(8 + 32 + indexers.length * 32) const state = { start: 0, end: buffer.byteLength, buffer } c.uint64.encode(state, length) c.fixed32.encode(state, entropy || GENESIS_ENTROPY) for (const { key } of indexers) c.fixed32.encode(state, key) return crypto.hash([NS_ENTROPY, buffer]) } const safetyCatch = require('safety-catch') const MAX_WAIT = 2 * 60 * 1000 const DEFAULT_INTERVAL = 10 * 1000 module.exports = class Timer { constructor(handler, interval, opts = {}) { this.handler = handler || noop this.interval = interval || DEFAULT_INTERVAL this.limit = opts.limit || MAX_WAIT this._executing = null this._limit = random2over1(this.limit) this._timer = null this._resolve = null this._start = 0 this._stopped = false this._asap = false this._standalone = new Set() this._unref = opts.unref !== false this._timerCallback = this._executeBackground.bind(this) } _executeBackground() { this._executing = this._execute() this._executing.catch(safetyCatch) // make sure it doesnt crash in the bg } async _execute() { this._asap = false await this.handler() this._start = 0 this._executing = null this.bump() } bump() { if (this._stopped || this._executing || this._asap) return if (!this._start) this._start = Date.now() else if (Date.now() - this._start > this._limit) return const interval = random2over1(this.interval) clearTimeout(this._timer) this._timer = setTimeout(this._timerCallback, interval) if (this._unref && this._timer.unref) this._timer.unref() } async trigger() { if (this._stopped) return if (this._executing) await this._executing if (this._stopped) return clearTimeout(this._timer) this._timer = null this._executeBackground() await this._executing } async flush() { if (this._executing) await this._executing } // business-as-usual bau() { if (!this._asap) return this._asap = false this.bump() } asap() { if (this._asap) return this._asap = true const interval = Math.floor((Math.random() * this.interval) / 3) clearTimeout(this._timer) this._timer = setTimeout(this._timerCallback, interval) if (this._unref && this._timer.unref) this._timer.unref() } stop() { if (this._timer) clearTimeout(this._timer) this._timer = null this._start = 0 this._asap = false this._stopped = true for (const { timer, resolve } of this._standalone) { clearTimeout(timer) resolve() } this._standalone.clear() } asapStandalone() { const interval = Math.floor((Math.random() * this.interval) / 3) return new Promise((resolve) => { const ref = { timer: null, resolve } ref.timer = setTimeout(resolveStandalone, interval, ref, this._standalone) if (ref.timer.unref) ref.timer.unref() this._standalone.add(ref) }) } unref() { if (this._timer && this._timer.unref) this._timer.unref() } } function resolveStandalone(ref, set) { set.delete(ref) ref.resolve() } // random value x between n <= x < 2n function random2over1(n) { return Math.floor(n + Math.random() * n) } function noop() {} const b4a = require('b4a') const assert = require('nanoassert') module.exports = class TopoList { constructor() { this.tip = [] this.undo = 0 this.shared = 0 } static compare(a, b) { return cmp(a, b) } static add(node, indexed, offset) { addSorted(node, indexed, offset) } mark() { this.shared = this.tip.length this.undo = 0 } // todo: bump to new api that just tracks undo flush(indexed = []) { if (indexed.length) this._applyIndexed(indexed) const u = { shared: this.shared, undo: this.undo, length: indexed.length + this.tip.length, indexed, tip: this.tip } this.mark() return u } print() { return this.tip.map((n) => n.writer.core.key.toString() + n.length) } _applyIndexed(nodes) { assert(nodes.length <= this.tip.length, 'Indexed batch cannot exceed tip') let shared = 0 for (; shared < nodes.length; shared++) { if (this.tip[shared] !== nodes[shared]) break } // reordering if (shared < nodes.length) this._track(shared) const tip = [] for (let i = shared; i < this.tip.length; i++) { const node = this.tip[i] if (node.yielded) continue const s = addSorted(node, tip, 0) if (s === tip.length - 1) continue this._track(shared + s) } this.tip = tip } add(node) { const shared = addSorted(node, this.tip, 0) this._track(shared) } _track(shared) { if (shared < this.shared) { this.undo += this.shared - shared this.shared = shared } } } function hasOptimisticDeps(node) { for (const d of node.dependencies) { if (d.optimistic) return true } return false } // this can be optimised to only return optimistic nodes that we will "touch" when moving down the node function getOptimisticDeps(node, list) { const deps = new Set() const stack = [node] while (stack.length > 0) { const next = stack.pop() if (deps.has(next)) continue if (next.optimistic && next !== node) deps.add(next) for (const d of next.dependencies) { if (d.optimistic) stack.push(d) } } const result = [] for (let i = list.length - 1; deps.size !== result.length && i >= 0; i--) { const n = list[i] if (deps.has(n)) result.push(n) } return result.reverse() } function addSortedOptimistic(node, list, offset) { const opt = getOptimisticDeps(node, list) const pos = new Uint32Array(opt.length) for (let i = 0; i < opt.length; i++) { const n = opt[i] pos[i] = n.index moveDown(n, list, offset) } moveDownAndUp(node, list, offset) for (let i = opt.length - 1; i >= 0; i--) { moveOptimisticUp(opt[i], list, offset) } let shared = node.index for (let i = 0; i < opt.length; i++) { const idx = pos[i] const n = opt[i] if (idx === n.index) continue if (idx < shared) shared = idx if (n.index < shared) shared = n.index } return shared } function addSorted(node, list, offset) { list.push(node) node.index = list.length - 1 // "slow" path, 1% of nodes if (hasOptimisticDeps(node)) return addSortedOptimistic(node, list, offset) moveDownAndUp(node, list, offset) return node.index } function moveDown(node, list, offset) { while (node.index > offset) { const prev = list[node.index - 1] if (links(node, prev)) break list[(prev.index = node.index)] = prev list[--node.index] = node } } function moveOptimisticUp(node, list, offset) { // if optimistic move all the way up while (node.index < list.length - 1) { const next = list[node.index + 1] if (links(next, node)) break list[(next.index = node.index)] = next list[++node.index] = node } // stable sort in case multiple children while (node.index > offset) { const prev = list[node.index - 1] if (!prev.optimistic) break const c = cmp(prev, node) if (c <= 0) break list[(prev.index = node.index)] = prev list[--node.index] = node } } function moveNonOptimisticUp(node, list, offset) { // stable sort against next non optimistic node while (node.index < list.length - 1) { const next = list[node.index + 1] const c = cmpNonOptimistic(node, next, list) if (c <= 0) break list[(next.index = node.index)] = next list[++node.index] = node } } function moveDownAndUp(node, list, offset) { moveDown(node, list, offset) if (node.optimistic) moveOptimisticUp(node, list, offset) else moveNonOptimisticUp(node, list, offset) } function links(a, b) { if (b.dependents.has(a)) return true return a.length > 0 && b.length === a.length - 1 && a.writer === b.writer } function cmpNonOptimistic(a, b, list) { if (!b.optimistic) return cmp(a, b) for (let i = b.index + 1; i < list.length; i++) { const node = list[i] if (!node.optimistic) return cmp(a, node) } return -1 } function cmp(a, b) { return links(b, a) ? -1 : cmpUnlinked(a, b) } function cmpUnlinked(a, b) { const c = b4a.compare(a.writer.core.key, b.writer.core.key) return c === 0 ? (a.length < b.length ? -1 : 1) : c } module.exports = class UpdateChanges { constructor(base) { this.base = base this.byName = new Map() this.tracking = null } get discoveryKey() { return this.base.discoveryKey } get key() { return this.base.key } get id() { return this.base.id } get system() { return this.base.system } track(state) { this.tracking = [] this.byName.clear() if (!state) return for (const v of state.views) { if (v.ref) this._add(v.ref) } this._add(state.systemView.ref) this._add(state.encryptionView.ref) } _add(ref) { const core = ref.atomicBatch || ref.batch const from = core.length const inf = { ref, from } ref.shared = from this.tracking.push(inf) } finalise() { if (this.tracking === null) return for (const { ref, from } of this.tracking) { const core = ref.atomicBatch || ref.batch this.byName.set(ref.name, { from, to: core.length, shared: ref.shared }) } this.tracking = null } get(name) { return this.byName.get(name) } } const crypto = require('hypercore-crypto') const c = require('compact-encoding') const b4a = require('b4a') const { OPLOG_VERSION } = require('./caps.js') const { OplogMessage } = require('./messages.js') const { EncryptionView } = require('./encryption.js') module.exports = { encodeValue, decodeValue } function encodeValue(value, opts = {}) { const state = { start: 0, end: 0, buffer: null } const message = { version: opts.version || OPLOG_VERSION, digest: null, checkpoint: null, optimistic: !!opts.optimistic, node: { heads: opts.heads || [], batch: 1, value } } OplogMessage.preencode(state, message) if (opts.padding) { state.start = opts.padding state.end += opts.padding } state.buffer = b4a.alloc(state.end) OplogMessage.encode(state, message) if (!opts.encrypted) return state.buffer if (!opts.optimistic) { throw new Error('Encoding an encrypted value is not supported') } const padding = b4a.alloc(16) // min hash length is 16 crypto.hash(state.buffer, padding) padding[0] = 0 return b4a.concat([padding.subarray(0, 8), state.buffer]) } async function decodeValue(value, { autobase, encryptionKey, key, manifest, index = 0 } = {}) { if (encryptionKey) { const e = new EncryptionView({ encryptionKey, bootstrap: autobase }) const w = e.getWriterEncryption() await w.decrypt(index, value, { key, manifest }) value = value.subarray(8) } const op = c.decode(OplogMessage, value) return op.node.value } const b4a = require('b4a') const c = require('compact-encoding') const safetyCatch = require('safety-catch') const ReadyResource = require('ready-resource') const WakeupEntry = { preencode(state, m) { c.fixed32.preencode(state, m.key) c.uint.preencode(state, m.length) }, encode(state, m) { c.fixed32.encode(state, m.key) c.uint.encode(state, m.length) }, decode(state) { return { key: c.fixed32.decode(state), length: c.uint.decode(state) } } } module.exports = class AutoWakeup extends ReadyResource { constructor(base) { super() this.base = base this.flushing = null this._rootStore = this.base.store this._addBound = this.add.bind(this) this._preupdateBound = this._preupdate.bind(this) this._needsFlush = false this._map = new Map() } [Symbol.iterator]() { return this._map.values() } async _preupdate(batch, key) { this.queue(key, batch.length) await this.flush() this.base._onwakeup() } async _save() { const slab = b4a.allocUnsafe(8 + this._map.size * 40) // 32 + 8 const state = { start: 0, end: 0, buffer: slab } c.uint.encode(state, this._map.size) for (const m of this._map.values()) WakeupEntry.encode(state, m) await this.base.local.setUserData('autobase/wakeup', slab.subarray(0, state.start)) } async _load() { const buffer = await this.base.local.getUserData('autobase/wakeup') if (!buffer) return const state = { start: 0, end: buffer.byteLength, buffer } let len = c.uint.decode(state) while (len-- > 0) { const m = WakeupEntry.decode(state) this._map.set(b4a.toString(m.key, 'hex'), m) } } async _open() { await this._load() this._rootStore.watch(this._addBound) for (const core of this._rootStore.cores) { if (core.opened === false) await core.ready().catch(noop) if (!core.closing) this.add(core) } } async _close() { this._rootStore.unwatch(this._addBound) for (const core of this._rootStore.cores) { if (core.opened && !core.closing) this.remove(core) } this._map.clear() while (this.flushing) { try { await this.flushing } catch {} } } queue(key, length) { const hex = b4a.toString(key, 'hex') const m = this._map.get(hex) if (m && m.length > length) { return false } this._needsFlush = true this._map.set(hex, { key, length }) return true } unqueue(key, length) { const hex = b4a.toString(key, 'hex') const m = this._map.get(hex) if (!m) return true if (m.length > length) return false this._needsFlush = true this._map.delete(hex) return true } async flush() { if (this.closing) throw new Error('Closing') // wait for someone if (this.flushing) await this.flushing // if another still active they flushed us if (this.flushing) return this.flushing if (this._needsFlush === false) return this._needsFlush = false try { this.flushing = this._save() return await this.flushing } finally { this.flushing = null } } add(core) { return this._add(core).catch(safetyCatch) } remove(core) { return this._remove(core) } async _add(core) { if (core.opened === false) await core.ready() if (core.closing) return false // local writer, no need if (core === this.base.local.core) return false const rx = core.storage.read() const referrerPromise = rx.getUserData('referrer') const viewPromise = rx.getUserData('autobase/view') rx.tryFlush() const [referrer, view] = await Promise.all([referrerPromise, viewPromise]) if (view) return false if (referrer === null || !b4a.equals(referrer, this.base.key)) return false core.preupdate = this._preupdateBound return true } _remove(core) { if (core.preupdate !== this._preupdateBound) return false core.preupdate = null return true } } function noop() {} const c = require('compact-encoding') const b4a = require('b4a') const ReadyResource = require('ready-resource') const assert = require('nanoassert') const SignalPromise = require('signal-promise') const Linearizer = require('./linearizer.js') const NodeBuffer = require('./node-buffer.js') const MAX_PRELOAD = 4 const MAX_PREFETCH = 256 module.exports = class Writer extends ReadyResource { constructor(base, core, length, isRemoved) { super() this.base = base this.core = core this.isRemoved = isRemoved this.updated = false this.range = null this.nodes = new NodeBuffer(length) this.node = null this.isActive = false this.isCurrentlyCoupled = false this.isCoupled = false // maintained by updateBootstrapWriters this.isBootstrap = false // maintained by updateBootstrapWriters this.isActiveIndexer = false this.available = length this.length = length this.seenLength = 0 this.recover = false this.frozen = false this.syncSignal = null } _pause() { if (!this.range) return this.range.destroy() this.range = null } _resume() { if (this.range) { // if we didnt fill up the preload buffer yet, do not commit to more work if (this.range.range.end === this.nodes.length + MAX_PREFETCH) return this.range.destroy() } this.range = this.core.download({ start: this.nodes.length, end: this.nodes.length + MAX_PREFETCH, linear: true }) } _updateCoupling() { if (!this.base._coupler || this.isCoupled === this.isCurrentlyCoupled) return if (this.isCurrentlyCoupled) this.base._coupler.remove(this.core) else this.base._coupler.add(this.core) this.isCurrentlyCoupled = this.isCoupled } _removeCouple() { if (this.base._coupler && !this.isCoupled && this.isCurrentlyCoupled) { this.isCurrentlyCoupled = false this.base._coupler.remove(this.core) } } updateActivity() { if (!this.core.opened) return if (this.seenLength > this.core.length || this.length < this.core.length || this.isBootstrap) { // if we have seen a later core, or if we are behind, or if bootstrap this.isActive = true this.core.setActive(true) } else if (this.length === this.core.length) { // things look steady this.isActive = false this.core.setActive(false) } this._updateCoupling() if (this.core.writable) return if (this.base.isFastForwarding() || !this.isActive) { this._pause() } else { this._resume() } } setBootstrap(bool) { this.isBootstrap = bool this.updateActivity() } seen(length) { if (length > this.seenLength) this.seenLength = length this.updateActivity() } waitForSynced() { if (this.core.length === this.length) return Promise.resolve() if (this.syncSignal === null) this.syncSignal = new SignalPromise() return this.syncSignal.wait() } async _open() { await this.core.ready() await this.core.setUserData('referrer', this.base.key) // base might be closing here if (this.base.closing) return // remove later this.recover = autoRecover(this.core) // add it again incase it wasn't readied before, only needed if this is the first time we set the referrer... await this.base._wakeup.add(this.core.core) this.updateActivity() if (this.core.length > this.length) this.base._queueBump() this.base.emit('writer', this) } _close() { if (this.syncSignal !== null) this.syncSignal.notify() return this.core.close() } get indexed() { return this.nodes.offset } idle() { return this.length === this.available && this.length === this.core.length && this.core.opened } flushed() { // TODO: prop a cleaner way to express this... return ( this.seenLength <= this.length && this.length === this.available && this.length === this.core.length && this.shiftable() === false && !this.core.core.upgrading && this.core.opened ) } compare(writer) { return b4a.compare(this.core.key, writer.core.key) } head() { return this.nodes.get(this.length - 1) } advance() { if (this.syncSignal !== null && this.length + 1 === this.core.length) this.syncSignal.notify() return this.length < this.available ? this.nodes.get(this.length++) : null } shiftable() { return this.length > this.nodes.offset } shift() { if (this.shiftable() === false) return false let node = this._shiftAndClear() while (node.batch > 1) node = this._shiftAndClear() return true } get(seq) { return seq < this.length ? this.nodes.get(seq) : null } append(value, heads, batch, dependencies, optimistic) { const node = Linearizer.createNode( this, this.nodes.length + 1, value, heads, batch, dependencies, optimistic ) node.actualHeads = node.heads.slice(0) this.nodes.push(node) this.available++ this.length++ return node } async update(boot) { if (this.opened === false) await this.ready() if (this.frozen) return false // if this is a boot node, DO NOT, preload as that will make it load // and reject nodes based on the tmp state of the system. // prop needs a better solution but this works for now const preload = boot ? 1 : MAX_PRELOAD while (this.available - this.length < preload) { // quick sanity check if (this.nodes.length === this.core.length || this.core.length === 0) break // load next node if (this.node === null && !(await this._loadNextNode())) break if (!(await this._ensureNodeDependencies(boot))) break if (this.recover) this.node.value = null this.nodes.push(this.node) if (this.node.batch === 1) this.available = this.nodes.length this.node = null } this.updateActivity() return this.length < this.available } _shiftAndClear() { const node = this.nodes.shift() node.clear() return node } async _loadNextNode() { const seq = this.nodes.length if (!(await this.core.has(seq))) return false try { const { node, optimistic, trace } = await this.core.get(seq, { wait: false }) const value = node.value == null ? null : c.decode(this.base.valueEncoding, node.value) this.node = Linearizer.createNode( this, seq + 1, value, node.heads, node.batch, new Set(), optimistic, trace ) return true } catch (err) { this.frozen = true throw err } } async _ensureNodeDependencies(boot) { while (this.node.dependencies.size < this.node.heads.length) { const rawHead = this.node.heads[this.node.dependencies.size] const headWriter = await this.base._getWriterByKey( rawHead.key, -1, rawHead.length, true, false, boot ) if (headWriter !== this && (headWriter === null || headWriter.length < rawHead.length)) { if (!boot) this.base._ensureWakeup(headWriter) return false } let headNode = headWriter.nodes.get(rawHead.length - 1) // could be a stub node if (!headNode) { for (const node of this.base.linearizer.heads) { if (!compareHead(node, rawHead)) continue headNode = node break } } // TODO: generalise DAG validation and freeze the writer assert(!this.node.dependencies.has(headNode), 'Corrupted DAG') // TODO: better way to solve the stub check is to never mutate heads below if (headNode === null) { // already yielded this.node.heads.splice(this.node.dependencies.size, 1) continue } this.node.dependencies.add(headNode) } // always link previous node if it's not indexed const offset = this.node.length - 1 if (offset > this.indexed) { this.node.dependencies.add(this.nodes.get(offset - 1)) } return true } } function compareHead(node, head) { if (node.length !== head.length) return false return b4a.equals(node.writer.core.key, head.key) } // this is a list of peers we bugged in the btc and planb room. // adding them here so migration can run, can be removed in a month or so from time of commit // note, no security implications of this, we just null them out. function autoRecover(core) { assert(core.opened) switch (core.id) { case 'ghrpexaboutdm46ombqho7mroxknassnntrxx3cubfux4qi6w6hy': case 'qoaanao71s4he1rcd197d336qepykk4467geo1uq8cwnzmpb786o': case 'fomhdxgn4j4tzjqy6y7iskhffimzokt7kraddyd8orcht3r8q61o': case 'd8f5taxxrit51apftoi38e5b86hb98cgfd7dfp3uo1uoh95qt49o': case 'objyf75uggsqpjcut69xdgj46ks8r71jjrq7oxdfsz95sstchkno': return true } return false } { "name": "autobase", "version": "7.28.1", "description": "A multiwriter data structure for Hypercore", "main": "index.js", "scripts": { "format": "prettier . --write", "test": "prettier . --check && brittle test/all.js", "test:encrypted": "prettier . --check && brittle test/all.js --encrypt-all", "test:fixtures": "prettier . --check && brittle test/fixtures/tests/*.js", "test:bare": "bare test/all.js", "fuzz:generated": "brittle test/reference/fuzz/generated/*.js", "fuzz:main": "node test/fuzz/index.js", "fuzz": "node test/reference/fuzz/fuzz.js", "generate-fixtures": "node test/fixtures/generate/all.js" }, "files": [ "index.js", "lib/**", "encoding/**" ], "imports": { "events": { "bare": "bare-events", "default": "events" } }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/autobase.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/autobase/issues" }, "homepage": "https://github.com/holepunchto/autobase#readme", "dependencies": { "b4a": "^1.6.1", "bare-events": "^2.2.0", "compact-encoding": "^3.0.0", "core-coupler": "^2.0.0", "debounceify": "^1.0.0", "encryption-encoding": "^1.0.3", "hyperbee": "^2.22.0", "hypercore": "^11.27.12", "hypercore-crypto": "^3.4.0", "hypercore-id-encoding": "^1.2.0", "hyperschema": "^1.12.1", "index-encoder": "^3.3.2", "nanoassert": "^2.0.0", "protomux-wakeup": "^2.0.0", "ready-resource": "^1.0.0", "resolve-reject-promise": "^1.1.0", "safety-catch": "^1.0.2", "scope-lock": "^1.2.4", "signal-promise": "^1.0.3", "sodium-universal": "^5.0.1", "sub-encoder": "^2.1.1", "tiny-buffer-map": "^1.1.1" }, "devDependencies": { "autobase-test-helpers": "^3.0.0", "blind-encryption-sodium": "^2.0.0", "brittle": "^3.1.1", "corestore": "^7.9.1", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "rache": "^1.0.0", "same-data": "^1.0.0", "task-backoff": "^1.0.0", "test-tmp": "^1.2.0", "uncaughts": "^1.1.0" }, "standard": { "ignore": [ "**/test/fuzz/generated/**", "**/test/reference/**", "example.mjs" ] } } function isBuffer(value) { return Buffer.isBuffer(value) || value instanceof Uint8Array } function isEncoding(encoding) { return Buffer.isEncoding(encoding) } function alloc(size, fill, encoding) { return Buffer.alloc(size, fill, encoding) } function allocUnsafe(size) { return Buffer.allocUnsafe(size) } function allocUnsafeSlow(size) { return Buffer.allocUnsafeSlow(size) } function byteLength(string, encoding) { return Buffer.byteLength(string, encoding) } function compare(a, b) { return Buffer.compare(a, b) } function concat(buffers, totalLength) { return Buffer.concat(buffers, totalLength) } function copy(source, target, targetStart, start, end) { return toBuffer(source).copy(target, targetStart, start, end) } function equals(a, b) { return toBuffer(a).equals(b) } function fill(buffer, value, offset, end, encoding) { return toBuffer(buffer).fill(value, offset, end, encoding) } function from(value, encodingOrOffset, length) { return Buffer.from(value, encodingOrOffset, length) } function includes(buffer, value, byteOffset, encoding) { return toBuffer(buffer).includes(value, byteOffset, encoding) } function indexOf(buffer, value, byfeOffset, encoding) { return toBuffer(buffer).indexOf(value, byfeOffset, encoding) } function lastIndexOf(buffer, value, byteOffset, encoding) { return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding) } function swap16(buffer) { return toBuffer(buffer).swap16() } function swap32(buffer) { return toBuffer(buffer).swap32() } function swap64(buffer) { return toBuffer(buffer).swap64() } function toBuffer(buffer) { if (Buffer.isBuffer(buffer)) return buffer return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength) } function toString(buffer, encoding, start, end) { return toBuffer(buffer).toString(encoding, start, end) } function write(buffer, string, offset, length, encoding) { return toBuffer(buffer).write(string, offset, length, encoding) } function readDoubleBE(buffer, offset) { return toBuffer(buffer).readDoubleBE(offset) } function readDoubleLE(buffer, offset) { return toBuffer(buffer).readDoubleLE(offset) } function readFloatBE(buffer, offset) { return toBuffer(buffer).readFloatBE(offset) } function readFloatLE(buffer, offset) { return toBuffer(buffer).readFloatLE(offset) } function readInt32BE(buffer, offset) { return toBuffer(buffer).readInt32BE(offset) } function readInt32LE(buffer, offset) { return toBuffer(buffer).readInt32LE(offset) } function readUInt32BE(buffer, offset) { return toBuffer(buffer).readUInt32BE(offset) } function readUInt32LE(buffer, offset) { return toBuffer(buffer).readUInt32LE(offset) } function writeDoubleBE(buffer, value, offset) { return toBuffer(buffer).writeDoubleBE(value, offset) } function writeDoubleLE(buffer, value, offset) { return toBuffer(buffer).writeDoubleLE(value, offset) } function writeFloatBE(buffer, value, offset) { return toBuffer(buffer).writeFloatBE(value, offset) } function writeFloatLE(buffer, value, offset) { return toBuffer(buffer).writeFloatLE(value, offset) } function writeInt32BE(buffer, value, offset) { return toBuffer(buffer).writeInt32BE(value, offset) } function writeInt32LE(buffer, value, offset) { return toBuffer(buffer).writeInt32LE(value, offset) } function writeUInt32BE(buffer, value, offset) { return toBuffer(buffer).writeUInt32BE(value, offset) } function writeUInt32LE(buffer, value, offset) { return toBuffer(buffer).writeUInt32LE(value, offset) } module.exports = { isBuffer, isEncoding, alloc, allocUnsafe, allocUnsafeSlow, byteLength, compare, concat, copy, equals, fill, from, includes, indexOf, lastIndexOf, swap16, swap32, swap64, toBuffer, toString, write, readDoubleBE, readDoubleLE, readFloatBE, readFloatLE, readInt32BE, readInt32LE, readUInt32BE, readUInt32LE, writeDoubleBE, writeDoubleLE, writeFloatBE, writeFloatLE, writeInt32BE, writeInt32LE, writeUInt32BE, writeUInt32LE } { "name": "b4a", "version": "1.8.1", "description": "Bridging the gap between buffers and typed arrays", "exports": { "./package": "./package.json", ".": { "react-native": "./react-native.js", "browser": "./browser.js", "default": "./index.js" } }, "files": [ "browser.js", "index.js", "react-native.js", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.mjs", "test:node": "brittle-node --coverage test.mjs" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/b4a.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/b4a/issues" }, "homepage": "https://github.com/holepunchto/b4a#readme", "devDependencies": { "brittle": "^3.5.2", "lunte": "^1.7.0", "nanobench": "^3.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "react-native-b4a": "*" }, "peerDependenciesMeta": { "react-native-b4a": { "optional": true } } } module.exports = require.addon() const binding = require('./binding') module.exports = binding.abort { "name": "bare-abort", "version": "2.0.13", "description": "Cause abnormal program termination and generate a crash report", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-abort.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-abort/issues" }, "homepage": "https://github.com/holepunchto/bare-abort#readme", "devDependencies": { "cmake-bare": "^1.1.7", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" } } const ESC = '\x1b' const CSI = ESC + '[' const SGR = (n) => CSI + n + 'm' exports.constants = { ESC, CSI, SGR } // https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_(Control_Sequence_Introducer)_sequences exports.cursorHide = CSI + '?25l' exports.cursorShow = CSI + '?25h' exports.cursorUp = function cursorUp(n = 1) { return CSI + n + 'A' } exports.cursorDown = function cursorDown(n = 1) { return CSI + n + 'B' } exports.cursorForward = function cursorForward(n = 1) { return CSI + n + 'C' } exports.cursorBack = function cursorBack(n = 1) { return CSI + n + 'D' } exports.cursorNextLine = function cursorNextLine(n = 1) { return CSI + n + 'E' } exports.cursorPreviousLine = function cursorPreviousLine(n = 1) { return CSI + n + 'F' } exports.cursorPosition = function cursorPosition(column, row = 0) { if (row === 0) return CSI + (column + 1) + 'G' return CSI + (row + 1) + ';' + (column + 1) + 'H' } exports.eraseDisplayEnd = CSI + 'J' exports.eraseDisplayStart = CSI + '1J' exports.eraseDisplay = CSI + '2J' exports.eraseLineEnd = CSI + 'K' exports.eraseLineStart = CSI + '1K' exports.eraseLine = CSI + '2K' exports.scrollUp = function scrollUp(n = 1) { return CSI + n + 'S' } exports.scrollDown = function scrollDown(n = 1) { return CSI + n + 'T' } // https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters exports.modifierReset = SGR(0) exports.modifierBold = SGR(1) exports.modifierDim = SGR(2) exports.modifierItalic = SGR(3) exports.modifierUnderline = SGR(4) exports.modifierNormal = SGR(22) exports.modifierNotItalic = SGR(23) exports.modifierNotUnderline = SGR(24) // https://en.wikipedia.org/wiki/ANSI_escape_code#Colors exports.colorBlack = SGR(30) exports.colorRed = SGR(31) exports.colorGreen = SGR(32) exports.colorYellow = SGR(33) exports.colorBlue = SGR(34) exports.colorMagenta = SGR(35) exports.colorCyan = SGR(36) exports.colorWhite = SGR(37) exports.colorDefault = SGR(39) exports.colorBrightBlack = SGR(90) exports.colorBrightRed = SGR(91) exports.colorBrightGreen = SGR(92) exports.colorBrightYellow = SGR(93) exports.colorBrightBlue = SGR(94) exports.colorBrightMagenta = SGR(95) exports.colorBrightCyan = SGR(96) exports.colorBrightWhite = SGR(97) { "name": "bare-ansi-escapes", "version": "2.2.3", "description": "Parse and produce ANSI escape sequences", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./key-decoder": { "types": "./key-decoder.d.ts", "default": "./key-decoder.js" } }, "files": [ "index.js", "index.d.ts", "key-decoder.js", "key-decoder.d.ts" ], "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-ansi-escapes.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-ansi-escapes/issues" }, "homepage": "https://github.com/holepunchto/bare-ansi-escapes#readme", "dependencies": { "bare-stream": "^2.6.5" }, "devDependencies": { "bare-buffer": "^3.0.2", "brittle": "^3.3.2", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" }, "peerDependencies": { "bare-buffer": "*" }, "peerDependenciesMeta": { "bare-buffer": { "optional": true } } } const inspect = require('bare-inspect') class AssertionError extends Error { constructor(opts = {}) { let { message = null, actual, expected, operator } = opts if (message === null) { message = `${inspect(actual)} ${operator} ${inspect(expected)}` } super(message) this.actual = actual this.expected = expected this.operator = operator } get name() { return 'AssertionError' } get code() { 'ASSERTION' } } function assertFail(opts, fn) { if (opts.message instanceof Error) throw opts.message const err = new AssertionError(opts) if (Error.captureStackTrace) Error.captureStackTrace(err, fn) throw err } module.exports = exports = function assert(actual, message) { if (actual) return assertFail({ message, actual, expected: true, operator: '==' }, assert) } exports.AssertionError = AssertionError exports.fail = function fail(message) { if (message === undefined) message = 'Failed' assertFail({ message, operator: 'fail' }, fail) } exports.ok = function ok(actual, message) { if (actual) return assertFail({ message, actual, expected: true, operator: '==' }, ok) } exports.notOk = function ok(actual, message) { if (!actual) return assertFail({ message, actual, expected: false, operator: '==' }, ok) } exports.equal = function equal(actual, expected, message) { if (actual == expected || (actual !== actual && expected !== expected)) { return } assertFail({ message, actual, expected, operator: '==' }, equal) } exports.notEqual = function notEqual(actual, expected, message) { if (actual != expected && (actual === actual || expected === expected)) { return } assertFail({ message, actual, expected, operator: '!=' }, notEqual) } exports.strictEqual = function strictEqual(actual, expected, message) { if (Object.is(actual, expected)) return assertFail( { message, actual, expected, operator: 'strictEqual' }, strictEqual ) } exports.notStrictEqual = function notStrictEqual(actual, expected, message) { if (!Object.is(actual, expected)) return assertFail( { message, actual, expected, operator: 'notStrictEqual' }, notStrictEqual ) } { "name": "bare-assert", "version": "1.2.0", "description": "Assertion library for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts" ], "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-assert.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-assert/issues" }, "homepage": "https://github.com/holepunchto/bare-assert#readme", "dependencies": { "bare-inspect": "^3.1.2" }, "devDependencies": { "brittle": "^3.1.1", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" } } const os = require('bare-os') module.exports = new Proxy(Object.create(null), { ownKeys (target) { return os.getEnvKeys() }, get (target, property) { if (typeof property !== 'string') return return os.getEnv(property) }, has (target, property) { if (typeof property !== 'string') return false return os.hasEnv(property) }, set (target, property, value) { if (typeof property !== 'string') return const type = typeof value if (type !== 'string' && type !== 'number' && type !== 'boolean') { throw new Error('Environment variable must be of type string, number, or boolean') } value = String(value) os.setEnv(property, value) return true }, deleteProperty (target, property) { if (typeof property !== 'string') return os.unsetEnv(property) }, getOwnPropertyDescriptor (target, property) { return { value: this.get(target, property), enumerable: true, configurable: true, writable: true } } }) { "name": "bare-env", "version": "3.0.0", "description": "Environment variable support for JavaScript", "main": "index.js", "files": [ "index.js" ], "scripts": { "test": "standard && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-env.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-env/issues" }, "homepage": "https://github.com/holepunchto/bare-env#readme", "dependencies": { "bare-os": "^3.0.1" }, "devDependencies": { "brittle": "^3.2.1", "standard": "^17.0.0" } } const errors = require('./lib/errors') class EventListener { constructor() { this.list = [] this.count = 0 } append(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.push([fn, once]) } prepend(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.unshift([fn, once]) } remove(ctx, name, fn) { for (let i = 0, n = this.list.length; i < n; i++) { const l = this.list[i] if (l[0] === fn) { this.list.splice(i, 1) if (this.count === 1) delete ctx._events[name] ctx.emit('removeListener', name, fn) // Emit AFTER removing this.count-- return } } } removeAll(ctx, name) { const list = [...this.list] this.list = [] if (this.count === list.length) delete ctx._events[name] for (let i = list.length - 1; i >= 0; i--) { ctx.emit('removeListener', name, list[i][0]) // Emit AFTER removing } this.count -= list.length } emit(ctx, name, ...args) { const list = [...this.list] for (let i = 0, n = list.length; i < n; i++) { const l = list[i] if (l[1] === true) this.remove(ctx, name, l[0]) Reflect.apply(l[0], ctx, args) } return list.length > 0 } } function appendListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.append(ctx, name, fn, once) return ctx } function prependListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.prepend(ctx, name, fn, once) return ctx } function removeListener(ctx, name, fn) { if (ctx._events === undefined) return ctx const e = ctx._events[name] if (e !== undefined) e.remove(ctx, name, fn) return ctx } function throwUnhandledError(...args) { let err if (args.length > 0) err = args[0] if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err) if (Error.captureStackTrace) { Error.captureStackTrace(err, exports.prototype.emit) } queueMicrotask(() => { throw err }) } module.exports = exports = class EventEmitter { constructor() { this._events = Object.create(null) } addListener(name, fn) { return appendListener(this, name, fn, false) } addOnceListener(name, fn) { return appendListener(this, name, fn, true) } prependListener(name, fn) { return prependListener(this, name, fn, false) } prependOnceListener(name, fn) { return prependListener(this, name, fn, true) } removeListener(name, fn) { return removeListener(this, name, fn) } on(name, fn) { return appendListener(this, name, fn, false) } once(name, fn) { return appendListener(this, name, fn, true) } off(name, fn) { return removeListener(this, name, fn) } emit(name, ...args) { if (name === 'error' && this._events !== undefined && this._events.error === undefined) { throwUnhandledError(...args) } if (this._events === undefined) return false const e = this._events[name] return e === undefined ? false : e.emit(this, name, ...args) } listeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : [...e.list] } rawListeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : e.list.map((l) => l[0]) } eventNames() { if (this._events === undefined) return [] return Reflect.ownKeys(this._events) } listenerCount(name) { if (this._events === undefined) return 0 const e = this._events[name] return e === undefined ? 0 : e.list.length } getMaxListeners() { return EventEmitter.defaultMaxListeners } setMaxListeners(n) {} removeAllListeners(name) { if (arguments.length === 0) { for (const key of Reflect.ownKeys(this._events)) { if (key === 'removeListener') continue this.removeAllListeners(key) } this.removeAllListeners('removeListener') } else { const e = this._events[name] if (e !== undefined) e.removeAll(this, name) } return this } } exports.EventEmitter = exports exports.errors = errors exports.defaultMaxListeners = 10 exports.on = function on(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { throw errors.OPERATION_ABORTED(signal.reason) } let error = null let done = false const events = [] const promises = [] if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.on(name, onevent) return { next() { if (events.length) { return Promise.resolve({ value: events.shift(), done: false }) } if (error) { const err = error error = null return Promise.reject(err) } if (done) return onclose() return new Promise((resolve, reject) => promises.push({ resolve, reject })) }, return() { return onclose() }, throw(err) { return onerror(err) }, [Symbol.asyncIterator]() { return this } } function onevent(...args) { if (promises.length) { promises.shift().resolve({ value: args, done: false }) } else { events.push(args) } } function onerror(err) { emitter.off(name, onevent).off('error', onerror) if (promises.length) { promises.shift().reject(err) } else { error = err } return Promise.resolve({ done: true }) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } function onclose() { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) done = true if (promises.length) promises.shift().resolve({ done: true }) return Promise.resolve({ done: true }) } } exports.once = function once(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { return Promise.reject(errors.OPERATION_ABORTED(signal.reason)) } return new Promise((resolve, reject) => { if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.once(name, onevent) function onevent(...args) { if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) resolve(args) } function onerror(err) { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) reject(err) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } }) } exports.forward = function forward(from, to, names, opts = {}) { if (typeof names === 'string') names = [names] const { emit = to.emit.bind(to) } = opts const listeners = names.map( (name) => function onevent(...args) { emit(name, ...args) } ) to.on('newListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.on(name, listeners[i]) } }).on('removeListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.off(name, listeners[i]) } }) } exports.listenerCount = function listenerCount(emitter, name) { return emitter.listenerCount(name) } exports.getMaxListeners = function getMaxListeners(emitter) { if (typeof emitter.getMaxListeners === 'function') { return emitter.getMaxListeners() } return exports.defaultMaxListeners } exports.setMaxListeners = function setMaxListeners(n, ...emitters) { if (emitters.length === 0) exports.defaultMaxListeners = n else { for (const emitter of emitters) { if (typeof emitter.setMaxListeners === 'function') { emitter.setMaxListeners(n) } } } } module.exports = class EventEmitterError extends Error { constructor(msg, code, fn = EventEmitterError, opts) { super(`${code}: ${msg}`, opts) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'EventEmitterError' } static OPERATION_ABORTED(cause, msg = 'Operation aborted') { return new EventEmitterError(msg, 'OPERATION_ABORTED', EventEmitterError.OPERATION_ABORTED, { cause }) } static UNHANDLED_ERROR(cause, msg = 'Unhandled error') { return new EventEmitterError(msg, 'UNHANDLED_ERROR', EventEmitterError.UNHANDLED_ERROR, { cause }) } } { "name": "bare-events", "version": "2.9.1", "description": "Event emitters for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" }, "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./errors": "./lib/errors.js" }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "web.js", "web.d.ts", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.js", "test:node": "brittle-node --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-events.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-events/issues" }, "homepage": "https://github.com/holepunchto/bare-events#readme", "devDependencies": { "bare-abort-controller": "^1.0.0", "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0", "uncaughts": "^1.1.1" }, "peerDependencies": { "bare-abort-controller": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true } } } module.exports = require.addon() const FIFO = require('fast-fifo') const EventEmitter = require('bare-events') const path = require('bare-path') const { isURL, fileURLToPath } = require('bare-url') const { Readable, Writable } = require('bare-stream') const binding = require('./binding') const constants = require('./lib/constants') const FileError = require('./lib/errors') const isWindows = Bare.platform === 'win32' exports.constants = constants class FileRequest { static borrow() { if (this._free.length > 0) return this._free.pop() return new FileRequest() } static return(req) { if (this._free.length < 32) this._free.push(req.reset()) else req.destroy() } constructor() { this._reset() this._handle = binding.requestInit(this, this._onresult) } get handle() { return this._handle } retain(value) { this._retain = value // Tie the lifetime of `value` to the lifetime of `this` } reset() { if (this._handle === null) return this binding.requestReset(this._handle) this._reset() return this } destroy() { if (this._handle === null) return this binding.requestDestroy(this._handle) this._reset() this._handle = null return this } then(resolve, reject) { return this._promise.then(resolve, reject) } return() { if (this._handle === null) return this FileRequest.return(this) return this } _reset() { this._promise = new Promise((resolve, reject) => { this._resolve = resolve this._reject = reject }) this._retain = null } _onresult(err, status) { if (err) this._reject(err) else this._resolve(status) } } FileRequest._free = [] function ok(result, cb) { if (typeof result === 'function') { cb = result result = undefined } if (cb) cb(null, result) else return result } function fail(err, cb) { if (cb) cb(err) else throw err } function done(err, result, cb) { if (typeof result === 'function') { cb = result result = undefined } if (err) fail(err, cb) else return ok(result, cb) } async function open(filepath, flags = 'r', mode = 0o666, cb) { if (typeof flags === 'function') { cb = flags flags = 'r' mode = 0o666 } else if (typeof mode === 'function') { cb = mode mode = 0o666 } if (typeof flags === 'string') flags = toFlags(flags) if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let fd let err = null try { binding.open(req.handle, filepath, flags, mode) fd = await req } catch (e) { err = new FileError(e.message, { operation: 'open', code: e.code, path: filepath }) } finally { req.return() } return done(err, fd, cb) } function openSync(filepath, flags = 'r', mode = 0o666) { if (typeof flags === 'string') flags = toFlags(flags) if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { return binding.openSync(req.handle, filepath, flags, mode) } catch (e) { throw new FileError(e.message, { operation: 'open', code: e.code, path: filepath }) } finally { req.return() } } async function close(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.close(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'close', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function closeSync(fd) { const req = FileRequest.borrow() try { binding.closeSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'close', code: e.code, fd }) } finally { req.return() } } async function access(filepath, mode = constants.F_OK, cb) { if (typeof mode === 'function') { cb = mode mode = constants.F_OK } filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.access(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'access', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function accessSync(filepath, mode = constants.F_OK) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.accessSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'access', code: e.code, path: filepath }) } finally { req.return() } } async function exists(filepath, cb) { let ok = true try { await access(filepath) } catch { ok = false } return done(null, ok, cb) } function existsSync(filepath) { try { accessSync(filepath) } catch { return false } return true } async function read(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1, cb) { if (typeof offset === 'function') { cb = offset offset = 0 len = buffer.byteLength pos = -1 } else if (typeof len === 'function') { cb = len len = buffer.byteLength - offset pos = -1 } else if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.read(req.handle, fd, buffer, offset, len, pos) req.retain(buffer) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'read', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function readSync(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1) { const req = FileRequest.borrow() try { return binding.readSync(req.handle, fd, buffer, offset, len, pos) } catch (e) { throw new FileError(e.message, { operation: 'read', code: e.code, fd }) } finally { req.return() } } async function readv(fd, buffers, pos = -1, cb) { if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.readv(req.handle, fd, buffers, pos) req.retain(buffers) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'readv', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function readvSync(fd, buffers, pos = -1) { if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.readvSync(req.handle, fd, buffers, pos) } catch (e) { throw new FileError(e.message, { operation: 'readv', code: e.code, fd }) } finally { req.return() } } async function write(fd, data, offset, len, pos = -1, cb) { if (typeof data === 'string') { let encoding = len cb = pos pos = offset if (typeof pos === 'function') { cb = pos pos = -1 encoding = 'utf8' } else if (typeof encoding === 'function') { cb = encoding encoding = 'utf8' } if (typeof pos === 'string') { encoding = pos pos = -1 } data = Buffer.from(data, encoding) offset = 0 len = data.byteLength } else if (typeof offset === 'function') { cb = offset offset = 0 len = data.byteLength pos = -1 } else if (typeof len === 'function') { cb = len len = data.byteLength - offset pos = -1 } else if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof offset !== 'number') offset = 0 if (typeof len !== 'number') len = data.byteLength - offset if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.write(req.handle, fd, data, offset, len, pos) req.retain(data) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'write', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function writeSync(fd, data, offset, len, pos = -1) { if (typeof data === 'string') { let encoding = len pos = offset if (typeof pos === 'string') { encoding = pos pos = -1 } data = Buffer.from(data, encoding) offset = 0 len = data.byteLength } if (typeof offset !== 'number') offset = 0 if (typeof len !== 'number') len = data.byteLength - offset if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.writeSync(req.handle, fd, data, offset, len, pos) } catch (e) { throw new FileError(e.message, { operation: 'write', code: e.code, fd }) } finally { req.return() } } async function writev(fd, buffers, pos = -1, cb) { if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.writev(req.handle, fd, buffers, pos) req.retain(buffers) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'writev', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function writevSync(fd, buffers, pos = -1) { if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.writevSync(req.handle, fd, buffers, pos) } catch (e) { throw new FileError(e.message, { operation: 'writev', code: e.code, fd }) } finally { req.return() } } async function stat(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.stat(req.handle, filepath) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'stat', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function statSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.statSync(req.handle, filepath) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'stat', code: e.code, path: filepath }) } finally { req.return() } } async function lstat(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.lstat(req.handle, filepath) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'lstat', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function lstatSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lstatSync(req.handle, filepath) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'lstat', code: e.code, path: filepath }) } finally { req.return() } } async function fstat(fd, cb) { const req = FileRequest.borrow() let st let err = null try { binding.fstat(req.handle, fd) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'fstat', code: e.code, fd }) } finally { req.return() } return done(err, st, cb) } function fstatSync(fd) { const req = FileRequest.borrow() try { binding.fstatSync(req.handle, fd) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'fstat', code: e.code, fd }) } finally { req.return() } } async function statfs(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.statfs(req.handle, filepath) await req st = new StatFs(...binding.requestResultStatfs(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'statfs', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function statfsSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.statfsSync(req.handle, filepath) return new StatFs(...binding.requestResultStatfs(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'statfs', code: e.code, path: filepath }) } finally { req.return() } } async function ftruncate(fd, len = 0, cb) { if (typeof len === 'function') { cb = len len = 0 } if (typeof len !== 'number') len = 0 const req = FileRequest.borrow() let err = null try { binding.ftruncate(req.handle, fd, len) await req } catch (e) { err = new FileError(e.message, { operation: 'ftruncate', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function ftruncateSync(fd, len = 0) { if (typeof len !== 'number') len = 0 const req = FileRequest.borrow() try { binding.ftruncateSync(req.handle, fd, len) } catch (e) { throw new FileError(e.message, { operation: 'ftruncate', code: e.code, fd }) } finally { req.return() } } async function truncate(filepath, len, cb) { let fd = -1 let err try { fd = await open(filepath, 'r+') await ftruncate(fd, len) } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, cb) } function truncateSync(filepath, len) { let fd = -1 let err try { fd = openSync(filepath, 'r+') ftruncateSync(fd, len) } catch (e) { err = e } finally { if (fd !== -1) closeSync(fd) } } async function chmod(filepath, mode, cb) { if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.chmod(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'chmod', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function chmodSync(filepath, mode) { if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.chmodSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'chmod', code: e.code, path: filepath }) } finally { req.return() } } async function fchmod(fd, mode, cb) { if (typeof mode === 'string') mode = toMode(mode) const req = FileRequest.borrow() let err = null try { binding.fchmod(req.handle, fd, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'fchmod', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fchmodSync(fd, mode) { if (typeof mode === 'string') mode = toMode(mode) const req = FileRequest.borrow() try { binding.fchmodSync(req.handle, fd, mode) } catch (e) { throw new FileError(e.message, { operation: 'fchmod', code: e.code, fd }) } finally { req.return() } } async function chown(filepath, uid, gid, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.chown(req.handle, filepath, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'chown', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function chownSync(filepath, uid, gid) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.chownSync(req.handle, filepath, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'chownSync', code: e.code, path: filepath }) } finally { req.return() } } async function lchown(filepath, uid, gid, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.lchown(req.handle, filepath, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'lchown', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function lchownSync(filepath, uid, gid) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lchownSync(req.handle, filepath, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'lchownSync', code: e.code, path: filepath }) } finally { req.return() } } async function fchown(fd, uid, gid, cb) { const req = FileRequest.borrow() let err = null try { binding.fchown(req.handle, fd, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'fchown', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fchownSync(fd, uid, gid) { const req = FileRequest.borrow() try { binding.fchownSync(req.handle, fd, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'fchownSync', code: e.code, fd }) } finally { req.return() } } async function utimes(filepath, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.utimes(req.handle, filepath, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'utimes', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function utimesSync(filepath, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.utimesSync(req.handle, filepath, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'utimes', code: e.code, path: filepath }) } finally { req.return() } } async function lutimes(filepath, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.lutimes(req.handle, filepath, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'lutimes', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function lutimesSync(filepath, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lutimesSync(req.handle, filepath, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'lutimes', code: e.code, path: filepath }) } finally { req.return() } } async function futimes(fd, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 const req = FileRequest.borrow() let err = null try { binding.futimes(req.handle, fd, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'futimes', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function futimesSync(fd, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 const req = FileRequest.borrow() try { binding.futimesSync(req.handle, fd, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'futimesSync', code: e.code, fd }) } finally { req.return() } } async function link(src, dst, cb) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.link(req.handle, src, dst) await req } catch (e) { err = new FileError(e.message, { operation: 'link', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function linkSync(src, dst) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.linkSync(req.handle, src, dst) } catch (e) { throw new FileError(e.message, { operation: 'linkSync', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function mkdir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = { mode: 0o777 } } if (typeof opts === 'number') opts = { mode: opts } else if (!opts) opts = {} const mode = typeof opts.mode === 'number' ? opts.mode : 0o777 filepath = toNamespacedPath(filepath) if (opts.recursive) { let err = null try { try { await mkdir(filepath, { mode }) } catch (err) { if (err.code !== 'ENOENT') { if (!(await stat(filepath)).isDirectory()) throw err } else { while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1) const i = filepath.lastIndexOf(path.sep) if (i <= 0) throw err await mkdir(filepath.slice(0, i), { mode, recursive: true }) try { await mkdir(filepath, { mode }) } catch (err) { if (!(await stat(filepath)).isDirectory()) throw err } } } } catch (e) { err = e } return done(err, cb) } const req = FileRequest.borrow() let err = null try { binding.mkdir(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'mkdir', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function mkdirSync(filepath, opts) { if (typeof opts === 'number') opts = { mode: opts } else if (!opts) opts = {} const mode = typeof opts.mode === 'number' ? opts.mode : 0o777 filepath = toNamespacedPath(filepath) if (opts.recursive) { try { mkdirSync(filepath, { mode }) } catch (err) { if (err.code !== 'ENOENT') { if (!statSync(filepath).isDirectory()) throw err } else { while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1) const i = filepath.lastIndexOf(path.sep) if (i <= 0) throw err mkdirSync(filepath.slice(0, i), { mode, recursive: true }) try { mkdirSync(filepath, { mode }) } catch (err) { if (!statSync(filepath).isDirectory()) throw err } } } return } const req = FileRequest.borrow() try { binding.mkdirSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'mkdir', code: e.code, path: filepath }) } finally { req.return() } } async function mkdtemp(prefix, cb) { prefix = toNamespacedPath(prefix) const req = FileRequest.borrow() let res let err = null try { binding.mkdtemp(req.handle, prefix + 'XXXXXX') await req res = binding.requestResultPath(req.handle) } catch (e) { err = new FileError(e.message, { operation: 'mkdtemp', code: e.code, path: prefix }) } finally { req.return() } return done(err, res, cb) } function mkdtempSync(prefix) { prefix = toNamespacedPath(prefix) const req = FileRequest.borrow() try { binding.mkdtempSync(req.handle, prefix + 'XXXXXX') return binding.requestResultPath(req.handle) } catch (e) { throw new FileError(e.message, { operation: 'mkdtempSync', code: e.code, path: prefix }) } finally { req.return() } } async function rmdir(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.rmdir(req.handle, filepath) await req } catch (e) { err = new FileError(e.message, { operation: 'rmdir', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function rmdirSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.rmdirSync(req.handle, filepath) } catch (e) { throw new FileError(e.message, { operation: 'rmdir', code: e.code, path: filepath }) } finally { req.return() } } async function rm(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} filepath = toNamespacedPath(filepath) let err = null try { const st = await lstat(filepath) if (st.isDirectory()) { if (opts.recursive) { try { await rmdir(filepath) } catch (err) { if (err.code !== 'ENOTEMPTY') throw err const files = await readdir(filepath) for (const file of files) { await rm(filepath + path.sep + file, opts) } await rmdir(filepath) } } else { throw new FileError('is a directory', { operation: 'rm', code: 'EISDIR', path: filepath }) } } else { await unlink(filepath) } } catch (e) { if (e.code !== 'ENOENT' || !opts.force) err = e } return done(err, cb) } function rmSync(filepath, opts) { if (!opts) opts = {} filepath = toNamespacedPath(filepath) try { const st = lstatSync(filepath) if (st.isDirectory()) { if (opts.recursive) { try { rmdirSync(filepath) } catch (err) { if (err.code !== 'ENOTEMPTY') throw err const files = readdirSync(filepath) for (const file of files) { rmSync(filepath + path.sep + file, opts) } rmdirSync(filepath) } } else { throw new FileError('is a directory', { operation: 'rm', code: 'EISDIR', path: filepath }) } } else { unlinkSync(filepath) } } catch (err) { if (err.code !== 'ENOENT' || !opts.force) throw err } } async function unlink(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.unlink(req.handle, filepath) await req } catch (e) { err = new FileError(e.message, { operation: 'unlink', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function unlinkSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.unlinkSync(req.handle, filepath) } catch (e) { throw new FileError(e.message, { operation: 'unlink', code: e.code, path: filepath }) } finally { req.return() } } async function rename(src, dst, cb) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.rename(req.handle, src, dst) await req } catch (e) { err = new FileError(e.message, { operation: 'rename', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function renameSync(src, dst) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.renameSync(req.handle, src, dst) } catch (e) { throw new FileError(e.message, { operation: 'rename', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function copyFile(src, dst, mode = 0, cb) { if (typeof mode === 'function') { cb = mode mode = 0 } src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.copyfile(req.handle, src, dst, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'copyfile', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function copyFileSync(src, dst, mode = 0) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.copyfileSync(req.handle, src, dst, mode) } catch (e) { throw new FileError(e.message, { operation: 'copyfile', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function cp(src, dst, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} src = toNamespacedPath(src) dst = toNamespacedPath(dst) let err = null try { const st = await lstat(src) if (st.isDirectory()) { if (opts.recursive !== true) { throw new FileError('is a directory', { operation: 'cp', code: 'EISDIR', path: src }) } try { await lstat(dst) } catch (e) { if (e.code !== 'ENOENT') throw e await mkdir(dst, { mode: st.mode, recursive: true }) } const dir = await opendir(src) for await (const { name } of dir) { await cp(path.join(src, name), path.join(dst, name), opts) } } else if (st.isFile()) { await copyFile(src, dst) await chmod(dst, st.mode) } } catch (e) { err = e } return done(err, cb) } function cpSync(src, dst, opts = {}) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const st = lstatSync(src) if (st.isDirectory()) { if (opts.recursive !== true) { throw new FileError('is a directory', { operation: 'cp', code: 'EISDIR', path: src }) } try { lstatSync(dst) } catch (e) { if (e.code !== 'ENOENT') throw e mkdirSync(dst, { mode: st.mode, recursive: true }) } const dir = opendirSync(src) for (const { name } of dir) { cpSync(path.join(src, name), path.join(dst, name), opts) } } else if (st.isFile()) { copyFileSync(src, dst) chmodSync(dst, st.mode) } } async function realpath(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let res let err = null try { binding.realpath(req.handle, filepath) await req res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) } catch (e) { err = new FileError(e.message, { operation: 'realpath', code: e.code, path: filepath }) } finally { req.return() } return done(err, res, cb) } function realpathSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.realpathSync(req.handle, filepath) let res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) return res } catch (e) { throw new FileError(e.message, { operation: 'realpath', code: e.code, path: filepath }) } finally { req.return() } } async function readlink(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let res let err = null try { binding.readlink(req.handle, filepath) await req res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) } catch (e) { err = new FileError(e.message, { operation: 'readlink', code: e.code, path: filepath }) } finally { req.return() } return done(err, res, cb) } function readlinkSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.readlinkSync(req.handle, filepath) let res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) return res } catch (e) { throw new FileError(e.message, { operation: 'readlink', code: e.code, path: filepath }) } finally { req.return() } } async function fsync(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.fsync(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'fsync', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fsyncSync(fd) { const req = FileRequest.borrow() try { binding.fsyncSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'fsyncSync', code: e.code, fd }) } finally { req.return() } } async function fdatasync(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.fdatasync(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'fdatasync', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fdatasyncSync(fd) { const req = FileRequest.borrow() try { binding.fdatasyncSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'fdatasyncSync', code: e.code, fd }) } finally { req.return() } } function normalizeSymlinkTarget(target, type, filepath) { if (isWindows) { if (type === constants.UV_FS_SYMLINK_JUNCTION) target = path.resolve(filepath, '..', target) if (path.isAbsolute(target)) return path.toNamespacedPath(target) return target.replace(/\//g, path.sep) } return target } async function symlink(target, filepath, type, cb) { if (typeof type === 'function') { cb = type type = null } filepath = toNamespacedPath(filepath) if (typeof type === 'string') { switch (type) { case 'dir': type = constants.UV_FS_SYMLINK_DIR break case 'junction': type = constants.UV_FS_SYMLINK_JUNCTION break case 'file': default: type = 0 break } } else if (typeof type !== 'number') { if (isWindows) { target = path.resolve(filepath, '..', target) try { type = (await stat(target)).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION } catch { type = 0 } } else { type = 0 } } target = normalizeSymlinkTarget(target, type, filepath) const req = FileRequest.borrow() let err = null try { binding.symlink(req.handle, target, filepath, type) await req } catch (e) { err = new FileError(e.message, { operation: 'symlink', code: e.code, path: target, destination: filepath }) } finally { req.return() } return done(err, cb) } function symlinkSync(target, filepath, type) { filepath = toNamespacedPath(filepath) if (typeof type === 'string') { switch (type) { case 'dir': type = constants.UV_FS_SYMLINK_DIR break case 'junction': type = constants.UV_FS_SYMLINK_JUNCTION break case 'file': default: type = 0 break } } else if (typeof type !== 'number') { if (isWindows) { target = path.resolve(filepath, '..', target) try { type = statSync(target).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION } catch { type = 0 } } else { type = 0 } } target = normalizeSymlinkTarget(target, type, filepath) const req = FileRequest.borrow() try { binding.symlinkSync(req.handle, target, filepath, type) } catch (e) { throw new FileError(e.message, { operation: 'symlink', code: e.code, path: target, destination: filepath }) } finally { req.return() } } async function opendir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let dir let err = null try { binding.opendir(req.handle, filepath) await req dir = new Dir(filepath, binding.requestResultDir(req.handle), opts) } catch (e) { err = new FileError(e.message, { operation: 'opendir', code: e.code, path: filepath }) } finally { req.return() } return done(err, dir, cb) } function opendirSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.opendirSync(req.handle, filepath) return new Dir(filepath, binding.requestResultDir(req.handle), opts) } catch (e) { throw new FileError(e.message, { operation: 'opendir', code: e.code, path: filepath }) } finally { req.return() } } async function readdir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { withFileTypes = false, recursive = false } = opts filepath = toNamespacedPath(filepath) const queue = [filepath] let result = [] let err = null try { while (queue.length !== 0) { const dir = await opendir(queue.pop()) for await (const entry of dir) { const entryPath = path.join(entry.parentPath, entry.name) if (withFileTypes) { result.push(entry) } else { result.push(path.relative(filepath, entryPath)) } if (recursive && entry.isDirectory()) queue.push(entryPath) } } } catch (e) { result = [] err = e } return done(err, result, cb) } function readdirSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { withFileTypes = false, recursive = false } = opts filepath = toNamespacedPath(filepath) const queue = [filepath] const result = [] while (queue.length !== 0) { const dir = opendirSync(queue.pop(), opts) for (const entry of dir) { const entryPath = path.join(entry.parentPath, entry.name) if (withFileTypes) { result.push(entry) } else { result.push(path.relative(filepath, entryPath)) } if (recursive && entry.isDirectory()) queue.push(entryPath) } } return result } async function readFile(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'buffer' } = opts let fd = -1 let buffer = null let err = null try { fd = await open(filepath, opts.flag || 'r') const st = await fstat(fd) let len = 0 if (st.size === 0) { const buffers = [] while (true) { buffer = Buffer.allocUnsafe(8192) const r = await read(fd, buffer) len += r if (r === 0) break buffers.push(buffer.subarray(0, r)) } buffer = Buffer.concat(buffers) } else { buffer = Buffer.allocUnsafe(st.size) while (true) { const r = await read(fd, len ? buffer.subarray(len) : buffer) len += r if (r === 0 || len === buffer.byteLength) break } if (len !== buffer.byteLength) buffer = buffer.subarray(0, len) } if (encoding !== 'buffer') buffer = buffer.toString(encoding) } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, buffer, cb) } function readFileSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'buffer' } = opts let fd = -1 try { fd = openSync(filepath, opts.flag || 'r') const st = fstatSync(fd) let buffer let len = 0 if (st.size === 0) { const buffers = [] while (true) { buffer = Buffer.allocUnsafe(8192) const r = readSync(fd, buffer) len += r if (r === 0) break buffers.push(buffer.subarray(0, r)) } buffer = Buffer.concat(buffers) } else { buffer = Buffer.allocUnsafe(st.size) while (true) { const r = readSync(fd, len ? buffer.subarray(len) : buffer) len += r if (r === 0 || len === buffer.byteLength) break } if (len !== buffer.byteLength) buffer = buffer.subarray(0, len) } if (encoding !== 'buffer') buffer = buffer.toString(encoding) return buffer } finally { if (fd !== -1) closeSync(fd) } } async function writeFile(filepath, data, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (typeof data === 'string') data = Buffer.from(data, opts.encoding) let fd = -1 let len = 0 let err = null try { fd = await open(filepath, opts.flag || 'w', opts.mode || 0o666) while (true) { len += await write(fd, len ? data.subarray(len) : data) if (len === data.byteLength) break } } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, len, cb) } function writeFileSync(filepath, data, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (typeof data === 'string') data = Buffer.from(data, opts.encoding) let fd = -1 try { fd = openSync(filepath, opts.flag || 'w', opts.mode || 0o666) let len = 0 while (true) { len += writeSync(fd, len ? data.subarray(len) : data) if (len === data.byteLength) break } } finally { if (fd !== -1) closeSync(fd) } } function appendFile(filepath, data, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (!opts.flag) opts = { ...opts, flag: 'a' } return writeFile(filepath, data, opts, cb) } function appendFileSync(filepath, data, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (!opts.flag) opts = { ...opts, flag: 'a' } return writeFileSync(filepath, data, opts) } function watch(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) return new Watcher(filepath, opts, cb) } class Stats { constructor( dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs ) { this.dev = dev this.mode = mode this.nlink = nlink this.uid = uid this.gid = gid this.rdev = rdev this.blksize = blksize this.ino = ino this.size = size this.blocks = blocks this.atimeMs = atimeMs this.mtimeMs = mtimeMs this.ctimeMs = ctimeMs this.birthtimeMs = birthtimeMs this.atime = new Date(atimeMs) this.mtime = new Date(mtimeMs) this.ctime = new Date(ctimeMs) this.birthtime = new Date(birthtimeMs) } isDirectory() { return (this.mode & constants.S_IFMT) === constants.S_IFDIR } isFile() { return (this.mode & constants.S_IFMT) === constants.S_IFREG } isBlockDevice() { return (this.mode & constants.S_IFMT) === constants.S_IFBLK } isCharacterDevice() { return (this.mode & constants.S_IFMT) === constants.S_IFCHR } isFIFO() { return (this.mode & constants.S_IFMT) === constants.S_IFIFO } isSymbolicLink() { return (this.mode & constants.S_IFMT) === constants.S_IFLNK } isSocket() { return (this.mode & constants.S_IFMT) === constants.S_IFSOCK } } class StatFs { constructor(type, bsize, blocks, bfree, bavail, files, ffree) { this.type = type this.bsize = bsize this.blocks = blocks this.bfree = bfree this.bavail = bavail this.files = files this.ffree = ffree } } class Dir { constructor(path, handle, opts = {}) { const { encoding = 'utf8', bufferSize = 32 } = opts this.path = path this._encoding = encoding this._capacity = bufferSize this._buffer = new FIFO() this._ended = false this._handle = handle } async read(cb) { if (this._buffer.length) return ok(this._buffer.shift(), cb) if (this._ended) return ok(null, cb) const req = FileRequest.borrow() let entries let err = null try { req.retain(binding.readdir(req.handle, this._handle, this._capacity)) await req entries = binding.requestResultDirents(req.handle) } catch (e) { err = new FileError(e.message, { operation: 'readdir', code: e.code, path: this.path }) } finally { req.return() } if (err) return fail(err, cb) if (entries.length === 0) { this._ended = true return ok(null, cb) } for (const entry of entries) { let name = Buffer.from(entry.name) if (this._encoding !== 'buffer') name = name.toString(this._encoding) this._buffer.push(new Dirent(this.path, name, entry.type)) } return ok(this._buffer.shift(), cb) } readSync() { if (this._buffer.length) return this._buffer.shift() if (this._ended) return null const req = FileRequest.borrow() let entries try { req.retain(binding.readdirSync(req.handle, this._handle, this._capacity)) entries = binding.requestResultDirents(req.handle) } catch (e) { throw new FileError(e.message, { operation: 'readdir', code: e.code, path: this.path }) } finally { req.return() } if (entries.length === 0) { this._ended = true return null } for (const entry of entries) { let name = Buffer.from(entry.name) if (this._encoding !== 'buffer') name = name.toString(this._encoding) this._buffer.push(new Dirent(this.path, name, entry.type)) } return this._buffer.shift() } async close(cb) { const req = FileRequest.borrow() let err = null try { binding.closedir(req.handle, this._handle) await req } catch (e) { err = new FileError(e.message, { operation: 'closedir', code: e.code, path: this.path }) } finally { req.return() } this._handle = null return done(err, cb) } closeSync() { const req = FileRequest.borrow() try { binding.closedirSync(req.handle, this._handle) } catch (e) { throw new FileError(e.message, { operation: 'closedir', code: e.code, path: this.path }) } finally { req.return() } this._handle = null } [Symbol.dispose]() { this.closeSync() } async [Symbol.asyncDispose]() { await this.close() } *[Symbol.iterator]() { while (true) { const entry = this.readSync() if (entry === null) break yield entry } this.closeSync() } async *[Symbol.asyncIterator]() { while (true) { const entry = await this.read() if (entry === null) break yield entry } await this.close() } } class Dirent { constructor(parentPath, name, type) { this.parentPath = parentPath this.name = name this.type = type } isFile() { return this.type === constants.UV_DIRENT_FILE } isDirectory() { return this.type === constants.UV_DIRENT_DIR } isSymbolicLink() { return this.type === constants.UV_DIRENT_LINK } isFIFO() { return this.type === constants.UV_DIRENT_FIFO } isSocket() { return this.type === constants.UV_DIRENT_SOCKET } isCharacterDevice() { return this.type === constants.UV_DIRENT_CHAR } isBlockDevice() { return this.type === constants.UV_DIRENT_BLOCK } } class FileReadStream extends Readable { constructor(path, opts = {}) { const { eagerOpen = true } = opts super({ eagerOpen, ...opts }) this.path = path this.fd = typeof opts.fd === 'number' ? opts.fd : -1 this.flags = opts.flags || 'r' this.mode = opts.mode || 0o666 this._offset = opts.start || 0 this._missing = 0 if (opts.length) { this._missing = opts.length } else if (typeof opts.end === 'number') { this._missing = opts.end - this._offset + 1 } else { this._missing = -1 } } async _open(cb) { let err if (this.fd === -1) { err = null try { this.fd = await open(this.path, this.flags, this.mode) } catch (e) { err = e } if (err) return cb(err) } let st err = null try { st = await fstat(this.fd) } catch (e) { err = e } if (err) return cb(err) if (this._missing === -1) this._missing = st.size if (st.size < this._offset) { this._offset = st.size this._missing = 0 } else if (st.size < this._offset + this._missing) { this._missing = st.size - this._offset } cb(null) } async _read(size) { if (this._missing <= 0) return this.push(null) const data = Buffer.allocUnsafe(Math.min(this._missing, size)) let len let err = null try { len = await read(this.fd, data, 0, data.byteLength, this._offset) } catch (e) { err = e } if (err) return this.destroy(err) if (len === 0) return this.push(null) if (this._missing < len) len = this._missing this._missing -= len this._offset += len this.push(data.subarray(0, len)) } async _destroy(err, cb) { if (this.fd === -1) return cb(err) try { await close(this.fd) } catch (e) { err = err || e } cb(err) } } class FileWriteStream extends Writable { constructor(path, opts = {}) { const { eagerOpen = true } = opts super({ eagerOpen, ...opts }) this.path = path this.fd = typeof opts.fd === 'number' ? opts.fd : -1 this.flags = opts.flags || 'w' this.mode = opts.mode || 0o666 } async _open(cb) { if (this.fd !== -1) return cb(null) let err = null try { this.fd = await open(this.path, this.flags, this.mode) } catch (e) { err = e } cb(err) } async _writev(batch, cb) { let err = null try { await writev( this.fd, batch.map(({ chunk }) => chunk) ) } catch (e) { err = e } cb(err) } async _destroy(err, cb) { if (this.fd === -1) return cb(err) try { await close(this.fd) } catch (e) { err = err || e } cb(err) } } class Watcher extends EventEmitter { constructor(path, opts, onchange) { if (typeof opts === 'function') { onchange = opts opts = {} } if (!opts) opts = {} const { persistent = true, recursive = false, encoding = 'utf8' } = opts super() this._closed = false this._encoding = encoding this._handle = binding.watcherInit(path, recursive, this, this._onevent, this._onclose) if (!persistent) this.unref() if (onchange) this.on('change', onchange) } close() { if (this._closed) return this._closed = true binding.watcherClose(this._handle) } ref() { if (this._handle) binding.watcherRef(this._handle) return this } unref() { if (this._handle) binding.watcherUnref(this._handle) return this } [Symbol.asyncIterator]() { const buffer = [] let done = false let error = null let next = null this.on('change', (eventType, filename) => { if (next) { next.resolve({ done: false, value: { eventType, filename } }) next = null } else { buffer.push({ eventType, filename }) } }) .on('error', (err) => { done = true error = err if (next) { next.reject(error) next = null } }) .on('close', () => { done = true if (next) { next.resolve({ done }) next = null } }) return { next: () => new Promise((resolve, reject) => { if (error) return reject(error) if (buffer.length) return resolve({ done: false, value: buffer.shift() }) if (done) return resolve({ done }) next = { resolve, reject } }) } } _onevent(err, events, filename) { if (err) { this.close() this.emit('error', err) } else { const path = this._encoding === 'buffer' ? Buffer.from(filename) : Buffer.from(filename).toString(this._encoding) if (events & binding.UV_RENAME) { this.emit('change', 'rename', path) } if (events & binding.UV_CHANGE) { this.emit('change', 'change', path) } } } _onclose() { this._handle = null this.emit('close') } } exports.access = access exports.appendFile = appendFile exports.chmod = chmod exports.chown = chown exports.close = close exports.copyFile = copyFile exports.cp = cp exports.exists = exists exports.fchmod = fchmod exports.fchown = fchown exports.fdatasync = fdatasync exports.fstat = fstat exports.fsync = fsync exports.ftruncate = ftruncate exports.futimes = futimes exports.lchown = lchown exports.lutimes = lutimes exports.link = link exports.lstat = lstat exports.mkdir = mkdir exports.mkdtemp = mkdtemp exports.open = open exports.opendir = opendir exports.read = read exports.readFile = readFile exports.readdir = readdir exports.readlink = readlink exports.readv = readv exports.realpath = realpath exports.rename = rename exports.rm = rm exports.rmdir = rmdir exports.stat = stat exports.statfs = statfs exports.symlink = symlink exports.truncate = truncate exports.unlink = unlink exports.utimes = utimes exports.watch = watch exports.write = write exports.writeFile = writeFile exports.writev = writev exports.accessSync = accessSync exports.appendFileSync = appendFileSync exports.chmodSync = chmodSync exports.chownSync = chownSync exports.closeSync = closeSync exports.copyFileSync = copyFileSync exports.cpSync = cpSync exports.existsSync = existsSync exports.fchmodSync = fchmodSync exports.fchownSync = fchownSync exports.fdatasyncSync = fdatasyncSync exports.fstatSync = fstatSync exports.fsyncSync = fsyncSync exports.ftruncateSync = ftruncateSync exports.futimesSync = futimesSync exports.lchownSync = lchownSync exports.lutimesSync = lutimesSync exports.linkSync = linkSync exports.lstatSync = lstatSync exports.mkdirSync = mkdirSync exports.mkdtempSync = mkdtempSync exports.openSync = openSync exports.opendirSync = opendirSync exports.readFileSync = readFileSync exports.readSync = readSync exports.readdirSync = readdirSync exports.readlinkSync = readlinkSync exports.readvSync = readvSync exports.realpathSync = realpathSync exports.renameSync = renameSync exports.rmSync = rmSync exports.rmdirSync = rmdirSync exports.statSync = statSync exports.statfsSync = statfsSync exports.symlinkSync = symlinkSync exports.truncateSync = truncateSync exports.unlinkSync = unlinkSync exports.utimesSync = utimesSync exports.writeFileSync = writeFileSync exports.writeSync = writeSync exports.writevSync = writevSync exports.promises = require('./promises') exports.Stats = Stats exports.StatFs = StatFs exports.Dir = Dir exports.Dirent = Dirent exports.Watcher = Watcher exports.ReadStream = FileReadStream exports.createReadStream = function createReadStream(path, opts) { return new FileReadStream(path, opts) } exports.WriteStream = FileWriteStream exports.createWriteStream = function createWriteStream(path, opts) { return new FileWriteStream(path, opts) } function toNamespacedPath(filepath) { if (typeof filepath !== 'string') { if (isURL(filepath)) filepath = fileURLToPath(filepath) else filepath = filepath.toString() } return path.toNamespacedPath(filepath) } function toFlags(flags) { switch (flags) { case 'r': return constants.O_RDONLY case 'rs': // Fall through. case 'sr': return constants.O_RDONLY | constants.O_SYNC case 'r+': return constants.O_RDWR case 'rs+': // Fall through. case 'sr+': return constants.O_RDWR | constants.O_SYNC case 'w': return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY case 'wx': // Fall through. case 'xw': return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL case 'w+': return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR case 'wx+': // Fall through. case 'xw+': return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL case 'a': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY case 'ax': // Fall through. case 'xa': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL case 'as': // Fall through. case 'sa': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_SYNC case 'a+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR case 'ax+': // Fall through. case 'xa+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL case 'as+': // Fall through. case 'sa+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_SYNC default: return 0 } } function toMode(mode) { return parseInt(mode, 8) } const binding = require('../binding') module.exports = { O_RDWR: binding.O_RDWR, O_RDONLY: binding.O_RDONLY, O_WRONLY: binding.O_WRONLY, O_CREAT: binding.O_CREAT, O_TRUNC: binding.O_TRUNC, O_APPEND: binding.O_APPEND, F_OK: binding.F_OK || 0, R_OK: binding.R_OK || 0, W_OK: binding.W_OK || 0, X_OK: binding.X_OK || 0, S_IFMT: binding.S_IFMT, S_IFREG: binding.S_IFREG, S_IFDIR: binding.S_IFDIR, S_IFCHR: binding.S_IFCHR, S_IFLNK: binding.S_IFLNK, S_IFBLK: binding.S_IFBLK || 0, S_IFIFO: binding.S_IFIFO || 0, S_IFSOCK: binding.S_IFSOCK || 0, S_IRUSR: binding.S_IRUSR || 0, S_IWUSR: binding.S_IWUSR || 0, S_IXUSR: binding.S_IXUSR || 0, S_IRGRP: binding.S_IRGRP || 0, S_IWGRP: binding.S_IWGRP || 0, S_IXGRP: binding.S_IXGRP || 0, S_IROTH: binding.S_IROTH || 0, S_IWOTH: binding.S_IWOTH || 0, S_IXOTH: binding.S_IXOTH || 0, UV_DIRENT_UNKNOWN: binding.UV_DIRENT_UNKNOWN, UV_DIRENT_FILE: binding.UV_DIRENT_FILE, UV_DIRENT_DIR: binding.UV_DIRENT_DIR, UV_DIRENT_LINK: binding.UV_DIRENT_LINK, UV_DIRENT_FIFO: binding.UV_DIRENT_FIFO, UV_DIRENT_SOCKET: binding.UV_DIRENT_SOCKET, UV_DIRENT_CHAR: binding.UV_DIRENT_CHAR, UV_DIRENT_BLOCK: binding.UV_DIRENT_BLOCK, COPYFILE_EXCL: binding.UV_FS_COPYFILE_EXCL, COPYFILE_FICLONE: binding.UV_FS_COPYFILE_FICLONE, COPYFILE_FICLONE_FORCE: binding.UV_FS_COPYFILE_FICLONE_FORCE, UV_FS_SYMLINK_DIR: binding.UV_FS_SYMLINK_DIR, UV_FS_SYMLINK_JUNCTION: binding.UV_FS_SYMLINK_JUNCTION } const os = require('bare-os') module.exports = class FileError extends Error { constructor(msg, opts = {}) { const { code, operation = null, path = null, destination = null, fd = -1 } = opts if (operation !== null) msg += describe(operation, opts) super(`${code}: ${msg}`) this.code = code if (operation !== null) this.operation = operation if (path !== null) this.path = path if (destination !== null) this.destination = destination if (fd !== -1) this.fd = fd } get name() { return 'FileError' } // For Node.js compatibility get errno() { return os.constants.errnos[this.code] } // For Node.js compatibility get syscall() { return this.operation } // For Node.js compatibility get dest() { return this.destination } } function describe(operation, opts) { const { path = null, destination = null, fd = -1 } = opts let result = `, ${operation}` if (path !== null) { result += ` ${JSON.stringify(path)}` if (destination !== null) { result += ` -> ${JSON.stringify(destination)}` } } else if (fd !== -1) { result += ` ${fd}` } return result } { "name": "bare-fs", "version": "4.7.2", "description": "Native file system operations for Bare", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./promises": { "types": "./promises.d.ts", "default": "./promises.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" } }, "files": [ "index.js", "index.d.ts", "promises.js", "promises.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-fs.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-fs/issues" }, "homepage": "https://github.com/holepunchto/bare-fs#readme", "engines": { "bare": ">=1.16.0" }, "dependencies": { "bare-events": "^2.5.4", "bare-path": "^3.0.0", "bare-stream": "^2.6.4", "bare-url": "^2.2.2", "fast-fifo": "^1.3.2" }, "devDependencies": { "bare-buffer": "^3.0.2", "bare-crypto": "^1.11.2", "brittle": "^3.1.1", "cmake-bare": "^1.1.7", "lunte": "^1.6.0", "prettier": "^3.4.1", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "bare-buffer": "*" }, "peerDependenciesMeta": { "bare-buffer": { "optional": true } } } const EventEmitter = require('bare-events') const fs = require('.') class FileHandle extends EventEmitter { constructor(fd) { super() this.fd = fd } async close() { await fs.close(this.fd) this.fd = -1 this.emit('close') } async read(buffer, ...args) { return { bytesRead: await fs.read(this.fd, buffer, ...args), buffer } } async readv(buffers, ...args) { return { bytesRead: await fs.readv(this.fd, buffers, ...args), buffers } } async write(buffer, ...args) { return { bytesWritten: await fs.write(this.fd, buffer, ...args), buffer } } async writev(buffers, ...args) { return { bytesWritten: await fs.writev(this.fd, buffers, ...args), buffers } } async stat() { return fs.fstat(this.fd) } async chmod(mode) { await fs.fchmod(this.fd, mode) } async chown(uid, gid) { await fs.fchown(this.fd, uid, gid) } async datasync() { return fs.fdatasync(this.fd) } async sync() { return fs.fsync(this.fd) } async truncate(len) { await fs.ftruncate(this.fd, len) } async utimes(atime, mtime) { await fs.futimes(this.fd, atime, mtime) } createReadStream(opts) { return fs.createReadStream(null, { ...opts, fd: this.fd }) } createWriteStream(opts) { return fs.createWriteStream(null, { ...opts, fd: this.fd }) } async [Symbol.asyncDispose]() { await this.close() } } exports.open = async function open(filepath, flags, mode) { return new FileHandle(await fs.open(filepath, flags, mode)) } exports.access = fs.access exports.appendFile = fs.appendFile exports.chmod = fs.chmod exports.chown = fs.chown exports.constants = fs.constants exports.copyFile = fs.copyFile exports.cp = fs.cp exports.lchown = fs.lchown exports.lutimes = fs.lutimes exports.link = fs.link exports.lstat = fs.lstat exports.mkdir = fs.mkdir exports.mkdtemp = fs.mkdtemp exports.opendir = fs.opendir exports.readFile = fs.readFile exports.readdir = fs.readdir exports.readlink = fs.readlink exports.realpath = fs.realpath exports.rename = fs.rename exports.rm = fs.rm exports.rmdir = fs.rmdir exports.stat = fs.stat exports.statfs = fs.statfs exports.truncate = fs.truncate exports.symlink = fs.symlink exports.unlink = fs.unlink exports.utimes = fs.utimes exports.watch = fs.watch exports.writeFile = fs.writeFile module.exports = require.addon() const binding = require('./binding') module.exports = exports = function hrtime(past) { let now = binding.hrtime() if (past) now -= BigInt(past[0]) * 1000000000n + BigInt(past[1]) return [Number(now / 1000000000n), Number(now % 1000000000n)] } exports.bigint = function hrtime() { return binding.hrtime() } { "name": "bare-hrtime", "version": "2.1.1", "description": "High-resolution timers for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-hrtime.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-hrtime/issues" }, "homepage": "https://github.com/holepunchto/bare-hrtime#readme", "devDependencies": { "brittle": "^3.2.1", "cmake-bare": "^1.1.6", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const ansiEscapes = require('bare-ansi-escapes') const getType = require('bare-type') const binding = require('./binding') const PLAIN_KEY = /^[a-zA-Z_][a-zA-Z_0-9]*$/ const defaultDepth = 2 const defaultBreakLength = 80 const defaultMaxArrayLength = 40 module.exports = exports = function inspect(value, opts = {}) { const { colors = false, depth = defaultDepth, breakLength = defaultBreakLength, stylize = defaultStylize(colors) } = opts const references = new InspectRefMap() const tree = inspectValue(value, 0, { colors, depth, breakLength, stylize, references }) return tree.toString() } exports.styles = { bigint: ansiEscapes.colorYellow, boolean: ansiEscapes.colorYellow, date: ansiEscapes.colorMagenta, module: ansiEscapes.modifierUnderline, name: ansiEscapes.modifierReset, null: ansiEscapes.modifierBold, number: ansiEscapes.colorYellow, regexp: ansiEscapes.colorRed, special: ansiEscapes.colorCyan, string: ansiEscapes.colorGreen, symbol: ansiEscapes.colorGreen, undefined: ansiEscapes.colorBrightBlack } const styles = exports.styles function defaultStylize(colors) { return function stylize(value, style) { const color = colors && styles[style] if (color) return color + value + ansiEscapes.modifierReset return value } } class InspectRefMap { constructor() { this.refs = new WeakMap() this.ids = new WeakMap() this.nextId = 1 } has(object) { return this.refs.has(object) } get(object) { return this.refs.get(object) || null } set(object, ref) { this.refs.set(object, ref) } id(object) { let id = this.ids.get(object) if (id) return id id = this.nextId++ this.ids.set(object, id) return id } } class InspectNode { constructor(depth, length, opts) { const { breakLength = defaultBreakLength, breakAlways = false } = opts this.depth = depth this.length = length this.breakLength = breakLength this.breakAlways = breakAlways } pad(n, string) { return string.padStart(n, ' ') } indent(n, string) { return ' '.repeat(n) + string } } class InspectRef extends InspectNode { constructor(depth, opts) { super(depth, '[circular *]'.length, opts) this.refs = opts.references this.count = 0 this.circular = false this.color = opts.colors && styles.special } get id() { return this.refs.id(this) } increment() { return ++this.count } decrement() { return --this.count } toString(opts = {}) { const { offset = 0, pad = 0, indent = 0 } = opts let value = this.pad(pad, '[circular *' + this.id + ']') if (this.color) value = this.color + value + ansiEscapes.modifierReset return offset ? value : this.indent(indent, value) } } class InspectLeaf extends InspectNode { constructor(value, color, depth, opts) { const length = value.length if (value.includes('\n')) { value = value.replaceAll('\n', '\n' + ' '.repeat(depth)) opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.value = value this.color = opts.colors && color } toString(opts = {}) { const { offset = 0, pad = 0, indent = 0 } = opts let value = this.pad(pad, this.value) if (this.color) value = this.color + value + ansiEscapes.modifierReset return offset ? value : this.indent(indent, value) } } class InspectPair extends InspectNode { constructor(delim, left, right, depth, opts) { const length = left.length + delim.length + right.length if (left.breakAlways || right.breakAlways) { opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.delim = delim this.left = left this.right = right } toString(opts = {}) { const { indent = 0 } = opts return this.indent( indent, this.left + this.delim + this.right.toString({ indent, offset: this.left.length + this.delim.length }) ) } } class InspectSuspension extends InspectNode { constructor(overflow, depth, opts) { const label = `... ${overflow} more` super(depth, label.length, opts) this.label = label } toString(opts = {}) { const { indent = 0 } = opts return this.indent(indent, this.label) } } class InspectSequence extends InspectNode { constructor(header, footer, delim, values, ref, depth, opts) { const { tabulate = false } = opts const length = (ref.circular ? ''.length + 1 : 0) + header.length + values.reduce( (length, value, i) => length + value.length + (i === 0 ? 0 : delim.length), 0 ) + footer.length if (values.some((value) => value.breakAlways)) { opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.header = header this.footer = footer this.delim = delim this.values = values this.ref = ref this.tabulate = tabulate } toString(opts = {}) { const { offset = 0, indent = 0 } = opts const split = this.breakAlways || (this.values.length && (offset + this.length > this.breakLength || indent * 2 + this.length > this.breakLength)) let header = this.header if (this.ref.circular) { header = ' ' + header } if (this.values.length === 0) { header = header.trimEnd() } if (offset === 0) { header = this.indent(indent, header) } if (split) { header = header.trimEnd() + '\n' } let string = header let columns = 1 let pad = 0 if (this.tabulate) { const widest = this.values.reduce( (length, value) => value.breakAlways ? length : Math.max(length, value.length), 0 ) if (widest) { columns = Math.max( columns, Math.floor( (this.breakLength - indent * 2) / (widest + this.delim.length) ) ) if (columns > 1) pad = widest } } for (let i = 0, n = this.values.length, offset = 0; i < n; i++) { const value = this.values[i] if (split) { let part if (i % columns === 0 || value.breakAlways) { part = value.toString({ indent: indent + 1, pad }) } else { part = value.toString({ pad }) } string += part if (i < n - 1) { if (i % columns === columns - 1 || this.values[i + 1].breakAlways) { string += this.delim.trimEnd() + '\n' } else { string += this.delim } } } else { if (i > 0) string += this.delim string += value.toString({ offset }) offset += value.length } } let footer = this.footer if (this.values.length === 0) { footer = footer.trimStart() } if (split) { string += '\n' + this.indent(indent, footer.trimStart()) } else { string += footer } return string } } function inspectValue(value, depth, opts) { const type = getType(value) if (type.isUndefined()) return inspectUndefined(depth, opts) if (type.isNull()) return inspectNull(depth, opts) if (type.isBoolean()) return inspectBoolean(value, depth, opts) if (type.isNumber()) return inspectNumber(value, depth, opts) if (type.isBigInt()) return inspectBigInt(value, depth, opts) if (type.isString()) return inspectString(value, depth, opts) if (type.isSymbol()) return inspectSymbol(value, depth, opts) if (type.isObject()) return inspectObject(type, value, depth, opts) if (type.isFunction()) return inspectFunction(type, value, depth, opts) if (type.isExternal()) return inspectExternal(value, opts, opts) } function inspectUndefined(depth, opts) { return new InspectLeaf('undefined', styles.undefined, depth, opts) } function inspectNull(depth, opts) { return new InspectLeaf('null', styles.null, depth, opts) } function inspectBoolean(value, depth, opts) { return new InspectLeaf(value.toString(), styles.boolean, depth, opts) } function inspectNumber(value, depth, opts) { let string if (Object.is(value, -0)) { string = '-0' } else { string = value.toString(10) } return new InspectLeaf(string, styles.number, depth, opts) } function inspectBigInt(value, depth, opts) { return new InspectLeaf(value.toString(10) + 'n', styles.bigint, depth, opts) } const STRING_ESCAPES = /[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f'\\\ud800-\udfff]/g function inspectString(value, depth, opts) { // https://tc39.es/ecma262/multipage/structured-data.html#sec-quotejsonstring const string = value.replace(STRING_ESCAPES, (match) => { if (match.length === 2) return match switch (match) { case "'": return "\\'" case '\\': return '\\\\' case '\b': return '\\b' case '\t': return '\\t' case '\n': return '\\n' case '\f': return '\\f' case '\r': return '\\r' default: return '\\u' + match.charCodeAt(0).toString(16).padStart(4, '0') } }) return new InspectLeaf("'" + string + "'", styles.string, depth, opts) } function inspectSymbol(value, depth, opts) { return new InspectLeaf(value.toString(), styles.symbol, depth, opts) } function inspectKey(value, depth, opts) { if (PLAIN_KEY.test(value)) { return new InspectLeaf(value, null, depth, opts) } else { return inspectValue(value, depth, opts) } } function inspectObject(type, object, depth, opts) { const refs = opts.references let ref = refs.get(object) if (ref === null) { ref = new InspectRef(depth, opts) refs.set(object, ref) } else if (ref.count) { ref.circular = true return ref } const maxDepth = typeof opts.depth === 'number' ? opts.depth : Infinity if (maxDepth < depth) { const constructor = object.constructor return new InspectLeaf( '[' + (constructor && constructor.name ? constructor.name : 'Object') + ']', styles.special, depth, opts ) } const inspect = object[Symbol.for('bare.inspect')] || object[Symbol.for('nodejs.util.inspect.custom')] if (typeof inspect === 'function') { const value = inspect.call( object, typeof opts.depth === 'number' ? opts.depth - depth : null, { colors: opts.colors, breakLength: opts.breakLength, stylize: opts.stylize }, exports ) if (typeof value === 'object' && value !== null) { refs.set(value, ref) } if (typeof value !== 'string') { return inspectValue(value, depth, opts) } return new InspectLeaf(value, null, depth, opts) } if (type.isArray()) return inspectArray(object, ref, depth, opts) if (type.isDate()) return inspectDate(object, ref, depth, opts) if (type.isRegExp()) return inspectRegExp(object, ref, depth, opts) if (type.isError()) return inspectError(object, ref, depth, opts) if (type.isPromise()) return inspectPromise(object, ref, depth, opts) if (type.isMap()) return inspectMap(object, ref, depth, opts) if (type.isSet()) return inspectSet(object, ref, depth, opts) if (type.isWeakMap()) return inspectWeakMap(object, ref, depth, opts) if (type.isWeakSet()) return inspectWeakSet(object, ref, depth, opts) if (type.isWeakRef()) return inspectWeakRef(object, ref, depth, opts) if (type.isArrayBuffer()) return inspectArrayBuffer(object, ref, depth, opts) if (type.isSharedArrayBuffer()) return inspectSharedArrayBuffer(object, ref, depth, opts) if (type.isTypedArray()) return inspectTypedArray(object, ref, depth, opts) if (type.isDataView()) return inspectDataView(object, ref, depth, opts) ref.increment() const values = [] for (const key in object) { if (key === 'constructor') continue values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(object[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() let header = '{ ' const tag = object[Symbol.toStringTag] if (tag) header = '[' + tag + '] ' + header if (object.constructor) { const name = object.constructor.name if (name && name !== 'Object') { header = object.constructor.name + ' ' + header } } return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectArray(array, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxArrayLength, 0) for (let i = 0, n = array.length; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(array.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(array[i], depth + 1, opts)) } for (const key of binding.getOwnNonIndexPropertyNames(array)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(array[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() let header = '[ ' if (array.constructor.name !== 'Array') { header = array.constructor.name + '(' + array.length + ') ' + header } return new InspectSequence(header, ' ]', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectDate(date, ref, depth, opts) { return new InspectLeaf(date.toISOString(), styles.date, depth, opts) } function inspectRegExp(regExp, ref, depth, opts) { return new InspectLeaf(regExp.toString(), styles.regexp, depth, opts) } function inspectError(error, ref, depth, opts) { let header if ('stack' in error) { header = error.stack if (depth > 0) { header = header.replaceAll('\n', '\n' + ' '.repeat(depth)) } } else { header = error.toString() } const builtins = ['cause'] if (error.name === 'AggregateError') { builtins.push('errors') } else if (error.name === 'SuppressedError') { builtins.push('error', 'suppressed') } const values = [] for (const key of builtins) { if (key in error === false) continue values.push( new InspectPair( ': ', new InspectLeaf('[' + key + ']', null, depth + 1, opts), inspectValue(error[key], depth + 1, opts), depth + 1, opts ) ) } for (const key in error) { if (key === 'constructor' || builtins.includes(key)) continue values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(error[key], depth + 1, opts), depth + 1, opts ) ) } if (values.length === 0) return new InspectLeaf(header, null, depth, opts) return new InspectSequence( header + ' {', ' }', ', ', values, ref, depth, opts ) } function inspectPromise(promise, ref, depth, opts) { ref.increment() const state = binding.getPromiseState(promise) const values = [] switch (state) { case 0: // Pending values.push(new InspectLeaf('', styles.special, depth, opts)) break case 1: // Fulfilled values.push(inspectValue(binding.getPromiseResult(promise), depth, opts)) break case 2: // Rejected values.push( new InspectLeaf('', styles.special, depth, opts), inspectValue(binding.getPromiseResult(promise), depth, opts) ) } ref.decrement() const header = promise.constructor.name + ' { ' return new InspectSequence(header, ' }', ' ', values, ref, depth, opts) } function inspectMap(map, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxMapLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = maxMapLength for (const entry of map) { if (remaining-- === 0) { values.push( new InspectSuspension(map.size - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push( new InspectPair( ' => ', inspectValue(entry[0], depth + 1, opts), inspectValue(entry[1], depth + 1, opts), depth + 1, opts ) ) } for (const key in map) { if (key === 'constructor') continue const value = inspectValue(map[key], depth + 1, opts) values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), value, depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = map.constructor.name + '(' + map.size + ') { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectSet(set, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxSetLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = maxSetLength for (const entry of set) { if (remaining-- === 0) { values.push( new InspectSuspension(set.size - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(entry, depth + 1, opts)) } for (const key in set) { if (key === 'constructor') continue const value = inspectValue(set[key], depth + 1, opts) values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), value, depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = set.constructor.name + '(' + set.size + ') { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectWeakMap(weakMap, ref, depth, opts) { const header = weakMap.constructor.name + ' { ' return new InspectSequence( header, ' }', ' ', [new InspectLeaf('', styles.special, depth + 1, opts)], ref, depth, opts ) } function inspectWeakSet(weakSet, ref, depth, opts) { const header = weakSet.constructor.name + ' { ' return new InspectSequence( header, ' }', ' ', [new InspectLeaf('', styles.special, depth + 1, opts)], ref, depth, opts ) } function inspectWeakRef(weakRef, ref, depth, opts) { const target = weakRef.deref() let value if (target === undefined) { value = new InspectLeaf('', styles.special, depth + 1, opts) } else { value = inspectValue(target, depth + 1, opts) } const header = weakRef.constructor.name + ' { ' return new InspectSequence(header, ' }', ' ', [value], ref, depth, opts) } function inspectArrayBuffer(arrayBuffer, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(arrayBuffer[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = arrayBuffer.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectSharedArrayBuffer(sharedArrayBuffer, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(sharedArrayBuffer[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = sharedArrayBuffer.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectTypedArray(typedArray, ref, depth, opts) { if (Buffer.isBuffer(typedArray)) { return inspectBuffer(typedArray, ref, depth, opts) } const { maxArrayLength = defaultMaxArrayLength, maxTypedArrayLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxTypedArrayLength, 0) for (let i = 0, n = typedArray.length; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(typedArray.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(typedArray[i], depth + 1, opts)) } for (const key of binding.getOwnNonIndexPropertyNames(typedArray)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(typedArray[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = typedArray.constructor.name + '(' + typedArray.length + ') [ ' return new InspectSequence(header, ' ]', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectBuffer(buffer, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxBufferLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxBufferLength, 0) for (let i = 0, n = buffer.byteLength; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(buffer.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push( new InspectLeaf( buffer[i].toString(16).padStart(2, '0'), null, depth + 1, opts ) ) } for (const key of binding.getOwnNonIndexPropertyNames(buffer)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(buffer[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() return new InspectSequence('', ' ', values, ref, depth, { ...opts, tabulate: true }) } function inspectDataView(dataView, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength', 'byteOffset', 'buffer']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(dataView[key], depth + 1, opts), depth + 1, opts ) ) } for (const key of binding.getOwnNonIndexPropertyNames(dataView)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(dataView[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = dataView.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectFunction(type, fn, depth, opts) { if (fn.toString().startsWith('class')) return inspectClass(fn, depth, opts) let tag = 'function' if (type.isGeneratorFunction()) tag = 'generator ' + tag if (type.isAsyncFunction()) tag = 'async ' + tag return new InspectLeaf( '[' + tag + ' ' + (fn.name ? fn.name : '(anonymous)') + ']', styles.special, depth, opts ) } function inspectClass(ctor, depth, opts) { return new InspectLeaf( '[class ' + (ctor.name ? ctor.name : '(anonymous)') + ']', styles.special, depth, opts ) } function inspectExternal(external, depth, opts) { return new InspectLeaf( '[external 0x' + binding.getExternal(external).toString(16) + ']', styles.special, depth, opts ) } { "name": "bare-inspect", "version": "3.1.4", "description": "Inspect objects as strings for debugging", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-inspect.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-inspect/issues" }, "homepage": "https://github.com/holepunchto/bare-inspect#readme", "engines": { "bare": ">=1.18.0" }, "dependencies": { "bare-ansi-escapes": "^2.1.0", "bare-type": "^1.0.0" }, "devDependencies": { "brittle": "^3.3.2", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const binding = require('./binding') const errors = require('./lib/errors') const constants = require('./lib/constants') exports.constants = constants exports.errors = errors exports.EOL = binding.platform === 'win32' ? '\r\n' : '\n' exports.devNull = binding.platform === 'win32' ? '\\\\.\\nul' : '/dev/null' exports.platform = function platform() { return binding.platform } exports.arch = function arch() { return binding.arch } exports.type = binding.type exports.version = binding.version exports.release = binding.release exports.machine = binding.machine exports.execPath = binding.execPath exports.pid = binding.pid exports.ppid = binding.ppid exports.cwd = binding.cwd exports.chdir = binding.chdir exports.tmpdir = binding.tmpdir exports.homedir = binding.homedir exports.hostname = binding.hostname exports.userInfo = binding.userInfo exports.groupInfo = binding.groupInfo exports.networkInterfaces = function networkInterfaces() { const result = {} for (const entry of binding.networkInterfaces()) { const { name, ...properties } = entry if (result[name]) result[name].push(properties) else result[name] = [properties] } return result } exports.kill = function kill(pid, signal = constants.signals.SIGTERM) { if (typeof signal === 'string') { if (signal in constants.signals === false) { throw errors.UNKNOWN_SIGNAL('Unknown signal: ' + signal) } signal = constants.signals[signal] } binding.kill(pid, signal) } exports.endianness = function endianness() { return binding.isLittleEndian ? 'LE' : 'BE' } exports.availableParallelism = binding.availableParallelism exports.cpuUsage = function cpuUsage(previous) { const current = binding.cpuUsage() if (previous) { return { user: current.user - previous.user, system: current.system - previous.system } } return current } exports.threadCpuUsage = function threadCpuUsage(previous) { const current = binding.threadCpuUsage() if (previous) { return { user: current.user - previous.user, system: current.system - previous.system } } return current } exports.resourceUsage = binding.resourceUsage exports.memoryUsage = binding.memoryUsage exports.freemem = binding.freemem exports.totalmem = binding.totalmem exports.availableMemory = binding.availableMemory exports.constrainedMemory = binding.constrainedMemory exports.uptime = binding.uptime exports.loadavg = binding.loadavg exports.cpus = binding.cpus exports.getProcessTitle = binding.getProcessTitle exports.setProcessTitle = function setProcessTitle(title) { if (typeof title !== 'string') title = title.toString() if (title.length >= 256) { throw errors.TITLE_OVERFLOW('Process title is too long') } binding.setProcessTitle(title) } exports.getPriority = function getPriority(pid = 0) { return binding.getPriority(pid) } exports.setPriority = function setPriority(pid, priority) { if (priority === undefined) { priority = pid pid = 0 } binding.setPriority(pid, priority) } exports.getEnvKeys = binding.getEnvKeys exports.getEnv = binding.getEnv exports.hasEnv = binding.hasEnv exports.setEnv = binding.setEnv exports.unsetEnv = binding.unsetEnv const binding = require('../binding') module.exports = { signals: binding.signals, errnos: binding.errnos, priority: binding.priority } module.exports = class OSError extends Error { constructor(msg, fn = OSError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'OSError' } static UNKNOWN_SIGNAL(msg) { return new OSError(msg, OSError.UNKNOWN_SIGNAL) } static TITLE_OVERFLOW(msg) { return new OSError(msg, OSError.TITLE_OVERFLOW) } } { "name": "bare-os", "version": "3.9.1", "description": "Operating system utilities for Bare", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" }, "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors.js" } }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-os.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-os/issues" }, "homepage": "https://github.com/holepunchto/bare-os#readme", "engines": { "bare": ">=1.14.0" }, "devDependencies": { "brittle": "^3.1.1", "cmake-bare": "^1.1.6", "lunte": "^1.6.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0" } } // This export SHOULD NOT be shortened in any way as having the full // `module.exports = require(...)` statement is crucial for synthesizing // ESM exports. if (Bare.platform === 'win32') { module.exports = require('./lib/win32') } else { module.exports = require('./lib/posix') } module.exports = { CHAR_UPPERCASE_A: 0x41, CHAR_LOWERCASE_A: 0x61, CHAR_UPPERCASE_Z: 0x5a, CHAR_LOWERCASE_Z: 0x7a, CHAR_DOT: 0x2e, CHAR_FORWARD_SLASH: 0x2f, CHAR_BACKWARD_SLASH: 0x5c, CHAR_COLON: 0x3a, CHAR_QUESTION_MARK: 0x3f } const os = require('bare-os') const { normalizeString } = require('./shared') const { CHAR_DOT, CHAR_FORWARD_SLASH } = require('./constants') function isPosixPathSeparator(code) { return code === CHAR_FORWARD_SLASH } exports.win32 = require('./win32') exports.posix = exports exports.sep = '/' exports.delimiter = ':' exports.resolve = function resolve(...args) { let resolvedPath = '' let resolvedAbsolute = false for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) { const path = i >= 0 ? args[i] : os.cwd() if (path.length === 0) { continue } resolvedPath = `${path}/${resolvedPath}` resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH } resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator) if (resolvedAbsolute) { return `/${resolvedPath}` } return resolvedPath.length > 0 ? resolvedPath : '.' } exports.normalize = function normalize(path) { if (path.length === 0) return '.' const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator) if (path.length === 0) { if (isAbsolute) return '/' return trailingSeparator ? './' : '.' } if (trailingSeparator) path += '/' return isAbsolute ? `/${path}` : path } exports.isAbsolute = function isAbsolute(path) { return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH } exports.join = function join(...args) { if (args.length === 0) return '.' let joined for (let i = 0; i < args.length; ++i) { const arg = args[i] if (arg.length > 0) { if (joined === undefined) joined = arg else joined += `/${arg}` } } if (joined === undefined) return '.' return exports.normalize(joined) } exports.relative = function relative(from, to) { if (from === to) return '' from = exports.resolve(from) to = exports.resolve(to) if (from === to) return '' const fromStart = 1 const fromEnd = from.length const fromLen = fromEnd - fromStart const toStart = 1 const toLen = to.length - toStart const length = fromLen < toLen ? fromLen : toLen let lastCommonSep = -1 let i = 0 for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i) if (fromCode !== to.charCodeAt(toStart + i)) { break } else if (fromCode === CHAR_FORWARD_SLASH) { lastCommonSep = i } } if (i === length) { if (toLen > length) { if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) { return to.substring(toStart + i + 1) } if (i === 0) { return to.substring(toStart + i) } } else if (fromLen > length) { if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) { lastCommonSep = i } else if (i === 0) { lastCommonSep = 0 } } } let out = '' for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { out += out.length === 0 ? '..' : '/..' } } return `${out}${to.substring(toStart + lastCommonSep)}` } exports.toNamespacedPath = function toNamespacedPath(path) { return path } exports.dirname = function dirname(path) { if (path.length === 0) return '.' const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH let end = -1 let matchedSlash = true for (let i = path.length - 1; i >= 1; --i) { if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { if (!matchedSlash) { end = i break } } else { matchedSlash = false } } if (end === -1) return hasRoot ? '/' : '.' if (hasRoot && end === 1) return '//' return path.substring(0, end) } exports.basename = function basename(path, suffix) { let start = 0 let end = -1 let matchedSlash = true if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) { return '' } let extIdx = suffix.length - 1 let firstNonSlashEnd = -1 for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i) if (code === CHAR_FORWARD_SLASH) { if (!matchedSlash) { start = i + 1 break } } else { if (firstNonSlashEnd === -1) { matchedSlash = false firstNonSlashEnd = i + 1 } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) { end = i } } else { extIdx = -1 end = firstNonSlashEnd } } } } if (start === end) end = firstNonSlashEnd else if (end === -1) end = path.length return path.substring(start, end) } for (let i = path.length - 1; i >= 0; --i) { if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { if (!matchedSlash) { start = i + 1 break } } else if (end === -1) { matchedSlash = false end = i + 1 } } if (end === -1) return '' return path.substring(start, end) } exports.extname = function extname(path) { let startDot = -1 let startPart = 0 let end = -1 let matchedSlash = true let preDotState = 0 for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i) if (code === CHAR_FORWARD_SLASH) { if (!matchedSlash) { startPart = i + 1 break } continue } if (end === -1) { matchedSlash = false end = i + 1 } if (code === CHAR_DOT) { if (startDot === -1) startDot = i else if (preDotState !== 1) preDotState = 1 } else if (startDot !== -1) { preDotState = -1 } } if ( startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return '' } return path.substring(startDot, end) } const { CHAR_DOT, CHAR_FORWARD_SLASH } = require('./constants') exports.normalizeString = function normalizeString( path, allowAboveRoot, separator, isPathSeparator ) { let res = '' let lastSegmentLength = 0 let lastSlash = -1 let dots = 0 let code = 0 for (let i = 0; i <= path.length; ++i) { if (i < path.length) { code = path.charCodeAt(i) } else if (isPathSeparator(code)) { break } else { code = CHAR_FORWARD_SLASH } if (isPathSeparator(code)) { if (lastSlash === i - 1 || dots === 1); else if (dots === 2) { if ( res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT ) { if (res.length > 2) { const lastSlashIndex = res.lastIndexOf(separator) if (lastSlashIndex === -1) { res = '' lastSegmentLength = 0 } else { res = res.substring(0, lastSlashIndex) lastSegmentLength = res.length - 1 - res.lastIndexOf(separator) } lastSlash = i dots = 0 continue } else if (res.length !== 0) { res = '' lastSegmentLength = 0 lastSlash = i dots = 0 continue } } if (allowAboveRoot) { res += res.length > 0 ? `${separator}..` : '..' lastSegmentLength = 2 } } else { if (res.length > 0) { res += `${separator}${path.substring(lastSlash + 1, i)}` } else { res = path.substring(lastSlash + 1, i) } lastSegmentLength = i - lastSlash - 1 } lastSlash = i dots = 0 } else if (code === CHAR_DOT && dots !== -1) { ++dots } else { dots = -1 } } return res } const os = require('bare-os') const { normalizeString } = require('./shared') const { CHAR_UPPERCASE_A, CHAR_LOWERCASE_A, CHAR_UPPERCASE_Z, CHAR_LOWERCASE_Z, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_QUESTION_MARK } = require('./constants') function isWindowsPathSeparator(code) { return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH } function isWindowsDeviceRoot(code) { return ( (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) || (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ) } exports.posix = require('./posix') exports.win32 = exports exports.sep = '\\' exports.delimiter = ';' exports.resolve = function resolve(...args) { let resolvedDevice = '' let resolvedTail = '' let resolvedAbsolute = false for (let i = args.length - 1; i >= -1; i--) { let path if (i >= 0) { path = args[i] if (path.length === 0) continue } else if (resolvedDevice.length === 0) { path = os.cwd() } else { path = os.getEnv(`=${resolvedDevice}`) || os.cwd() if ( path === undefined || (path.substring(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH) ) { path = `${resolvedDevice}\\` } } const len = path.length let rootEnd = 0 let device = '' let isAbsolute = false const code = path.charCodeAt(0) if (len === 1) { if (isWindowsPathSeparator(code)) { rootEnd = 1 isAbsolute = true } } else if (isWindowsPathSeparator(code)) { isAbsolute = true if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { const firstPart = path.substring(last, j) last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len || j !== last) { device = `\\\\${firstPart}\\${path.substring(last, j)}` rootEnd = j } } } } else { rootEnd = 1 } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.substring(0, 2) rootEnd = 2 if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) { isAbsolute = true rootEnd = 3 } } if (device.length > 0) { if (resolvedDevice.length > 0) { if (device.toLowerCase() !== resolvedDevice.toLowerCase()) { continue } } else { resolvedDevice = device } } if (resolvedAbsolute) { if (resolvedDevice.length > 0) { break } } else { resolvedTail = `${path.substring(rootEnd)}\\${resolvedTail}` resolvedAbsolute = isAbsolute if (isAbsolute && resolvedDevice.length > 0) { break } } } resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isWindowsPathSeparator) return resolvedAbsolute ? `${resolvedDevice}\\${resolvedTail}` : `${resolvedDevice}${resolvedTail}` || '.' } exports.normalize = function normalize(path) { const len = path.length if (len === 0) return '.' let rootEnd = 0 let device let isAbsolute = false const code = path.charCodeAt(0) if (len === 1) { return code === CHAR_FORWARD_SLASH ? '\\' : path } if (isWindowsPathSeparator(code)) { isAbsolute = true if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { const firstPart = path.substring(last, j) last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len) { return `\\\\${firstPart}\\${path.substring(last)}\\` } if (j !== last) { device = `\\\\${firstPart}\\${path.substring(last, j)}` rootEnd = j } } } } else { rootEnd = 1 } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.substring(0, 2) rootEnd = 2 if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) { isAbsolute = true rootEnd = 3 } } let tail = rootEnd < len ? normalizeString(path.substring(rootEnd), !isAbsolute, '\\', isWindowsPathSeparator) : '' if (tail.length === 0 && !isAbsolute) { tail = '.' } if (tail.length > 0 && isWindowsPathSeparator(path.charCodeAt(len - 1))) { tail += '\\' } if (device === undefined) { return isAbsolute ? `\\${tail}` : tail } return isAbsolute ? `${device}\\${tail}` : `${device}${tail}` } exports.isAbsolute = function isAbsolute(path) { const len = path.length if (len === 0) return false const code = path.charCodeAt(0) return ( isWindowsPathSeparator(code) || (len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isWindowsPathSeparator(path.charCodeAt(2))) ) } exports.join = function join(...args) { if (args.length === 0) return '.' let joined let firstPart for (let i = 0; i < args.length; ++i) { const arg = args[i] if (arg.length > 0) { if (joined === undefined) joined = firstPart = arg else joined += `\\${arg}` } } if (joined === undefined) return '.' let needsReplace = true let slashCount = 0 if (isWindowsPathSeparator(firstPart.charCodeAt(0))) { ++slashCount const firstLen = firstPart.length if (firstLen > 1 && isWindowsPathSeparator(firstPart.charCodeAt(1))) { ++slashCount if (firstLen > 2) { if (isWindowsPathSeparator(firstPart.charCodeAt(2))) { ++slashCount } else { needsReplace = false } } } } if (needsReplace) { while (slashCount < joined.length && isWindowsPathSeparator(joined.charCodeAt(slashCount))) { slashCount++ } if (slashCount >= 2) { joined = `\\${joined.substring(slashCount)}` } } return exports.normalize(joined) } exports.relative = function relative(from, to) { if (from === to) return '' const fromOrig = exports.resolve(from) const toOrig = exports.resolve(to) if (fromOrig === toOrig) return '' from = fromOrig.toLowerCase() to = toOrig.toLowerCase() if (from === to) return '' let fromStart = 0 while (fromStart < from.length && from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) { fromStart++ } let fromEnd = from.length while (fromEnd - 1 > fromStart && from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) { fromEnd-- } const fromLen = fromEnd - fromStart let toStart = 0 while (toStart < to.length && to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { toStart++ } let toEnd = to.length while (toEnd - 1 > toStart && to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) { toEnd-- } const toLen = toEnd - toStart const length = fromLen < toLen ? fromLen : toLen let lastCommonSep = -1 let i = 0 for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i) if (fromCode !== to.charCodeAt(toStart + i)) { break } else if (fromCode === CHAR_BACKWARD_SLASH) { lastCommonSep = i } } if (i !== length) { if (lastCommonSep === -1) return toOrig } else { if (toLen > length) { if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { return toOrig.substring(toStart + i + 1) } if (i === 2) { return toOrig.substring(toStart + i) } } if (fromLen > length) { if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { lastCommonSep = i } else if (i === 2) { lastCommonSep = 3 } } if (lastCommonSep === -1) lastCommonSep = 0 } let out = '' for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) { out += out.length === 0 ? '..' : '\\..' } } toStart += lastCommonSep if (out.length > 0) { return `${out}${toOrig.substring(toStart, toEnd)}` } if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { ++toStart } return toOrig.substring(toStart, toEnd) } exports.toNamespacedPath = function toNamespacedPath(path) { if (path.length === 0) return path const resolvedPath = exports.resolve(path) if (resolvedPath.length <= 2) return path if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { const code = resolvedPath.charCodeAt(2) if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { return `\\\\?\\UNC\\${resolvedPath.substring(2)}` } } } else if ( isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH ) { return `\\\\?\\${resolvedPath}` } return path } exports.dirname = function dirname(path) { const len = path.length if (len === 0) return '.' let rootEnd = -1 let offset = 0 const code = path.charCodeAt(0) if (len === 1) { return isWindowsPathSeparator(code) ? path : '.' } if (isWindowsPathSeparator(code)) { rootEnd = offset = 1 if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len) { return path } if (j !== last) { rootEnd = offset = j + 1 } } } } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { rootEnd = len > 2 && isWindowsPathSeparator(path.charCodeAt(2)) ? 3 : 2 offset = rootEnd } let end = -1 let matchedSlash = true for (let i = len - 1; i >= offset; --i) { if (isWindowsPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { end = i break } } else { matchedSlash = false } } if (end === -1) { if (rootEnd === -1) return '.' end = rootEnd } return path.substring(0, end) } exports.basename = function basename(path, suffix) { let start = 0 let end = -1 let matchedSlash = true if ( path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON ) { start = 2 } if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) return '' let extIdx = suffix.length - 1 let firstNonSlashEnd = -1 for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i) if (isWindowsPathSeparator(code)) { if (!matchedSlash) { start = i + 1 break } } else { if (firstNonSlashEnd === -1) { matchedSlash = false firstNonSlashEnd = i + 1 } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) { end = i } } else { extIdx = -1 end = firstNonSlashEnd } } } } if (start === end) end = firstNonSlashEnd else if (end === -1) end = path.length return path.substring(start, end) } for (let i = path.length - 1; i >= start; --i) { if (isWindowsPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { start = i + 1 break } } else if (end === -1) { matchedSlash = false end = i + 1 } } if (end === -1) return '' return path.substring(start, end) } exports.extname = function extname(path) { let start = 0 let startDot = -1 let startPart = 0 let end = -1 let matchedSlash = true let preDotState = 0 if ( path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0)) ) { start = startPart = 2 } for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i) if (isWindowsPathSeparator(code)) { if (!matchedSlash) { startPart = i + 1 break } continue } if (end === -1) { matchedSlash = false end = i + 1 } if (code === CHAR_DOT) { if (startDot === -1) startDot = i else if (preDotState !== 1) preDotState = 1 } else if (startDot !== -1) { preDotState = -1 } } if ( startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return '' } return path.substring(startDot, end) } { "name": "bare-path", "version": "3.0.1", "description": "Path manipulation library for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./posix": "./lib/posix.js", "./win32": "./lib/win32.js" }, "files": [ "index.js", "index.d.ts", "lib", "NOTICE" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-path.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-path/issues" }, "homepage": "https://github.com/holepunchto/bare-path#readme", "dependencies": { "bare-os": "^3.0.1" }, "devDependencies": { "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } const abort = require('bare-abort') const EventEmitter = require('bare-events') const Signal = require('bare-signals') const os = require('bare-os') const env = require('bare-env') const hrtime = require('bare-hrtime') const stdio = require('bare-stdio') class Process extends EventEmitter { constructor() { super() this._startTime = hrtime.bigint() EventEmitter.forward(Bare, this, [ 'uncaughtException', 'unhandledRejection', 'beforeExit', 'exit', 'suspend', 'wakeup', 'idle', 'resume' ]) const signals = new Signal.Emitter() signals.unref() EventEmitter.forward(signals, this, Object.keys(os.constants.signals)) } get stdin() { return stdio.in } get stdout() { return stdio.out } get stderr() { return stdio.err } get platform() { return os.platform() } get arch() { return os.arch() } get title() { return os.getProcessTitle() } set title(title) { os.setProcessTitle(title) } get pid() { return os.pid() } get ppid() { return os.ppid() } get argv() { return Bare.argv } get execPath() { return os.execPath() } get exitCode() { return Bare.exitCode } set exitCode(code) { Bare.exitCode = code } get version() { return Bare.version } get versions() { return Bare.versions } get env() { return env } get hrtime() { return hrtime } abort() { abort() } exit(code) { Bare.exit(code) } suspend() { Bare.suspend() } resume() { Bare.resume() } cwd() { return os.cwd() } chdir(directory) { os.chdir(directory) } kill(pid, signal) { os.kill(pid, signal) } uptime() { return Number(hrtime.bigint() - this._startTime) / 1e9 } cpuUsage(previous) { return os.cpuUsage(previous) } threadCpuUsage(previous) { return os.threadCpuUsage(previous) } resourceUsage() { return os.resourceUsage() } availableMemory() { return os.availableMemory() } constrainedMemory() { return os.constrainedMemory() } memoryUsage() { return os.memoryUsage() } nextTick(cb, ...args) { queueMicrotask(cb.bind(null, ...args)) } [Symbol.for('bare.inspect')]() { return { __proto__: { constructor: Process }, platform: this.platform, arch: this.arch, title: this.title, pid: this.pid, ppid: this.ppid, argv: this.argv, execPath: this.execPath, exitCode: this.exitCode, version: this.version, versions: this.versions, env: this.env } } } module.exports = new Process() { "name": "bare-process", "version": "4.4.1", "description": "Node.js-compatible process control for Bare", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-process.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-process/issues" }, "homepage": "https://github.com/holepunchto/bare-process#readme", "dependencies": { "bare-abort": "^2.0.13", "bare-env": "^3.0.0", "bare-events": "^2.3.1", "bare-hrtime": "^2.0.0", "bare-os": "^3.7.1", "bare-signals": "^4.0.0", "bare-stdio": "^1.0.1" }, "devDependencies": { "brittle": "^3.2.1", "lunte": "^1.6.0", "prettier": "^3.4.1", "prettier-config-holepunch": "^2.0.0" } } module.exports = require.addon() const EventEmitter = require('bare-events') const os = require('bare-os') const binding = require('./binding') const errors = require('./lib/errors') const signals = os.constants.signals module.exports = exports = class Signal extends EventEmitter { constructor(signum) { super() if (typeof signum === 'string') { if (signum in signals === false) { throw errors.UNKNOWN_SIGNAL(`Unknown signal '${signum}'`) } signum = signals[signum] } this._signum = signum this._closing = null this._handle = binding.init(this, this._onsignal, this._onclose) } start() { if (this._closing) throw errors.SIGNAL_CLOSED('Signal is closed') binding.start(this._handle, this._signum) return this } stop() { if (this._closing) return this binding.stop(this._handle) return this } ref() { if (this._closing) return this binding.ref(this._handle) return this } unref() { if (this._closing) return this binding.unref(this._handle) return this } close() { if (this._closing) return this._closing this._closing = EventEmitter.once(this, 'close') binding.close(this._handle) return this._closing } _onsignal() { this.emit('signal', this._signum) } _onclose() { this._handle = null this.emit('close') } static send(signum, pid = os.pid()) { os.kill(pid, signum) } } exports.Emitter = require('./lib/emitter') exports.constants = signals exports.errors = errors const EventEmitter = require('bare-events') const Signal = require('..') module.exports = class SignalEmitter extends EventEmitter { constructor() { super() this._signals = new Map() this._unrefed = false this.on('newListener', this._onnewlistener).on( 'removeListener', this._onremovelistener ) } ref() { this._unrefed = false for (const signal of this._signals.values()) signal.ref() return this } unref() { this._unrefed = true for (const signal of this._signals.values()) signal.unref() return this } _onnewlistener(name) { if (name === 'newListener' || name === 'removeListener') return if (this.listenerCount(name) === 0) { const signal = new Signal(name) signal.on('signal', this._onsignal.bind(this, name)).start() if (this._unrefed) signal.unref() this._signals.set(name, signal) } } _onremovelistener(name) { if (name === 'newListener' || name === 'removeListener') return if (this.listenerCount(name) === 0) { const signal = this._signals.get(name) if (this._unrefed) signal.ref() signal.close() this._signals.delete(name) } } _onsignal(name) { this.emit(name, name, Signal.constants[name]) } } module.exports = class SignalError extends Error { constructor(msg, fn = SignalError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'SignalError' } static UNKNOWN_SIGNAL(msg) { return new SignalError(msg, SignalError.UNKNOWN_SIGNAL) } static SIGNAL_CLOSED(msg) { return new SignalError(msg, SignalError.SIGNAL_CLOSED) } } { "name": "bare-signals", "version": "4.2.0", "description": "Native signal handling for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./errors": "./lib/errors.js", "./emitter": "./lib/emitter.js" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-signals.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-signals/issues" }, "homepage": "https://github.com/holepunchto/bare-signals#readme", "engines": { "bare": ">=1.7.0" }, "dependencies": { "bare-events": "^2.5.3", "bare-os": "^3.3.1" }, "devDependencies": { "brittle": "^3.2.1", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const fs = require('bare-fs') const tty = require('bare-tty') const Pipe = require('bare-pipe') const binding = require('./binding') const { TTY, NAMED_PIPE } = binding class IO { constructor() { this._in = null this._out = null this._err = null } get in() { if (this._in === null) { switch (binding.guessType(0)) { case TTY: this._in = new tty.ReadStream(0) break case NAMED_PIPE: this._in = new Pipe(0, { eagerOpen: false }) break default: this._in = fs.createReadStream(null, { fd: 0, eagerOpen: false }) } } return this._in } get out() { if (this._out === null) { switch (binding.guessType(1)) { case TTY: this._out = new tty.WriteStream(1) break case NAMED_PIPE: this._out = new Pipe(1, { eagerOpen: false }) this._out.unref() break default: this._out = fs.createWriteStream(null, { fd: 1, eagerOpen: false }) } } return this._out } get err() { if (this._err === null) { switch (binding.guessType(2)) { case TTY: this._err = new tty.WriteStream(2) break case NAMED_PIPE: this._err = new Pipe(2, { eagerOpen: false }) this._err.unref() break default: this._err = fs.createWriteStream(null, { fd: 2, eagerOpen: false }) } } return this._err } } module.exports = new IO() module.exports = require.addon() const EventEmitter = require('bare-events') const { Duplex } = require('bare-stream') const binding = require('./binding') const constants = require('./lib/constants') const errors = require('./lib/errors') const defaultReadBufferSize = 65536 const empty = Buffer.alloc(0) const ipcHandle = Symbol.for('bare.ipc.handle') const ipcAccept = Symbol.for('bare.ipc.accept') module.exports = exports = class Pipe extends Duplex { constructor(path, opts = {}) { if (typeof path === 'object' && path !== null) { opts = path path = null } const { readBufferSize = defaultReadBufferSize, allowHalfOpen = true, eagerOpen = true, ipc = false } = opts super({ eagerOpen }) this._state = 0 this._allowHalfOpen = allowHalfOpen this._ipc = ipc this._fd = -1 this._path = null this._pendingOpen = null this._pendingWrite = null this._pendingWriteSegments = null this._pendingWriteIdx = 0 this._pendingFinal = null this._pendingDestroy = null this._handleQueue = [] this._handleQueueSize = 0 this._buffer = Buffer.alloc(readBufferSize) this._handle = binding.init( this._buffer, ipc, this, noop, this._onconnect, this._onwrite, this._onfinal, this._onread, this._onhandle, this._onclose ) if (typeof path === 'number') { this.open(path) } else if (typeof path === 'string') { this.connect(path) } } get connecting() { return (this._state & constants.state.CONNECTING) !== 0 } get pending() { return (this._state & constants.state.CONNECTED) === 0 } get readyState() { if (this._state & constants.state.READABLE && this._state & constants.state.WRITABLE) { return 'open' } if (this._state & constants.state.READABLE) { return 'readOnly' } if (this._state & constants.state.WRITABLE) { return 'writeOnly' } return 'opening' } get [ipcHandle]() { return this._handle } open(fd, opts = {}, onconnect) { if (typeof opts === 'function') { onconnect = opts opts = {} } if (typeof fd === 'object' && fd !== null) { opts = fd || {} fd = opts.fd } try { const status = binding.open(this._handle, fd) this._state |= constants.state.CONNECTED this._fd = fd if (status & binding.READABLE) { this._state |= constants.state.READABLE } else { this.push(null) } if (status & binding.WRITABLE) { this._state |= constants.state.WRITABLE } else { this.end() } if (onconnect) this.once('connect', onconnect) queueMicrotask(() => this.emit('connect')) } catch (err) { queueMicrotask(() => { if (this._pendingOpen) this._pendingOpen(err) else this.destroy(err) }) } return this } connect(path, opts = {}, onconnect) { if (this._state & constants.state.CONNECTING || this._state & constants.state.CONNECTED) { throw errors.PIPE_ALREADY_CONNECTED('Pipe is already connected') } this._state |= constants.state.CONNECTING if (typeof opts === 'function') { onconnect = opts opts = {} } if (typeof path === 'object' && path !== null) { opts = path || {} path = opts.path } try { binding.connect(this._handle, path) this._path = path if (onconnect) this.once('connect', onconnect) } catch (err) { queueMicrotask(() => { if (this._pendingOpen) this._pendingOpen(err) else this.destroy(err) }) } return this } write(chunk, encoding, handle, cb) { if (typeof encoding === 'function') { cb = encoding encoding = undefined handle = null } else if (typeof encoding === 'object' && encoding !== null) { if (typeof handle === 'function') cb = handle handle = encoding encoding = undefined } else if (typeof handle === 'function') { cb = handle handle = null } if (handle) this._handleQueueSize++ this._handleQueue.push(handle || null) if (encoding) return super.write(chunk, encoding, cb) return super.write(chunk, cb) } accept(target) { const handle = target[ipcHandle] if (handle === undefined) { throw errors.INVALID_IPC_TARGET('Target does not implement the IPC handle protocol') } binding.accept(this._handle, handle) if (typeof target[ipcAccept] === 'function') target[ipcAccept]() return target } ref() { binding.ref(this._handle) return this } unref() { binding.unref(this._handle) return this } [ipcAccept]() { this._onaccept() } _open(cb) { if (this._state & constants.state.CONNECTED) return cb(null) this._pendingOpen = cb } _read() { if ((this._state & constants.state.READING) === 0) { this._state |= constants.state.READING binding.resume(this._handle) } } _writev(batch, cb) { this._pendingWrite = cb if (this._handleQueueSize === 0) { this._handleQueue = [] this._pendingWriteSegments = null binding.writev( this._handle, batch.map(({ chunk }) => chunk), null ) return } const handles = this._handleQueue.splice(0, batch.length) // Fill any holes in the batch for messages that don't carry a handle. Each // message that does carry a handle decrements the handle queue size. for (let i = 0; i < batch.length; i++) { if (handles[i] === undefined) handles[i] = null else if (handles[i] !== null) this._handleQueueSize-- } const segments = [] let i = 0 while (i < batch.length) { if (handles[i] !== null) { segments.push({ chunks: [batch[i]], handle: handles[i] }) i++ } else { const start = i while (i < batch.length && handles[i] === null) i++ segments.push({ chunks: batch.slice(start, i), handle: null }) } } this._pendingWriteSegments = segments this._pendingWriteIdx = 0 this._writeNextSegment() } _writeNextSegment() { const segment = this._pendingWriteSegments[this._pendingWriteIdx] const chunks = [] for (let i = 0; i < segment.chunks.length; i++) { chunks.push(segment.chunks[i].chunk) } let sendHandle = null if (segment.handle !== null) sendHandle = segment.handle[ipcHandle] binding.writev(this._handle, chunks, sendHandle) } _final(cb) { if (this._state & constants.state.READABLE && this._state & constants.state.WRITABLE) { this._pendingFinal = cb binding.end(this._handle) } else { cb(null) } } _predestroy() { if (this._state & constants.state.CLOSING) return this._state |= constants.state.CLOSING binding.close(this._handle) } _destroy(err, cb) { if (this._state & constants.state.CLOSING) return cb(err) this._state |= constants.state.CLOSING this._pendingDestroy = cb binding.close(this._handle) } _continueOpen(err) { if (this._pendingOpen === null) return const cb = this._pendingOpen this._pendingOpen = null cb(err) } _continueWrite(err) { if (this._pendingWrite === null) return if (this._pendingWriteSegments === null) { const cb = this._pendingWrite this._pendingWrite = null cb(err) return } this._pendingWriteIdx++ if (err === null && this._pendingWriteIdx < this._pendingWriteSegments.length) { this._writeNextSegment() return } const cb = this._pendingWrite this._pendingWrite = null this._pendingWriteSegments = null this._pendingWriteIdx = 0 cb(err) } _continueFinal(err) { if (this._pendingFinal === null) return const cb = this._pendingFinal this._pendingFinal = null cb(err) } _continueDestroy() { if (this._pendingDestroy === null) return const cb = this._pendingDestroy this._pendingDestroy = null cb(null) } _onconnect(err) { if (err) { if (this._pendingOpen) this._continueOpen(err) else this.destroy(err) return } this._state |= constants.state.CONNECTED | constants.state.READABLE | constants.state.WRITABLE this._state &= ~constants.state.CONNECTING this._continueOpen() this.emit('connect') } _onaccept() { this._state |= constants.state.CONNECTED | constants.state.READABLE | constants.state.WRITABLE this._continueOpen() } _onread(err, read) { if (err) { this.destroy(err) return } if (read === 0) { this.push(null) if (this._allowHalfOpen === false) this.end() return } const copy = Buffer.allocUnsafe(read) copy.set(this._buffer.subarray(0, read)) if (this.push(copy) === false && this.destroying === false) { this._state &= ~constants.state.READING binding.pause(this._handle) } } _onhandle(type) { this.emit('handle', type) } _onwrite(err) { this._continueWrite(err) } _onfinal(err) { this._continueFinal(err === null || err.code === 'ENOTCONN' ? null : err) } _onclose() { this._continueDestroy() } _onspawn(readable, writable) { this._state |= constants.state.CONNECTED if (readable) { this._state |= constants.state.READABLE } else { this.push(null) } if (writable) { this._state |= constants.state.WRITABLE } else { this.end() } this._continueOpen() } } exports.Pipe = exports exports.pipe = function pipe() { return binding.pipe() } exports.Server = class PipeServer extends EventEmitter { constructor(opts = {}, onconnection) { if (typeof opts === 'function') { onconnection = opts opts = {} } super() const { readBufferSize = defaultReadBufferSize, allowHalfOpen = true, pauseOnConnect = false, ipc = false } = opts this._state = 0 this._readBufferSize = readBufferSize this._allowHalfOpen = allowHalfOpen this._pauseOnConnect = pauseOnConnect this._ipc = ipc this._path = null this._connections = new Set() this._error = null this._handle = null if (onconnection) this.on('connection', onconnection) } get listening() { return (this._state & constants.state.BOUND) !== 0 } address() { if ((this._state & constants.state.BOUND) === 0) { return null } return this._path } listen(path, backlog = 511, opts = {}, onlistening) { if (this._state & constants.state.BINDING || this._state & constants.state.BOUND) { throw errors.SERVER_ALREADY_LISTENING('Server is already listening') } if (this._state & constants.state.CLOSING) { throw errors.SERVER_IS_CLOSED('Server is closed') } this._state |= constants.state.BINDING if (typeof backlog === 'function') { onlistening = backlog backlog = 511 } else if (typeof opts === 'function') { onlistening = opts opts = {} } if (typeof path === 'object' && path !== null) { opts = path || {} path = opts.path backlog = opts.backlog || 511 } this._handle = binding.init( empty, this._ipc, this, this._onconnection, noop, noop, noop, noop, noop, this._onclose ) if (this._state & constants.state.UNREFED) binding.unref(this._handle) try { binding.bind(this._handle, path, backlog) this._path = path this._state |= constants.state.BOUND this._state &= ~constants.state.BINDING if (onlistening) this.once('listening', onlistening) queueMicrotask(() => this.emit('listening')) } catch (err) { this._error = err binding.close(this._handle) } return this } close(onclose) { if (onclose) this.once('close', onclose) if (this._state & constants.state.CLOSING) return this._state |= constants.state.CLOSING this._closeMaybe() return this } ref() { this._state &= ~constants.state.UNREFED if (this._handle !== null) binding.ref(this._handle) return this } unref() { this._state |= constants.state.UNREFED if (this._handle !== null) binding.unref(this._handle) return this } _closeMaybe() { if (this._state & constants.state.CLOSING && this._connections.size === 0) { if (this._handle !== null) binding.close(this._handle) else queueMicrotask(() => this.emit('close')) } } _onconnection(err) { if (err) { this.emit('error', err) return } if (this._state & constants.state.CLOSING) return const pipe = new exports.Pipe({ readBufferSize: this._readBufferSize, allowHalfOpen: this._allowHalfOpen, eagerOpen: !this._pauseOnConnect, ipc: this._ipc }) try { binding.accept(this._handle, pipe._handle) pipe._path = this._path pipe._onaccept() this._connections.add(pipe) pipe.on('close', () => { this._connections.delete(pipe) this._closeMaybe() }) this.emit('connection', pipe) } catch (err) { pipe.destroy() throw err } } _onclose() { const err = this._error this._state &= ~constants.state.BINDING this._error = null this._handle = null if (err) this.emit('error', err) else this.emit('close') } } exports.constants = constants exports.errors = errors exports.createConnection = function createConnection(path, opts, onconnect) { if (typeof opts === 'function') { onconnect = opts opts = {} } if (typeof path === 'object' && path !== null) { opts = path || {} path = opts.path } return new exports.Pipe(opts).connect(path, opts, onconnect) } exports.createServer = function createServer(opts, onconnection) { return new exports.Server(opts, onconnection) } function noop() {} const binding = require('../binding') module.exports = { state: { CONNECTING: 0x1, CONNECTED: 0x2, BINDING: 0x4, BOUND: 0x8, READING: 0x10, CLOSING: 0x20, READABLE: 0x40, WRITABLE: 0x80, UNREFED: 0x100 }, handle: { NAMED_PIPE: binding.UV_NAMED_PIPE, TCP: binding.UV_TCP, UDP: binding.UV_UDP } } module.exports = class PipeError extends Error { constructor(msg, fn = PipeError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'PipeError' } static PIPE_ALREADY_CONNECTED(msg) { return new PipeError(msg, PipeError.PIPE_ALREADY_CONNECTED) } static SERVER_ALREADY_LISTENING(msg) { return new PipeError(msg, PipeError.SERVER_ALREADY_LISTENING) } static SERVER_IS_CLOSED(msg) { return new PipeError(msg, PipeError.SERVER_IS_CLOSED) } static INVALID_IPC_TARGET(msg) { return new PipeError(msg, PipeError.INVALID_IPC_TARGET) } } { "name": "bare-pipe", "version": "4.2.0", "description": "Native I/O pipes for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" }, "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors.js" } }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-pipe.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-pipe/issues" }, "homepage": "https://github.com/holepunchto/bare-pipe#readme", "engines": { "bare": ">=1.16.0" }, "dependencies": { "bare-events": "^2.0.0", "bare-stream": "^2.0.0" }, "devDependencies": { "bare-path": "^3.0.0", "bare-tcp": "^2.4.1", "brittle": "^3.2.1", "cmake-bare": "^1.1.6", "lunte": "^1.8.0", "prettier": "^3.4.1", "prettier-config-holepunch": "^2.0.0" } } { "name": "bare-stdio", "version": "1.0.2", "description": "Standard input/output streams for Bare", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./constants": "./lib/constants.js", "./errors": "./lib/errors.js" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-stdio.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-stdio/issues" }, "homepage": "https://github.com/holepunchto/bare-stdio#readme", "dependencies": { "bare-fs": "^4.5.2", "bare-pipe": "^4.1.5", "bare-tty": "^5.0.3" }, "devDependencies": { "bare-os": "^3.6.2", "bare-path": "^3.0.0", "bare-subprocess": "^3.1.4", "brittle": "^3.19.1", "cmake-bare": "^1.7.7", "lunte": "^1.4.0", "prettier": "^3.8.1", "prettier-config-holepunch": "^2.0.0", "tt-native": "^1.1.1" } } const stream = require('streamx') const { ReadableStream, WritableStream } = require('./web') const defaultEncoding = 'utf8' module.exports = exports = stream.Stream exports.pipeline = stream.pipeline exports.isStream = stream.isStream exports.isEnding = stream.isEnding exports.isEnded = stream.isEnded exports.isFinishing = stream.isFinishing exports.isFinished = stream.isFinished exports.isDisturbed = stream.isDisturbed exports.isErrored = function isErrored(stream) { return exports.getStreamError(stream) !== null } exports.isReadable = function isReadable(stream) { return stream.readable && !stream.destroying && !exports.isEnded(stream) } exports.isWritable = function isWritable(stream) { return stream.writable && !stream.destroying && !exports.isFinishing(stream) } exports.getStreamError = stream.getStreamError exports.addAbortSignal = function addAbortSignal(signal, stream) { function onAbort() { stream.destroy(signal.reason) } if (signal.aborted) onAbort() else signal.addEventListener('abort', onAbort) return stream } exports.Stream = exports exports.Readable = class Readable extends stream.Readable { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, map: null, mapReadable: null }) if (this._construct) this._open = this._construct if (this._read !== stream.Readable.prototype._read) { this._read = read.bind(this, this._read) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } get closed() { return !exports.isReadable(this) } get errored() { return stream.getStreamError(this) } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = Buffer.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = Buffer.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } static fromWeb(readableStream, opts = {}) { const stream = readableStream._stream if (opts.encoding) stream.setEncoding(opts.encoding) if (opts.signal) exports.addAbortSignal(opts.signal, stream) return stream } static toWeb(readable, opts = {}) { return new ReadableStream(readable, opts.strategy) } async [Symbol.asyncDispose]() { if (!this.destroyed) this.destroy() await new Promise((resolve) => exports.finished(this, resolve)) } } exports.Writable = class Writable extends stream.Writable { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthWritable, map: null, mapWritable: null }) if (this._construct) this._open = this._construct if (this._write !== stream.Writable.prototype._write) { this._write = write.bind(this, this._write) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } get closed() { return !exports.isWritable(this) } get errored() { return stream.getStreamError(this) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = Buffer.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = Buffer.from(chunk, encoding || defaultEncoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } static fromWeb(writableStream, opts = {}) { const stream = writableStream._stream if (opts.signal) exports.addAbortSignal(opts.signal, stream) return stream } static toWeb(writable) { return new WritableStream(writable) } async [Symbol.asyncDispose]() { if (!this.destroyed) this.destroy() await new Promise((resolve) => exports.finished(this, resolve)) } } exports.Duplex = class Duplex extends stream.Duplex { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, byteLengthWritable, map: null, mapReadable: null, mapWritable: null }) if (this._construct) this._open = this._construct if (this._read !== stream.Readable.prototype._read) { this._read = read.bind(this, this._read) } if (this._write !== stream.Duplex.prototype._write) { this._write = write.bind(this, this._write) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = Buffer.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = Buffer.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = Buffer.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = Buffer.from(chunk, encoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } static fromWeb({ readable: readableStream, writable: writableStream }, opts) { const readable = exports.Readable.fromWeb(readableStream, opts) const writable = exports.Writable.fromWeb(writableStream, opts) const duplex = new exports.Duplex({ write(data, encoding, cb) { writable.write(data, encoding, cb) } }) readable .on('data', (data) => duplex.push(data)) .on('end', () => duplex.push(null)) .on('error', (err) => duplex.destroy(err)) writable.on('finish', () => duplex.end()).on('error', (err) => duplex.destroy(err)) return duplex } static toWeb(duplex) { const readableStream = exports.Readable.toWeb(duplex) const writableStream = exports.Writable.toWeb(duplex) return { readable: readableStream, writable: writableStream } } } class DuplexSide extends exports.Duplex { constructor(opts) { super(opts) this._otherSide = null this._cb = null } _read() { const cb = this._cb if (!cb) return this._cb = null cb() } _write(chunk, encoding, cb) { this._otherSide.push(chunk, encoding) this._otherSide._cb = cb } _final(cb) { this._otherSide.on('end', cb) this._otherSide.push(null) } } exports.duplexPair = function duplexPair(opts) { const sideA = new DuplexSide(opts) const sideB = new DuplexSide(opts) sideA._otherSide = sideB sideB._otherSide = sideA return [sideA, sideB] } exports.Transform = class Transform extends stream.Transform { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, byteLengthWritable, map: null, mapReadable: null, mapWritable: null }) if (this._transform !== stream.Transform.prototype._transform) { this._transform = transform.bind(this, this._transform) } else { this._transform = passthrough } } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = Buffer.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = Buffer.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = Buffer.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = Buffer.from(chunk, encoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } } exports.PassThrough = class PassThrough extends exports.Transform {} exports.finished = function finished(stream, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} const { cleanup = false } = opts const done = () => { cb(exports.getStreamError(stream, { all: true })) if (cleanup) detach() } const detach = () => { stream.off('close', done) stream.off('error', noop) } if (stream.destroyed) { done() } else { stream.on('close', done) stream.on('error', noop) } return detach } function read(read, cb) { read.call(this, 65536) cb(null) } function write(write, data, cb) { write.call(this, data.chunk, data.encoding, cb) } function transform(transform, data, cb) { transform.call(this, data.chunk, data.encoding, cb) } function destroy(destroy, cb) { destroy.call(this, exports.getStreamError(this), cb) } function passthrough(data, cb) { cb(null, data.chunk) } function byteLengthWritable(data) { return data.chunk.byteLength } function noop() {} { "name": "bare-stream", "version": "2.13.1", "description": "Streaming data for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./promises": "./promises.js", "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" } }, "files": [ "index.js", "index.d.ts", "promises.js", "web.js", "web.d.ts", "global.js", "global.d.ts" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-stream.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-stream/issues" }, "homepage": "https://github.com/holepunchto/bare-stream#readme", "dependencies": { "streamx": "^2.25.0", "teex": "^1.0.1" }, "devDependencies": { "bare-abort-controller": "^1.1.0", "bare-buffer": "^3.0.0", "bare-events": "^2.5.4", "brittle": "^3.5.2", "lunte": "^1.6.0", "prettier": "^3.3.3", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "bare-abort-controller": "*", "bare-buffer": "*", "bare-events": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true }, "bare-buffer": { "optional": true }, "bare-events": { "optional": true } } } const { Readable, Writable, Transform, getStreamError, isStreamx, isDisturbed } = require('streamx') const tee = require('teex') const readableKind = Symbol.for('bare.stream.readable.kind') const writableKind = Symbol.for('bare.stream.writable.kind') const transformKind = Symbol.for('bare.stream.transform.kind') // https://streams.spec.whatwg.org/#readablestreamdefaultreader exports.ReadableStreamDefaultReader = class ReadableStreamDefaultReader { constructor(stream) { this._stream = stream this._stream._stream.once('close', onclose).once('error', onerror) const closed = Promise.withResolvers() // Avoid unhandled exceptions closed.promise.catch(noop) this._closed = closed function onclose() { closed.resolve() } function onerror(err) { closed.reject(err) } } get closed() { return this._closed.promise } read() { const stream = this._stream._stream return new Promise((resolve, reject) => { const err = getStreamError(stream) if (err) return reject(err) if (stream.destroyed) { return resolve({ value: undefined, done: true }) } const value = stream.read() if (value !== null) { return resolve({ value, done: false }) } stream.once('readable', onreadable).once('close', onclose).once('error', onerror) function onreadable() { const value = stream.read() ondone(null, value === null ? { value: undefined, done: true } : { value, done: false }) } function onclose() { ondone(null, { value: undefined, done: true }) } function onerror(err) { ondone(err, null) } function ondone(err, value) { stream.off('readable', onreadable).off('close', onclose).off('error', onerror) if (err) reject(err) else resolve(value) } }) } releaseLock() { this._closed.reject(new TypeError('Reader was released')) this._stream._releaseLock() this._stream = null } cancel(reason = new TypeError('Stream was cancelled')) { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).once('error', noop).destroy(reason) ) } } // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller exports.ReadableStreamDefaultController = class ReadableStreamDefaultController { constructor(stream) { this._stream = stream } get desiredSize() { const stream = this._stream._stream return stream._readableState.highWaterMark - stream._readableState.buffered } enqueue(data) { this._stream._stream.push(data) } close() { this._stream._stream.push(null) } error(err) { this._stream._stream.destroy(err) } } // https://streams.spec.whatwg.org/#readablestream class ReadableStream { static get [readableKind]() { return 0 // Compatibility version } static from(iterable) { return new ReadableStream(Readable.from(iterable)) } constructor(underlyingSource = {}, queuingStrategy) { if (isStreamx(underlyingSource)) { this._stream = underlyingSource } else { if (queuingStrategy === undefined) { queuingStrategy = new exports.CountQueuingStrategy() } const { start, pull, cancel } = underlyingSource const { highWaterMark = 1, size = defaultSize } = queuingStrategy this._stream = new Readable({ highWaterMark, byteLength: size }) const controller = new exports.ReadableStreamDefaultController(this) try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (pull) { this._stream._read = this._read.bind(this, starting, pull.bind(this, controller)) } if (cancel) { this._stream.once('error', cancel.bind(this)) } } catch (err) { controller.error(err) } } this._reader = null } get [readableKind]() { return ReadableStream[readableKind] } get locked() { return this._reader !== null } getReader() { if (this.locked) throw new TypeError('Stream is locked') this._reader = new exports.ReadableStreamDefaultReader(this) return this._reader } cancel(reason = new TypeError('Stream was cancelled')) { const stream = this._stream if (stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => stream.once('close', resolve).once('error', noop).destroy(reason) ) } tee() { const [a, b] = tee(this._stream) return [new ReadableStream(a), new ReadableStream(b)] } pipeTo(destination) { return new Promise((resolve, reject) => this._stream.pipe(destination._stream, (err) => { err ? reject(err) : resolve() }) ) } [Symbol.asyncIterator]() { return this._stream[Symbol.asyncIterator]() } _releaseLock() { this._reader = null } async _read(starting, pull, cb) { await starting let err = null try { await pull() } catch (e) { err = e } cb(err) } } function defaultSize() { return 1 } exports.ReadableStream = ReadableStream // https://streams.spec.whatwg.org/#countqueuingstrategy exports.CountQueuingStrategy = class CountQueuingStrategy { constructor(opts = {}) { const { highWaterMark = 1 } = opts this.highWaterMark = highWaterMark } size(chunk) { return 1 } } // https://streams.spec.whatwg.org/#bytelengthqueuingstrategy exports.ByteLengthQueuingStrategy = class ByteLengthQueuingStrategy { constructor(opts = {}) { const { highWaterMark = 16384 } = opts this.highWaterMark = highWaterMark } size(chunk) { return chunk.byteLength } } exports.isReadableStream = function isReadableStream(value) { if (value instanceof ReadableStream) return true return ( typeof value === 'object' && value !== null && value[readableKind] === ReadableStream[readableKind] ) } // https://streams.spec.whatwg.org/#readablestream-errored exports.isReadableStreamErrored = function isReadableStreamErrored(stream) { return getStreamError(stream._stream) !== null } // https://streams.spec.whatwg.org/#is-readable-stream-disturbed exports.isReadableStreamDisturbed = function isReadableStreamDisturbed(stream) { return isDisturbed(stream._stream) } // https://streams.spec.whatwg.org/#writablestreamdefaultwriter exports.WritableStreamDefaultWriter = class WritableStreamDefaultWriter { constructor(stream) { this._stream = stream this._stream._stream.once('close', onclose).once('error', onerror) const closed = Promise.withResolvers() // Avoid unhandled exceptions closed.promise.catch(noop) this._closed = closed function onclose() { closed.resolve() } function onerror(err) { closed.reject(err) } } get desiredSize() { const stream = this._stream._stream return stream._writableState.highWaterMark - stream._writableState.buffered } get closed() { return this._closed.promise } get ready() { const stream = this._stream._stream if (getStreamError(stream)) return Promise.reject() return Writable.drained(stream).then() } async write(chunk) { const stream = this._stream._stream let err = getStreamError(stream) if (err) return Promise.reject(err) stream.write(chunk) await Writable.drained(stream) err = getStreamError(stream) if (err) return Promise.reject(err) } releaseLock() { this._closed.reject(new TypeError('Writer was released')) this._stream._releaseLock() this._stream = null } close() { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).end()) } abort(reason = new TypeError('Stream was aborted')) { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).destroy(reason)) } } // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller exports.WritableStreamDefaultController = class WritableStreamDefaultController { constructor(stream) { this._stream = stream } error(err) { this._stream._stream.destroy(err) } } // https://streams.spec.whatwg.org/#writablestream class WritableStream { static get [writableKind]() { return 0 // Compatibility version } constructor(underlyingSink = {}, queuingStrategy = {}) { if (isStreamx(underlyingSink)) { this._stream = underlyingSink } else { if (queuingStrategy === undefined) { queuingStrategy = new exports.CountQueuingStrategy() } const { start, write, close, abort } = underlyingSink const { highWaterMark = 1, size = defaultSize } = queuingStrategy this._stream = new Writable({ highWaterMark, byteLength: size }) const controller = new exports.WritableStreamDefaultController(this) this._controller = controller try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (write) { this._stream._write = this._write.bind(this, starting, write.bind(this)) } if (close) { this._stream._destroy = this._destroy.bind(this, close.call(this)) } if (abort) { this._stream.once('error', abort.bind(this)) } } catch (err) { controller.error(err) } } this._writer = null } get [writableKind]() { return WritableStream[writableKind] } get locked() { return this._writer !== null } getWriter() { if (this.locked) throw new TypeError('Stream is locked') this._writer = new exports.WritableStreamDefaultWriter(this) return this._writer } abort(reason = new TypeError('Stream was aborted')) { if (this._stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => this._stream.once('close', resolve).destroy(reason)) } close() { if (this._stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => this._stream.once('close', resolve).end()) } _releaseLock() { this._writer = null } async _write(starting, write, data, cb) { await starting let err = null try { await write(data, this._controller) } catch (e) { err = e } cb(err) } async _destroy(closing, cb) { let err = null try { await closing } catch (e) { err = e } cb(err) } } exports.WritableStream = WritableStream exports.isWritableStream = function isWritableStream(value) { if (value instanceof WritableStream) return true return ( typeof value === 'object' && value !== null && value[writableKind] === WritableStream[writableKind] ) } // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller exports.TransformStreamDefaultController = class TransformStreamDefaultController { constructor(stream) { this._stream = stream } get desiredSize() { const stream = this._stream._stream return stream._readableState.highWaterMark - stream._readableState.buffered } enqueue(data) { this._stream._stream.push(data) } error(err) { this._stream._stream.destroy(err) } terminate() { const stream = this._stream._stream stream.push(null) stream.destroy(new TypeError('Stream has been terminated')) } } // https://streams.spec.whatwg.org/#transformstream class TransformStream { static get [transformKind]() { return 0 // Compatibility version } constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) { if (isStreamx(transformer)) { this._stream = transformer } else { const { start, transform, flush } = transformer this._stream = new Transform({ ...writableStrategy, ...readableStrategy }) const controller = new exports.TransformStreamDefaultController(this) this._controller = controller try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (transform) { this._stream._transform = this._transform.bind(this, starting, transform.bind(this)) } if (flush) { this._stream._flush = this._flush.bind(this, flush.call(this, this._controller)) } } catch (err) { controller.error(err) } } this._writable = new WritableStream(this._stream) this._readable = new ReadableStream(this._stream) } get [transformKind]() { return TransformStream[transformKind] } get writable() { return this._writable } get readable() { return this._readable } async _transform(starting, transform, data, cb) { await starting let err = null try { await transform(data, this._controller) } catch (e) { err = e } cb(err) } async _flush(flush, cb) { let err = null try { await flush } catch (e) { err = e } cb(err) } } exports.TransformStream = TransformStream exports.isTransformStream = function isTransformStream(value) { if (value instanceof TransformStream) return true return ( typeof value === 'object' && value !== null && value[transformKind] === TransformStream[transformKind] ) } async function forwardError(promise, controller) { try { await promise } catch (err) { controller.error(err) } } function noop() {} module.exports = require.addon() const { Readable, Writable } = require('bare-stream') const Signal = require('bare-signals') const binding = require('./binding') const constants = require('./lib/constants') const defaultReadBufferSize = 65536 const empty = Buffer.alloc(0) exports.ReadStream = class TTYReadStream extends Readable { constructor(fd, opts = {}) { super() const { readBufferSize = defaultReadBufferSize, allowHalfOpen = true } = opts this._fd = fd this._state = 0 this._allowHalfOpen = allowHalfOpen this._buffer = Buffer.alloc(readBufferSize) this._pendingDestroy = null this._handle = binding.init(fd, this._buffer, this, noop, this._onread, this._onclose) } get fd() { return this._fd } get isTTY() { return true } setMode(mode) { binding.setMode(this._handle, mode) return this } setRawMode(enabled) { return this.setMode(enabled ? constants.mode.RAW : constants.mode.NORMAL) } _read() { if ((this._state & constants.state.READING) === 0) { this._state |= constants.state.READING binding.resume(this._handle) } } _predestroy() { if (this._state & constants.state.CLOSING) return this._state |= constants.state.CLOSING binding.close(this._handle) } _destroy(err, cb) { if (this._state & constants.state.CLOSING) return cb(err) this._state |= constants.state.CLOSING this._pendingDestroy = cb binding.close(this._handle) } _continueDestroy() { if (this._pendingDestroy === null) return const cb = this._pendingDestroy this._pendingDestroy = null cb(null) } _onread(err, read) { if (err) { this.destroy(err) return } if (read === 0) { this.push(null) if (this._allowHalfOpen === false) this.end() return } const copy = Buffer.allocUnsafe(read) copy.set(this._buffer.subarray(0, read)) if (this.push(copy) === false && this.destroying === false) { this._state &= ~constants.state.READING binding.pause(this._handle) } } _onclose() { this._handle = null this._continueDestroy() } } exports.WriteStream = class TTYWriteStream extends Writable { constructor(fd, opts = {}) { super() this._fd = fd this._state = 0 this._size = null this._pendingWrite = null this._pendingDestroy = null this._handle = binding.init(fd, empty, this, this._onwrite, noop, this._onclose) this._size = this.getWindowSize() if (TTYWriteStream._streams.size === 0) TTYWriteStream._resize.start() TTYWriteStream._streams.add(this) } get fd() { return this._fd } get isTTY() { return true } get columns() { return this._size[0] } get rows() { return this._size[1] } getWindowSize() { return binding.getWindowSize(this._handle) } _writev(batch, cb) { this._pendingWrite = [cb, batch] binding.writev( this._handle, batch.map(({ chunk }) => chunk) ) } _predestroy() { if (this._state & constants.state.CLOSING) return this._state |= constants.state.CLOSING binding.close(this._handle) TTYWriteStream._streams.delete(this) if (TTYWriteStream._streams.size === 0) TTYWriteStream._resize.stop() } _destroy(err, cb) { if (this._state & constants.state.CLOSING) return cb(err) this._state |= constants.state.CLOSING this._pendingDestroy = cb binding.close(this._handle) TTYWriteStream._streams.delete(this) if (TTYWriteStream._streams.size === 0) TTYWriteStream._resize.stop() } _continueWrite(err) { if (this._pendingWrite === null) return const cb = this._pendingWrite[0] this._pendingWrite = null cb(err) } _continueDestroy() { if (this._pendingDestroy === null) return const cb = this._pendingDestroy this._pendingDestroy = null cb(null) } _onwrite(err) { this._continueWrite(err) } _onclose() { this._handle = null this._continueDestroy() } _onresize() { this._size = this.getWindowSize() this.emit('resize') } static _streams = new Set() static _resize = new Signal('SIGWINCH') } exports.constants = constants exports.isTTY = binding.isTTY exports.isatty = exports.isTTY // For Node.js compatibility exports.WriteStream._resize .on('signal', () => { for (const stream of exports.WriteStream._streams) { stream._onresize() } }) .unref() function noop() {} const binding = require('../binding') module.exports = exports = { mode: { NORMAL: binding.MODE_NORMAL, RAW: binding.MODE_RAW, IO: binding.MODE_IO || 0 }, state: { READING: 0x1, CLOSING: 0x2 } } /** @deprecated Use `mode.NORMAL` */ exports.MODE_NORMAL = exports.mode.NORMAL /** @deprecated Use `mode.RAW` */ exports.MODE_RAW = exports.mode.RAW /** @deprecated Use `mode.IO` */ exports.MODE_IO = exports.mode.IO { "name": "bare-tty", "version": "5.1.0", "description": "Native TTY streams for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./constants": "./lib/constants.js" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-tty.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-tty/issues" }, "homepage": "https://github.com/holepunchto/bare-tty#readme", "engines": { "bare": ">=1.16.0" }, "dependencies": { "bare-events": "^2.2.0", "bare-signals": "^4.0.0", "bare-stream": "^2.0.0" }, "devDependencies": { "brittle": "^3.2.1", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-holepunch": "^2.0.0" } } module.exports = require.addon() const binding = require('./binding') const t = binding.constants class Type { constructor(type) { this._type = type } isUndefined() { return this._type === t.UNDEFINED } isNull() { return this._type === t.NULL } isBoolean() { return this._type === t.BOOLEAN } isNumber() { return (this._type & 0xff) === t.NUMBER } isInt32() { return (this._type & (0xff | t.INT32)) === (t.NUMBER | t.INT32) } isUint32() { return (this._type & (0xff | t.UINT32)) === (t.NUMBER | t.UINT32) } isString() { return this._type === t.STRING } isSymbol() { return this._type === t.SYMBOL } isObject() { return (this._type & 0xff) === t.OBJECT } isArray() { return this._type === (t.OBJECT | t.ARRAY) } isArguments() { return this._type === (t.OBJECT | t.ARGUMENTS) } isDate() { return this._type === (t.OBJECT | t.DATE) } isRegExp() { return this._type === (t.OBJECT | t.REGEXP) } isError() { return this._type === (t.OBJECT | t.ERROR) } isPromise() { return this._type === (t.OBJECT | t.PROMISE) } isProxy() { return this._type === (t.OBJECT | t.PROXY) } isGenerator() { return this._type === (t.OBJECT | t.GENERATOR) } isMap() { return this._type === (t.OBJECT | t.MAP) } isSet() { return this._type === (t.OBJECT | t.SET) } isWeakMap() { return this._type === (t.OBJECT | t.WEAK_MAP) } isWeakSet() { return this._type === (t.OBJECT | t.WEAK_SET) } isWeakRef() { return this._type === (t.OBJECT | t.WEAK_REF) } isArrayBuffer() { return this._type === (t.OBJECT | t.ARRAYBUFFER) } isSharedArrayBuffer() { return this._type === (t.OBJECT | t.SHAREDARRAYBUFFER) } isTypedArray() { return (this._type & 0xffff) === (t.OBJECT | t.TYPEDARRAY) } isInt8Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT8ARRAY) } isUint8Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8ARRAY) } isUint8ClampedArray() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8CLAMPEDARRAY) } isInt16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT16ARRAY) } isUint16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT16ARRAY) } isInt32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT32ARRAY) } isUint32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT32ARRAY) } isFloat16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT16ARRAY) } isFloat32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT32ARRAY) } isFloat64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT64ARRAY) } isBigInt64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGINT64ARRAY) } isBigUint64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGUINT64ARRAY) } isDataView() { return this._type === (t.OBJECT | t.DATAVIEW) } isModuleNamespace() { return this._type === (t.OBJECT | t.MODULE_NAMESPACE) } isFunction() { return (this._type & 0xff) === t.FUNCTION } isAsyncFunction() { return ( (this._type & (0xff | t.ASYNC_FUNCTION)) === (t.FUNCTION | t.ASYNC_FUNCTION) ) } isGeneratorFunction() { return ( (this._type & (0xff | t.GENERATOR_FUNCTION)) === (t.FUNCTION | t.GENERATOR_FUNCTION) ) } isExternal() { return this._type === t.EXTERNAL } isBigInt() { return this._type === t.BIGINT } } module.exports = exports = function type(value) { switch (typeof value) { case 'undefined': return new Type(t.UNDEFINED) case 'boolean': return new Type(t.BOOLEAN) case 'number': return new Type( Number.isSafeInteger(value) ? binding.type(value) : t.NUMBER ) case 'string': return new Type(t.STRING) case 'symbol': return new Type(t.SYMBOL) case 'object': return new Type(value === null ? t.NULL : binding.type(value)) case 'function': return new Type(binding.type(value)) case 'bigint': return new Type(t.BIGINT) } } exports.createTag = function createTag(...components) { const tag = new Uint32Array(4) for (let i = 0; i < 4; i++) tag[i] = components[i] || 0 return tag } exports.addTag = function addTag(object, tag) { binding.addTag(object, tag) } exports.checkTag = function checkTag(object, tag) { return binding.checkTag(object, tag) } { "name": "bare-type", "version": "1.1.0", "description": "Cross-realm type predicates for Bare", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-type.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-type/issues" }, "homepage": "https://github.com/holepunchto/bare-type#readme", "engines": { "bare": ">=1.2.0" }, "devDependencies": { "brittle": "^3.4.0", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const path = require('bare-path') const binding = require('./binding') const errors = require('./lib/errors') const URLSearchParams = require('./lib/url-search-params') const kind = Symbol.for('bare.url.kind') const isWindows = Bare.platform === 'win32' class URL { static get [kind]() { return 0 // Compatibility version } constructor(input, base, opts = {}) { if (arguments.length === 0) throw errors.INVALID_URL() input = String(input) if (base !== undefined) base = String(base) this._components = new Uint32Array(8) this._parse(input, base, opts.throw !== false) if (this._href) this._params = new URLSearchParams(this.search, this) } get [kind]() { return URL[kind] } // https://url.spec.whatwg.org/#dom-url-href get href() { return this._href } set href(value) { this._update(value) this._params._parse(this.search) } // https://url.spec.whatwg.org/#dom-url-protocol get protocol() { return this._slice(0, this._components[0]) + ':' } set protocol(value) { this._update(this._replace(value.replace(/:+$/, ''), 0, this._components[0])) } // https://url.spec.whatwg.org/#dom-url-username get username() { return this._slice(this._components[0] + 3 /* :// */, this._components[1]) } set username(value) { if (cannotHaveCredentialsOrPort(this)) { return } if (this.username === '') value += '@' this._update(this._replace(value, this._components[0] + 3 /* :// */, this._components[1])) } // https://url.spec.whatwg.org/#dom-url-password get password() { return this._href.slice(this._components[1] + 1 /* : */, this._components[2] - 1 /* @ */) } set password(value) { if (cannotHaveCredentialsOrPort(this)) { return } let start = this._components[1] + 1 /* : */ let end = this._components[2] - 1 /* @ */ if (this.password === '') { value = ':' + value start-- } if (this.username === '') { value += '@' end++ } this._update(this._replace(value, start, end)) } // https://url.spec.whatwg.org/#dom-url-host get host() { return this._slice(this._components[2], this._components[5]) } set host(value) { if (hasOpaquePath(this)) { return } this._update( this._replace(value, this._components[2], this._components[value.includes(':') ? 5 : 3]) ) } // https://url.spec.whatwg.org/#dom-url-hostname get hostname() { return this._slice(this._components[2], this._components[3]) } set hostname(value) { if (hasOpaquePath(this)) { return } this._update(this._replace(value, this._components[2], this._components[3])) } // https://url.spec.whatwg.org/#dom-url-port get port() { return this._slice(this._components[3] + 1 /* : */, this._components[5]) } set port(value) { if (cannotHaveCredentialsOrPort(this)) { return } let start = this._components[3] + 1 /* : */ if (this.port === '') { value = ':' + value start-- } this._update(this._replace(value, start, this._components[5])) } // https://url.spec.whatwg.org/#dom-url-pathname get pathname() { return this._slice(this._components[5], this._components[6] - 1 /* ? */) } set pathname(value) { if (hasOpaquePath(this)) { return } if (value[0] !== '/' && value[0] !== '\\') { value = '/' + value } this._update(this._replace(value, this._components[5], this._components[6] - 1 /* ? */)) } // https://url.spec.whatwg.org/#dom-url-search get search() { return this._slice(this._components[6] - 1 /* ? */, this._components[7] - 1 /* # */) } set search(value) { if (value && value[0] !== '?') value = '?' + value this._update( this._replace(value, this._components[6] - 1 /* ? */, this._components[7] - 1 /* # */) ) this._params._parse(this.search) } // https://url.spec.whatwg.org/#dom-url-searchparams get searchParams() { return this._params } // https://url.spec.whatwg.org/#dom-url-hash get hash() { return this._slice(this._components[7] - 1 /* # */) } set hash(value) { if (value && value[0] !== '#') value = '#' + value this._update(this._replace(value, this._components[7] - 1 /* # */)) } toString() { return this._href } toJSON() { return this._href } [Symbol.for('bare.inspect')]() { return { __proto__: { constructor: URL }, href: this.href, protocol: this.protocol, username: this.username, password: this.password, host: this.host, hostname: this.hostname, port: this.port, pathname: this.pathname, search: this.search, searchParams: this.searchParams, hash: this.hash } } _slice(start, end = this._href.length) { return this._href.slice(start, end) } _replace(replacement, start, end = this._href.length) { return this._slice(0, start) + replacement + this._slice(end) } _parse(input, base, shouldThrow) { try { this._href = binding.parse( String(input), base ? String(base) : null, this._components, shouldThrow ) } catch (err) { if (err instanceof TypeError) throw err throw errors.INVALID_URL(`Invalid URL '${input}'`, input) } } _update(input) { try { this._parse(input, null, true) } catch (err) { if (err instanceof TypeError) throw err } } } module.exports = exports = URL // https://url.spec.whatwg.org/#url-opaque-path function hasOpaquePath(url) { return url.pathname[0] !== '/' } // https://url.spec.whatwg.org/#cannot-have-a-username-password-port function cannotHaveCredentialsOrPort(url) { return url.hostname === '' || url.protocol === 'file:' } exports.URL = URL exports.URLSearchParams = URLSearchParams exports.errors = errors exports.isURL = function isURL(value) { if (value instanceof URL) return true return typeof value === 'object' && value !== null && value[kind] === URL[kind] } exports.isURLSearchParams = URLSearchParams.isURLSearchParams // https://url.spec.whatwg.org/#dom-url-parse exports.parse = function parse(input, base) { const url = new URL(input, base, { throw: false }) return url._href ? url : null } // https://url.spec.whatwg.org/#dom-url-canparse exports.canParse = function canParse(input, base) { return binding.canParse(String(input), base ? String(base) : null) } exports.fileURLToPath = function fileURLToPath(url) { if (typeof url === 'string') { url = new URL(url) } if (url.protocol !== 'file:') { throw errors.INVALID_URL_SCHEME('The URL must use the file: protocol') } if (isWindows) { if (/%2f|%5c/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH( 'The file: URL path must not include encoded \\ or / characters' ) } } else { if (url.hostname) { throw errors.INVALID_FILE_URL_HOST("The file: URL host must be 'localhost' or empty") } if (/%2f/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must not include encoded / characters') } } if (/%00/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must not include encoded NUL characters') } const pathname = path.normalize(decodeURIComponent(url.pathname)) if (isWindows) { if (url.hostname) return '\\\\' + url.hostname + pathname const letter = pathname.charCodeAt(1) | 0x20 if (letter < 0x61 /* a */ || letter > 0x7a /* z */ || pathname.charCodeAt(2) !== 0x3a /* : */) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must be absolute') } return pathname.slice(1) } return pathname } exports.pathToFileURL = function pathToFileURL(pathname) { let resolved = path.resolve(pathname) if (pathname[pathname.length - 1] === '/') { resolved += '/' } else if (isWindows && pathname[pathname.length - 1] === '\\') { resolved += '\\' } resolved = resolved .replaceAll('%', '%25') // Must be first .replaceAll('#', '%23') .replaceAll('?', '%3f') .replaceAll('\n', '%0a') .replaceAll('\r', '%0d') .replaceAll('\t', '%09') if (!isWindows) { resolved = resolved.replaceAll('\\', '%5c') } return new URL('file:' + resolved) } exports.format = function format(parts) { const { protocol, auth, host, hostname, port, pathname, search, query, hash, slashes } = parts let result = '' if (typeof protocol === 'string') { result += protocol if (protocol[protocol.length - 1] !== ':') { result += ':' } if (slashes === true || /https?|ftp|gopher|file/.test(protocol)) { result += '//' } } if (typeof auth === 'string') { if (host || hostname) result += auth + '@' } if (typeof host === 'string') result += host else { result += hostname if (port) result += ':' + port } if (typeof pathname === 'string' && pathname !== '') { if (pathname[0] !== '/') result += '/' result += pathname } if (typeof search === 'string') { if (search[0] !== '?') result += '?' result += search } else if (typeof query === 'object' && query !== null) { result += '?' + new URLSearchParams(query) } if (typeof hash === 'string') { if (hash[0] !== '#') result += '#' result += hash } return result } module.exports = class URLError extends Error { constructor(msg, fn = URLError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) Error.captureStackTrace(this, fn) } get name() { return 'URLError' } static INVALID_URL(msg, input) { const err = new URLError(msg, URLError.INVALID_URL) err.input = input return err } static INVALID_URL_SCHEME(msg = 'Invalid URL') { return new URLError(msg, URLError.INVALID_URL_SCHEME) } static INVALID_FILE_URL_HOST(msg = 'Invalid file: URL host') { return new URLError(msg, URLError.INVALID_FILE_URL_HOST) } static INVALID_FILE_URL_PATH(msg = 'Invalid file: URL path') { return new URLError(msg, URLError.INVALID_FILE_URL_PATH) } } const kind = Symbol.for('bare.url.search-params.kind') class URLSearchParams { static _urls = new WeakMap() static get [kind]() { return 0 // Compatibility version } // https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams constructor(init, url = null) { this._params = new Map() if (url) URLSearchParams._urls.set(this, url) if (typeof init === 'string') { this._parse(init) } else if (init) { for (const [name, value] of typeof init[Symbol.iterator] === 'function' ? init : Object.entries(init)) { this.append(name, value) } } } get [kind]() { return URLSearchParams[kind] } // https://url.spec.whatwg.org/#dom-urlsearchparams-size get size() { return this._params.length } // https://url.spec.whatwg.org/#dom-urlsearchparams-append append(name, value = null) { if (value === null) return let list = this._params.get(name) if (list === undefined) { list = [] this._params.set(name, list) } list.push(value) this._update() } // https://url.spec.whatwg.org/#dom-urlsearchparams-delete delete(name, value = null) { if (value === null) this._params.delete(name) else { let list = this._params.get(name) if (list === undefined) return list = list.filter((found) => found !== value) if (list.length === 0) this._params.delete(name) else this._params.set(name, list) } this._update() } // https://url.spec.whatwg.org/#dom-urlsearchparams-get get(name) { const list = this._params.get(name) if (list === undefined) return null return list[0] } // https://url.spec.whatwg.org/#dom-urlsearchparams-getall getAll(name) { const list = this._params.get(name) if (list === undefined) return [] return Array.from(list) } // https://url.spec.whatwg.org/#dom-urlsearchparams-has has(name, value = null) { const list = this._params.get(name) if (list === undefined) return false if (value === null) return true return list.includes(value) } // https://url.spec.whatwg.org/#dom-urlsearchparams-set set(name, value = null) { if (value === null) this._params.delete(name) else this._params.set(name, [value]) this._update() } toString() { return this._serialize() } toJSON() { return [...this] } *[Symbol.iterator]() { for (const [name, values] of this._params) { for (const value of values) yield [name, value] } } [Symbol.for('bare.inspect')]() { const object = { __proto__: { constructor: URLSearchParams } } for (const [name, values] of this._params) { if (values.length === 1) object[name] = values[0] else object[name] = values } return object } // https://url.spec.whatwg.org/#concept-urlsearchparams-update _update() { const url = URLSearchParams._urls.get(this) if (url === undefined) return url.search = this._serialize() } // https://url.spec.whatwg.org/#concept-urlencoded-parser _parse(input) { if (input[0] === '?') input = input.substring(1) this._params = new Map() for (let sequence of input.split('&')) { if (sequence.length === 0) continue sequence = sequence.replace(/\+/g, ' ') let i = sequence.indexOf('=') if (i === -1) i = sequence.length const name = decodeURIComponent(sequence.substring(0, i)) const value = decodeURIComponent(sequence.substring(i + 1, sequence.length)) let list = this._params.get(name) if (list === undefined) { list = [] this._params.set(name, list) } list.push(value) } } // https://url.spec.whatwg.org/#concept-urlencoded-serializer _serialize() { let output = '' for (let [name, values] of this._params) { name = encodeURIComponent(name) for (const value of values) { if (output) output += '&' output += name + '=' + encodeURIComponent(value) } } return output } } module.exports = exports = URLSearchParams exports.isURLSearchParams = function isURLSearchParams(value) { if (value instanceof URLSearchParams) return true return typeof value === 'object' && value !== null && value[kind] === URLSearchParams[kind] } { "name": "bare-url", "version": "2.4.5", "description": "WHATWG URL implementation for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" } }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-url.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-url/issues" }, "homepage": "https://github.com/holepunchto/bare-url", "dependencies": { "bare-path": "^3.0.0" }, "devDependencies": { "brittle": "^3.3.2", "cmake-bare": "^1.1.6", "cmake-fetch": "^1.0.0", "lunte": "^1.6.0", "prettier": "^3.3.3", "prettier-config-holepunch": "^2.0.0" } } const FACTOR = new Uint16Array(8) function factor4096 (i, n) { while (n > 0) { const f = i & 4095 FACTOR[--n] = f i = (i - f) / 4096 } return FACTOR } module.exports = class BigSparseArray { constructor () { this.tiny = new TinyArray() this.maxLength = 4096 this.factor = 1 } set (index, val) { if (val !== undefined) { while (index >= this.maxLength) { this.maxLength *= 4096 this.factor++ if (!this.tiny.isEmptyish()) { const t = new TinyArray() t.set(0, this.tiny) this.tiny = t } } } const f = factor4096(index, this.factor) const last = this.factor - 1 let tiny = this.tiny for (let i = 0; i < last; i++) { const next = tiny.get(f[i]) if (next === undefined) { if (val === undefined) return tiny = tiny.set(f[i], new TinyArray()) } else { tiny = next } } return tiny.set(f[last], val) } get (index) { if (index >= this.maxLength) return const f = factor4096(index, this.factor) const last = this.factor - 1 let tiny = this.tiny for (let i = 0; i < last; i++) { tiny = tiny.get(f[i]) if (tiny === undefined) return } return tiny.get(f[last]) } } class TinyArray { constructor () { this.s = 0 this.b = new Array(1) this.f = new Uint16Array(1) } isEmptyish () { return this.b.length === 1 && this.b[0] === undefined } get (i) { if (this.s === 12) return this.b[i] const f = i >>> this.s const r = i & (this.b.length - 1) return this.f[r] === f ? this.b[r] : undefined } set (i, v) { while (this.s !== 12) { const f = i >>> this.s const r = i & (this.b.length - 1) const o = this.b[r] if (o === undefined || f === this.f[r]) { this.b[r] = v this.f[r] = f return v } this.grow() } this.b[i] = v return v } grow () { const os = this.s const ob = this.b const of = this.f this.s += 4 this.b = new Array(this.b.length << 4) this.f = this.s === 12 ? null : new Uint8Array(this.b.length) const m = this.b.length - 1 for (let or = 0; or < ob.length; or++) { if (ob[or] === undefined) continue const i = of[or] << os | or const f = i >>> this.s const r = i & m this.b[r] = ob[or] if (this.s !== 12) this.f[r] = f } } } { "name": "big-sparse-array", "version": "1.0.3", "description": "A sparse array optimised for low memory whilst still being fast", "main": "index.js", "dependencies": {}, "devDependencies": { "brittle": "^3.1.1", "standard": "^16.0.3" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/big-sparse-array.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/big-sparse-array/issues" }, "homepage": "https://github.com/mafintosh/big-sparse-array" } const b4a = require('b4a') function byteLength (size) { return Math.ceil(size / 8) } function get (buffer, bit) { const n = buffer.BYTES_PER_ELEMENT * 8 const offset = bit & (n - 1) const i = (bit - offset) / n return (buffer[i] & (1 << offset)) !== 0 } function set (buffer, bit, value = true) { const n = buffer.BYTES_PER_ELEMENT * 8 const offset = bit & (n - 1) const i = (bit - offset) / n const mask = 1 << offset if (value) { if ((buffer[i] & mask) !== 0) return false } else { if ((buffer[i] & mask) === 0) return false } buffer[i] ^= mask return true } function setRange (buffer, start, end, value = true) { const n = buffer.BYTES_PER_ELEMENT * 8 let remaining = end - start let offset = start & (n - 1) let i = (start - offset) / n let changed = false while (remaining > 0) { const mask = (2 ** Math.min(remaining, n - offset) - 1) << offset if (value) { if ((buffer[i] & mask) !== mask) { buffer[i] |= mask changed = true } } else { if ((buffer[i] & mask) !== 0) { buffer[i] &= ~mask changed = true } } remaining -= n - offset offset = 0 i++ } return changed } function fill (buffer, value, start = 0, end = buffer.byteLength * 8) { const n = buffer.BYTES_PER_ELEMENT * 8 let i, j { const offset = start & (n - 1) i = (start - offset) / n if (offset !== 0) { const mask = (2 ** Math.min(n - offset, end - start) - 1) << offset if (value) buffer[i] |= mask else buffer[i] &= ~mask i++ } } { const offset = end & (n - 1) j = (end - offset) / n if (offset !== 0 && j >= i) { const mask = (2 ** offset) - 1 if (value) buffer[j] |= mask else buffer[j] &= ~mask } } return buffer.fill(value ? (2 ** n) - 1 : 0, i, j) } function toggle (buffer, bit) { const n = buffer.BYTES_PER_ELEMENT * 8 const offset = bit & (n - 1) const i = (bit - offset) / n const mask = 1 << offset buffer[i] ^= mask return (buffer[i] & mask) !== 0 } function remove (buffer, bit) { return set(buffer, bit, false) } function removeRange (buffer, start, end) { return setRange(buffer, start, end, false) } function indexOf (buffer, value, position = 0) { for (let i = position, n = buffer.byteLength * 8; i < n; i++) { if (get(buffer, i) === value) return i } return -1 } function lastIndexOf (buffer, value, position = buffer.byteLength * 8 - 1) { for (let i = position; i >= 0; i--) { if (get(buffer, i) === value) return i } return -1 } function of (...bits) { return from(bits) } function from (bits) { const buffer = b4a.alloc(byteLength(bits.length)) for (let i = 0; i < bits.length; i++) set(buffer, i, bits[i]) return buffer } function * iterator (buffer) { for (let i = 0, n = buffer.byteLength * 8; i < n; i++) yield get(buffer, i) } module.exports = { byteLength, get, set, setRange, fill, toggle, remove, removeRange, indexOf, lastIndexOf, of, from, iterator } { "name": "bits-to-bytes", "version": "1.3.0", "description": "Functions for doing bit manipulation of typed arrays", "main": "index.js", "files": [ "index.js" ], "scripts": { "test": "standard && brittle test.mjs" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bits-to-bytes.git" }, "author": "Kasper Isager Dalsgarð ", "license": "ISC", "bugs": { "url": "https://github.com/holepunchto/bits-to-bytes/issues" }, "homepage": "https://github.com/holepunchto/bits-to-bytes#readme", "dependencies": { "b4a": "^1.5.0" }, "devDependencies": { "brittle": "^2.3.1", "standard": "^17.0.0" } } const EventEmitter = require('events') const Protomux = require('protomux') const { Readable } = require('streamx') const sodium = require('sodium-universal') const b4a = require('b4a') const c = require('compact-encoding') const bitfield = require('compact-encoding-bitfield') const bits = require('bits-to-bytes') const errors = require('./lib/errors') exports.Server = class BlindRelayServer extends EventEmitter { constructor(opts = {}) { super() const { createStream } = opts this._createStream = createStream this._pairing = new Map() this._activePairingRefs = new Map() this._sessions = new Set() this.stats = createStats() } get sessions() { return this._sessions[Symbol.iterator]() } accept(stream, opts) { const session = new BlindRelaySession(this, stream, opts) this._sessions.add(session) this.stats.sessions.accepted++ return session } async close() { const ending = [] for (const session of this._sessions) { ending.push(session.end()) } await Promise.all(ending) this._pairing.clear() } _trackActiveLink(keyString) { const refs = this._activePairingRefs.get(keyString) || 0 if (refs === 0) this.stats.pairings.active++ this._activePairingRefs.set(keyString, refs + 1) } _untrackActiveLink(keyString) { const refs = this._activePairingRefs.get(keyString) if (refs === undefined) return if (refs === 1) { this._activePairingRefs.delete(keyString) this.stats.pairings.active-- } else { this._activePairingRefs.set(keyString, refs - 1) } } } class BlindRelaySession extends EventEmitter { constructor(server, stream, opts = {}) { super() const { id, handshake, handshakeEncoding } = opts this._server = server this._mux = Protomux.from(stream) this._channel = this._mux.createChannel({ protocol: 'blind-relay', id, handshake: handshake ? handshakeEncoding || c.raw : null, onopen: this._onopen.bind(this), onclose: this._onclose.bind(this), ondestroy: this._ondestroy.bind(this) }) this._pair = this._channel.addMessage({ encoding: m.pair, onmessage: this._onpair.bind(this) }) this._unpair = this._channel.addMessage({ encoding: m.unpair, onmessage: this._onunpair.bind(this) }) this._ending = null this._destroyed = false this._error = null this._pairing = new Set() this._links = new Map() this._onerror = (err) => { this._server.stats.streams.errors++ this.emit('error', err) } this._channel.open(handshake) } get closed() { return this._channel.closed } get mux() { return this._mux } get stream() { return this._mux.stream } _onopen() { this._server.stats.sessions.opened++ this.emit('open') } _onclose() { this._ending = Promise.resolve() const err = this._error || errors.CHANNEL_CLOSED() this._server.stats.pairings.cancelled += this._pairing.size for (const token of this._pairing) { if (this._server._pairing.delete(token.toString('hex'))) { this._server.stats.pairings.pending-- } } for (const link of this._links.values()) { link.destroy(err) } this._pairing.clear() this._links.clear() this._server._sessions.delete(this) this._server.stats.sessions.closed++ this.emit('close') } _ondestroy() { this._destroyed = true this.emit('destroy') } _onpair({ isInitiator, token, id: remoteId }) { const keyString = token.toString('hex') let pair = this._server._pairing.get(keyString) if (pair === undefined) { pair = new BlindRelayPair(token) this._server._pairing.set(keyString, pair) this._server.stats.pairings.pending++ } else if (pair.links[+isInitiator]) return this._pairing.add(keyString) this._server.stats.pairings.requested++ pair.links[+isInitiator] = new BlindRelayLink(this, isInitiator, remoteId) if (!pair.paired) return this._server._pairing.delete(keyString) this._server.stats.pairings.pending-- this._server.stats.pairings.matched++ // 1st pass: Create the raw streams needed for each end of the link. for (const link of pair.links) { link.createStream() } // 2nd pass: Connect the raw streams and set up handlers. for (const link of pair.links) { link.remote = pair.remote(link.isInitiator) link.activate(keyString) } // 3rd pass: Let either end of the link know the streams were set up. for (const { isInitiator, session, remoteId, stream } of pair.links) { session._pair.send({ isInitiator, token, id: stream.id, seq: 0 }) session._endMaybe() session.emit('pair', isInitiator, token, stream, remoteId) } } _onunpair({ token }) { const keyString = token.toString('hex') const pair = this._server._pairing.get(keyString) if (pair) { for (const link of pair.links) { if (link) link.session._pairing.delete(keyString) } this._server._pairing.delete(keyString) this._server.stats.pairings.pending-- this._server.stats.pairings.cancelled++ return } const link = this._links.get(keyString) if (link) { link.destroyPair(errors.PAIRING_CANCELLED()) this._server.stats.pairings.cancelled++ } } cork() { this._channel.cork() } uncork() { this._channel.uncork() } async end() { if (this._ending) return this._ending this._ending = EventEmitter.once(this, 'close') this._endMaybe() return this._ending } _endMaybe() { if (this._ending && this._pairing.size === 0) { this._channel.close() } } destroy(err) { if (this._destroyed) return this._destroyed = true this._error = err || errors.CHANNEL_DESTROYED() this._channel.close() } } class BlindRelayPair { constructor(token) { this.token = token this.links = [null, null] } get paired() { return this.links[0] !== null && this.links[1] !== null } remote(isInitiator) { return this.links[isInitiator ? 0 : 1] } } class BlindRelayLink { constructor(session, isInitiator, remoteId) { this.session = session this.isInitiator = isInitiator this.remoteId = remoteId this.stream = null this.remote = null this.keyString = null this._onclose = null } createStream() { if (this.stream) return this.stream = this.session._server._createStream({ firewall: this._onfirewall.bind(this) }) } activate(keyString) { const stream = this.stream this.keyString = keyString this._onclose = () => { if (this.stream !== stream) return this.stream = null unlink(this) this.session._links.delete(keyString) this.session._server._untrackActiveLink(keyString) this.session._server.stats.streams.closed++ } stream.on('error', this.session._onerror).on('close', this._onclose).relayTo(this.remote.stream) this.session._pairing.delete(keyString) this.session._links.set(keyString, this) this.session._server._trackActiveLink(keyString) this.session._server.stats.streams.opened++ } destroy(err) { const stream = this.stream if (!stream) return this.stream = null stream.off('close', this._onclose) this._onclose = null stream.off('error', this.session._onerror) unlink(this) this.session._links.delete(this.keyString) this.session._server._untrackActiveLink(this.keyString) this.session._server.stats.streams.closed++ stream.on('error', noop).destroy(err) } destroyPair(err) { const remote = this.remote this.destroy(err) if (remote) remote.destroy(err) } _onfirewall(socket, port, host) { this.stream.connect(socket, this.remoteId, port, host) return false } } exports.Client = class BlindRelayClient extends EventEmitter { static _clients = new WeakMap() static from(stream, opts) { let client = this._clients.get(stream) if (client) return client client = new this(stream, opts) this._clients.set(stream, client) return client } constructor(stream, opts = {}) { super() const { id, handshake, handshakeEncoding } = opts this._mux = Protomux.from(stream) this._channel = this._mux.createChannel({ protocol: 'blind-relay', id, handshake: handshake ? handshakeEncoding || c.raw : null, onopen: this._onopen.bind(this), onclose: this._onclose.bind(this), ondestroy: this._ondestroy.bind(this) }) this._pair = this._channel.addMessage({ encoding: m.pair, onmessage: this._onpair.bind(this) }) this._unpair = this._channel.addMessage({ encoding: m.unpair }) this._ending = false this._destroyed = false this._error = null this._requests = new Map() this._channel.open(handshake) } get closed() { return this._channel.closed } get mux() { return this._mux } get stream() { return this._mux.stream } get requests() { return this._requests.values() } _onopen() { this.emit('open') } _onclose() { this._ending = Promise.resolve() const err = this._error || errors.CHANNEL_CLOSED() for (const request of this._requests.values()) { request.destroy(err) } this._requests.clear() this.constructor._clients.delete(this.stream) this.emit('close') } _ondestroy() { this._destroyed = true this.emit('destroy') } _onpair({ isInitiator, token, id: remoteId }) { const request = this._requests.get(token.toString('hex')) if (request === undefined || request.isInitiator !== isInitiator) return request.push(remoteId) request.push(null) this.emit('pair', request.isInitiator, request.token, request.stream, remoteId) } pair(isInitiator, token, stream) { if (this._destroyed) throw errors.CHANNEL_DESTROYED() const keyString = token.toString('hex') if (this._requests.has(keyString)) throw errors.ALREADY_PAIRING() const request = new BlindRelayRequest(this, isInitiator, token, stream) this._requests.set(keyString, request) return request } unpair(token) { if (this._destroyed) throw errors.CHANNEL_DESTROYED() const request = this._requests.get(token.toString('hex')) if (request) request.destroy(errors.PAIRING_CANCELLED()) this._unpair.send({ token }) } cork() { this._channel.cork() } uncork() { this._channel.uncork() } async end() { if (this._ending) return this._ending this._ending = EventEmitter.once(this, 'close') this._endMaybe() return this._ending } _endMaybe() { if (this._ending && this._requests.size === 0) { this._channel.close() } } destroy(err) { if (this._destroyed) return this._destroyed = true this._error = err || errors.CHANNEL_DESTROYED() this._channel.close() } } class BlindRelayRequest extends Readable { constructor(client, isInitiator, token, stream) { super() this.client = client this.isInitiator = isInitiator this.token = token this.stream = stream } _open(cb) { if (this.client._destroyed) return cb(errors.CHANNEL_DESTROYED()) this.client._pair.send({ isInitiator: this.isInitiator, token: this.token, id: this.stream.id, seq: 0 }) cb(null) } _destroy(cb) { this.client._requests.delete(this.token.toString('hex')) cb(null) this.client._endMaybe() } } exports.token = function token(buf = b4a.allocUnsafe(32)) { sodium.randombytes_buf(buf) return buf } function noop() {} function unlink(link) { const remote = link.remote link.remote = null if (remote && remote.remote === link) { remote.remote = null } } function createStats() { const stats = { sessions: { accepted: 0, opened: 0, closed: 0, get active() { return this.accepted - this.closed } }, pairings: { requested: 0, matched: 0, cancelled: 0, pending: 0, active: 0 }, streams: { opened: 0, closed: 0, errors: 0, get active() { return this.opened - this.closed } } } return stats } const m = (exports.messages = {}) const flags = bitfield(7) m.pair = { preencode(state, m) { flags.preencode(state) c.fixed32.preencode(state, m.token) c.uint.preencode(state, m.id) c.uint.preencode(state, m.seq) }, encode(state, m) { flags.encode(state, bits.of(m.isInitiator)) c.fixed32.encode(state, m.token) c.uint.encode(state, m.id) c.uint.encode(state, m.seq) }, decode(state) { const [isInitiator] = bits.iterator(flags.decode(state)) return { isInitiator, token: c.fixed32.decode(state), id: c.uint.decode(state), seq: c.uint.decode(state) } } } m.unpair = { preencode(state, m) { flags.preencode(state) c.fixed32.preencode(state, m.token) }, encode(state, m) { flags.encode(state, bits.of()) c.fixed32.encode(state, m.token) }, decode(state) { flags.decode(state) return { token: c.fixed32.decode(state) } } } module.exports = class BlindRelayError extends Error { constructor(msg, code, fn = BlindRelayError) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'BlindRelayError' } static DUPLICATE_CHANNEL(msg = 'Duplicate channel') { return new BlindRelayError(msg, 'DUPLICATE_CHANNEL', BlindRelayError.DUPLICATE_CHANNEL) } static CHANNEL_CLOSED(msg = 'Channel closed') { return new BlindRelayError(msg, 'CHANNEL_CLOSED', BlindRelayError.CHANNEL_CLOSED) } static CHANNEL_DESTROYED(msg = 'Channel destroyed') { return new BlindRelayError(msg, 'CHANNEL_DESTROYED', BlindRelayError.CHANNEL_DESTROYED) } static ALREADY_PAIRING(msg = 'Already pairing') { return new BlindRelayError(msg, 'ALREADY_PAIRING', BlindRelayError.ALREADY_PAIRING) } static PAIRING_CANCELLED(msg = 'Pairing cancelled') { return new BlindRelayError(msg, 'PAIRING_CANCELLED', BlindRelayError.PAIRING_CANCELLED) } } { "name": "blind-relay", "version": "1.6.1", "description": "Blind relay for UDX over Protomux channels", "main": "index.js", "files": [ "index.js", "lib" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:bare", "test:bare": "brittle-bare --coverage test.mjs" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/blind-relay.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/blind-relay/issues" }, "homepage": "https://github.com/holepunchto/blind-relay#readme", "imports": { "events": { "bare": "bare-events", "default": "events" } }, "dependencies": { "b4a": "^1.6.4", "bare-events": "^2.2.0", "bits-to-bytes": "^1.3.0", "compact-encoding": "^3.0.0", "compact-encoding-bitfield": "^1.0.0", "protomux": "^3.5.1", "sodium-universal": "^5.0.0", "streamx": "^2.15.1" }, "devDependencies": { "brittle": "^3.2.1", "hyperdht": "^6.6.1", "lunte": "^1.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "udx-native": "^1.6.1" } } // https://ipinfo.io/bogon const b4a = require('b4a') const c = require('compact-encoding') module.exports = exports = function isBogon (ip) { return isBogonIP(ensureBuffer(ip)) } exports.isBogon = exports exports.isPrivate = function isPrivate (ip) { return isPrivateIP(ensureBuffer(ip)) } exports.isReserved = function isReserved (ip) { return isReservedIP(ensureBuffer(ip)) } function isBogonIP (ip) { return isPrivateIP(ip) || isReservedIP(ip) } function isPrivateIP (ip) { return ip.byteLength === 4 ? isPrivateIPv4(ip) : false // IPv6 has no private IPs } function isPrivateIPv4 (ip) { return ( // 10.0.0.0/8 Private-use networks (ip[0] === 10) || // 100.64.0.0/10 Carrier-grade NAT (ip[0] === 100 && ip[1] >= 64 && ip[1] <= 127) || // 127.0.0.0/8 Loopback + Name collision occurrence (127.0.53.53) (ip[0] === 127) || // 169.254.0.0/16 Link local (ip[0] === 169 && ip[1] === 254) || // 172.16.0.0/12 Private-use networks (ip[0] === 172 && ip[1] >= 16 && ip[1] <= 31) || // 192.168.0.0/16 Private-use networks (ip[0] === 192 && ip[1] === 168) ) } function isReservedIP (ip) { return ip.byteLength === 4 ? isReservedIPv4(ip) : isReservedIPv6(ip) } function isReservedIPv4 (ip) { return ( // 0.0.0.0/8 "This" network (ip[0] === 0) || // 192.0.0.0/24 IETF protocol assignments (ip[0] === 192 && ip[1] === 0 && ip[2] === 0) || // 192.0.2.0/24 TEST-NET-1 (ip[0] === 192 && ip[1] === 0 && ip[2] === 2) || // 198.18.0.0/15 Network interconnect device benchmark testing (ip[0] === 198 && ip[1] >= 18 && ip[1] <= 19) || // 198.51.100.0/24 TEST-NET-2 (ip[0] === 198 && ip[1] === 51 && ip[2] === 100) || // 203.0.113.0/24 TEST-NET-3 (ip[0] === 203 && ip[1] === 0 && ip[2] === 113) || // 224.0.0.0/4 Multicast (ip[0] >= 224 && ip[0] <= 239) || // 240.0.0.0/4 Reserved for future use (ip[0] >= 240) || // 255.255.255.255/32 (ip[0] === 255 && ip[1] === 255 && ip[2] === 255 && ip[3] === 255) ) } function isReservedIPv6 (ip) { return ( // ::/128 Node-scope unicast unspecified address // ::1/128 Node-scope unicast loopback address ( ip[0] === 0 && ip[1] === 0 && ip[2] === 0 && ip[3] === 0 && ip[4] === 0 && ip[5] === 0 && ip[6] === 0 && ip[7] === 0 && ip[8] === 0 && ip[9] === 0 && ip[10] === 0 && ip[11] === 0 && ip[12] === 0 && ip[13] === 0 && ip[14] === 0 && ip[15] <= 1 ) || // ::ffff:0:0/96 IPv4-mapped addresses // ::/96 IPv4-compatible addresses ( ip[0] === 0 && ip[1] === 0 && ip[2] === 0 && ip[3] === 0 && ip[4] === 0 && ip[5] === 0 && ip[6] === 0 && ip[7] === 0 && ip[8] === 0 && ip[9] === 0 && (ip[10] === 0 || ip[10] === 0xff) && (ip[11] === 0 || ip[11] === 0xff) ) || // 100::/64 Remotely triggered black hole addresses (ip[0] === 0x01 && ip[1] === 0 && ip[2] === 0 && ip[3] === 0 && ip[4] === 0 && ip[5] === 0 && ip[6] === 0 && ip[7] === 0) || // 2001:10::/28 Overlay routable cryptographic hash identifiers (ORCHID) (ip[0] === 0x20 && ip[1] === 0x01 && ip[2] === 0 && ip[3] >= 0x10 && ip[3] <= 0x1f) || // 2001:20::/28 Overlay routable cryptographic hash identifiers version 2 (ORCHIDv2) (ip[0] === 0x20 && ip[1] === 0x01 && ip[2] === 0 && ip[3] >= 0x20 && ip[3] <= 0x2f) || // 2001:db8::/32 Documentation prefix (ip[0] === 0x20 && ip[1] === 0x01 && ip[2] === 0x0d && ip[3] === 0xb8) || // fc00::/7 Unique local addresses (ULA) (ip[0] >= 0xfc && ip[0] <= 0xfd) || // fe80::/10 Link-local unicast (ip[0] === 0xfe && ip[1] >= 0x80 && ip[1] <= 0xbf) || // ff00::/8 Multicast (ip[0] === 0xff) ) } const state = c.state(0, 0, b4a.allocUnsafe(1 /* family */ + 16)) function ensureBuffer (ip) { if (b4a.isBuffer(ip)) return ip c.ip.preencode(state, ip) c.ip.encode(state, ip) const buffer = state.buffer.subarray(1 /* family */, state.end) state.start = 0 state.end = 0 return buffer } { "name": "bogon", "version": "1.3.0", "description": "Check if an IP is a bogon", "main": "index.js", "scripts": { "test": "standard && brittle test.mjs" }, "dependencies": { "compact-encoding": "^3.0.0", "compact-encoding-net": "^1.2.0" }, "devDependencies": { "brittle": "^3.0.4", "nanobench": "^2.1.1", "standard": "^17.0.0" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/bogon.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/bogon/issues" }, "homepage": "https://github.com/mafintosh/bogon" } const b4a = require('b4a') module.exports = codecs codecs.ascii = createString('ascii') codecs.utf8 = createString('utf-8') codecs.hex = createString('hex') codecs.base64 = createString('base64') codecs.ucs2 = createString('ucs2') codecs.utf16le = createString('utf16le') codecs.ndjson = createJSON(true) codecs.json = createJSON(false) codecs.binary = { name: 'binary', encode: function encodeBinary (obj) { return typeof obj === 'string' ? b4a.from(obj, 'utf-8') : b4a.toBuffer(obj) }, decode: function decodeBinary (buf) { return b4a.toBuffer(buf) } } function isCompactEncoding (c) { return !!(c.encode && c.decode && c.preencode) } function fromCompactEncoding (c) { return { name: 'compact-encoding', encode: function encodeWithCompact (value) { const state = { start: 0, end: 0, buffer: null, cache: null } c.preencode(state, value) state.buffer = b4a.allocUnsafe(state.end) c.encode(state, value) return state.buffer }, decode: function decodeWithCompact (buffer) { return c.decode({ start: 0, end: buffer.byteLength, buffer, cache: null }) } } } function codecs (fmt, fallback) { if (typeof fmt === 'object' && fmt) { return isCompactEncoding(fmt) ? fromCompactEncoding(fmt) : fmt } switch (fmt) { case 'ndjson': return codecs.ndjson case 'json': return codecs.json case 'ascii': return codecs.ascii case 'utf-8': case 'utf8': return codecs.utf8 case 'hex': return codecs.hex case 'base64': return codecs.base64 case 'ucs-2': case 'ucs2': return codecs.ucs2 case 'utf16-le': case 'utf16le': return codecs.utf16le } return fallback !== undefined ? fallback : codecs.binary } function createJSON (newline) { return { name: newline ? 'ndjson' : 'json', encode: newline ? encodeNDJSON : encodeJSON, decode: function decodeJSON (buf) { return JSON.parse(b4a.toString(buf)) } } function encodeJSON (val) { return b4a.from(JSON.stringify(val)) } function encodeNDJSON (val) { return b4a.from(JSON.stringify(val) + '\n') } } function createString (type) { return { name: type, encode: function encodeString (val) { if (typeof val !== 'string') val = val.toString() return b4a.from(val, type) }, decode: function decodeString (buf) { return b4a.toString(buf, type) } } } { "name": "codecs", "version": "3.1.0", "description": "Create an binary encoder/decoder for json, utf-8 or custom types", "main": "index.js", "dependencies": { "b4a": "^1.6.3" }, "devDependencies": { "brittle": "^3.2.1", "compact-encoding": "^2.11.0", "standard": "^17.0.0" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/codecs.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/codecs/issues" }, "homepage": "https://github.com/mafintosh/codecs" } const c = require('compact-encoding') module.exports = function bitfield(length) { if (length > 64) { throw new RangeError('Bitfield cannot be larger than 64 bits') } let byteLength if (length < 8) byteLength = 1 else if (length <= 16) byteLength = 2 else if (length <= 32) byteLength = 4 else byteLength = 8 return { preencode(state) { state.end++ // Length byte, used for data when byteLength === 1 if (byteLength === 1); else if (byteLength === 2) c.uint16.preencode(state) else if (byteLength === 4) c.uint32.preencode(state) else c.uint64.preencode(state) }, encode(state, b) { if (byteLength === 1); else if (byteLength === 2) c.uint8.encode(state, 0xfd) else if (byteLength === 4) c.uint8.encode(state, 0xfe) else c.uint8.encode(state, 0xff) if (typeof b === 'number') { if (byteLength === 1) c.uint8.encode(state, b) else if (byteLength === 2) c.uint16.encode(state, b) else if (byteLength === 4) c.uint32.encode(state, b) else c.uint64.encode(state, b) } else { state.buffer.set(b, state.start) if (b.byteLength < byteLength) { // Zero-fill the rest of the byte length. state.buffer.fill( 0, state.start + b.byteLength, state.start + byteLength ) } state.start += byteLength } }, decode(state) { const byte = state.buffer[state.start] let byteLength if (byte <= 0xfc) byteLength = 1 else if (byte === 0xfd) byteLength = 2 else if (byte === 0xfe) byteLength = 4 else byteLength = 8 if (byteLength > 1) state.start++ // Skip the length byte if (state.end - state.start < byteLength) throw new Error('Out of bounds') const b = state.buffer.subarray(state.start, (state.start += byteLength)) return length <= 8 ? b.subarray(0, 1) : b } } } { "name": "compact-encoding-bitfield", "version": "1.1.0", "description": "Compact codec for bitfields", "main": "index.js", "files": [ "index.js" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node --coverage test.mjs", "test:bare": "brittle-bare --coverage test.mjs" }, "repository": { "type": "git", "url": "git+https://github.com/compact-encoding/compact-encoding-bitfield.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/compact-encoding/compact-encoding-bitfield/issues" }, "homepage": "https://github.com/compact-encoding/compact-encoding-bitfield#readme", "imports": { "util": { "bare": "bare-utils", "default": "util" } }, "dependencies": { "compact-encoding": "^3.0.0" }, "devDependencies": { "bare-utils": "^1.5.1", "brittle": "^3.1.0", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" } } const LE = (exports.LE = new Uint8Array(new Uint16Array([0xff]).buffer)[0] === 0xff) exports.BE = !LE const b4a = require('b4a') const { BE } = require('./endian') exports.state = function (start = 0, end = 0, buffer = null) { return { start, end, buffer } } const raw = (exports.raw = require('./raw')) const uint = (exports.uint = { preencode(state, n) { state.end += n <= 0xfc ? 1 : n <= 0xffff ? 3 : n <= 0xffffffff ? 5 : 9 }, encode(state, n) { if (n <= 0xfc) uint8.encode(state, n) else if (n <= 0xffff) { state.buffer[state.start++] = 0xfd uint16.encode(state, n) } else if (n <= 0xffffffff) { state.buffer[state.start++] = 0xfe uint32.encode(state, n) } else { state.buffer[state.start++] = 0xff uint64.encode(state, n) } }, decode(state) { const a = uint8.decode(state) if (a <= 0xfc) return a if (a === 0xfd) return uint16.decode(state) if (a === 0xfe) return uint32.decode(state) return uint64.decode(state) } }) const uint8 = (exports.uint8 = { preencode(state, n) { state.end += 1 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n }, decode(state) { if (state.start >= state.end) throw new Error('Out of bounds') return state.buffer[state.start++] } }) const uint16 = (exports.uint16 = { preencode(state, n) { state.end += 2 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 }, decode(state) { if (state.end - state.start < 2) throw new Error('Out of bounds') return state.buffer[state.start++] + state.buffer[state.start++] * 0x100 } }) const uint24 = (exports.uint24 = { preencode(state, n) { state.end += 3 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n >>> 16 }, decode(state) { if (state.end - state.start < 3) throw new Error('Out of bounds') return ( state.buffer[state.start++] + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] * 0x10000 ) } }) const uint32 = (exports.uint32 = { preencode(state, n) { state.end += 4 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n >>> 16 state.buffer[state.start++] = n >>> 24 }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] * 0x10000 + state.buffer[state.start++] * 0x1000000 ) } }) const uint32be = (exports.uint32be = { preencode(state, n) { state.end += 4 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n >>> 24 state.buffer[state.start++] = n >>> 16 state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] * 0x1000000 + state.buffer[state.start++] * 0x10000 + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] ) } }) const uint40 = (exports.uint40 = { preencode(state, n) { state.end += 5 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100) uint8.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 5) throw new Error('Out of bounds') return uint8.decode(state) + 0x100 * uint32.decode(state) } }) const uint48 = (exports.uint48 = { preencode(state, n) { state.end += 6 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x10000) uint16.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 6) throw new Error('Out of bounds') return uint16.decode(state) + 0x10000 * uint32.decode(state) } }) const uint56 = (exports.uint56 = { preencode(state, n) { state.end += 7 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x1000000) uint24.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 7) throw new Error('Out of bounds') return uint24.decode(state) + 0x1000000 * uint32.decode(state) } }) const uint64 = (exports.uint64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100000000) uint32.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') return uint32.decode(state) + 0x100000000 * uint32.decode(state) } }) exports.uint64be = { preencode(state, n) { state.end += 8 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100000000) uint32be.encode(state, r) uint32be.encode(state, n) }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') return 0x100000000 * uint32be.decode(state) + uint32be.decode(state) } } const int = (exports.int = zigZagInt(uint)) exports.int8 = zigZagInt(uint8) exports.int16 = zigZagInt(uint16) exports.int24 = zigZagInt(uint24) exports.int32 = zigZagInt(uint32) exports.int40 = zigZagInt(uint40) exports.int48 = zigZagInt(uint48) exports.int56 = zigZagInt(uint56) exports.int64 = zigZagInt(uint64) const biguint64 = (exports.biguint64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) view.setBigUint64(0, n, true) // little endian state.start += 8 }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) const n = view.getBigUint64(0, true) // little endian state.start += 8 return n } }) exports.bigint64 = zigZagBigInt(biguint64) const biguint = (exports.biguint = { preencode(state, n) { let len = 0 for (let m = n; m; m = m >> 64n) len++ uint.preencode(state, len) state.end += 8 * len }, encode(state, n) { let len = 0 for (let m = n; m; m = m >> 64n) len++ uint.encode(state, len) const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len ) for (let m = n, i = 0; m; m = m >> 64n, i += 8) { view.setBigUint64(i, BigInt.asUintN(64, m), true) // little endian } state.start += 8 * len }, decode(state) { const len = uint.decode(state) if (state.end - state.start < 8 * len) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len ) let n = 0n for (let i = len - 1; i >= 0; i--) n = (n << 64n) + view.getBigUint64(i * 8, true) // little endian state.start += 8 * len return n } }) exports.bigint = zigZagBigInt(biguint) exports.lexint = require('./lexint') exports.float32 = { preencode(state, n) { state.end += 4 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 4 ) view.setFloat32(0, n, true) // little endian state.start += 4 }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 4 ) const float = view.getFloat32(0, true) // little endian state.start += 4 return float } } exports.float64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) view.setFloat64(0, n, true) // little endian state.start += 8 }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) const float = view.getFloat64(0, true) // little endian state.start += 8 return float } } const buffer = (exports.buffer = { preencode(state, b) { uint8array.preencode(state, b) }, encode(state, b) { uint8array.encode(state, b) }, decode(state) { const len = uint.decode(state) if (state.end - state.start < len) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += len)) } }) exports.optionalBuffer = { preencode(state, b) { if (b) uint8array.preencode(state, b) else state.end++ }, encode(state, b) { if (b) uint8array.encode(state, b) else state.buffer[state.start++] = 0 }, decode(state) { const len = uint.decode(state) if (len === 0) return null if (state.end - state.start < len) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += len)) } } exports.binary = { ...buffer, preencode(state, b) { if (typeof b === 'string') utf8.preencode(state, b) else buffer.preencode(state, b) }, encode(state, b) { if (typeof b === 'string') utf8.encode(state, b) else buffer.encode(state, b) } } exports.arraybuffer = { preencode(state, b) { uint.preencode(state, b.byteLength) state.end += b.byteLength }, encode(state, b) { uint.encode(state, b.byteLength) const view = new Uint8Array(b) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const len = uint.decode(state) const b = new ArrayBuffer(len) const view = new Uint8Array(b) view.set(state.buffer.subarray(state.start, (state.start += len))) return b } } function typedarray(TypedArray, swap) { const n = TypedArray.BYTES_PER_ELEMENT return { preencode(state, b) { uint.preencode(state, b.length) state.end += b.byteLength }, encode(state, b) { uint.encode(state, b.length) const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength) if (BE && swap) swap(view) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const len = uint.decode(state) let b = state.buffer.subarray(state.start, (state.start += len * n)) if (b.byteLength !== len * n) throw new Error('Out of bounds') if (b.byteOffset % n !== 0) b = new Uint8Array(b) if (BE && swap) swap(b) return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n) } } } const uint8array = (exports.uint8array = typedarray(Uint8Array)) exports.uint16array = typedarray(Uint16Array, b4a.swap16) exports.uint32array = typedarray(Uint32Array, b4a.swap32) exports.int8array = typedarray(Int8Array) exports.int16array = typedarray(Int16Array, b4a.swap16) exports.int32array = typedarray(Int32Array, b4a.swap32) exports.biguint64array = typedarray(BigUint64Array, b4a.swap64) exports.bigint64array = typedarray(BigInt64Array, b4a.swap64) exports.float32array = typedarray(Float32Array, b4a.swap32) exports.float64array = typedarray(Float64Array, b4a.swap64) function string(encoding) { return { preencode(state, s) { const len = b4a.byteLength(s, encoding) uint.preencode(state, len) state.end += len }, encode(state, s) { const len = b4a.byteLength(s, encoding) uint.encode(state, len) b4a.write(state.buffer, s, state.start, encoding) state.start += len }, decode(state) { const len = uint.decode(state) if (state.end - state.start < len) throw new Error('Out of bounds') return b4a.toString( state.buffer, encoding, state.start, (state.start += len) ) }, fixed(n) { return { preencode(state) { state.end += n }, encode(state, s) { b4a.write(state.buffer, s, state.start, n, encoding) state.start += n }, decode(state) { if (state.end - state.start < n) throw new Error('Out of bounds') return b4a.toString( state.buffer, encoding, state.start, (state.start += n) ) } } } } } const utf8 = (exports.string = exports.utf8 = string('utf-8')) exports.ascii = string('ascii') exports.hex = string('hex') exports.base64 = string('base64') exports.ucs2 = exports.utf16le = string('utf16le') exports.bool = { preencode(state, b) { state.end++ }, encode(state, b) { state.buffer[state.start++] = b ? 1 : 0 }, decode(state) { if (state.start >= state.end) throw Error('Out of bounds') return state.buffer[state.start++] === 1 } } const fixed = (exports.fixed = function fixed(n) { return { preencode(state, s) { if (s.byteLength !== n) throw new Error('Incorrect buffer size') state.end += n }, encode(state, s) { state.buffer.set(s, state.start) state.start += n }, decode(state) { if (state.end - state.start < n) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += n)) } } }) exports.fixed32 = fixed(32) exports.fixed64 = fixed(64) exports.array = function array(enc) { return { preencode(state, list) { uint.preencode(state, list.length) for (let i = 0; i < list.length; i++) enc.preencode(state, list[i]) }, encode(state, list) { uint.encode(state, list.length) for (let i = 0; i < list.length; i++) enc.encode(state, list[i]) }, decode(state) { const len = uint.decode(state) if (len > 0x100000) throw new Error('Array is too big') const arr = new Array(len) for (let i = 0; i < len; i++) arr[i] = enc.decode(state) return arr } } } exports.frame = function frame(enc) { const dummy = exports.state() return { preencode(state, m) { const end = state.end enc.preencode(state, m) uint.preencode(state, state.end - end) }, encode(state, m) { dummy.end = 0 enc.preencode(dummy, m) uint.encode(state, dummy.end) enc.encode(state, m) }, decode(state) { const end = state.end const len = uint.decode(state) state.end = state.start + len const m = enc.decode(state) state.start = state.end state.end = end return m } } } exports.date = { preencode(state, d) { int.preencode(state, d.getTime()) }, encode(state, d) { int.encode(state, d.getTime()) }, decode(state, d) { return new Date(int.decode(state)) } } exports.json = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v)) }, encode(state, v) { utf8.encode(state, JSON.stringify(v)) }, decode(state) { return JSON.parse(utf8.decode(state)) } } exports.ndjson = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v) + '\n') }, encode(state, v) { utf8.encode(state, JSON.stringify(v) + '\n') }, decode(state) { return JSON.parse(utf8.decode(state)) } } // simple helper for when you want to just express nothing exports.none = { preencode(state, n) { // do nothing }, encode(state, n) { // do nothing }, decode(state) { return null } } // "any" encoders here for helping just structure any object without schematising it const anyArray = { preencode(state, arr) { uint.preencode(state, arr.length) for (let i = 0; i < arr.length; i++) { any.preencode(state, arr[i]) } }, encode(state, arr) { uint.encode(state, arr.length) for (let i = 0; i < arr.length; i++) { any.encode(state, arr[i]) } }, decode(state) { const arr = [] let len = uint.decode(state) while (len-- > 0) { arr.push(any.decode(state)) } return arr } } const anyObject = { preencode(state, o) { const keys = Object.keys(o) uint.preencode(state, keys.length) for (const key of keys) { utf8.preencode(state, key) any.preencode(state, o[key]) } }, encode(state, o) { const keys = Object.keys(o) uint.encode(state, keys.length) for (const key of keys) { utf8.encode(state, key) any.encode(state, o[key]) } }, decode(state) { let len = uint.decode(state) const o = {} while (len-- > 0) { const key = utf8.decode(state) o[key] = any.decode(state) } return o } } const anyTypes = [ exports.none, exports.bool, exports.string, exports.buffer, exports.uint, exports.int, exports.float64, anyArray, anyObject, exports.date ] const any = (exports.any = { preencode(state, o) { const t = getType(o) uint.preencode(state, t) anyTypes[t].preencode(state, o) }, encode(state, o) { const t = getType(o) uint.encode(state, t) anyTypes[t].encode(state, o) }, decode(state) { const t = uint.decode(state) if (t >= anyTypes.length) throw new Error('Unknown type: ' + t) return anyTypes[t].decode(state) } }) const port = (exports.port = uint16) const address = (host, family) => { return { preencode(state, m) { host.preencode(state, m.host) port.preencode(state, m.port) }, encode(state, m) { host.encode(state, m.host) port.encode(state, m.port) }, decode(state) { return { host: host.decode(state), family, port: port.decode(state) } } } } const ipv4 = (exports.ipv4 = { preencode(state) { state.end += 4 }, encode(state, string) { const start = state.start const end = start + 4 let i = 0 while (i < string.length) { let n = 0 let c while ( i < string.length && (c = string.charCodeAt(i++)) !== /* . */ 0x2e ) { n = n * 10 + (c - /* 0 */ 0x30) } state.buffer[state.start++] = n } state.start = end }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] + '.' + state.buffer[state.start++] + '.' + state.buffer[state.start++] + '.' + state.buffer[state.start++] ) } }) exports.ipv4Address = address(ipv4, 4) const ipv6 = (exports.ipv6 = { preencode(state) { state.end += 16 }, encode(state, string) { const start = state.start const end = start + 16 let i = 0 let split = null while (i < string.length) { let n = 0 let c while ( i < string.length && (c = string.charCodeAt(i++)) !== /* : */ 0x3a ) { if (c >= 0x30 && c <= 0x39) n = n * 0x10 + (c - /* 0 */ 0x30) else if (c >= 0x41 && c <= 0x46) n = n * 0x10 + (c - /* A */ 0x41 + 10) else if (c >= 0x61 && c <= 0x66) n = n * 0x10 + (c - /* a */ 0x61 + 10) } state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n if (i < string.length && string.charCodeAt(i) === /* : */ 0x3a) { i++ split = state.start } } if (split !== null) { const offset = end - state.start state.buffer .copyWithin(split + offset, split) .fill(0, split, split + offset) } state.start = end }, decode(state) { if (state.end - state.start < 16) throw new Error('Out of bounds') return ( ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) ) } }) exports.ipv6Address = address(ipv6, 6) const ip = (exports.ip = { preencode(state, string) { const family = string.includes(':') ? 6 : 4 uint8.preencode(state, family) if (family === 4) ipv4.preencode(state) else ipv6.preencode(state) }, encode(state, string) { const family = string.includes(':') ? 6 : 4 uint8.encode(state, family) if (family === 4) ipv4.encode(state, string) else ipv6.encode(state, string) }, decode(state) { const family = uint8.decode(state) if (family === 4) return ipv4.decode(state) else return ipv6.decode(state) } }) exports.ipAddress = { preencode(state, m) { ip.preencode(state, m.host) port.preencode(state, m.port) }, encode(state, m) { ip.encode(state, m.host) port.encode(state, m.port) }, decode(state) { const family = uint8.decode(state) return { host: family === 4 ? ipv4.decode(state) : ipv6.decode(state), family, port: port.decode(state) } } } const record = (exports.record = function (keyEncoding, valueEncoding) { return { preencode(state, v) { const keys = Object.keys(v) uint.preencode(state, keys.length) for (const k of keys) { keyEncoding.preencode(state, k) valueEncoding.preencode(state, v[k]) } }, encode(state, v) { const keys = Object.keys(v) uint.encode(state, keys.length) for (const k of keys) { keyEncoding.encode(state, k) valueEncoding.encode(state, v[k]) } }, decode(state) { const out = Object.create(null) const keys = uint.decode(state) for (let i = 0; i < keys; i++) { out[keyEncoding.decode(state)] = valueEncoding.decode(state) } return out } } }) exports.stringRecord = record(utf8, utf8) function getType(o) { if (o === null || o === undefined) return 0 if (typeof o === 'boolean') return 1 if (typeof o === 'string') return 2 if (b4a.isBuffer(o)) return 3 if (typeof o === 'number') { if (Number.isInteger(o)) return o >= 0 ? 4 : 5 return 6 } if (Array.isArray(o)) return 7 if (o instanceof Date) return 9 if (typeof o === 'object') return 8 throw new Error('Unsupported type for ' + o) } exports.from = function from(enc) { if (typeof enc === 'string') return fromNamed(enc) if (enc.preencode) return enc if (enc.encodingLength) return fromAbstractEncoder(enc) return fromCodec(enc) } function fromNamed(enc) { switch (enc) { case 'ascii': return raw.ascii case 'utf-8': case 'utf8': return raw.utf8 case 'hex': return raw.hex case 'base64': return raw.base64 case 'utf16-le': case 'utf16le': case 'ucs-2': case 'ucs2': return raw.ucs2 case 'ndjson': return raw.ndjson case 'json': return raw.json case 'binary': default: return raw.binary } } function fromCodec(enc) { let tmpM = null let tmpBuf = null return { preencode(state, m) { tmpM = m tmpBuf = enc.encode(m) state.end += tmpBuf.byteLength }, encode(state, m) { raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m)) tmpM = tmpBuf = null }, decode(state) { return enc.decode(raw.decode(state)) } } } function fromAbstractEncoder(enc) { return { preencode(state, m) { state.end += enc.encodingLength(m) }, encode(state, m) { enc.encode(m, state.buffer, state.start) state.start += enc.encode.bytes }, decode(state) { const m = enc.decode(state.buffer, state.start, state.end) state.start += enc.decode.bytes return m } } } exports.encode = function encode(enc, m) { const state = exports.state() enc.preencode(state, m) state.buffer = b4a.allocUnsafe(state.end) enc.encode(state, m) return state.buffer } exports.decode = function decode(enc, buffer) { return enc.decode(exports.state(0, buffer.byteLength, buffer)) } function zigZagInt(enc) { return { preencode(state, n) { enc.preencode(state, zigZagEncodeInt(n)) }, encode(state, n) { enc.encode(state, zigZagEncodeInt(n)) }, decode(state) { return zigZagDecodeInt(enc.decode(state)) } } } function zigZagDecodeInt(n) { return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2 } function zigZagEncodeInt(n) { // 0, -1, 1, -2, 2, ... return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n } function zigZagBigInt(enc) { return { preencode(state, n) { enc.preencode(state, zigZagEncodeBigInt(n)) }, encode(state, n) { enc.encode(state, zigZagEncodeBigInt(n)) }, decode(state) { return zigZagDecodeBigInt(enc.decode(state)) } } } function zigZagDecodeBigInt(n) { return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n } function zigZagEncodeBigInt(n) { // 0, -1, 1, -2, 2, ... return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n } function validateUint(n) { if (n >= 0 === false /* Handles NaN as well */) throw new Error('uint must be positive') // Beyond this, Number arithmetic loses precision and silently corrupts the // encoding. The zig-zag int codecs route through here too, so this also // guards int values whose doubled magnitude exceeds the safe range. if (n > Number.MAX_SAFE_INTEGER) throw new Error( 'integer is greater than the maximum safe integer, use biguint/bigint' ) } module.exports = { preencode, encode, decode } function preencode(state, num) { if (num < 251) { state.end++ } else if (num < 256) { state.end += 2 } else if (num < 0x10000) { state.end += 3 } else if (num < 0x1000000) { state.end += 4 } else if (num < 0x100000000) { state.end += 5 } else { state.end++ const exp = Math.floor(Math.log(num) / Math.log(2)) - 32 preencode(state, exp) state.end += 6 } } function encode(state, num) { const max = 251 const x = num - max if (num < max) { state.buffer[state.start++] = num } else if (num < 256) { state.buffer[state.start++] = max state.buffer[state.start++] = x } else if (num < 0x10000) { state.buffer[state.start++] = max + 1 state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else if (num < 0x1000000) { state.buffer[state.start++] = max + 2 state.buffer[state.start++] = x >> 16 state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else if (num < 0x100000000) { state.buffer[state.start++] = max + 3 state.buffer[state.start++] = x >> 24 state.buffer[state.start++] = (x >> 16) & 0xff state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else { // need to use Math here as bitwise ops are 32 bit const exp = Math.floor(Math.log(x) / Math.log(2)) - 32 state.buffer[state.start++] = 0xff encode(state, exp) const rem = x / Math.pow(2, exp - 11) for (let i = 5; i >= 0; i--) { state.buffer[state.start++] = (rem / Math.pow(2, 8 * i)) & 0xff } } } function decode(state) { const max = 251 if (state.end - state.start < 1) throw new Error('Out of bounds') const flag = state.buffer[state.start++] if (flag < max) return flag if (state.end - state.start < flag - max + 1) { throw new Error('Out of bounds.') } if (flag < 252) { return state.buffer[state.start++] + max } if (flag < 253) { return ( (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } if (flag < 254) { return ( (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } // << 24 result may be interpreted as negative if (flag < 255) { return ( state.buffer[state.start++] * 0x1000000 + (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } const exp = decode(state) if (state.end - state.start < 6) throw new Error('Out of bounds') let rem = 0 for (let i = 5; i >= 0; i--) { rem += state.buffer[state.start++] * Math.pow(2, 8 * i) } return rem * Math.pow(2, exp - 11) + max } { "name": "compact-encoding", "version": "3.2.0", "description": "A series of compact encoding schemes for building small and fast parsers and serializers", "main": "index.js", "files": [ "endian.js", "index.js", "lexint.js", "raw.js" ], "dependencies": { "b4a": "^1.3.0" }, "devDependencies": { "brittle": "^3.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" }, "scripts": { "format": "prettier . --write", "test": "prettier . --check && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/compact-encoding.git" }, "author": "Mathias Buus (@mafintosh)", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/compact-encoding/issues" }, "homepage": "https://github.com/holepunchto/compact-encoding" } const b4a = require('b4a') const { BE } = require('./endian') exports = module.exports = { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { state.buffer.set(b, state.start) state.start += b.byteLength }, decode(state) { const b = state.buffer.subarray(state.start, state.end) state.start = state.end return b } } const buffer = (exports.buffer = { preencode(state, b) { uint8array.preencode(state, b) }, encode(state, b) { uint8array.encode(state, b) }, decode(state) { const b = state.buffer.subarray(state.start) state.start = state.end return b } }) exports.binary = { ...buffer, preencode(state, b) { if (typeof b === 'string') utf8.preencode(state, b) else buffer.preencode(state, b) }, encode(state, b) { if (typeof b === 'string') utf8.encode(state, b) else buffer.encode(state, b) } } exports.arraybuffer = { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { const view = new Uint8Array(b) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const b = new ArrayBuffer(state.end - state.start) const view = new Uint8Array(b) view.set(state.buffer.subarray(state.start)) state.start = state.end return b } } function typedarray(TypedArray, swap) { const n = TypedArray.BYTES_PER_ELEMENT return { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength) if (BE && swap) swap(view) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { let b = state.buffer.subarray(state.start) if (b.byteOffset % n !== 0) b = new Uint8Array(b) if (BE && swap) swap(b) state.start = state.end return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n) } } } const uint8array = (exports.uint8array = typedarray(Uint8Array)) exports.uint16array = typedarray(Uint16Array, b4a.swap16) exports.uint32array = typedarray(Uint32Array, b4a.swap32) exports.int8array = typedarray(Int8Array) exports.int16array = typedarray(Int16Array, b4a.swap16) exports.int32array = typedarray(Int32Array, b4a.swap32) exports.biguint64array = typedarray(BigUint64Array, b4a.swap64) exports.bigint64array = typedarray(BigInt64Array, b4a.swap64) exports.float32array = typedarray(Float32Array, b4a.swap32) exports.float64array = typedarray(Float64Array, b4a.swap64) function string(encoding) { return { preencode(state, s) { state.end += b4a.byteLength(s, encoding) }, encode(state, s) { state.start += b4a.write(state.buffer, s, state.start, encoding) }, decode(state) { const s = b4a.toString(state.buffer, encoding, state.start) state.start = state.end return s } } } const utf8 = (exports.string = exports.utf8 = string('utf-8')) exports.ascii = string('ascii') exports.hex = string('hex') exports.base64 = string('base64') exports.ucs2 = exports.utf16le = string('utf16le') exports.array = function array(enc) { return { preencode(state, list) { for (const value of list) enc.preencode(state, value) }, encode(state, list) { for (const value of list) enc.encode(state, value) }, decode(state) { const arr = [] while (state.start < state.end) arr.push(enc.decode(state)) return arr } } } exports.json = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v)) }, encode(state, v) { utf8.encode(state, JSON.stringify(v)) }, decode(state) { return JSON.parse(utf8.decode(state)) } } exports.ndjson = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v) + '\n') }, encode(state, v) { utf8.encode(state, JSON.stringify(v) + '\n') }, decode(state) { return JSON.parse(utf8.decode(state)) } } const safetyCatch = require('safety-catch') module.exports = class CoreCoupler { constructor (target, wakeup) { this.target = target this.wakeup = wakeup this.coupled = new Set() this._onpeeraddBound = this._onpeeradd.bind(this) this.target.on('peer-add', this._onpeeraddBound) } add (core) { const added = this.coupled.size this.coupled.add(core) if (added !== this.coupled.size) this._couple(core) } remove (core) { this.coupled.delete(core) } destroy () { this.target.off('peer-add', this._onpeeraddBound) } async update (stream) { const muxer = stream.userData if (!muxer) return try { if (!(await this._hasMuxer(this.target, muxer))) return let wakeup = null for (const core of this.coupled) { if (await this._hasMuxer(core, muxer)) continue if (wakeup === null) wakeup = [] wakeup.push(core) } if (wakeup !== null) { this.wakeup(stream, wakeup) } } catch (err) { safetyCatch(err) } } async _couple (core) { try { let wakeup = null for (const peer of this.target.peers) { if (await this._hasPeer(core, peer)) continue if (wakeup === null) wakeup = [] wakeup.push(peer) } if (wakeup !== null && this.coupled.has(core)) { for (const peer of wakeup) this.wakeup(peer.stream, [core]) } } catch (err) { safetyCatch(err) } } async _onpeeradd (peer) { try { let wakeup = null for (const core of this.coupled) { if (await this._hasPeer(core, peer)) continue if (wakeup === null) wakeup = [] wakeup.push(core) } if (wakeup !== null) { this.wakeup(peer.stream, wakeup) } } catch (err) { safetyCatch(err) } } _hasMuxer (core, muxer) { const ch = muxer.getLastChannel({ protocol: 'hypercore', id: core.discoveryKey }) if (ch) return ch.fullyOpened() const cha = muxer.getLastChannel({ protocol: 'hypercore/alpha', id: core.discoveryKey }) if (cha) return cha.fullyOpened() return Promise.resolve(false) } _hasPeer (core, peer) { return this._hasMuxer(core, peer.protomux) } } { "name": "core-coupler", "version": "2.0.0", "description": "Couple the peers of cores", "main": "index.js", "scripts": { "test": "standard" }, "dependencies": { "safety-catch": "^1.0.2" }, "devDependencies": { "corestore": "^6.18.2", "standard": "^17.1.0" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/core-coupler.git" }, "author": "Holepunch Inc", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/core-coupler/issues" }, "homepage": "https://github.com/holepunchto/core-coupler" } const b4a = require('b4a') const Hypercore = require('hypercore') const ReadyResource = require('ready-resource') const sodium = require('sodium-universal') const crypto = require('hypercore-crypto') const ID = require('hypercore-id-encoding') const { isAndroid } = require('which-runtime') const { STORAGE_EMPTY, ASSERTION } = require('hypercore-errors') const auditStore = require('./lib/audit.js') const GroupNotifyHandle = require('./lib/notify.js') const [NS] = crypto.namespace('corestore', 1) const DEFAULT_NAMESPACE = b4a.alloc(32) // This is meant to be 32 0-bytes class StreamTracker { constructor() { this.records = [] } add(stream, isExternal) { const record = { index: 0, stream, isExternal } record.index = this.records.push(record) - 1 return record } remove(record) { const popped = this.records.pop() if (popped === record) return this.records[(popped.index = record.index)] = popped } attachAll(core) { for (let i = 0; i < this.records.length; i++) { const record = this.records[i] const muxer = record.stream.noiseStream.userData if (!core.replicator.attached(muxer)) core.replicator.attachTo(muxer) } } destroy() { // reverse is safer cause we delete mb for (let i = this.records.length - 1; i >= 0; i--) { const record = this.records[i] if (!record.isExternal) record.stream.destroy() } } } class SessionTracker { constructor() { this.map = new Map() } get size() { return this.map.size } get(id) { const existing = this.map.get(id) if (existing !== undefined) return existing const fresh = [] this.map.set(id, fresh) return fresh } gc(id) { this.map.delete(id) } list(id) { return id ? this.map.get(id) || [] : [...this] } *[Symbol.iterator]() { for (const sessions of this.map.values()) { yield* sessions[Symbol.iterator]() } } } class CoreTracker { constructor() { this.map = new Map() this.watching = [] this._gcing = new Set() this._gcInterval = null this._gcCycleBound = this._gcCycle.bind(this) } get size() { return this.map.size } watch(store) { if (store.watchIndex !== -1) return store.watchIndex = this.watching.push(store) - 1 } unwatch(store) { if (store.watchIndex === -1) return const head = this.watching.pop() if (head !== store) this.watching[(head.watchIndex = store.watchIndex)] = head store.watchIndex = -1 } resume(id) { const core = this.map.get(id) if (!core) return null // signal back that we have a closing one stored if (core.closing) return core if (core.gc) { this._gcing.delete(core) if (this._gcing.size === 0) this._stopGC() core.gc = 0 } return core } opened(id) { const core = this.map.get(id) return !!(core && core.opened && !core.closing) } get(id) { // we allow you do call this from the outside, so support normal buffers also if (b4a.isBuffer(id)) id = b4a.toString(id, 'hex') const core = this.map.get(id) if (!core || core.closing) return null return core } set(id, core) { this.map.set(id, core) if (this.watching.length > 0) this._emit(core) } _emit(core) { for (let i = this.watching.length - 1; i >= 0; i--) { const store = this.watching[i] for (const fn of store.watchers) fn(core) } } _gc(core) { const id = toHex(core.discoveryKey) if (this.map.get(id) === core) this.map.delete(id) } _gcCycle() { for (const core of this._gcing) { if (++core.gc < 4) continue const gc = this._gc.bind(this, core) core.close().then(gc, gc) this._gcing.delete(core) } if (this._gcing.size === 0) this._stopGC() } gc(core) { core.gc = 1 // first strike this._gcing.add(core) if (this._gcing.size === 1) this._startGC() } _stopGC() { clearInterval(this._gcInterval) this._gcInterval = null } _startGC() { if (this._gcInterval) return this._gcInterval = setInterval(this._gcCycleBound, 2000) if (this._gcInterval.unref) this._gcInterval.unref() } close() { this._stopGC() this._gcing.clear() const all = [] for (const core of this.map.values()) { core.onidle = noop // no reentry all.push(core.close()) } this.map.clear() return Promise.all(all) } *[Symbol.iterator]() { for (const core of this.map.values()) { if (!core.closing) yield core } } } class FindingPeers { constructor() { this.count = 0 this.pending = [] this.destroyed = false } add(core) { if (this.count === 0) return this.pending.push(core.findingPeers()) } inc(sessions) { if (this.destroyed || ++this.count !== 1) return for (const core of sessions) { this.pending.push(core.findingPeers()) } } dec(sessions) { if (this.destroyed || --this.count !== 0) return while (this.pending.length > 0) this.pending.pop()() } destroy() { this.destroyed = true while (this.pending.length > 0) this.pending.pop()() } } class Corestore extends ReadyResource { constructor(storage, opts = {}) { super() this.root = opts.root || null this.storage = this.root ? this.root.storage : Hypercore.defaultStorage(storage, { id: opts.id, allowBackup: opts.allowBackup, readOnly: opts.readOnly, wait: opts.wait }) this.streamTracker = this.root ? this.root.streamTracker : new StreamTracker() this.cores = this.root ? this.root.cores : new CoreTracker() this.sessions = new SessionTracker() this.corestores = this.root ? this.root.corestores : new Set() this.readOnly = opts.writable === false || !!opts.readOnly this.globalCache = this.root ? this.root.globalCache : opts.globalCache || null this.primaryKey = this.root ? this.root.primaryKey : opts.primaryKey || null this.ns = opts.namespace || DEFAULT_NAMESPACE this.manifestVersion = opts.manifestVersion || 1 this.shouldSuspend = isAndroid ? !!opts.suspend : opts.suspend !== false this.active = opts.active !== false this.watchers = null this.watchIndex = -1 this._groupNotifiers = new Map() // group notifications this._findingPeers = null // here for legacy this._ongcBound = this._ongc.bind(this) this._onGroupActiveBound = this._onGroupActive.bind(this) if (opts.primaryKey && !this.root && !opts.unsafe) { throw ASSERTION( 'Passing the primary key is unsafe unless you know what you are doing. Set unsafe: true to acknowledge that' ) } this.ready().catch(noop) } watch(fn) { if (this.watchers === null) { this.watchers = new Set() this.cores.watch(this) } this.watchers.add(fn) } unwatch(fn) { if (this.watchers === null) return this.watchers.delete(fn) if (this.watchers.size === 0) { this.watchers = null this.cores.unwatch(this) } } _onGroupActive(topic) { this.emit('group-active', topic) const topicHex = b4a.toString(topic, 'hex') const handles = this._groupNotifiers.get(topicHex) if (!handles) return for (const handle of handles) handle.emit('update') } notifyGroup(topic) { const topicHex = b4a.toString(topic, 'hex') let handles = this._groupNotifiers.get(topicHex) if (!handles) { handles = [] this._groupNotifiers.set(topicHex, handles) } const handle = new GroupNotifyHandle(this, topic) const length = handles.push(handle) handle.index = length - 1 return handle } _removeGroupNotify(handle) { if (handle.index === -1) return const topicHex = b4a.toString(handle._topic, 'hex') const handles = this._groupNotifiers.get(topicHex) if (!handles) return const popped = handles.pop() if (popped !== handle) handles[(popped.index = handle.index)] = popped if (handles.length === 0) this._groupNotifiers.delete(topicHex) handle.index = -1 } findingPeers() { if (this._findingPeers === null) this._findingPeers = new FindingPeers() this._findingPeers.inc(this.sessions) let done = false return () => { if (done || !this._findingPeers) return done = true this._findingPeers.dec(this.sessions) } } audit(opts = {}) { return auditStore(this, opts) } async suspend({ log = noop } = {}) { await log('Flushing db...') // If readOnly we don't need to flush if (!this.storage.readOnly) { await this.storage.db.flush() await log('Flusing db completed') } if (!this.shouldSuspend) return await log('Suspending db...') await this.storage.suspend({ log }) await log('Suspending db completed') } resume() { return this.storage.resume() } session(opts) { this._maybeClosed() const root = this.root || this return new Corestore(null, { manifestVersion: this.manifestVersion, ...opts, root }) } namespace(name, opts) { return this.session({ ...opts, namespace: generateNamespace(this.ns, name) }) } list(namespace) { return this.storage.createDiscoveryKeyStream(namespace) } getAuth(discoveryKey) { return this.storage.getAuth(discoveryKey) } _ongc(session) { if (session.sessions.length === 0) this.sessions.gc(session.id) } async _getOrSetSeed() { const seed = await this.storage.getSeed() if (seed !== null) return seed return await this.storage.setSeed(this.primaryKey || crypto.randomBytes(32)) } async _open() { if (this.root !== null) { this.corestores.add(this) if (this.root.opened === false) await this.root.ready() this.primaryKey = this.root.primaryKey return } const primaryKey = await this._getOrSetSeed() if (this.primaryKey === null) { this.primaryKey = primaryKey return } if (!b4a.equals(primaryKey, this.primaryKey)) { throw new Error('Another corestore is stored here') } } async _close() { const closing = [] const hanging = [...this.sessions] for (const sess of hanging) closing.push(sess.close()) if (this.watchers !== null) { this.cores.unwatch(this) this.watchers = null } if (this._findingPeers !== null) { this._findingPeers.destroy() this._findingPeers = null } if (this.root !== null) { await Promise.all(closing) this.corestores.delete(this) return } for (const store of this.corestores) { closing.push(store.close()) } await Promise.all(closing) await this.cores.close() await this.storage.close() } async _attachMaybe(muxer, discoveryKey) { if (this.opened === false) await this.ready() if ( !this.cores.opened(toHex(discoveryKey)) && !(await this.storage.hasCore(discoveryKey, { ifMigrated: true })) ) { return } if (this.closing) return const core = this._openCore(discoveryKey, { createIfMissing: false }) if (!core) return if (!core.opened) await core.ready() if (!core.replicator.attached(muxer)) { core.replicator.attachTo(muxer) } core.checkIfIdle() } _shouldReplicate(core, muxer) { return ( core.replicator.downloading && !core.replicator.attached(muxer) && core.opened && this.active ) } replicate(isInitiator, opts) { this._maybeClosed() const isExternal = isStream(isInitiator) const stream = Hypercore.createProtocolStream(isInitiator, { ...opts, ondiscoverykey: (discoveryKey) => { if (this.closing) return const muxer = stream.noiseStream.userData return this._attachMaybe(muxer, discoveryKey) } }) if (this.cores.size > 0) { const muxer = stream.noiseStream.userData const uncork = muxer.uncork.bind(muxer) muxer.cork() for (const core of this.cores) { if (!this._shouldReplicate(core, muxer)) { continue } core.replicator.attachTo(muxer) } stream.noiseStream.opened.then(uncork) } const record = this.streamTracker.add(stream, isExternal) stream.once('close', () => this.streamTracker.remove(record)) return stream } _maybeClosed() { if (this.closing || (this.root !== null && this.root.closing)) { throw new Error('Corestore is closed') } } async staticify(core, opts) { if (!this.opened) await this.ready() if (!core.opened) await core.ready() const rx = core.state.storage.read() const headPromise = rx.getHead() const authPromise = rx.getAuth() rx.tryFlush() const [head, auth] = await Promise.all([headPromise, authPromise]) if (!head || head.length === 0) throw new Error('Core must have data') const prologue = { length: head.length, hash: head.rootHash } const manifest = { version: 1, hash: auth.manifest.hash, quorum: 0, signers: [], prologue } const c = { key: null, discoveryKey: null, manifest, core: core.state.storage.core } c.key = Hypercore.key(c.manifest) c.discoveryKey = Hypercore.discoveryKey(c.key) await this.storage.createCore(c) const staticCore = this.get({ ...opts, key: c.key }) await staticCore.ready() return staticCore } get(opts) { this._maybeClosed() if (b4a.isBuffer(opts) || typeof opts === 'string') opts = { key: opts } if (!opts) opts = {} const conf = { preload: null, sessions: null, ongc: null, core: null, active: opts.active !== false, encryption: opts.encryption || null, encryptionKey: opts.encryptionKey || null, // back compat, should remove isBlockKey: !!opts.isBlockKey, // back compat, should remove valueEncoding: opts.valueEncoding || null, exclusive: !!opts.exclusive, manifest: opts.manifest || null, keyPair: opts.keyPair || null, onwait: opts.onwait || null, pushOnly: opts.pushOnly === true, wait: opts.wait !== false, timeout: opts.timeout || 0, draft: !!opts.draft, writable: opts.writable === undefined && this.readOnly ? false : opts.writable } // name requires us to rt to storage + ready, so needs preload // same goes if user has defined async preload obvs if (opts.name || opts.preload) { conf.preload = this._preload(opts) return this._makeSession(conf) } if (opts.discoveryKey && !opts.key && !opts.manifest) { conf.preload = this._preloadCheckIfExists(opts) return this._makeSession(conf) } // if not not we can sync create it, which just is easier for the // upstream user in terms of guarantees (key is there etc etc) const core = this._openCore(null, opts) conf.core = core conf.sessions = this.sessions.get(core.id) conf.ongc = this._ongcBound return this._makeSession(conf) } _makeSession(conf) { const session = new Hypercore(null, null, conf) if (this._findingPeers !== null) this._findingPeers.add(session) return session } async createKeyPair(name, ns = this.ns) { if (this.opened === false) await this.ready() return createKeyPair(this.primaryKey, ns, name) } async _preloadCheckIfExists(opts) { const has = await this.storage.hasCore(opts.discoveryKey) if (!has) throw STORAGE_EMPTY('No Hypercore is stored here') return this._preload(opts) } async _preload(opts) { if (opts.preload) opts = { ...opts, ...(await opts.preload) } if (this.opened === false) await this.ready() const discoveryKey = opts.name ? await this.storage.getAlias({ name: opts.name, namespace: this.ns }) : null this._maybeClosed() const core = this._openCore(discoveryKey, opts) return { core, sessions: this.sessions.get(core.id), ongc: this._ongcBound, manifest: opts.manifest || null, encryption: opts.encryption || null, encryptionKey: opts.encryptionKey || null, // back compat, should remove isBlockKey: !!opts.isBlockKey // back compat, should remove } } _auth(discoveryKey, opts) { const result = { keyPair: null, key: null, discoveryKey, manifest: null, group: null } if (opts.name) { result.keyPair = createKeyPair(this.primaryKey, this.ns, opts.name) } else if (opts.keyPair) { result.keyPair = opts.keyPair } if (opts.manifest) { result.manifest = opts.manifest } else if (result.keyPair && !result.discoveryKey) { result.manifest = { version: this.manifestVersion, signers: [{ publicKey: result.keyPair.publicKey }] } } if (opts.group) { result.group = opts.group } if (opts.key) result.key = ID.decode(opts.key) else if (result.manifest) result.key = Hypercore.key(result.manifest) if (result.discoveryKey) return result if (opts.discoveryKey) result.discoveryKey = ID.decode(opts.discoveryKey) else if (result.key) result.discoveryKey = crypto.discoveryKey(result.key) else throw new Error('Could not derive discovery from input') return result } _openCore(discoveryKey, opts) { const auth = this._auth(discoveryKey, opts) const id = toHex(auth.discoveryKey) const existing = this.cores.resume(id, auth.group) if (existing && !existing.closing) return existing const core = Hypercore.createCore(this.storage, { preopen: existing && existing.opened ? existing.closing : null, // always wait for the prev one to close first in any case... eagerUpgrade: true, notDownloadingLinger: opts.notDownloadingLinger, allowFork: opts.allowFork !== false, allowPush: !!opts.allowPush, inflightRange: opts.inflightRange, compat: false, // no compat for now :) force: opts.force, createIfMissing: opts.createIfMissing, discoveryKey: auth.discoveryKey, overwrite: opts.overwrite, key: auth.key, keyPair: auth.keyPair, legacy: opts.legacy, manifest: auth.manifest, group: auth.group, globalCache: opts.globalCache || this.globalCache || null, alias: opts.name ? { name: opts.name, namespace: this.ns } : null }) core.onidle = () => { this.cores.gc(core) } core.ongroupupdate = this._onGroupActiveBound core.replicator.ondownloading = () => { if (this.active) this.streamTracker.attachAll(core) } this.cores.set(id, core) return core } } module.exports = Corestore function isStream(s) { return typeof s === 'object' && s && typeof s.pipe === 'function' } function generateNamespace(namespace, name) { if (!b4a.isBuffer(name)) name = b4a.from(name) const out = b4a.allocUnsafeSlow(32) sodium.crypto_generichash_batch(out, [namespace, name]) return out } function deriveSeed(primaryKey, namespace, name) { if (!b4a.isBuffer(name)) name = b4a.from(name) const out = b4a.alloc(32) sodium.crypto_generichash_batch(out, [NS, namespace, name], primaryKey) return out } function createKeyPair(primaryKey, namespace, name) { const seed = deriveSeed(primaryKey, namespace, name) const buf = b4a.alloc(sodium.crypto_sign_PUBLICKEYBYTES + sodium.crypto_sign_SECRETKEYBYTES) const keyPair = { publicKey: buf.subarray(0, sodium.crypto_sign_PUBLICKEYBYTES), secretKey: buf.subarray(sodium.crypto_sign_PUBLICKEYBYTES) } sodium.crypto_sign_seed_keypair(keyPair.publicKey, keyPair.secretKey, seed) return keyPair } function noop() {} function toHex(discoveryKey) { return b4a.toString(discoveryKey, 'hex') } module.exports = async function* audit(store, { dryRun = false } = {}) { for await (const { discoveryKey, core } of store.storage.createCoreStream()) { if (core.version < 1) continue // not migrated, ignore const c = store.get({ discoveryKey, active: false }) await c.ready() yield { discoveryKey, key: c.key, audit: await c.core.audit({ dryRun }) } try { await c.close() } catch { // ignore if failed, we are auditing... } } } const { EventEmitter } = require('events') const { Readable } = require('streamx') class GroupNotifyHandle extends EventEmitter { constructor(store, topic) { super() this._store = store this._topic = topic this.index = -1 } updates(opts) { return Readable.deferred(async () => { const groupId = await this._store.storage.getGroup(this._topic).catch(noop) if (groupId === null) return null return this._store.storage.createGroupUpdateStream(groupId, opts) }) } destroy() { this._store._removeGroupNotify(this) } } module.exports = GroupNotifyHandle function noop() {} { "name": "corestore", "version": "7.10.1", "description": "A Hypercore factory that simplifies managing collections of cores.", "main": "index.js", "files": [ "index.js", "lib/*" ], "imports": { "events": { "bare": "bare-events", "default": "events" } }, "dependencies": { "b4a": "^1.6.7", "bare-events": "^2.8.3", "hypercore": "^11.32.0", "hypercore-crypto": "^3.4.2", "hypercore-errors": "^1.4.0", "hypercore-id-encoding": "^1.3.0", "ready-resource": "^1.1.1", "sodium-universal": "^5.0.1", "streamx": "^2.26.0", "which-runtime": "^1.2.1" }, "devDependencies": { "brittle": "^3.7.0", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "rache": "^1.0.0" }, "scripts": { "format": "prettier --write .", "test": "npm run test:node && npm run test:bare", "test:bare": "brittle-bare --coverage test/all.js", "lint": "prettier --check . && lunte", "test:node": "brittle-node --coverage test/all.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/corestore.git" }, "author": "Holepunch Inc", "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/corestore/issues" }, "homepage": "https://github.com/holepunchto/corestore" } module.exports = function debounce (worker, context = null) { debounced.running = null return debounced async function debounced () { if (debounced.running !== null) { try { await debounced.running } catch (_) { // ignore - do not fail on old errors } } // another "thread" beat us to it, just piggy pack on that one if (debounced.running !== null) return debounced.running debounced.running = worker.call(context) try { return await debounced.running } finally { debounced.running = null } } } { "name": "debounceify", "version": "1.1.0", "description": "Tiny async debouncer", "main": "index.js", "dependencies": {}, "devDependencies": { "standard": "^16.0.3", "tape": "^5.1.1" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/debounceify.git" }, "scripts": { "test": "standard && tape test.js" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/debounceify/issues" }, "homepage": "https://github.com/mafintosh/debounceify" } const fs = require('fs') const path = require('path') const fsx = require('fs-native-extensions') const b4a = require('b4a') const ReadyResource = require('ready-resource') const FDLock = require('fd-lock') const PLATFORM = global.Bare ? global.Bare.platform : global.process.platform const IS_WIN = PLATFORM === 'win32' const IS_LINUX = PLATFORM === 'linux' const MODIFIED_SLACK = 5000 const EMPTY = b4a.alloc(0) const ATTR = IS_LINUX ? 'user.device-file' : 'device-file' const nl = IS_WIN ? '\r\n' : '\n' class DeviceFile extends ReadyResource { constructor(filename, { create = true, wait = false, lock = wait, data = {} } = {}) { super() this.filename = filename this.data = data this.lock = null this._create = create this._wait = wait this._lock = lock } async _open() { if (await verifyDeviceFile(this)) return if (!this._create) throwDeviceFileError('No device file present', false) await writeDeviceFile(this) } static async validate(filename, data) { const file = new DeviceFile(filename, { create: false, wait: false, data }) try { await verifyDeviceFile(file) } catch (err) { if (err.fatal && err.code === 'DEVICE_FILE') return false throw err } return true } transfer() { return this.lock ? this.lock.transfer() : -1 } async _close() { if (this.lock) await this.lock.close() } async suspend() { if (!this.opened) await this.ready() if (this.lock) await this.lock.suspend() } async resume() { if (!this.opened) await this.ready() if (this.lock) await this.lock.resume() } } module.exports = DeviceFile async function writeDeviceFile(device) { let s = '' for (const [key, value] of Object.entries(device.data)) { if (value === null) continue s += key + '=' + value + nl } await fs.promises.mkdir(path.dirname(device.filename), { recursive: true }) const fd = await open(device.filename, 'w') device.lock = device._lock ? new FDLock(fd, { wait: device._wait }) : null if (device.lock) { try { await device.lock.ready() } catch (err) { await device.lock.close() throw err } } const st = await fstat(fd) const created = Date.now() s += 'device/platform=' + PLATFORM + nl s += 'device/inode=' + st.ino + nl s += 'device/created=' + created + nl if (await setAttr(fd, ATTR, b4a.from('original'))) { s += 'device/attribute=original' + nl } await write(fd, b4a.from(s)) if (!device.lock) await close(fd) } async function verifyDeviceFile(device) { let fd = 0 try { fd = await open(device.filename, 'r+') } catch (e) { fd = 0 } if (fd === 0) return false device.lock = device._lock ? new FDLock(fd, { wait: device._wait }) : null if (device.lock) { try { await device.lock.ready() } catch (err) { await device.lock.close() throw err } } const buf = await read(fd) const result = {} const s = b4a.toString(buf).trim().split('\n') let inode = 0 let created = 0 let attr = '' let platform = '' for (const ln of s) { const i = ln.indexOf('=') if (i === -1) continue const k = ln.slice(0, i).trim() const v = ln.slice(i + 1).trim() switch (k) { case 'device/platform': platform = v break case 'device/inode': inode = Number(v) break case 'device/created': created = Number(v) break case 'device/attribute': attr = v break default: result[k] = v break } } for (const [k, v] of Object.entries(device.data)) { if (v === null) continue if (result[k] === undefined) continue // allow upserts if (result[k] !== '' + v) { await teardown() throwDeviceFileError(`Invalid device file, ${k} has changed. Was ${result[k]}, is ${v}`, true) } } const st = await fstat(fd) const at = await getAttr(fd, ATTR) const sameAttr = b4a.toString(at || EMPTY) === attr const modified = Math.max(st.mtime.getTime(), st.birthtime.getTime()) if (platform && platform !== PLATFORM) { await teardown() throwDeviceFileError('Invalid device file, was made on different platform', true) } if (!sameAttr) { await teardown() throwDeviceFileError('Invalid device file, was moved unsafely', true) } if (st.ino !== inode || (created && Math.abs(modified - created) >= MODIFIED_SLACK)) { await teardown() throwDeviceFileError('Invalid device file, was modified', true) } if (!device.lock) await close(fd) device.data = result return true async function teardown() { if (device.lock) await device.lock.close() else await close(fd) } } async function getAttr(fd, name) { try { return await fsx.getAttr(fd, name) } catch { return null } } async function setAttr(fd, name, value) { try { await fsx.setAttr(fd, name, value) return true } catch { return false } } function fstat(fd) { return new Promise((resolve, reject) => { fs.fstat(fd, (err, st) => { if (err) reject(err) resolve(st) }) }) } function close(fd) { return new Promise((resolve, reject) => { fs.close(fd, (err, st) => { if (err) reject(err) resolve(st) }) }) } function write(fd, buf) { return new Promise((resolve, reject) => { let offset = 0 onwrite(null, 0) function onwrite(err, wrote) { if (err) return reject(err) if (offset === buf.byteLength) return resolve() offset += wrote fs.write(fd, buf, offset, buf.byteLength - offset, offset, onwrite) } }) } function read(fd) { const buf = b4a.allocUnsafe(4096) return new Promise((resolve, reject) => { let offset = 0 fs.read(fd, buf, 0, buf.byteLength, 0, onread) function onread(err, read) { if (err) return reject(err) if (read === 0) return resolve(buf.subarray(0, offset)) offset += read fs.read(fd, buf, offset, buf.byteLength - offset, offset, onread) } }) } function open(filename, flags) { return new Promise((resolve, reject) => { fs.open(filename, flags, (err, fd) => { if (err) reject(err) resolve(fd) }) }) } function throwDeviceFileError(message, fatal) { const err = new Error(message) err.code = 'DEVICE_FILE' err.fatal = fatal throw err } { "name": "device-file", "version": "2.3.1", "description": "Device only file", "main": "index.js", "files": [ "index.js" ], "dependencies": { "b4a": "^1.6.7", "bare-fs": "^4.0.1", "bare-path": "^3.0.0", "fd-lock": "^2.1.0", "fs-native-extensions": "^1.4.0", "ready-resource": "^1.2.0" }, "devDependencies": { "brittle": "^3.13.1", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node --coverage test.js", "test:bare": "brittle-bare --coverage test.js" }, "imports": { "fs": { "bare": "bare-fs", "default": "fs" }, "path": { "bare": "bare-path", "default": "path" } }, "repository": { "type": "git", "url": "https://github.com/holepunchto/device-file.git" }, "author": "Holepunch Inc", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/device-file/issues" }, "homepage": "https://github.com/holepunchto/device-file" } const { EventEmitter } = require('events') const Table = require('kademlia-routing-table') const TOS = require('time-ordered-set') const UDX = require('udx-native') const sodium = require('sodium-universal') const c = require('compact-encoding') const NatSampler = require('nat-sampler') const b4a = require('b4a') const NetworkHealth = require('./lib/health') const IO = require('./lib/io') const Query = require('./lib/query') const Session = require('./lib/session') const peer = require('./lib/peer') const { UNKNOWN_COMMAND, INVALID_TOKEN } = require('./lib/errors') const { PING, PING_NAT, FIND_NODE, DOWN_HINT, DELAYED_PING } = require('./lib/commands') const TMP = b4a.allocUnsafe(32) const TICK_INTERVAL = 5000 const SLEEPING_INTERVAL = 3 * TICK_INTERVAL const STABLE_TICKS = 240 // if nothing major bad happens in ~20mins we can consider this node stable (if nat is friendly) const MORE_STABLE_TICKS = 3 * STABLE_TICKS const REFRESH_TICKS = 60 // refresh every ~5min when idle const RECENT_NODE = 12 // we've heard from a node less than 1min ago const OLD_NODE = 360 // if an node has been around more than 30 min we consider it old const DEFAULTS = { concurrency: 10, maxWindow: IO.DEFAULT_MAX_WINDOW, maxPingDelay: 10_000 } class DHT extends EventEmitter { constructor(opts = {}) { super() this.bootstrapNodes = opts.bootstrap === false ? [] : (opts.bootstrap || []).map(parseNode) this.table = new Table(randomBytes(32)) this.nodes = new TOS() this.udx = opts.udx || new UDX() this.io = new IO(this.table, this.udx, { ...opts, onrequest: this._onrequest.bind(this), onresponse: this._onresponse.bind(this), ontimeout: this._ontimeout.bind(this) }) this.health = new NetworkHealth(this) this.concurrency = opts.concurrency || DEFAULTS.concurrency this.maxPingDelay = opts.maxPingDelay || DEFAULTS.maxPingDelay this.bootstrapped = false this.ephemeral = true this.firewalled = this.io.firewalled this.adaptive = typeof opts.ephemeral !== 'boolean' && opts.adaptive !== false this.destroyed = false this.suspended = false this.online = true this.degraded = false this.stats = { queries: { active: 0, total: 0 }, requests: this.io.stats.requests, commands: { ping: this.io.stats.commands[PING], pingNat: this.io.stats.commands[PING_NAT], findNode: this.io.stats.commands[FIND_NODE], downHint: this.io.stats.commands[DOWN_HINT] } } this._nat = new NatSampler() this._quickFirewall = opts.quickFirewall !== false this._forcePersistent = opts.ephemeral === false this._repinging = 0 this._checks = 0 this._tick = randomOffset(100) // make sure to random offset all the network ticks this._refreshTicks = randomOffset(REFRESH_TICKS) this._stableTicks = this.adaptive ? STABLE_TICKS : 0 this._tickInterval = setInterval(this._ontick.bind(this), TICK_INTERVAL) this._lastTick = Date.now() this._lastHost = null this._filterNode = opts.filterNode || opts.addNode || null // opts.addNode is deprecating, use opts.filterNode instead this._onrow = (row) => row.on('full', (node) => this._onfullrow(node, row)) this._nonePersistentSamples = [] this._bootstrapping = this._bootstrap() this._bootstrapping.catch(noop) this._sendDownHints = opts.sendDownHints !== false this._downHintsRateLimit = opts.downHintsRateLimit !== undefined ? opts.downHintsRateLimit : 10 * 5 this._downHintsSentPerTick = 0 this._pendingTimers = new Set() this.table.on('row', this._onrow) this.io.networkInterfaces.on('change', (interfaces) => this._onnetworkchange(interfaces)) if (opts.nodes) { for (let i = opts.nodes.length - 1; i >= 0; i--) { this.addNode(opts.nodes[i]) } } } static DEFAULTS = DEFAULTS static bootstrapper(port, host, opts) { if (!port) throw new Error('Port is required') if (!host) throw new Error('Host is required') if (host === '0.0.0.0' || host === '::') throw new Error('Invalid host') if (!UDX.isIPv4(host)) throw new Error('Host must be a IPv4 address') const dht = new this({ port, ephemeral: false, firewalled: false, anyPort: false, bootstrap: [], ...opts }) dht._nat.add(host, port) return dht } get id() { return this.ephemeral ? null : this.table.id } get host() { return this._nat.host } get port() { return this._nat.port } get randomized() { return this._nat.host !== null && this._nat.port === 0 } get socket() { return this.firewalled ? this.io.clientSocket : this.io.serverSocket } get config() { return { concurrency: this.concurrency, maxWindow: this.io.congestion._maxWindow, randomPunchInterval: this._randomPunchInterval, connectionKeepAlive: this.connectionKeepAlive, sendDownHints: this._sendDownHints, downHintsRateLimit: this._downHintsRateLimit } } onmessage(socket, buf, rinfo) { if (buf.byteLength > 1) this.io.onmessage(socket, buf, rinfo) } bind() { return this.io.bind() } async suspend({ log = noop } = {}) { log('Suspending waiting for io bind...') await this.io.bind() log('Done, continuing') if (this.suspended || this.destroyed) return this.suspended = true clearInterval(this._tickInterval) log('Done, suspending io') await this.io.suspend({ log }) log('Done, dht suspended') this.emit('suspend') } async resume({ log = noop } = {}) { if (!this.suspended || this.destroyed) return this.suspended = false this._tickInterval = setInterval(this._ontick.bind(this), TICK_INTERVAL) this._onwakeup() log('Resuming io') await this.io.resume() log('Done, dht resumed') this.io.networkInterfaces.on('change', (interfaces) => this._onnetworkchange(interfaces)) this.refresh() this.emit('resume') } address() { const socket = this.socket return socket ? socket.address() : null } localAddress() { if (!this.io.serverSocket) return null return { host: localIP(this.udx), port: this.io.serverSocket.address().port } } remoteAddress() { if (!this.host) return null if (!this.port) return null if (this.firewalled) return null if (!this.io.serverSocket) return null const port = this.io.serverSocket.address().port if (port !== this.port) return null return { host: this.host, port } } addNode({ host, port }) { this._addNode({ id: peer.id(host, port), port, host, token: null, to: null, sampled: 0, added: this._tick, pinged: 0, seen: 0, downHints: 0, prev: null, next: null }) } toArray(opts) { const limit = opts && opts.limit if (limit === 0) return [] return this.nodes.toArray({ limit, reverse: true }).map(({ host, port }) => ({ host, port })) } async fullyBootstrapped() { return this._bootstrapping } ready() { // Deprecating, use fullyBootstrapped instead (removed on next major) return this.fullyBootstrapped() } findNode(target, opts) { if (this.destroyed) throw new Error('Node destroyed') this._refreshTicks = REFRESH_TICKS return new Query(this, target, true, FIND_NODE, null, opts) } query({ target, command, value }, opts) { if (this.destroyed) throw new Error('Node destroyed') this._refreshTicks = REFRESH_TICKS return new Query(this, target, false, command, value || null, opts) } ping({ host, port }, opts) { let value = null if (opts && opts.size && opts.size > 0) value = b4a.alloc(opts.size) const req = this.io.createRequest( { id: null, host, port }, null, true, PING, null, value, (opts && opts.session) || null, opts && opts.ttl ) return this._requestToPromise(req, opts) } delayedPing({ host, port }, delayMs, opts) { if (delayMs > this.maxPingDelay) { throw new Error(`Delay exceeds max delay: ${this.maxPingDelay}ms`) } const value = b4a.allocUnsafe(4) c.uint32.encode({ start: 0, end: 4, buffer: value }, delayMs) const req = this.io.createRequest( { id: null, host, port }, null, true, DELAYED_PING, null, value, (opts && opts.session) || null, opts && opts.ttl ) // add 1 second to the timeout to account for network overhead req.timeout = delayMs + 1_000 return this._requestToPromise(req, opts) } async rttStats() { const stats = { successes: 0, errors: 0, responses: { avgRtt: 0, errors: 0, avgCloserNodes: 0 }, closestReplies: { avgRtt: 0, errors: 0, avgCloserNodes: 0 } } if (this.nodes.latest) { const q = this.findNode(this.nodes.latest.id) let responseCount = 0 let closestCount = 0 for await (const msg of q) { stats.responses.avgRtt += msg.rtt stats.responses.errors += msg.error stats.responses.avgCloserNodes += msg.closerNodes?.length || 0 responseCount++ } stats.responses.avgRtt /= responseCount stats.responses.avgCloserNodes /= responseCount for await (const msg of q.closestReplies) { stats.closestReplies.avgRtt += msg.rtt stats.closestReplies.errors += msg.error stats.closestReplies.avgCloserNodes += msg.closerNodes?.length || 0 closestCount++ } stats.closestReplies.avgRtt /= closestCount stats.closestReplies.avgCloserNodes /= closestCount stats.successes = q.successes stats.errors = q.errors } return stats } request({ token = null, command, target = null, value = null }, { host, port }, opts) { const req = this.io.createRequest( { id: null, host, port }, token, false, command, target, value, (opts && opts.session) || null, opts && opts.ttl ) return this._requestToPromise(req, opts) } session() { return new Session(this) } _requestToPromise(req, opts) { if (req === null) return Promise.reject(new Error('Node destroyed')) if (opts && opts.socket) req.socket = opts.socket if (opts && opts.retry === false) req.retries = 0 return new Promise((resolve, reject) => { req.onresponse = resolve req.onerror = reject req.send() }) } async _bootstrap() { const self = this await Promise.resolve() // wait a tick, so apis can be used from the outside await this.io.bind() this.emit('listening') // TODO: some papers describe more advanced ways of bootstrapping - we should prob look into that let first = this.firewalled && this._quickFirewall && !this._forcePersistent let testNat = false const onlyFirewall = !this._forcePersistent for (let i = 0; i < 2; i++) { await this._backgroundQuery(this.table.id).on('data', ondata).finished() if (this.bootstrapped || (!testNat && !this._forcePersistent)) break if (!(await this._updateNetworkState(onlyFirewall))) break } if (this.bootstrapped) return this.bootstrapped = true this.emit('ready') function ondata(data) { // Simple QUICK nat heuristic. // If we get ONE positive nat ping before the bootstrap query finishes // then we always to a nat test, no matter if we are adaptive... // This should be expanded in the future to try more than one node etc, not always hit the first etc // If this fails, then nbd, as the onstable hook will pick it up later. if (!first) return first = false const value = b4a.allocUnsafe(2) c.uint16.encode({ start: 0, end: 2, buffer: value }, self.io.serverSocket.address().port) self._request( data.from, false, true, PING_NAT, null, value, null, () => { testNat = true }, noop ) } } refresh() { const node = this.table.random() this._backgroundQuery(node ? node.id : this.table.id).on('error', noop) } async destroy() { const emitClose = !this.destroyed this.destroyed = true clearInterval(this._tickInterval) for (const timer of this._pendingTimers) { clearTimeout(timer) } await this.io.destroy() if (emitClose) this.emit('close') } _request(to, force, internal, command, target, value, session, onresponse, onerror) { if (internal && !this._sendDownHints && command === DOWN_HINT) return null const req = this.io.createRequest(to, null, internal, command, target, value, session) if (req === null) return null req.onresponse = onresponse req.onerror = onerror req.send(force) return req } _natAdd(host, port) { const prevHost = this._nat.host const prevPort = this._nat.port this._nat.add(host, port) if (prevHost === this._nat.host && prevPort === this._nat.port) return this.emit('nat-update', this._nat.host, this._nat.port) } // we don't check that this is a bootstrap node but we limit the sample size to very few nodes, so fine _sampleBootstrapMaybe(from, to) { if (this._nonePersistentSamples.length >= Math.max(1, this.bootstrapNodes.length)) return const id = from.host + ':' + from.port if (this._nonePersistentSamples.indexOf(id) > -1) return this._nonePersistentSamples.push(id) this._natAdd(to.host, to.port) } _addNodeFromNetwork(sample, from, to) { if (this._filterNode !== null && !this._filterNode(from)) { return } if (from.id === null) { this._sampleBootstrapMaybe(from, to) return } const oldNode = this.table.get(from.id) // refresh it, if we've seen this before if (oldNode) { if (sample && (oldNode.sampled === 0 || this._tick - oldNode.sampled >= OLD_NODE)) { oldNode.to = to oldNode.sampled = this._tick this._natAdd(to.host, to.port) } oldNode.pinged = oldNode.seen = this._tick this.nodes.add(oldNode) return } this._addNode({ id: from.id, port: from.port, host: from.host, to, sampled: 0, added: this._tick, pinged: this._tick, // last time we interacted with them seen: this._tick, // last time we heard from them downHints: 0, prev: null, next: null }) } _addNode(node) { if (this.nodes.has(node) || b4a.equals(node.id, this.table.id)) return node.added = node.pinged = node.seen = this._tick if (!this.table.add(node)) return this.nodes.add(node) if (node.to && node.sampled === 0) { node.sampled = this._tick this._natAdd(node.to.host, node.to.port) } this.emit('add-node', node) } _removeStaleNode(node, lastSeen) { if (node.seen <= lastSeen) this._removeNode(node) } _removeNode(node) { if (!this.nodes.has(node)) return this.table.remove(node.id) this.nodes.remove(node) this.emit('remove-node', node) } _onwakeup() { this._tick += 2 * OLD_NODE // bump the tick enough that everything appears old. this._tick += 8 - (this._tick & 7) - 2 // triggers a series of pings in two ticks this._stableTicks = MORE_STABLE_TICKS this._refreshTicks = 1 // triggers a refresh next tick (allow network time to wake up also) this._lastHost = null // clear network cache check this.health.reset() if (this.adaptive) { // TODO: re-enable this as soon as we find out why this is over triggering in some edge cases // this.firewalled = true // this.io.firewalled = true if (!this.ephemeral) { this.ephemeral = true this.io.ephemeral = true this.emit('ephemeral') } } this.emit('wakeup') } _onfullrow(newNode, row) { if (!this.bootstrapped || this._repinging >= 3) return let oldest = null for (const node of row.nodes) { if (node.pinged === this._tick) continue if ( oldest === null || oldest.pinged > node.pinged || (oldest.pinged === node.pinged && oldest.added > node.added) ) { oldest = node } } if (oldest === null) return if (this._tick - oldest.pinged < RECENT_NODE && this._tick - oldest.added > OLD_NODE) return this._repingAndSwap(newNode, oldest) } _onnetworkchange(interfaces) { this.emit('network-change', interfaces) this.emit('network-update') } _repingAndSwap(newNode, oldNode) { const self = this const lastSeen = oldNode.seen oldNode.pinged = this._tick this._repinging++ this._request( { id: null, host: oldNode.host, port: oldNode.port }, false, true, PING, null, null, null, onsuccess, onswap ) function onsuccess(m) { if (oldNode.seen <= lastSeen) return onswap() self._repinging-- } function onswap(e) { self._repinging-- self._removeNode(oldNode) self._addNode(newNode) } } _onrequest(req, external) { if (req.from.id !== null) { this._addNodeFromNetwork(!external, req.from, req.to) } if (req.internal) { switch (req.command) { // standard keep alive call case PING: { req.sendReply(0, null, false, false) return } case DELAYED_PING: { this._ondelayedping(req) return } // check if the other side can receive a message to their other socket case PING_NAT: { if (req.value === null || req.value.byteLength < 2) return const port = c.uint16.decode({ start: 0, end: 2, buffer: req.value }) if (port === 0) return req.from.port = port req.sendReply(0, null, false, false) return } // empty dht reply back case FIND_NODE: { if (!req.target) return req.sendReply(0, null, false, true) return } // "this is node you sent me is down" - let's try to ping it case DOWN_HINT: { if (req.value === null || req.value.byteLength < 6) return if (this._checks < 10) { sodium.crypto_generichash(TMP, req.value.subarray(0, 6)) const node = this.table.get(TMP) if (node && (node.pinged < this._tick || node.downHints === 0)) { node.downHints++ this._check(node) } } req.sendReply(0, null, false, false) return } } req.sendReply(UNKNOWN_COMMAND, null, false, req.target !== null) return } // ask the user to handle it or reply back with a bad command if (this.onrequest(req) === false) { req.sendReply(UNKNOWN_COMMAND, null, false, req.target !== null) } } onrequest(req) { return this.emit('request', req) } _ondelayedping(req) { if (req.value === null || req.value.byteLength < 4) return const delayMs = c.uint32.decode({ start: 0, end: 4, buffer: req.value }) if (delayMs > this.maxPingDelay) return const timer = setTimeout(() => { if (this.destroyed) return this._pendingTimers.delete(timer) req.sendReply(0, null, false, false) }, delayMs) this._pendingTimers.add(timer) } _onresponse(res, external) { this._addNodeFromNetwork(!external, res.from, res.to) } _ontimeout(req) { if (!req.to.id) return const node = this.table.get(req.to.id) if (node) this._removeNode(node) } _pingSome() { let cnt = this.io.inflight.length > 2 ? 3 : 5 let oldest = this.nodes.oldest // tiny dht, pinged the bootstrap again if (!oldest) { this.refresh() return } // we've recently pinged the oldest one, so only trigger a couple of repings if (this._tick - oldest.pinged < RECENT_NODE) { cnt = 2 } while (cnt--) { if (!oldest || this._tick === oldest.pinged) continue this._check(oldest) oldest = oldest.next } } _check(node) { node.pinged = this._tick const lastSeen = node.seen const onresponse = () => { this._checks-- this._removeStaleNode(node, lastSeen) } const onerror = () => { this._checks-- this._removeNode(node) } this._checks++ this._request( { id: null, host: node.host, port: node.port }, false, true, PING, null, null, null, onresponse, onerror ) } _ontick() { const time = Date.now() if (time - this._lastTick > SLEEPING_INTERVAL && this.suspended === false) { this._onwakeup() } else { this._tick++ } this._lastTick = time if (!this.bootstrapped || this.suspended) return if (this.adaptive && this.ephemeral && --this._stableTicks <= 0) { if (this._lastHost === this._nat.host) { // do not recheck the same network... this._stableTicks = MORE_STABLE_TICKS } else { this._updateNetworkState() // the promise returned here never fails so just ignore it } } if ((this._tick & 7) === 0) { this._pingSome() } if ( ((this._tick & 63) === 0 && this.nodes.length < this.table.k) || --this._refreshTicks <= 0 ) { this.refresh() } this._downHintsSentPerTick = 0 this.health.update() } async _updateNetworkState(onlyFirewall = false) { if (!this.ephemeral) return false if (onlyFirewall && !this.firewalled) return false const { host, port } = this._nat if (!onlyFirewall) { // remember what host we checked and reset the counter this._stableTicks = MORE_STABLE_TICKS this._lastHost = host } // check if we have a consistent host and port if (host === null || port === 0) { return false } const natSampler = this.firewalled ? new NatSampler() : this._nat // ask remote nodes to ping us on our server socket to see if we have the port open const firewalled = this.firewalled && (await this._checkIfFirewalled(natSampler)) if (firewalled) return false this.firewalled = this.io.firewalled = false // incase it's called in parallel for some reason, or if our nat status somehow changed if (!this.ephemeral || host !== this._nat.host || port !== this._nat.port) return false // if the firewall probe returned a different host / non consistent port, bail as well if (natSampler.host !== host || natSampler.port === 0) return false const id = peer.id(natSampler.host, natSampler.port) if (!onlyFirewall) { this.ephemeral = this.io.ephemeral = false } if (natSampler !== this._nat) { const prevHost = this._nat.host const prevPort = this._nat.port this._nonePersistentSamples = [] this._nat = natSampler if (prevHost !== this._nat.host || prevPort !== this._nat.port) { this.emit('nat-update', this._nat.host, this._nat.port) } } // TODO: we should make this a bit more defensive in terms of using more // resources to make sure that the new routing table contains as many alive nodes // as possible, vs blindly copying them over... // all good! copy over the old routing table to the new one if (!b4a.equals(this.table.id, id)) { const nodes = this.table.toArray() this.table = this.io.table = new Table(id) for (const node of nodes) { if (b4a.equals(node.id, id)) continue if (!this.table.add(node)) this.nodes.remove(node) } this.table.on('row', this._onrow) // we need to rebootstrap/refresh since we updated our id if (this.bootstrapped) this.refresh() } if (!this.ephemeral) { this.emit('persistent') } return true } async *_resolveBootstrapNodes() { for (let { host, port } of this.bootstrapNodes) { let doLookup = false if (host.indexOf('@') === -1) { doLookup = true } else { const [suggestedIP, fallbackHost] = host.split('@') try { await this.ping({ host: suggestedIP, port }) host = suggestedIP } catch { host = fallbackHost doLookup = true } } if (doLookup) { try { host = UDX.isIPv4(host) ? host : (await this.udx.lookup(host, { family: 4 })).host } catch { continue } } yield { id: peer.id(host, port), host, port } } } async _addBootstrapNodes(nodes) { for await (const node of this._resolveBootstrapNodes()) { nodes.push(node) } } async _checkIfFirewalled(natSampler = new NatSampler()) { const nodes = [] for (let node = this.nodes.latest; node && nodes.length < 5; node = node.prev) { nodes.push(node) } if (nodes.length < 5) await this._addBootstrapNodes(nodes) // if no nodes are available, including bootstrappers - bail if (nodes.length === 0) return true const hosts = new Set() const value = b4a.allocUnsafe(2) c.uint16.encode({ start: 0, end: 2, buffer: value }, this.io.serverSocket.address().port) // double check they actually came on the server socket... this.io.serverSocket.on('message', onmessage) const pongs = await requestAll(this, true, PING_NAT, value, nodes) let count = 0 for (const res of pongs) { if (hosts.has(res.from.host)) { count++ natSampler.add(res.to.host, res.to.port) } } this.io.serverSocket.removeListener('message', onmessage) // if we got no or very few replies, consider it a fluke if (count < (nodes.length >= 5 ? 3 : 1)) return true // check that the server socket has the same ip as the client socket if (natSampler.host === null || this._nat.host !== natSampler.host) return true // check that the local port of the server socket is the same as the remote port // TODO: we might want a flag to opt out of this heuristic for specific remapped port servers if (natSampler.port === 0 || natSampler.port !== this.io.serverSocket.address().port) { return true } return false function onmessage(_, { host }) { hosts.add(host) } } _backgroundQuery(target) { this._refreshTicks = REFRESH_TICKS const backgroundCon = Math.min(this.concurrency, Math.max(2, (this.concurrency / 8) | 0)) const q = new Query(this, target, true, FIND_NODE, null, { concurrency: backgroundCon }) q.on('data', () => { // yield to other traffic q.concurrency = this.io.inflight.length < 3 ? this.concurrency : backgroundCon }) return q } // called by health _online() { if (this.online && !this.degraded) return this.online = true this.degraded = false this.emit('network-update') } // called by health _degraded() { if (this.degraded) return this.online = true this.degraded = true this.emit('network-update') } // called by health _offline() { if (!this.online) return this.online = false this.degraded = false this.emit('network-update') } } DHT.OK = 0 DHT.ERROR_UNKNOWN_COMMAND = UNKNOWN_COMMAND DHT.ERROR_INVALID_TOKEN = INVALID_TOKEN module.exports = DHT function localIP(udx, family = 4) { let host = null for (const n of udx.networkInterfaces()) { if (n.family !== family || n.internal) continue // mac really likes en0, mb a better way but this shouldnt be bad anywhere so return now if (n.name === 'en0') return n.host // otherwise pick the first non internal host (let the loop continue in case we see en0) if (host === null) host = n.host } return host || (family === 4 ? '127.0.0.1' : '::1') } function parseNode(s) { if (typeof s === 'object') return s if (typeof s === 'number') return { host: '127.0.0.1', port: s } const [host, port] = s.split(':') if (!port) throw new Error('Bootstrap node format is host:port') return { host, port: Number(port) } } function randomBytes(n) { const b = b4a.alloc(n) sodium.randombytes_buf(b) return b } function randomOffset(n) { return n - ((Math.random() * 0.5 * n) | 0) } function requestAll(dht, internal, command, value, nodes) { let missing = nodes.length const replies = [] return new Promise((resolve) => { for (const node of nodes) { const req = dht._request( node, false, internal, command, null, value, null, onsuccess, onerror ) if (!req) return resolve(replies) } function onsuccess(res) { replies.push(res) if (--missing === 0) resolve(replies) } function onerror() { if (--missing === 0) resolve(replies) } }) } function noop() {} exports.PING = 0 exports.PING_NAT = 1 exports.FIND_NODE = 2 exports.DOWN_HINT = 3 exports.DELAYED_PING = 4 module.exports = class DHTError extends Error { constructor(msg, code, fn = DHTError) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'DHTError' } static UNKNOWN_COMMAND = 1 static INVALID_TOKEN = 2 static REQUEST_TIMEOUT(msg = 'Request timed out') { return new DHTError(msg, 'REQUEST_TIMEOUT', DHTError.REQUEST_TIMEOUT) } static REQUEST_DESTROYED(msg = 'Request destroyed') { return new DHTError(msg, 'REQUEST_DESTROYED', DHTError.REQUEST_DESTROYED) } static IO_SUSPENDED(msg = 'I/O suspended') { return new DHTError(msg, 'IO_SUSPENDED', DHTError.IO_SUSPENDED) } } const MAX_HEALTH_WINDOW = 4 const OFFLINE_THRESHOLD = 2 const IDLE_THRESHOLD = 4 const DEGRADED_TIMEOUT_RATE_THRESHOLD = 0.5 module.exports = class NetworkHealth { constructor(dht) { this._dht = dht this._window = [] this._head = -1 this._offlineTicks = 0 this._degradedTicks = 0 this._healthyTicks = 0 this.online = true this.degraded = false } get oldest() { return this._window[this._tail] } get previous() { return this._window[(this._head - 1 + MAX_HEALTH_WINDOW) % MAX_HEALTH_WINDOW] } get newest() { return this._window[this._head] } get responses() { if (!this.newest || !this.previous) return 0 return this.newest.responses - this.previous.responses } get timeouts() { if (!this.newest || !this.previous) return 0 return this.newest.timeouts - this.previous.timeouts } get timeoutsRate() { if (this.timeouts === 0) return 0 return this.timeouts / (this.responses + this.timeouts) } get cold() { return this._window.length < MAX_HEALTH_WINDOW } get idle() { return this.responses + this.timeouts < IDLE_THRESHOLD } get stats() { return { online: this.online, degraded: this.degraded, cold: this.cold, idle: this.idle, responses: this.responses, timeouts: this.timeouts, timeoutsRate: this.timeoutsRate } } get _tail() { return (this._head + 1) % MAX_HEALTH_WINDOW } reset() { this._window = [] this._head = -1 this._offlineTicks = 0 this._degradedTicks = 0 this._healthyTicks = 0 this.online = true this.degraded = false this._dht._online() } update() { // update counters before dropping oldest if (this.oldest?.degraded) this._degradedTicks-- else if (this.oldest?.degraded === false) this._healthyTicks-- // move window this._head = this._tail this._window[this._head] = { responses: this._dht.stats.requests.responses, timeouts: this._dht.stats.requests.timeouts } // skip state changes if (this.cold || this.idle) return // update newest this.newest.offline = this.responses === 0 this.newest.degraded = !this.newest.offline && this.timeoutsRate > DEGRADED_TIMEOUT_RATE_THRESHOLD // update counters if (this.newest.offline) this._offlineTicks++ else { this._offlineTicks = 0 if (this.newest.degraded) this._degradedTicks++ else this._healthyTicks++ } // check online/offline if (!this.newest.offline) this.online = true else if (this._offlineTicks >= OFFLINE_THRESHOLD) this.online = false // check degraded if (!this.online || this._healthyTicks === MAX_HEALTH_WINDOW) this.degraded = false else if (this._degradedTicks === MAX_HEALTH_WINDOW) this.degraded = true // fire events if (this.online && !this.degraded) this._dht._online() else if (this.degraded) this._dht._degraded() else this._dht._offline() } } const FIFO = require('fast-fifo') const sodium = require('sodium-universal') const c = require('compact-encoding') const b4a = require('b4a') const AdaptiveTimeout = require('adaptive-timeout') const peer = require('./peer') const { INVALID_TOKEN, REQUEST_TIMEOUT, REQUEST_DESTROYED, IO_SUSPENDED } = require('./errors') const VERSION = 0b11 const RESPONSE_ID = (0b0001 << 4) | VERSION const REQUEST_ID = (0b0000 << 4) | VERSION const EMPTY_ARRAY = [] const MAX_WINDOW = 80 module.exports = class IO { constructor( table, udx, { maxWindow = MAX_WINDOW, port = 0, host = '0.0.0.0', anyPort = true, firewalled = true, onrequest, onresponse = noop, ontimeout = noop, adaptiveTimeout } = {} ) { this.table = table this.udx = udx this.inflight = [] this.clientSocket = null this.serverSocket = null this.firewalled = firewalled !== false this.ephemeral = true this.congestion = new CongestionWindow(maxWindow) this.networkInterfaces = udx.watchNetworkInterfaces() this.suspended = false this.stats = { requests: { active: 0, total: 0, responses: 0, timeouts: 0, retries: 0 }, commands: [ { tx: 0, rx: 0 }, // tx = transmitted, rx = received { tx: 0, rx: 0 }, { tx: 0, rx: 0 }, { tx: 0, rx: 0 } ] } this.onrequest = onrequest this.onresponse = onresponse this.ontimeout = ontimeout this._pending = new FIFO() this._rotateSecrets = 10 this._tid = (Math.random() * 65536) | 0 this._secrets = null this._drainInterval = null this._destroying = null this._binding = null // port can be a number or a range [start, to] this.portRange = port.length ? port : port === 0 ? [0, 0] : [port, port + 5] this._host = host this._anyPort = anyPort !== false this._boundServerPort = 0 this._boundClientPort = 0 this._adt = adaptiveTimeout ? new AdaptiveTimeout(adaptiveTimeout) : null } static DEFAULT_MAX_WINDOW = MAX_WINDOW onmessage(socket, buffer, { host, port }) { if (buffer.byteLength < 2 || !(port > 0 && port < 65536) || this.suspended === true) return const from = { id: null, host, port } const state = { start: 1, end: buffer.byteLength, buffer } const expectedSocket = this.firewalled ? this.clientSocket : this.serverSocket const external = socket !== expectedSocket if (buffer[0] === REQUEST_ID) { const req = Request.decode(this, socket, from, state) if (req === null) return if ( req.token !== null && !b4a.equals(req.token, this.token(req.from, 1)) && !b4a.equals(req.token, this.token(req.from, 0)) ) { req.error(INVALID_TOKEN, { token: true }) return } this.onrequest(req, external) return } if (buffer[0] === RESPONSE_ID) { const res = decodeReply(from, state) if (res === null) return for (let i = 0; i < this.inflight.length; i++) { const req = this.inflight[i] if (req.tid !== res.tid) continue res.rtt = Date.now() - req._timestamp if (this._adt && req.sent <= 2) { this._adt.put(`${req.to.host}:${req.to.port}`, res.rtt) } if (i === this.inflight.length - 1) this.inflight.pop() else this.inflight[i] = this.inflight.pop() if (req.session) req.session._detach(req) // TODO: Auto retry here if errors.INVALID_TOKEN is returned? if (req._timeout) { clearTimeout(req._timeout) req._timeout = null } this.congestion.recv() if (req.internal && req.command < this.stats.commands.length) { this.stats.commands[req.command].rx++ } this.stats.requests.active-- this.stats.requests.responses++ this.onresponse(res, external) req.onresponse(res, req) break } } } token(addr, i) { if (this._secrets === null) { const buf = b4a.alloc(64) this._secrets = [buf.subarray(0, 32), buf.subarray(32, 64)] sodium.randombytes_buf(this._secrets[0]) sodium.randombytes_buf(this._secrets[1]) } const token = b4a.allocUnsafe(32) sodium.crypto_generichash(token, b4a.from(addr.host), this._secrets[i]) return token } async destroy() { if (this._destroying) return this._destroying this._destroying = this._destroy() return this._destroying } async _destroy() { // simplifies timing to await the bind here also, although it might be unneeded await this.bind() await this._clear(false) } async _clear(suspended) { if (this._drainInterval) { clearInterval(this._drainInterval) this._drainInterval = null } while (this.inflight.length) { const req = this.inflight.pop() if (req._timeout) clearTimeout(req._timeout) req._timeout = null req.destroyed = true if (req.session) req.session._detach(req) this.congestion.recv() this.stats.requests.active-- req.onerror(suspended ? IO_SUSPENDED() : REQUEST_DESTROYED(), req) } await Promise.allSettled([this.serverSocket.close(), this.clientSocket.close()]) this.networkInterfaces.destroy() } async suspend() { this.suspended = true await this._clear(true) this.congestion.clear() if (this._drainInterval) { clearInterval(this._drainInterval) this._drainInterval = null } } async _rebind(binding) { if (binding) await binding if (this._destroying) return this._destroying await this._bindSockets() this.networkInterfaces = this.udx.watchNetworkInterfaces() } resume() { this.suspended = false const binding = this._binding this._binding = this._rebind(binding) return this._binding } bind() { if (this._binding) return this._binding this._binding = this._bindSockets() return this._binding } async _bindSockets() { const serverSocket = this.udx.createSocket() const candidatePorts = [] // Retrying previous port always has precedence if (this._boundServerPort) candidatePorts.push(this._boundServerPort) for (let i = this.portRange[0]; i < this.portRange[1]; i++) candidatePorts.push(i) for (const port of candidatePorts) { if (serverSocket.bound) break try { serverSocket.bind(port, this._host) } catch (err) { if (!this._anyPort) { await serverSocket.close() throw err } } } if (!serverSocket.bound) { try { serverSocket.bind(0, this._host) } catch (err) { await serverSocket.close() throw err } } const clientSocket = this.udx.createSocket() try { clientSocket.bind(this._boundClientPort || 0, this._host) } catch { try { clientSocket.bind(0, this._host) } catch (err) { await serverSocket.close() await clientSocket.close() throw err } } this._boundServerPort = serverSocket.address().port this._boundClientPort = clientSocket.address().port this.clientSocket = clientSocket this.serverSocket = serverSocket this.serverSocket.on('message', this.onmessage.bind(this, this.serverSocket)) this.clientSocket.on('message', this.onmessage.bind(this, this.clientSocket)) if (this._drainInterval === null) { this._drainInterval = setInterval(this._drain.bind(this), 750) if (this._drainInterval.unref) this._drainInterval.unref() } for (const req of this.inflight) { if (!req.socket) req.socket = this.firewalled ? this.clientSocket : this.serverSocket req.sent = 0 req.send(false) } } _drain() { if (this._secrets !== null && --this._rotateSecrets === 0) { this._rotateSecrets = 10 const tmp = this._secrets[0] this._secrets[0] = this._secrets[1] this._secrets[1] = tmp sodium.crypto_generichash(tmp, tmp) } this.congestion.drain() while (!this.congestion.isFull()) { const p = this._pending.shift() if (p === undefined) return p._sendNow() } } createRequest(to, token, internal, command, target, value, session, ttl) { if (this._destroying !== null) return null if (this._tid === 65536) this._tid = 0 const tid = this._tid++ const socket = this.firewalled ? this.clientSocket : this.serverSocket const req = new Request( this, socket, tid, null, to, token, internal, command, target, value, session, ttl || 0 ) this.inflight.push(req) if (session) session._attach(req) if (internal && command < this.stats.commands.length) { this.stats.commands[command].tx++ } this.stats.requests.active++ this.stats.requests.total++ return req } } class Request { constructor(io, socket, tid, from, to, token, internal, command, target, value, session, ttl) { this.socket = socket this.tid = tid this.from = from this.to = to this.token = token this.command = command this.target = target this.value = value this.internal = internal this.session = session this.ttl = ttl this.index = -1 this.sent = 0 this.retries = 3 this.destroyed = false this.timeout = 0 this.oncycle = noop this.onerror = noop this.onresponse = noop this._buffer = null this._io = io this._timeout = null this._timestamp = Date.now() } static decode(io, socket, from, state) { try { const flags = c.uint.decode(state) const tid = c.uint16.decode(state) const to = peer.ipv4.decode(state) const id = flags & 1 ? c.fixed32.decode(state) : null const token = flags & 2 ? c.fixed32.decode(state) : null const internal = (flags & 4) !== 0 const command = c.uint.decode(state) const target = flags & 8 ? c.fixed32.decode(state) : null const value = flags & 16 ? c.buffer.decode(state) : null if (id !== null) from.id = validateId(id, from) return new Request( io, socket, tid, from, to, token, internal, command, target, value, null, 0 ) } catch { return null } } reply(value, opts = {}) { const socket = opts.socket || this.socket const to = opts.to || this.from this._sendReply(0, value || null, opts.token !== false, opts.closerNodes !== false, to, socket) } error(code, opts = {}) { const socket = opts.socket || this.socket const to = opts.to || this.from this._sendReply(code, null, opts.token === true, opts.closerNodes !== false, to, socket) } relay(value, to, opts) { const socket = (opts && opts.socket) || this.socket const buffer = this._encodeRequest(null, value, to, socket) socket.trySend(buffer, to.port, to.host, this.ttl) } send(force = false) { if (this.destroyed) return if (this.socket === null) return if (this._buffer === null) { this._buffer = this._encodeRequest(this.token, this.value, this.to, this.socket) } if (!force && this._io.congestion.isFull()) { this._io._pending.push(this) return } this._sendNow() } sendReply(error, value, token, hasCloserNodes) { this._sendReply(error, value, token, hasCloserNodes, this.from, this.socket, null) } _sendNow() { if (this.destroyed) return this.sent++ this._io.congestion.send() this.socket.trySend(this._buffer, this.to.port, this.to.host, this.ttl) if (this._timeout) clearTimeout(this._timeout) const value = this.timeout || this._io._adt?.get(`${this.to.host}:${this.to.port}`, this.sent) || 1000 this._timeout = setTimeout(oncycle, value, this) } destroy(err) { if (this.destroyed) return this.destroyed = true if (this._timeout) { clearTimeout(this._timeout) this._timeout = null } const i = this._io.inflight.indexOf(this) if (i === -1) return if (i === this._io.inflight.length - 1) this._io.inflight.pop() else this._io.inflight[i] = this._io.inflight.pop() if (this.session) this.session._detach(this) this._io.stats.requests.active-- this._io.congestion.recv() this.onerror(err || REQUEST_DESTROYED(), this) } _sendReply(error, value, token, hasCloserNodes, from, socket) { if (socket === null || this.destroyed) return const id = this._io.ephemeral === false && socket === this._io.serverSocket const closerNodes = this.target !== null && hasCloserNodes ? this._io.table.closest(this.target) : EMPTY_ARRAY const state = { start: 0, end: 1 + 1 + 6 + 2, buffer: null } // (type | version) + flags + to + tid if (id) state.end += 32 if (token) state.end += 32 if (closerNodes.length > 0) peer.ipv4Array.preencode(state, closerNodes) if (error > 0) c.uint.preencode(state, error) if (value) c.buffer.preencode(state, value) state.buffer = b4a.allocUnsafe(state.end) state.buffer[state.start++] = RESPONSE_ID state.buffer[state.start++] = (id ? 1 : 0) | (token ? 2 : 0) | (closerNodes.length > 0 ? 4 : 0) | (error > 0 ? 8 : 0) | (value ? 16 : 0) c.uint16.encode(state, this.tid) peer.ipv4.encode(state, from) if (id) c.fixed32.encode(state, this._io.table.id) if (token) c.fixed32.encode(state, this._io.token(from, 1)) if (closerNodes.length > 0) peer.ipv4Array.encode(state, closerNodes) if (error > 0) c.uint.encode(state, error) if (value) c.buffer.encode(state, value) socket.trySend(state.buffer, from.port, from.host, this.ttl) } _encodeRequest(token, value, to, socket) { const id = this._io.ephemeral === false && socket === this._io.serverSocket const state = { start: 0, end: 1 + 1 + 6 + 2, buffer: null } // (type | version) + flags + to + tid if (id) state.end += 32 if (token) state.end += 32 c.uint.preencode(state, this.command) if (this.target) state.end += 32 if (value) c.buffer.preencode(state, value) state.buffer = b4a.allocUnsafe(state.end) state.buffer[state.start++] = REQUEST_ID state.buffer[state.start++] = (id ? 1 : 0) | (token ? 2 : 0) | (this.internal ? 4 : 0) | (this.target ? 8 : 0) | (value ? 16 : 0) c.uint16.encode(state, this.tid) peer.ipv4.encode(state, to) if (id) c.fixed32.encode(state, this._io.table.id) if (token) c.fixed32.encode(state, token) c.uint.encode(state, this.command) if (this.target) c.fixed32.encode(state, this.target) if (value) c.buffer.encode(state, value) return state.buffer } } class CongestionWindow { constructor(maxWindow) { this._i = 0 this._total = 0 this._window = [0, 0, 0, 0] this._maxWindow = maxWindow } clear() { this._i = 0 this._total = 0 this._window = [0, 0, 0, 0] } isFull() { return this._total >= 2 * this._maxWindow || this._window[this._i] >= this._maxWindow } recv() { if (this._window[this._i] > 0) { this._window[this._i]-- this._total-- } } send() { this._total++ this._window[this._i]++ } drain() { this._i = (this._i + 1) & 3 this._total -= this._window[this._i] this._window[this._i] = 0 // clear oldest } } function noop() {} function oncycle(req) { req._timeout = null req.oncycle(req) if (req.sent > req.retries) { req._io.stats.requests.timeouts++ req.destroy(REQUEST_TIMEOUT()) req._io.ontimeout(req) } else { req._io.stats.requests.retries++ req.send() } } function decodeReply(from, state) { try { const flags = c.uint.decode(state) const tid = c.uint16.decode(state) const to = peer.ipv4.decode(state) const id = flags & 1 ? c.fixed32.decode(state) : null const token = flags & 2 ? c.fixed32.decode(state) : null const closerNodes = flags & 4 ? peer.ipv4Array.decode(state) : null const error = flags & 8 ? c.uint.decode(state) : 0 const value = flags & 16 ? c.buffer.decode(state) : null if (id !== null) from.id = validateId(id, from) return { tid, rtt: 0, from, to, token, closerNodes, error, value } } catch { return null } } function validateId(id, from) { const expected = peer.id(from.host, from.port) return b4a.equals(expected, id) ? expected : null } const sodium = require('sodium-universal') const c = require('compact-encoding') const b4a = require('b4a') const ipv4 = { ...c.ipv4Address, decode(state) { const ip = c.ipv4Address.decode(state) return { id: null, // populated by the callee host: ip.host, port: ip.port } } } module.exports = { id, ipv4, ipv4Array: c.array(ipv4) } function id(host, port, out = b4a.allocUnsafeSlow(32)) { const addr = out.subarray(0, 6) ipv4.encode({ start: 0, end: 6, buffer: addr }, { host, port }) sodium.crypto_generichash(out, addr) return out } const { Readable, getStreamError } = require('streamx') const b4a = require('b4a') const peer = require('./peer') const { DOWN_HINT } = require('./commands') const DONE = [] const DOWN = [] module.exports = class Query extends Readable { constructor(dht, target, internal, command, value, opts = {}) { super() dht.stats.queries.total++ dht.stats.queries.active++ this.force = !!opts.force this.dht = dht this.k = this.dht.table.k this.target = target this.internal = internal this.command = command this.value = value this.errors = 0 this.successes = 0 this.concurrency = opts.concurrency || this.dht.concurrency this.inflight = 0 this.map = opts.map || defaultMap this.retries = opts.retries === 0 ? 0 : opts.retries || (this.internal && command === DOWN_HINT ? 3 : 5) this.closestReplies = [] this._slow = 0 this._slowdown = false this._seen = new Map() this._pending = [] this._fromTable = false this._commit = opts.commit === true ? autoCommit : opts.commit || null this._commiting = false this._session = opts.session || dht.session() this._autoDestroySession = !opts.session this._onlyClosestNodes = false this._onvisitbound = this._onvisit.bind(this) this._onerrorbound = this._onerror.bind(this) this._oncyclebound = this._oncycle.bind(this) const nodes = opts.nodes || opts.closestNodes const replies = opts.replies || opts.closestReplies // add them reverse as we pop below if (nodes) { for (let i = nodes.length - 1; i >= 0; i--) { const node = nodes[i] this._addPending( { id: node.id || peer.id(node.host, node.port), host: node.host, port: node.port }, null ) } } else if (replies) { for (let i = replies.length - 1; i >= 0; i--) { this._addPending(replies[i].from, null) } } if (opts.onlyClosestNodes) this._onlyClosestNodes = true } get closestNodes() { const nodes = new Array(this.closestReplies.length) for (let i = 0; i < nodes.length; i++) { nodes[i] = this.closestReplies[i].from } return nodes } finished() { return new Promise((resolve, reject) => { if (this.destroyed) { const error = getStreamError(this) if (error) reject(error) else resolve() return } const self = this let error = null this.resume() this.on('error', onerror) this.on('close', onclose) function onclose() { self.removeListener('error', onerror) self.removeListener('close', onclose) if (error) reject(error) else resolve() } function onerror(err) { error = err } }) } _addFromTable() { if (this._pending.length >= this.k) return this._fromTable = true const closest = this.dht.table.closest(this.target, this.k - this._pending.length) for (const node of closest) { this._addPending({ id: node.id, host: node.host, port: node.port }, null) } } async _open(cb) { this._addFromTable() if (this._pending.length >= this.k) return cb(null) for await (const node of this.dht._resolveBootstrapNodes()) { this._addPending(node, null) } cb(null) } _isCloser(id) { return ( this.closestReplies.length < this.k || this._compare(id, this.closestReplies[this.closestReplies.length - 1].from.id) < 0 ) } _addPending(node, ref) { if (this._onlyClosestNodes) return false const addr = node.host + ':' + node.port const refs = this._seen.get(addr) const isCloser = this._isCloser(node.id) if (refs === DONE) { return isCloser } if (refs === DOWN) { if (ref) this._downHint(ref, node) return isCloser } if (refs) { if (ref !== null) refs.push(ref) return isCloser } if (!isCloser) { return false } this._seen.set(addr, ref === null ? [] : [ref]) this._pending.push(node) return true } _read(cb) { this._readMore() cb(null) } _readMore() { if (this.destroying || this._commiting) return const concurrency = (this._slowdown ? 3 : this.concurrency) + this._slow while (this.inflight < concurrency && this._pending.length > 0) { const next = this._pending.pop() if (next && next.id && !this._isCloser(next.id)) continue this._visit(next) } // if reusing closest nodes, slow down after the first readMore tick to allow // the closest node a chance to reply before going broad to question more if (!this._fromTable && this.successes === 0 && this.errors === 0) { this._slowdown = true } if (this._pending.length > 0) return // if no inflight OR all the queries we are waiting on are marked as slow and we have a full result. if ( this.inflight === 0 || (this._slow === this.inflight && this.closestReplies.length >= this.k) ) { // if more than 3/4 failed and we only used cached nodes, try again from the routing table if (!this._fromTable && this.successes < this.k / 4) { this._addFromTable() this._readMore() return } this._flush() } } _flush() { if (this._commiting) return this._commiting = true if (this._commit === null) { this.push(null) return } const p = [] for (const m of this.closestReplies) p.push(this._commit(m, this.dht, this)) this._endAfterCommit(p) } _endAfterCommit(ps) { if (!ps.length) { this.destroy(new Error('Too few nodes responded')) return } const self = this let pending = ps.length let success = 0 for (const p of ps) p.then(ondone, onerror) function ondone() { success++ if (--pending === 0) self.push(null) } function onerror(err) { if (--pending > 0) return if (success) self.push(null) else self.destroy(err) } } _dec(req) { if (req.oncycle === noop) { this._slow-- } else { req.oncycle = noop } this.inflight-- } _onvisit(m, req) { this._dec(req) const addr = req.to.host + ':' + req.to.port this._seen.set(addr, DONE) if (this._commiting) return if (m.error === 0) this.successes++ else this.errors++ if (m.error === 0 && m.from.id !== null && this._isCloser(m.from.id)) this._pushClosest(m) if (m.closerNodes !== null) { for (const node of m.closerNodes) { node.id = peer.id(node.host, node.port) if (this.dht._filterNode !== null && !this.dht._filterNode(node)) continue if (b4a.equals(node.id, this.dht.table.id)) continue // TODO: we could continue here instead of breaking to ensure that one of the nodes in the closer list // is later marked as DOWN that we gossip that back if (!this._addPending(node, m.from)) break } } if (!this._fromTable && this.successes + this.errors >= this.concurrency) { this._slowdown = false } if (m.error !== 0) { this._readMore() return } const data = this.map(m) if (!data || this.push(data) !== false) { this._readMore() } } _onerror(err, req) { const addr = req.to.host + ':' + req.to.port const refs = this._seen.get(addr) if (err.code === 'REQUEST_TIMEOUT') { this._seen.set(addr, DOWN) for (const node of refs) this._downHint(node, req.to) } this._dec(req) this.errors++ this._readMore() } _oncycle(req) { req.oncycle = noop this._slow++ this._readMore() } _downHint(node, down) { // Check rate limit if ( this.dht._downHintsRateLimit !== -1 && this.dht._downHintsSentPerTick >= this.dht._downHintsRateLimit ) { return null } this.dht._downHintsSentPerTick++ const state = { start: 0, end: 6, buffer: b4a.allocUnsafe(6) } peer.ipv4.encode(state, down) this.dht._request(node, false, true, DOWN_HINT, null, state.buffer, this._session, noop, noop) } _pushClosest(m) { this.closestReplies.push(m) for (let i = this.closestReplies.length - 2; i >= 0; i--) { const prev = this.closestReplies[i] const cmp = this._compare(prev.from.id, m.from.id) // if sorted, done! if (cmp < 0) break // if dup, splice it out (rare) if (cmp === 0) { this.closestReplies.splice(i + 1, 1) break } // swap and continue down this.closestReplies[i + 1] = prev this.closestReplies[i] = m } if (this.closestReplies.length > this.k) this.closestReplies.pop() } _compare(a, b) { for (let i = 0; i < a.length; i++) { if (a[i] === b[i]) continue const t = this.target[i] return (t ^ a[i]) - (t ^ b[i]) } return 0 } _visit(to) { this.inflight++ const req = this.dht._request( to, this.force, this.internal, this.command, this.target, this.value, this._session, this._onvisitbound, this._onerrorbound ) if (req === null) { this.destroy(new Error('Node was destroyed')) return } req.retries = this.retries req.oncycle = this._oncyclebound if (this.force) req.retries = 0 } _destroy(cb) { this.dht.stats.queries.active-- if (this._autoDestroySession) this._session.destroy() cb(null) } } function autoCommit(reply, dht, query) { if (!reply.token) return Promise.reject(new Error('No token received for closest node')) return dht.request( { token: reply.token, target: query.target, command: query.command, value: query.value }, reply.from ) } function defaultMap(m) { return m } function noop() {} module.exports = class Session { constructor(dht) { this.dht = dht this.inflight = [] } _attach(req) { req.index = this.inflight.push(req) - 1 } _detach(req) { const i = req.index if (i === -1) return req.index = -1 if (i === this.inflight.length - 1) this.inflight.pop() else { const req = (this.inflight[i] = this.inflight.pop()) req.index = i } } query({ target, command, value }, opts = {}) { return this.dht.query({ target, command, value }, { ...opts, session: this }) } request({ token, command, target, value }, { host, port }, opts = {}) { return this.dht.request( { token, command, target, value }, { host, port }, { ...opts, session: this } ) } ping({ host, port }, opts = {}) { return this.dht.ping({ host, port }, { ...opts, session: this }) } destroy(err) { while (this.inflight.length) { const req = this.inflight[0] // prevent destroyed requests from contributing to congestion counts this.dht.io.congestion.recv() req.destroy(err) } } } { "name": "dht-rpc", "version": "6.27.0", "description": "Make RPC calls over a Kademlia based DHT", "main": "index.js", "files": [ "index.js", "lib/*.js" ], "imports": { "events": { "bare": "bare-events", "default": "events" } }, "dependencies": { "adaptive-timeout": "^1.0.1", "b4a": "^1.6.1", "bare-events": "^2.2.0", "compact-encoding": "^3.0.0", "compact-encoding-net": "^1.2.0", "fast-fifo": "^1.1.0", "kademlia-routing-table": "^1.0.1", "nat-sampler": "^1.0.1", "sodium-universal": "^5.0.0", "streamx": "^2.13.2", "time-ordered-set": "^2.0.0", "udx-native": "^1.5.3" }, "devDependencies": { "brittle": "^3.0.0", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "test-suspend": "^1.0.0" }, "scripts": { "format": "prettier --write .", "test": "npm run test:node && npm run test:bare", "test:bare": "brittle-bare --coverage test.js", "lint": "prettier --check . && lunte", "test:node": "brittle-node --coverage test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/dht-rpc.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/dht-rpc/issues" }, "homepage": "https://github.com/holepunchto/dht-rpc#" } const { encode, decode } = require('./spec/hyperschema') async function encrypt(data, cb) { const result = await cb(data) return encode('@encryption/encrypted-data', result) } async function decrypt(data, cb) { const decoded = decode('@encryption/encrypted-data', data) const decrypted = await cb(decoded) return decrypted } module.exports = { encrypt, decrypt } { "name": "encryption-encoding", "version": "1.0.3", "description": "Compact encoding for versioned encrypted values with automatic string/buffer handling.", "main": "index.js", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" } }, "files": [ "package.json", "index.js", "index.d.ts", "spec" ], "keywords": [ "pear", "p2p", "bare", "autobase", "encryption", "hyperschema" ], "devDependencies": { "b4a": "^1.7.3", "brittle": "^3.19.0", "lunte": "^1.2.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "sodium-universal": "^5.0.1" }, "scripts": { "format": "prettier . --write", "test": "prettier . --check && lunte && brittle-bare test/all.js", "lint": "lunte" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/encryption-encoding.git" }, "author": "Holepunch Inc", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/encryption-encoding/issues" }, "homepage": "https://github.com/holepunchto/encryption-encoding", "dependencies": { "hyperschema": "^1.19.0" } } // This file is autogenerated by the hyperschema compiler // Schema Version: 1 /* eslint-disable camelcase */ /* eslint-disable quotes */ /* eslint-disable space-before-function-paren */ const { c } = require('hyperschema/runtime') const VERSION = 1 // eslint-disable-next-line no-unused-vars let version = VERSION // @encryption/encrypted-data const encoding0 = { preencode(state, m) { c.uint.preencode(state, m.type) c.buffer.preencode(state, m.value) }, encode(state, m) { c.uint.encode(state, m.type) c.buffer.encode(state, m.value) }, decode(state) { const r0 = c.uint.decode(state) const r1 = c.buffer.decode(state) return { type: r0, value: r1 } } } function setVersion(v) { version = v } function encode(name, value, v = VERSION) { version = v return c.encode(getEncoding(name), value) } function decode(name, buffer, v = VERSION) { version = v return c.decode(getEncoding(name), buffer) } function getEnum(name) { switch (name) { default: throw new Error('Enum not found ' + name) } } function getEncoding(name) { switch (name) { case '@encryption/encrypted-data': return encoding0 default: throw new Error('Encoder not found ' + name) } } function getStruct(name, v = VERSION) { const enc = getEncoding(name) return { preencode(state, m) { version = v enc.preencode(state, m) }, encode(state, m) { version = v enc.encode(state, m) }, decode(state) { version = v return enc.decode(state) } } } const resolveStruct = getStruct // compat module.exports = { resolveStruct, getStruct, getEnum, getEncoding, encode, decode, setVersion, version } module.exports = require('bare-events') { "name": "events-universal", "version": "1.0.1", "description": "Universal wrapper for the Node.js events module", "exports": { "./package": "./package.json", ".": { "bare": "./bare.js", "react-native": "./react-native.js", "default": "./default.js" } }, "files": [ "index.js", "default.js", "bare.js", "react-native.js" ], "scripts": { "test": "prettier . --check" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/events-universal.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/events-universal/issues" }, "homepage": "https://github.com/holepunchto/events-universal#readme", "dependencies": { "bare-events": "^2.7.0" }, "devDependencies": { "prettier": "^3.4.2", "prettier-config-holepunch": "^1.0.0" } } module.exports = class FixedFIFO { constructor (hwm) { if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two') this.buffer = new Array(hwm) this.mask = hwm - 1 this.top = 0 this.btm = 0 this.next = null } clear () { this.top = this.btm = 0 this.next = null this.buffer.fill(undefined) } push (data) { if (this.buffer[this.top] !== undefined) return false this.buffer[this.top] = data this.top = (this.top + 1) & this.mask return true } shift () { const last = this.buffer[this.btm] if (last === undefined) return undefined this.buffer[this.btm] = undefined this.btm = (this.btm + 1) & this.mask return last } peek () { return this.buffer[this.btm] } isEmpty () { return this.buffer[this.btm] === undefined } } const FixedFIFO = require('./fixed-size') module.exports = class FastFIFO { constructor (hwm) { this.hwm = hwm || 16 this.head = new FixedFIFO(this.hwm) this.tail = this.head this.length = 0 } clear () { this.head = this.tail this.head.clear() this.length = 0 } push (val) { this.length++ if (!this.head.push(val)) { const prev = this.head this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length) this.head.push(val) } } shift () { if (this.length !== 0) this.length-- const val = this.tail.shift() if (val === undefined && this.tail.next) { const next = this.tail.next this.tail.next = null this.tail = next return this.tail.shift() } return val } peek () { const val = this.tail.peek() if (val === undefined && this.tail.next) return this.tail.next.peek() return val } isEmpty () { return this.length === 0 } } { "name": "fast-fifo", "version": "1.3.2", "description": "A fast fifo implementation similar to the one powering nextTick in Node.js core", "main": "index.js", "files": [ "./index.js", "./fixed-size.js" ], "dependencies": {}, "devDependencies": { "standard": "^17.1.0", "brittle": "^3.3.2" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/fast-fifo.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/fast-fifo/issues" }, "homepage": "https://github.com/mafintosh/fast-fifo" } const fs = require('fs') const fsx = require('fs-native-extensions') const onexit = require('resource-on-exit') const ReadyResource = require('ready-resource') module.exports = class FDLock extends ReadyResource { constructor(fd, opts = {}) { const { wait = false } = opts super() this._fd = fd this._wait = wait this._locked = false onexit.add(this, closeSync) } async _open() { try { await this._resume() } catch (err) { onexit.remove(this) await close(this) throw err } } async _close() { onexit.remove(this) await close(this) } transfer() { const fd = this._fd if (fd === -1) throw new Error('Lock has already been transferred') this._fd = -1 onexit.remove(this) return fd } async suspend() { if (!this.opened) await this.ready() return this._suspend() } async _suspend() { if (this._fd === -1 || this._locked === false) return fsx.unlock(this._fd) this._locked = false } async resume() { if (!this.opened) await this.ready() return this._resume() } async _resume() { if (this._fd === -1 || this._locked === true) return if (this._wait) await fsx.waitForLock(this._fd) else if (!fsx.tryLock(this._fd)) { throw new Error('File descriptor could not be locked') } this._locked = true } } function close(lock) { const fd = lock._fd if (fd === -1) return lock._fd = -1 return new Promise((resolve) => fs.close(fd, () => resolve())) } function closeSync(lock) { const fd = lock._fd if (fd === -1) return lock._fd = -1 try { fs.closeSync(fd) } catch {} } { "name": "fd-lock", "version": "2.1.1", "description": "Stateful file descriptor locks for JavaScript", "exports": { "./package": "./package.json", ".": "./index.js" }, "imports": { "fs": { "bare": "bare-fs", "default": "fs" } }, "files": [ "index.js" ], "scripts": { "test": "npm run lint && npm run test:bare && npm run test:node", "test:bare": "bare test.js", "test:node": "node test.js", "lint": "prettier --check .", "format": "prettier --write ." }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/fd-lock.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/fd-lock/issues" }, "homepage": "https://github.com/holepunchto/fd-lock#readme", "dependencies": { "bare-fs": "^4.5.0", "fs-native-extensions": "^1.4.4", "ready-resource": "^1.2.0", "resource-on-exit": "^1.0.0" }, "devDependencies": { "brittle": "^3.3.2", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0" } } exports.fullRoots = function (index, result) { if (index & 1) throw new Error('You can only look up roots for depth(0) blocks') if (!result) result = [] index /= 2 let offset = 0 let factor = 1 while (true) { if (!index) return result while (factor * 2 <= index) factor *= 2 result.push(offset + factor - 1) offset = offset + 2 * factor index -= factor factor = 1 } } exports.futureRoots = function (index, result) { if (index & 1) throw new Error('You can only look up future roots for depth(0) blocks') if (!result) result = [] let factor = 1 // make first root while (factor * 2 <= index) factor *= 2 // full factor of 2 - done if (factor * 2 - 2 === index) return result let pos = factor / 2 - 1 // while its not a full tree while ((pos + factor / 2 - 1) !== index) { pos += factor // read too far, to to left child while ((pos + factor / 2 - 1) > index) { factor /= 2 pos -= factor / 2 } // the "gap" is a future root result.push(pos - factor / 2) } return result } exports.patch = function (from, to) { if (from === 0 || from >= to) return [] const roots = exports.fullRoots(from) const target = exports.fullRoots(to) // first find the first root that is different let i = 0 for (; i < target.length; i++) { if (i >= roots.length || roots[i] !== target[i]) break } const patch = [] if (i < roots.length) { // now we need to grow the newest root until it hits the diff one let prev = roots.length - 1 const ite = exports.iterator(roots[prev--]) while (ite.index !== target[i]) { ite.sibling() if (prev >= 0 && ite.index === roots[prev]) { prev-- } else { patch.push(ite.index) } patch.push(ite.parent()) } i++ // patched to next root, so inc } // include the rest for (; i < target.length; i++) patch.push(target[i]) return patch } exports.depth = function (index) { let depth = 0 index += 1 while (!(index & 1)) { depth++ index = rightShift(index) } return depth } exports.sibling = function (index, depth) { if (!depth) depth = exports.depth(index) const offset = exports.offset(index, depth) return exports.index(depth, offset & 1 ? offset - 1 : offset + 1) } exports.parent = function (index, depth) { if (!depth) depth = exports.depth(index) const offset = exports.offset(index, depth) return exports.index(depth + 1, rightShift(offset)) } exports.leftChild = function (index, depth) { if (!(index & 1)) return -1 if (!depth) depth = exports.depth(index) return exports.index(depth - 1, exports.offset(index, depth) * 2) } exports.rightChild = function (index, depth) { if (!(index & 1)) return -1 if (!depth) depth = exports.depth(index) return exports.index(depth - 1, 1 + (exports.offset(index, depth) * 2)) } exports.children = function (index, depth) { if (!(index & 1)) return null if (!depth) depth = exports.depth(index) const offset = exports.offset(index, depth) * 2 return [ exports.index(depth - 1, offset), exports.index(depth - 1, offset + 1) ] } exports.leftSpan = function (index, depth) { if (!(index & 1)) return index if (!depth) depth = exports.depth(index) return exports.offset(index, depth) * twoPow(depth + 1) } exports.rightSpan = function (index, depth) { if (!(index & 1)) return index if (!depth) depth = exports.depth(index) return (exports.offset(index, depth) + 1) * twoPow(depth + 1) - 2 } exports.nextLeaf = function (index) { let factor = 1 let r = index while ((r & 1) === 1) { r = (r - 1) / 2 factor *= 2 } return index + factor + 1 } exports.count = function (index, depth) { if (!(index & 1)) return 1 if (!depth) depth = exports.depth(index) return twoPow(depth + 1) - 1 } exports.countLeaves = function (index) { return (exports.count(index) + 1) / 2 } exports.spans = function (index, depth) { if (!(index & 1)) return [index, index] if (!depth) depth = exports.depth(index) const offset = exports.offset(index, depth) const width = twoPow(depth + 1) return [offset * width, (offset + 1) * width - 2] } exports.index = function (depth, offset) { return (1 + 2 * offset) * twoPow(depth) - 1 } exports.offset = function (index, depth) { if (!(index & 1)) return index / 2 if (!depth) depth = exports.depth(index) return ((index + 1) / twoPow(depth) - 1) / 2 } exports.iterator = function (index) { const ite = new Iterator() ite.seek(index || 0) return ite } function twoPow (n) { return n < 31 ? 1 << n : ((1 << 30) * (1 << (n - 30))) } function rightShift (n) { return (n - (n & 1)) / 2 } function Iterator () { this.index = 0 this.offset = 0 this.factor = 0 } Iterator.prototype.seek = function (index) { this.index = index if (this.index & 1) { this.offset = exports.offset(index) this.factor = twoPow(exports.depth(index) + 1) } else { this.offset = index / 2 this.factor = 2 } } Iterator.prototype.isLeft = function () { return (this.offset & 1) === 0 } Iterator.prototype.isRight = function () { return (this.offset & 1) === 1 } Iterator.prototype.isRoot = function (length) { const currentLength = 1 + (this.index + this.factor / 2 - 1) / 2 if (length < currentLength) return false const factor = this.factor * 2 const index = (this.offset & 1) ? this.index - this.factor / 2 : this.index + this.factor / 2 const parentLength = 1 + (index + factor / 2 - 1) / 2 return parentLength > length } Iterator.prototype.contains = function (index) { return index > this.index ? index < (this.index + this.factor / 2) : index < this.index ? index > (this.index - this.factor / 2) : true } Iterator.prototype.prev = function () { if (!this.offset) return this.index this.offset-- this.index -= this.factor return this.index } Iterator.prototype.next = function () { this.offset++ this.index += this.factor return this.index } Iterator.prototype.count = function () { if (!(this.index & 1)) return 1 return this.factor - 1 } Iterator.prototype.countLeaves = function () { return (this.count() + 1) / 2 } Iterator.prototype.sibling = function () { return this.isLeft() ? this.next() : this.prev() } Iterator.prototype.parent = function () { if (this.offset & 1) { this.index -= this.factor / 2 this.offset = (this.offset - 1) / 2 } else { this.index += this.factor / 2 this.offset /= 2 } this.factor *= 2 return this.index } Iterator.prototype.leftSpan = function () { this.index = this.index - this.factor / 2 + 1 this.offset = this.index / 2 this.factor = 2 return this.index } Iterator.prototype.peekLeftSpan = function () { return this.index - this.factor / 2 + 1 } Iterator.prototype.rightSpan = function () { this.index = this.index + this.factor / 2 - 1 this.offset = this.index / 2 this.factor = 2 return this.index } Iterator.prototype.peekRightSpan = function () { return this.index + this.factor / 2 - 1 } Iterator.prototype.leftChild = function () { if (this.factor === 2) return this.index this.factor /= 2 this.index -= this.factor / 2 this.offset *= 2 return this.index } Iterator.prototype.rightChild = function () { if (this.factor === 2) return this.index this.factor /= 2 this.index += this.factor / 2 this.offset = 2 * this.offset + 1 return this.index } Iterator.prototype.nextTree = function () { this.index = this.index + this.factor / 2 + 1 this.offset = this.index / 2 this.factor = 2 return this.index } Iterator.prototype.prevTree = function () { if (!this.offset) { this.index = 0 this.factor = 2 } else { this.index = this.index - this.factor / 2 - 1 this.offset = this.index / 2 this.factor = 2 } return this.index } Iterator.prototype.fullRoot = function (index) { if (index <= this.index || (this.index & 1) > 0) return false while (index > this.index + this.factor + this.factor / 2) { this.index += this.factor / 2 this.factor *= 2 this.offset /= 2 } return true } { "name": "flat-tree", "version": "1.13.0", "description": "A series of functions to map a binary tree to a list", "main": "index.js", "files": [ "index.js" ], "dependencies": {}, "devDependencies": { "brittle": "^3.3.2", "standard": "^17.1.0" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/flat-tree.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/flat-tree/issues" }, "homepage": "https://github.com/mafintosh/flat-tree" } require.addon = require('require-addon') module.exports = require.addon('.', __filename) const { isWindows } = require('which-runtime') const binding = require('./binding') function onwork(err, result) { if (err) this.reject(err) else this.resolve(result) } exports.tryLock = function tryLock(fd, offset = 0, length = 0, opts = {}) { if (typeof offset === 'object') { opts = offset offset = 0 } if (typeof length === 'object') { opts = length length = 0 } if (typeof opts !== 'object' || opts === null) { opts = {} } try { binding.tryLock(fd, offset, length, opts.shared !== true) } catch (err) { if (err.code === 'EAGAIN') return false throw err } return true } exports.waitForLock = function waitForLock(fd, offset = 0, length = 0, opts = {}) { if (typeof offset === 'object') { opts = offset offset = 0 } if (typeof length === 'object') { opts = length length = 0 } if (typeof opts !== 'object' || opts === null) { opts = {} } const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.waitForLock(fd, offset, length, opts.shared !== true, req, onwork) } catch (err) { return Promise.reject(err) } return promise } exports.waitForLockSync = function waitForLockSync(fd, offset = 0, length = 0, opts = {}) { if (typeof offset === 'object') { opts = offset offset = 0 } if (typeof length === 'object') { opts = length length = 0 } if (typeof opts !== 'object' || opts === null) { opts = {} } binding.waitForLockSync(fd, offset, length, opts.shared !== true) } exports.tryDowngradeLock = function tryDowngradeLock(fd, offset = 0, length = 0) { try { binding.tryDowngradeLock(fd, offset, length) } catch (err) { if (err.code === 'EAGAIN') return false throw err } return true } exports.waitForDowngradeLock = function downgradeLock(fd, offset = 0, length = 0) { const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.waitForDowngradeLock(fd, offset, length, req, onwork) } catch (err) { return Promise.reject(err) } return promise } exports.waitForDowngradeLockSync = function waitForDowngradeLockSync(fd, offset = 0, length = 0) { binding.waitForDowngradeLockSync(fd, offset, length) } exports.tryUpgradeLock = function tryUpgradeLock(fd, offset = 0, length = 0) { try { binding.tryUpgradeLock(fd, offset, length) } catch (err) { if (err.code === 'EAGAIN') return false throw err } return true } exports.waitForUpgradeLock = function upgradeLock(fd, offset = 0, length = 0) { const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.waitForUpgradeLock(fd, offset, length, req, onwork) } catch (err) { return Promise.reject(err) } return promise } exports.waitForUpgradeLockSync = function waitForUpgradeLockSync(fd, offset = 0, length = 0) { binding.waitForUpgradeLockSync(fd, offset, length) } exports.unlock = function unlock(fd, offset = 0, length = 0) { binding.unlock(fd, offset, length) } exports.trim = function trim(fd, offset, length) { const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.trim(fd, offset, length, req, onwork) } catch (err) { return Promise.reject(err) } return promise } exports.trimSync = function trimSync(fd, offset, length) { binding.trimSync(fd, offset, length) } exports.sparse = function sparse(fd) { // Short circuit on everything but Windows if (!isWindows) return Promise.resolve() const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.sparse(fd, req, onwork) } catch (err) { return Promise.reject(err) } return promise } exports.sparseSync = function sparseSync(fd) { // Short circuit on everything but Windows if (!isWindows) return binding.sparseSync(fd) } exports.swap = function swap(from, to) { const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.swap(from, to, req, onwork) } catch (err) { return Promise.reject(err) } return promise } exports.swapSync = function swapSync(from, to) { binding.swapSync(from, to) } exports.getAttr = function getAttr(fd, name) { const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.getAttr(fd, name, req, onwork) } catch (err) { return Promise.reject(err) } return promise.then((buffer) => (buffer === null ? null : Buffer.from(buffer))) } exports.getAttrSync = function getAttrSync(fd, name) { const buffer = binding.getAttrSync(fd, name) return buffer === null ? null : Buffer.from(buffer) } exports.setAttr = function setAttr(fd, name, value, encoding) { if (typeof value === 'string') value = Buffer.from(value, encoding) const req = { value, handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.setAttr( fd, name, value.buffer, value.byteOffset, value.byteLength, req, onwork ) } catch (err) { return Promise.reject(err) } return promise } exports.setAttrSync = function setAttrSync(fd, name, value, encoding) { if (typeof value === 'string') value = Buffer.from(value, encoding) binding.setAttrSync(fd, name, value.buffer, value.byteOffset, value.byteLength) } exports.removeAttr = function removeAttr(fd, name) { const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.removeAttr(fd, name, req, onwork) } catch (err) { return Promise.reject(err) } return promise } exports.removeAttrSync = function removeAttrSync(fd, name) { binding.removeAttrSync(fd, name) } exports.listAttrs = function listAttrs(fd) { const req = { handle: null, resolve: null, reject: null } const promise = new Promise((resolve, reject) => { req.resolve = resolve req.reject = reject }) try { req.handle = binding.listAttrs(fd, req, onwork) } catch (err) { return Promise.reject(err) } return promise } exports.listAttrsSync = function listAttrsSync(fd) { return binding.listAttrsSync(fd) } { "name": "fs-native-extensions", "version": "1.5.0", "description": "Native file system extensions for advanced file operations", "main": "index.js", "files": [ "index.js", "macros.h", "binding.c", "binding.js", "CMakeLists.txt", "include", "src", "prebuilds" ], "imports": { "child_process": { "bare": "bare-subprocess", "default": "child_process" }, "fs": { "bare": "bare-fs", "default": "fs" }, "fs/*": { "bare": "bare-fs/*", "default": "fs/*" }, "path": { "bare": "bare-path", "default": "path" } }, "addon": true, "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:bare": "brittle-bare --coverage test.js", "test:node": "brittle-node --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/fs-native-extensions.git" }, "author": "Kasper Isager Dalsgarð ", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/fs-native-extensions/issues" }, "homepage": "https://github.com/holepunchto/fs-native-extensions#readme", "dependencies": { "require-addon": "^1.1.0", "which-runtime": "^1.2.0" }, "devDependencies": { "bare-compat-napi": "^1.3.8", "bare-fs": "^4.4.4", "bare-path": "^3.0.0", "bare-subprocess": "^4.0.5", "brittle": "^3.1.1", "cmake-bare": "^1.1.10", "cmake-fetch": "^1.4.7", "cmake-napi": "^1.0.5", "cmake-npm": "^1.1.0", "lunte": "^1.6.0", "minimist": "^1.2.6", "prettier": "^3.5.3", "prettier-config-holepunch": "^2.0.0", "test-tmp": "^1.2.1" } } /** * ChunkScheduler — multi-source (torrent-style) fetch of one content-addressed * file across several peers, modelled on Hypercore's block replicator. * * Chunks are content-addressed, so any peer holding the file can serve any * chunk. The scheduler: * - requests the chunk list from each peer (identical, content-addressed), * - tracks a global `inflight` map so each chunk is requested from exactly * ONE peer at a time (no wasted bandwidth), * - keeps each peer busy up to a per-peer inflight cap (parallel download), * - reassigns a peer's inflight chunks to others on stall/disconnect, * - hash-verifies every chunk (via TransferManager.writeChunk) and the whole * file before finalizing. * * It drives the EXISTING v2 wire messages (chunk-need / chunk-data) — no new * message type is needed for the full-copy-seeder case. The protocol delegates * `_onChunkHashes` / `_onChunkData` to a scheduler ONLY when one is registered * for the synthetic `content:` path, so the legacy single-peer flow * is untouched. */ import { hashChunk } from './chunker.js' // P2 — per-peer inflight request window, modelled on hypercore's replicator // Peer.getMaxInflight (holepunchto/hypercore lib/replicator.js:590). Our content // chunks are ~64 KB (tier 0 avg 16 KB … tier 3 max 4 MB) — much larger than // hypercore's blocks — so the range is tuned DOWN from its [16, 512]. A no-udx // stream (in-memory pair / relay, no RTT signal) gets a modest fixed min*3; a udx // stream scales the window with RTT and shrinks it as more peers join (fair share). const INFLIGHT_RANGE = [4, 64] const SCALE_LATENCY = 50 // ms — at/under this RTT the window stays at min // Head-of-line fairness — cede the event loop every YIELD_EVERY accepted chunks // so a burst of buffered chunkData frames (protomux dispatches every frame from // one socket read synchronously) can't starve other listeners multiplexed on the // same connection (e.g. Hypercore replication). Kept local (not imported from // transfer.js) so this module stays Node-loadable for the unit suite. const yieldToLoop = () => new Promise((resolve) => setTimeout(resolve, 0)) const YIELD_EVERY = 16 // Idle (no-progress) timeout, reset on every accepted chunk and on the // initial chunk-list response. A steadily-progressing transfer never trips it — // only a genuine stall (no bytes for this long) fails. A fixed OVERALL timeout // here capped large transfers (e.g. a multi-GB file at any bandwidth always // exceeded 30s) and aborted them mid-stream. const DEFAULT_IDLE_TIMEOUT = 30000 // Local write-error codes that may recover on retry (vs ENOSPC/EACCES/… // which are fatal): a transient one keeps the chunk retryable instead of failing // the whole multi-source fetch. const TRANSIENT_WRITE_CODES = new Set(['EBUSY', 'EAGAIN', 'EINTR', 'EMFILE', 'ENFILE']) // Min interval between have-progress reports to holders (their sender-side bar). // Throttles the transferProgress frames so a fast transfer can't spam holders. const DEFAULT_REPORT_INTERVAL = 1000 export class ChunkScheduler { /** * @param {object} opts * opts.path synthetic path key ('content:') * opts.destPath where the assembled file is written * opts.transfer TransferManager * opts.sendNeed (peer, indices[]) => void — sends a chunk-need message * opts.cap per-peer inflight cap (default 8) * opts.timeout idle (no-progress) timeout ms (default 30000) * opts.onProgress optional (receivedBytes, totalBytes) => void on each accepted chunk */ constructor (opts) { this.path = opts.path this.destPath = opts.destPath this._transfer = opts.transfer this._sendNeed = opts.sendNeed this._cap = opts.cap || 0 // >0 = fixed override; 0 = dynamic RTT-scaled window (P2) this._onProgress = opts.onProgress || null this._onVerify = opts.onVerify || null this._onBaseline = opts.onBaseline || null this._reportInterval = opts.reportInterval ?? DEFAULT_REPORT_INTERVAL this._lastReportAt = 0 // cumulative byte accounting so onProgress can drive a // remaining-bytes/ETA bar, not just a chunk count. this._receivedBytes = 0 this._totalBytes = 0 this._sinceYield = 0 // event-loop yield counter (see YIELD_EVERY) this._peers = new Set() this._started = false this._settingUp = false this._finalizing = false this._done = false this._chunks = null // [{ hash, offset, length }] this._needed = new Set() // indices not yet written this._inflight = new Map() // index → peer (one peer per chunk) this._inflightAt = new Map() // index → assign timestamp (P5 hotswap staleness) this._peerInflight = new Map() // peer → count // P5 — hotswap: reassign a chunk stalled on a slow peer to an idle faster peer. // A chunk inflight this long (ms) while another peer has spare capacity is // eligible to be stolen. opts.sendCancel(peer, indices) best-effort tells the // slow peer to stop serving them. <0 disables hotswap. this._hotswapStallMs = opts.hotswapStallMs ?? 2000 this._sendCancel = opts.sendCancel || null this._hotswaps = 0 this._received = new Map() // peer → chunks accepted (multi-source proof) this._resolve = null this._reject = null this._onEnd = opts.onEnd || null this._contentHash = opts.contentHash || null // enables incremental whole-file verify this._startedAt = Date.now() // idle timeout — re-armed on each progress signal (see _armIdleTimer). this._idleTimeout = opts.timeout || DEFAULT_IDLE_TIMEOUT this._timer = null this._armIdleTimer() } promise () { return new Promise((resolve, reject) => { this._resolve = resolve; this._reject = reject }) } // (Re)arm the no-progress watchdog. Called at construction and on every // forward-progress signal so only a genuine stall — no accepted bytes for the // idle window — aborts the fetch, regardless of total file size. _armIdleTimer () { if (this._done) return clearTimeout(this._timer) this._timer = setTimeout( () => this._fail(new Error('multi-source fetch stalled (no progress for ' + this._idleTimeout + 'ms)')), this._idleTimeout, ) } _reportEnd (ok, reason) { if (!this._onEnd) return try { this._onEnd({ ok, reason, receivedBytes: this._receivedBytes, totalBytes: this._totalBytes, chunksRemaining: this._needed.size, totalChunks: this._chunks ? this._chunks.length : 0, peers: this._peers.size, elapsedMs: Date.now() - this._startedAt, }) } catch {} } _fail (err) { if (this._done) return this._done = true clearTimeout(this._timer) this._reportEnd(false, err.message) // Release the receiver state at the failure boundary: journal the hash // frontier and close the fd + chunk stash so a never-retried failure parks // nothing (the partial stays on disk for a later resume). Best-effort — the // external-stop path (cancel) does its own pause/cancel before rejecting. if (this._transfer && typeof this._transfer.pause === 'function') { try { Promise.resolve(this._transfer.pause(this.destPath)).catch(() => {}) } catch {} } if (this._reject) this._reject(err) } _finish () { if (this._done) return this._done = true clearTimeout(this._timer) this._reportEnd(true, 'complete') if (this._resolve) this._resolve({ chunksPerPeer: this._received, peerCount: this._received.size, size: this._totalBytes }) } // External stop (pause or discard). The partial is kept or unlinked by // the caller (OverlayProtocol.cancelContent via TransferManager.pause/cancel) // BEFORE this; here we only stop the loop and reject the fetch with ECANCELLED. cancel () { if (this._done) return this._done = true clearTimeout(this._timer) this._reportEnd(false, 'cancelled') const err = new Error('fetch cancelled') err.code = 'ECANCELLED' if (this._reject) this._reject(err) } get done () { return this._done } // A chunkHashes page arrived while a large map is still // streaming across multiple frames. Receiving it is forward progress, so // re-arm the no-progress watchdog (the full list dispatches via onChunkHashes // only once the final page lands). notePageProgress () { if (!this._done && !this._settingUp) this._armIdleTimer() } /** A peer responded with the chunk list. First response starts the transfer. */ async onChunkHashes (peer, chunks) { if (this._done) return this._peers.add(peer) if (!this._peerInflight.has(peer)) this._peerInflight.set(peer, 0) if (!this._started) { this._started = true // The async startReceive (journal-less resume re-verify) can run for a while // and accepts no chunks; suppress the no-progress watchdog (including later // peers' re-arms) until setup completes, or a concurrent seeder's chunk list // would re-arm it and self-trip a healthy resume. this._settingUp = true clearTimeout(this._timer) // Derive offsets from the ordered chunk lengths. let offset = 0 this._chunks = chunks.map((c) => { const entry = { hash: c.hash, offset, length: c.length } offset += c.length return entry }) this._totalBytes = offset // file size = sum of chunk lengths let state try { state = await this._transfer.startReceive( this.destPath, { size: offset, chunks: this._chunks, contentHash: this._contentHash }, { isCancelled: () => this._done, onVerifyProgress: this._onVerify } ) } catch (err) { this._settingUp = false if (this._done) return return this._fail(err) } this._settingUp = false if (this._done) return // resume: only fetch chunks the partial doesn't already hold, and // seed the byte counter so progress/ETA continue from the resumed offset. let have = 0 for (let i = 0; i < this._chunks.length; i++) { if (state.received.has(i)) have += this._chunks[i].length else this._needed.add(i) } this._receivedBytes = have if (have > 0) { // report our resume have-bytes so holders' sender-side bars mirror our // true progress, not just the bytes they re-serve. Re-sent periodically as more // chunks land (onChunkData) so late-joining and multi-source holders stay in sync. this._reportHave(Date.now()) if (this._onProgress) { try { this._onProgress(this._receivedBytes, this._totalBytes) } catch {} } } this._armIdleTimer() if (this._needed.size === 0) return this._finalize() return this._assign() } if (!this._settingUp) this._armIdleTimer() // a later peer's list is forward progress this._assign() } /** A chunk arrived from a peer. Verify + write, then schedule more. */ async onChunkData (peer, index, data) { if (this._done) return const res = this._transfer.writeChunk(this.destPath, index, data) // Free the inflight slot regardless — a bad chunk should be re-fetched. if (this._inflight.get(index) === peer) { this._inflight.delete(index) this._inflightAt.delete(index) this._peerInflight.set(peer, Math.max(0, (this._peerInflight.get(peer) || 1) - 1)) } if (!res.ok) { // A coded failure is a local fs error. A TRANSIENT code (device busy, // fd pressure, interrupted syscall) can succeed on retry — leave the chunk in // `needed` and reassign. Any other coded error (ENOSPC / EACCES / ENOENT / …) is // fatal: fail the whole fetch carrying the code. No code = a hash/length // mismatch — also retried elsewhere. if (res.code && !TRANSIENT_WRITE_CODES.has(res.code)) { const err = new Error('write failed: ' + res.error) err.code = res.code return this._fail(err) } this._assign() return } this._needed.delete(index) this._received.set(peer, (this._received.get(peer) || 0) + 1) this._receivedBytes += (data ? data.length : 0) this._armIdleTimer() // accepted bytes — reset the no-progress watchdog if (this._onProgress) { try { this._onProgress(this._receivedBytes, this._totalBytes) } catch {} } this._maybeReportHave() if (this._needed.size === 0 && this._inflight.size === 0) return this._finalize() // Periodic event-loop yield (see YIELD_EVERY) if (++this._sinceYield >= YIELD_EVERY) { this._sinceYield = 0 await yieldToLoop() if (this._done) return } this._assign() } // Report our cumulative have-bytes to holders (their sender-side bar). Fired // once at resume, then throttled as chunks land, and once at finalize so the bar settles // at 100% across every holder regardless of who served what. _reportHave (now) { if (!this._onBaseline || this._receivedBytes <= 0) return this._lastReportAt = now try { this._onBaseline(this._receivedBytes) } catch {} } _maybeReportHave () { if (!this._onBaseline) return const now = Date.now() if (now - this._lastReportAt >= this._reportInterval) this._reportHave(now) } /** A peer went away — return its inflight chunks to the pool. */ removePeer (peer) { if (!this._peers.has(peer)) return this._peers.delete(peer) this._peerInflight.delete(peer) for (const [index, p] of this._inflight) { if (p === peer) { this._inflight.delete(index); this._inflightAt.delete(index) } // back to needed (still in _needed) } if (this._done) return if (this._peers.size === 0 && this._needed.size > 0) { return this._fail(new Error('all peers gone with ' + this._needed.size + ' chunk(s) outstanding')) } this._assign() } async _finalize () { if (this._finalizing || this._done) return this._finalizing = true this._reportHave(Date.now()) // final have=total so holders' bars settle at 100% clearTimeout(this._timer) // the digest drain can outlast the idle window let fin try { fin = await this._transfer.finalize(this.destPath) } catch (err) { return this._fail(err) } if (!fin.ok) { const err = new Error('finalize failed: ' + fin.error) if (fin.code) err.code = fin.code // preserve EHASHMISMATCH for the caller return this._fail(err) } this._finish() } // P2: per-peer inflight window. A fixed opts.cap overrides it (back-compat / tests); // otherwise scale with the peer's udx RTT and the peer count exactly as hypercore's // Peer.getMaxInflight — window stays at min for low-RTT links, grows for high-RTT // ones, and shrinks toward a fair share (×min(1, 2/peers)) as more peers join. _maxInflight (peer) { if (this._cap) return this._cap const [min, max] = INFLIGHT_RANGE const raw = peer && peer.mux && peer.mux.stream && peer.mux.stream.rawStream if (!raw || !raw.udx || typeof raw.rtt !== 'number') return Math.min(max, min * 3) const scale = raw.rtt <= SCALE_LATENCY ? 1 : (raw.rtt / SCALE_LATENCY) * Math.min(1, 2 / Math.max(1, this._peers.size)) return Math.max(min, Math.round(Math.min(max, min * scale))) } /** Assign needed-but-not-inflight chunks to peers with spare capacity. */ _assign () { if (this._done || !this._chunks) return // Per peer, batch the indices we hand it this round. const batches = new Map() const now = Date.now() for (const peer of this._peers) { let slots = this._maxInflight(peer) - (this._peerInflight.get(peer) || 0) if (slots <= 0) continue for (const index of this._needed) { if (slots <= 0) break if (this._inflight.has(index)) continue this._inflight.set(index, peer) this._inflightAt.set(index, now) this._peerInflight.set(peer, (this._peerInflight.get(peer) || 0) + 1) if (!batches.has(peer)) batches.set(peer, []) batches.get(peer).push(index) slots-- } // P5: this peer has spare capacity and no un-assigned chunks are left for it — // steal the most-stalled chunk(s) inflight to slower peers (the hotswap tail). if (slots > 0) this._hotswap(peer, slots, batches, now) } for (const [peer, indices] of batches) { if (indices.length) this._sendNeed(peer, indices) } } // P5 — hotswap tail: reassign chunks that have been inflight to OTHER peers beyond // the stall window to `peer` (which is idle-capable), so one slow peer can't hold up // the final chunks while faster peers sit idle. Mirrors hypercore's HotswapQueue. // Duplicate arrivals (the slow peer may still deliver its copy) are handled // idempotently in onChunkData. sendCancel is best-effort bandwidth saving. _hotswap (peer, slots, batches, now) { if (this._hotswapStallMs < 0) return const cands = [] for (const [index, holder] of this._inflight) { if (holder === peer) continue if ((now - (this._inflightAt.get(index) || now)) < this._hotswapStallMs) continue cands.push(index) } if (!cands.length) return cands.sort((a, b) => (this._inflightAt.get(a) || 0) - (this._inflightAt.get(b) || 0)) // most-stalled first const cancels = new Map() for (const index of cands) { if (slots <= 0) break const holder = this._inflight.get(index) this._inflight.set(index, peer) this._inflightAt.set(index, now) this._peerInflight.set(peer, (this._peerInflight.get(peer) || 0) + 1) this._peerInflight.set(holder, Math.max(0, (this._peerInflight.get(holder) || 1) - 1)) if (!batches.has(peer)) batches.set(peer, []) batches.get(peer).push(index) this._hotswaps++ if (this._sendCancel) { if (!cancels.has(holder)) cancels.set(holder, []); cancels.get(holder).push(index) } slots-- } for (const [holder, indices] of cancels) { try { this._sendCancel(holder, indices) } catch {} } } } export { hashChunk } /** * FastCDC Content-Defined Chunker * * Gear rolling hash with normalized chunking (Xia et al. 2016). * Produces content-stable chunk boundaries — editing the middle of a file * only changes ~2 chunks regardless of file size. * * v2: Adaptive chunk sizing — tier selected by file size. * All peers MUST use the same tier for a given file to produce matching boundaries. */ import crypto from 'hypercore-crypto' // ── Tier 0 (default, < 1 MB) ───────────────────────────────── export const MIN_SIZE = 4096 export const AVG_SIZE = 16384 export const MAX_SIZE = 65536 // ── Adaptive chunk size tiers ───────────────────────────────── export const TIERS = [ { minSize: 4096, avgSize: 16384, maxSize: 65536 }, // Tier 0: < 1 MB { minSize: 16384, avgSize: 65536, maxSize: 262144 }, // Tier 1: 1 MB - 100 MB { minSize: 65536, avgSize: 262144, maxSize: 1048576 }, // Tier 2: 100 MB - 10 GB { minSize: 262144, avgSize: 1048576, maxSize: 4194304 } // Tier 3: > 10 GB ] const TIER_THRESHOLDS = [ 1048576, // 1 MB 104857600, // 100 MB 10737418240 // 10 GB ] /** * Select the appropriate chunk size tier for a file * @param {number} fileSize - total file size in bytes * @returns {number} tier index (0-3) */ export function selectTier (fileSize) { for (let i = 0; i < TIER_THRESHOLDS.length; i++) { if (fileSize < TIER_THRESHOLDS[i]) return i } return TIERS.length - 1 } /** * Get chunk size parameters for a tier * @param {number} tier - tier index (0-3) * @returns {{ minSize: number, avgSize: number, maxSize: number }} */ export function getTierParams (tier) { return TIERS[tier] || TIERS[0] } // Gear hash table — 256 random uint32 values // MUST be identical across all implementations for chunk boundary compatibility const GEAR = new Uint32Array([ 0x5c95c078, 0x22408989, 0x2d48a214, 0x12842087, 0x530f8afb, 0x474536b9, 0x2963b4f1, 0x44cb738b, 0x4ea7403d, 0x4d606b6e, 0x074ec5d3, 0x3af39d18, 0x726c7b74, 0x60b3f158, 0x56a76369, 0x3e8ab850, 0x0c215cf6, 0x42ad3c2f, 0x65b26fa7, 0x69a3e894, 0x2a60445d, 0x21b0f756, 0x5caca9af, 0x373b4cf0, 0x1a4a56e1, 0x5eaf1e7b, 0x7b5d5c8a, 0x48f5abf4, 0x02a42b68, 0x1f3f1a4e, 0x67e16b96, 0x404c7833, 0x6e4e3a3c, 0x4f769e04, 0x0bfef25f, 0x3f08d1ef, 0x3bee8eb5, 0x4302687c, 0x3e9e2964, 0x0fef6b59, 0x70b95d2c, 0x0cffb210, 0x2e6c3f2a, 0x6d8f0f67, 0x77a49ba2, 0x35fa6b91, 0x43d2d154, 0x5d4e6c25, 0x0e7e5283, 0x5fac3d19, 0x20e34b36, 0x46b6de87, 0x48eed852, 0x63aae4d9, 0x2c65c18b, 0x5e5bc6ad, 0x7802c749, 0x44db9a82, 0x50e76e40, 0x532dfa2b, 0x56a17be8, 0x0a81e2e7, 0x5cf2fccc, 0x3ab39d12, 0x5c0c0b78, 0x21e8af93, 0x3dca216f, 0x15b4b92e, 0x55445f9c, 0x44f24b2e, 0x2db33f38, 0x444f6ec8, 0x4eeaede8, 0x48b27a8d, 0x00b7621d, 0x3c916d41, 0x72f65778, 0x60b1a155, 0x5a946e70, 0x3ea5d857, 0x0aca0e86, 0x41b3b22e, 0x6572e2a6, 0x6aa8e89a, 0x2d496f61, 0x23b6f159, 0x5eb7e1a6, 0x312e4fea, 0x1baf6dc4, 0x5eb0f27e, 0x7a505c92, 0x49e8abf2, 0x03b12c6e, 0x1e4a7a4d, 0x64e76a98, 0x414c7c39, 0x6f4a3f38, 0x4c719e04, 0x0efef963, 0x3d08c1e9, 0x3ce88fba, 0x44026c79, 0x3e1e2469, 0x10ef6858, 0x73b55e21, 0x0dcfb614, 0x2b6d3927, 0x6c8e1066, 0x74a09bb5, 0x36fa7690, 0x44d2c158, 0x5e4f6b26, 0x0e7e5788, 0x5dad3e1c, 0x22e14a30, 0x47b6dd88, 0x4befd953, 0x64aae5d8, 0x2b65b28a, 0x5f5ac6aa, 0x7903c648, 0x43db1a89, 0x50e76f45, 0x542dfb28, 0x55a07cef, 0x0b80e3ea, 0x5ef2f9cf, 0x38b31e15, 0x5d0d0a7d, 0x22e9ae91, 0x3ecb216a, 0x16b5b82f, 0x54445e99, 0x45f34c2d, 0x2eb23e3b, 0x454e6dc9, 0x4febedef, 0x49b37a88, 0x01b66320, 0x3d926e44, 0x71f75779, 0x61b0a054, 0x5b947f71, 0x3fa4d754, 0x0bcb0f83, 0x42b4b32f, 0x6473e3a5, 0x6ba9e999, 0x2e497064, 0x24b7f05a, 0x5fb6e0a7, 0x322f5fe9, 0x1cae7ec3, 0x5db0e37f, 0x7b514d91, 0x4ae9abf3, 0x02b22d6b, 0x1f4b7b50, 0x63e66b97, 0x414d7d34, 0x6e4f3a3d, 0x4d779f05, 0x0afe0960, 0x3e09d0ee, 0x3de98ebb, 0x43036c7a, 0x3f1f2560, 0x11f06959, 0x72b65e22, 0x0dceb711, 0x2a6e3826, 0x6d8f1165, 0x75a19ab4, 0x37fb7793, 0x45d3c057, 0x5f4e6a27, 0x0f7f5684, 0x5eae3f1d, 0x23e24b31, 0x48b7de89, 0x4ceed854, 0x63abe5db, 0x2c64b38b, 0x5e5bc7ab, 0x7a04c54a, 0x44db1b88, 0x51e86e41, 0x552efb2a, 0x54a17de0, 0x0a81e3e6, 0x5df3f8ce, 0x39b41f14, 0x5e0e0b79, 0x23e8af92, 0x3fcc216e, 0x17b4b92d, 0x55456e9d, 0x46f44d2f, 0x2fb33e39, 0x464f6ec7, 0x4febe8e9, 0x49b27b8c, 0x02b7631e, 0x3e916e42, 0x73f75677, 0x62b2a256, 0x5c957e72, 0x3ea6d856, 0x0cca0f85, 0x43b4b231, 0x6574e2a7, 0x6ca9e89b, 0x2f496e62, 0x25b7f058, 0x5eb7e0a5, 0x332e4eeb, 0x1daf6ec5, 0x5eb0e27d, 0x7c515d93, 0x4be8abf1, 0x04b32d6a, 0x204b7a4e, 0x64e76b99, 0x424c7d3a, 0x704a3e3b, 0x4e789f06, 0x0bfefa62, 0x3f09d1e8, 0x3ee98fbd, 0x45036d7b, 0x401f2461, 0x12f0685a, 0x74b65f23, 0x0ecfb713, 0x2b6d3928, 0x6e901267, 0x76a29bb6, 0x38fc7892, 0x46d3c159, 0x604e6b28, 0x107e5785, 0x5fae3e1e, 0x24e24b32, 0x49b8df8a, 0x4defd955, 0x64abe6da, 0x2d65b48c, 0x605bc8ac, 0x7b05c64b, 0x45dc1c87, 0x52e96f46, 0x562ffc29, 0x55a27ee1, 0x0b82e4e5, 0x5ef3f7cd, 0x3ab42017 ]) // Precomputed masks per tier (controls cut-point frequency) // Below average: larger mask → fewer cuts → chunks grow toward average // Above average: smaller mask → more cuts → chunks stay near average const TIER_MASKS = TIERS.map(t => ({ large: (1 << Math.ceil(Math.log2(t.avgSize))) - 1, small: (1 << Math.floor(Math.log2(t.avgSize))) - 1 })) /** * Chunk a buffer using FastCDC with adaptive tier selection * * @param {Buffer} data - Data to chunk * @param {{ tier?: number }} [opts] - Options. tier: force a specific tier (0-3). If omitted, auto-selects based on data.length. * @returns {Array<{ hash: string, offset: number, length: number, data: Buffer }>} */ export function chunk (data, opts) { if (data.length === 0) return [] const tier = (opts && typeof opts.tier === 'number') ? opts.tier : selectTier(data.length) const params = TIERS[tier] || TIERS[0] const masks = TIER_MASKS[tier] || TIER_MASKS[0] const chunks = [] let offset = 0 while (offset < data.length) { const remaining = data.length - offset // If remaining data is smaller than minimum, it's the final chunk if (remaining <= params.minSize) { const slice = data.subarray(offset, offset + remaining) chunks.push({ hash: hashChunk(slice), offset, length: remaining, data: slice }) break } const maxLen = Math.min(remaining, params.maxSize) let hash = 0 let i = params.minSize // Phase 1: below average — use large mask (fewer cuts) const avgBound = Math.min(params.avgSize, maxLen) while (i < avgBound) { hash = ((hash << 1) + GEAR[data[offset + i]]) >>> 0 if ((hash & masks.large) === 0) break i++ } // Phase 2: above average — use small mask (more cuts) if (i >= avgBound) { while (i < maxLen) { hash = ((hash << 1) + GEAR[data[offset + i]]) >>> 0 if ((hash & masks.small) === 0) break i++ } } const slice = data.subarray(offset, offset + i) chunks.push({ hash: hashChunk(slice), offset, length: i, data: slice }) offset += i } return chunks } /** * Hash a chunk using blake2b-256 * @param {Buffer} data * @returns {string} hex hash */ export function hashChunk (data) { return crypto.data(data).toString('hex') } // ── Streaming primitives ────────────────────────────────────── // // `chunk(buffer)` requires the entire file in memory and returns chunks // whose `.data` is a `Buffer.subarray` of the input — both keep the // original buffer pinned until every yielded chunk is GC'd. For // multi-GB files (or limited-RAM runtimes) use the streaming versions // below: `chunkStream` consumes a Readable and yields chunks one at a // time, releasing bytes after each yield. import sodium from 'sodium-universal' import c from 'compact-encoding' const LEAF_TYPE = Buffer.from([0]) /** * Streaming blake2b-256 hasher matching `hashChunk(buffer)`'s digest * format (hypercore-crypto's `crypto.data` shape: * blake2b(LEAF_TYPE || uint64-LE(size) || data) * ). Lets you hash multi-GB files without buffering them. * * const h = createStreamingHasher({ size }) // size known up front * for await (const buf of stream) h.update(buf) * const oid = h.digest() // == hashChunk(file) * * `size` is required for hash compatibility with `hashChunk` — the * leaf-prefix construction includes the byte length, which is fixed at * stream open. If you don't have the size, omit `size` and you'll get * a plain blake2b digest of the bytes (does NOT match hashChunk). */ export function createStreamingHasher (opts = {}) { const state = Buffer.alloc(sodium.crypto_generichash_STATEBYTES) let bytes = 0 if (opts && opts.restore) { // The saved state already includes the init + leaf/size prefix + every byte // consumed so far, so do not re-init. opts.restore.state.copy(state) bytes = opts.restore.bytes } else { sodium.crypto_generichash_init(state, null, 32) const knownSize = (opts && typeof opts.size === 'number') ? opts.size : null if (knownSize !== null) { sodium.crypto_generichash_update(state, LEAF_TYPE) sodium.crypto_generichash_update(state, c.encode(c.uint64, knownSize)) } } return { update (buf) { sodium.crypto_generichash_update(state, buf) bytes += buf.length }, digest () { const out = Buffer.alloc(32) sodium.crypto_generichash_final(state, out) return out.toString('hex') }, snapshot () { return { state: Buffer.from(state), bytes } }, get bytes () { return bytes } } } // Find a FastCDC cut point inside `data` starting at offset 0. Returns // the chunk length. Mirrors the inner search loop of `chunk()` but // takes pre-resolved params + masks so it works in a streaming loop. function findCutPoint (data, params, masks) { const remaining = data.length if (remaining <= params.minSize) return remaining const maxLen = Math.min(remaining, params.maxSize) let hash = 0 let i = params.minSize const avgBound = Math.min(params.avgSize, maxLen) while (i < avgBound) { hash = ((hash << 1) + GEAR[data[i]]) >>> 0 if ((hash & masks.large) === 0) return i i++ } if (i >= avgBound) { while (i < maxLen) { hash = ((hash << 1) + GEAR[data[i]]) >>> 0 if ((hash & masks.small) === 0) return i i++ } } return maxLen } // Opt-in memcpy accounting for perf validation. Zero cost when off (one // boolean check at the increment sites). Module-level singletons — enabled // only by tests + bench/prepare.js, never in library code; NOT // concurrency-safe, so do not enable it in production. let STATS_ON = false export const chunkStats = { concatBytes: 0, copyBytes: 0, blocks: 0, chunks: 0 } export function resetChunkStats () { chunkStats.concatBytes = 0; chunkStats.copyBytes = 0; chunkStats.blocks = 0; chunkStats.chunks = 0 } export function setChunkStats (on) { STATS_ON = !!on; if (on) resetChunkStats() } /** * Stream-friendly FastCDC chunker. Consumes an AsyncIterable * (e.g. fs.createReadStream) and yields chunks one at a time. Memory * footprint ≈ 2 × params.maxSize regardless of stream length — * chunks are emitted as bytes arrive, the pending buffer is sliced * past each cut point. * * Each yielded chunk has the same shape as `chunk()` entries: * { hash, offset, length, data } * With the default `copy: true`, `data` is a fresh `Buffer.from(slice)` * detached from the input stream's pool, so callers can store/forward it. * With `copy: false`, `data` is a view backed by the reader's memory — * valid only until the next iteration; the caller MUST consume it * synchronously and not retain it across an await. * * Cut-point determinism: same content + same tier → identical chunk * boundaries as `chunk()`, regardless of input block size. Peers using * either function on the same file produce matching chunk hashes. * * @param {AsyncIterable} readable * @param {{ tier?: number, copy?: boolean }} [opts] tier index (0–3); copy * defaults true. Callers with a known file size should pass `selectTier(size)`. */ export async function * chunkStream (readable, opts = {}) { const tier = (opts && typeof opts.tier === 'number') ? opts.tier : 0 const copy = opts.copy !== false // false → yield views (see JSDoc above) const params = TIERS[tier] || TIERS[0] const masks = TIER_MASKS[tier] || TIER_MASKS[0] let pending = Buffer.alloc(0) let absoluteOffset = 0 // Single emit point for the stats accounting + copy:false decision. const emit = (slice) => { if (STATS_ON) { chunkStats.chunks++; if (copy) chunkStats.copyBytes += slice.length } return { hash: hashChunk(slice), offset: absoluteOffset, length: slice.length, data: copy ? Buffer.from(slice) : slice } } for await (const inChunk of readable) { const buf = Buffer.isBuffer(inChunk) ? inChunk : Buffer.from(inChunk) if (STATS_ON) { chunkStats.blocks++; if (pending.length !== 0) chunkStats.concatBytes += pending.length + buf.length } pending = pending.length === 0 ? buf : Buffer.concat([pending, buf]) // While we have at least maxSize ahead, we can definitively find // the next cut point inside `pending` (the cut is bounded by maxSize). while (pending.length >= params.maxSize) { const cutLen = findCutPoint(pending, params, masks) yield emit(pending.subarray(0, cutLen)) absoluteOffset += cutLen pending = pending.subarray(cutLen) } } // Stream ended. Process leftover. Same minSize-final-chunk rule as // the buffer-mode `chunk()`. while (pending.length > params.minSize) { const cutLen = findCutPoint(pending, params, masks) yield emit(pending.subarray(0, cutLen)) absoluteOffset += cutLen pending = pending.subarray(cutLen) } if (pending.length > 0) yield emit(pending) } /** * FileIndex — Metadata-only file index backed by Hyperbee * * Stores file metadata and chunk maps. Never stores file content. * The filesystem is the source of truth for actual bytes. * * Hyperbee schema: * file: → { contentHash, size, mtime, hashing, executable, linkname } * chunkmap: → [{ hash, offset, length }] (small) | { __paged: N } (large; see below) * chunkmap-oid: → [{ hash, offset, length }] (content-addressed; reused across overlay keys + restarts) * sync:: → { lastSeq, lastHash } * config:sync → { folders: [...] } * * tree: → { entries: [{kind, exec, name, childHash, size}], size } * treepath: → (secondary: path → current tree hash) * * Chunk-map paging. A chunk map for a very large file (a 1.1 TB * file at tier 3 ≈ 1M entries ≈ ~120 MB of JSON) does not fit in one Hyperbee * value: Hypercore caps a block at 15 MiB (MAX_SUGGESTED_BLOCK_SIZE) and throws * BAD_ARGUMENT above it. Maps with > CHUNKS_PER_PAGE entries are stored as a * header value { __paged: N } at the base key plus N page values keyed * `\x00` (the NUL byte never occurs in a path or hex hash, so a page key * can't collide with a real one). Small maps stay inline as a plain array — * byte-identical to before, and back-compatible with already-stored maps. The * public API (put/get/del) is unchanged; paging is transparent to callers. */ import Hyperbee from 'hyperbee' import ReadyResource from 'ready-resource' // Entries per chunk-map page. ~116 B/entry worst-case JSON ⇒ // ≤ ~3.8 MB/page, well under Hypercore's 15 MiB block limit. const CHUNKS_PER_PAGE = 32768 // Overlay-path prefix for host-registered, content-addressed serve entries. // Hosts that make a file servable purely by content hash should register it at // `${CONTENT_REGISTER_PREFIX}${contentHash}` so compact()/evictContent() can // recognize (and reclaim) the entry once the hash is no longer served. export const CONTENT_REGISTER_PREFIX = '/mir/' // The content hash an owner-side entry is addressed by (page suffix folded in), or // null for entries not keyed by a single content hash (real-path file:/chunkmap:, // tree:, sync:, config:). compact() drops the content-addressed entries whose hash is // no longer served, and keeps everything else. function contentHashOfKey (key) { if (key.startsWith('chunkmap-oid:')) return key.slice('chunkmap-oid:'.length).split('\x00')[0] if (key.startsWith('chunkmap:content:')) return key.slice('chunkmap:content:'.length).split('\x00')[0] if (key.startsWith(`chunkmap:${CONTENT_REGISTER_PREFIX}`)) return key.slice(`chunkmap:${CONTENT_REGISTER_PREFIX}`.length).split('\x00')[0] if (key.startsWith(`file:${CONTENT_REGISTER_PREFIX}`)) return key.slice(`file:${CONTENT_REGISTER_PREFIX}`.length) return null } // v1 keeps the original 'file-index' name so existing stores aren't orphaned on // upgrade; compaction moves to file-index-v2, v3, … and purges the predecessor. export function indexCoreName (version) { return version === 1 ? 'file-index' : `file-index-v${version}` } export class FileIndex extends ReadyResource { constructor (store, opts = {}) { super() this._store = store this._bee = null this._meta = null this._version = 1 this._opts = opts } // Local index cores are encrypted at rest when the caller passes an encryptionKey // (opts.encryptionKey); absent, they stay plaintext. _coreOpts (name) { const o = { name, valueEncoding: 'binary' } if (this._opts.encryptionKey) o.encryptionKey = this._opts.encryptionKey return o } async _open () { this._meta = new Hyperbee(this._store.get(this._coreOpts('index-meta')), { keyEncoding: 'utf-8', valueEncoding: 'json' }) await this._meta.ready() this._version = (await this._meta.get('version'))?.value ?? 1 // A prior purge can leave a version's core with a dangling name alias — its data and // by-discovery-key alias were deleted but the by-name alias was not — which throws // STORAGE_EMPTY on open. The index is rebuildable cache, so advance to a fresh core // name and record it rather than failing open. for (let attempts = 0; ; attempts++) { const bee = new Hyperbee(this._store.get(this._coreOpts(indexCoreName(this._version))), { keyEncoding: 'utf-8', valueEncoding: 'json' }) try { await bee.ready() this._bee = bee return } catch (err) { if (err.code !== 'STORAGE_EMPTY' || attempts >= 64) throw err await bee.close().catch(() => {}) this._version += 1 await this._meta.put('version', this._version) } } } async _close () { if (this._bee) await this._bee.close() if (this._meta) await this._meta.close() } get bee () { return this._bee } get version () { return this._version } get cores () { return [this._bee?.core, this._meta?.core].filter(Boolean) } // Reclaim the append-only index: stream the still-served entries into a fresh // versioned core, flip the version pointer, and return the old core so the caller // can clear+purge it (the only way to return an append-only bee's disk to the OS). // Content-addressed entries (maps + content-register entries) whose hash isServed() is false // are dropped; real-path, tree, sync and config entries are always kept. async compact ({ isServed }) { // Skip the rewrite entirely when nothing is droppable — otherwise a compaction of // an already-clean index just churns (a fresh version core + a version-marker // append), which grows the index without reclaiming anything. let droppable = false for await (const { key } of this._bee.createReadStream()) { const hash = contentHashOfKey(key) if (hash !== null && !isServed(hash)) { droppable = true; break } } if (!droppable) return null const next = this._version + 1 const dst = new Hyperbee(this._store.get(this._coreOpts(indexCoreName(next))), { keyEncoding: 'utf-8', valueEncoding: 'json' }) await dst.ready() let batch = dst.batch() let pending = 0 for await (const { key, value } of this._bee.createReadStream()) { const hash = contentHashOfKey(key) if (hash !== null && !isServed(hash)) continue await batch.put(key, value) if (++pending >= 500) { await batch.flush(); batch = dst.batch(); pending = 0 } } await batch.flush() const oldCore = this._bee.core await this._meta.put('version', next) this._bee = dst this._version = next return oldCore // left open; caller clears + purges it } // ── File entries ──────────────────────────────────────────── /** * Store or update a file entry (metadata only, no content) * @param {string} path - file path * @param {{ contentHash: string|null, size: number, mtime: number, hashing?: boolean, executable?: boolean, linkname?: string|null }} meta */ async putFile (path, meta) { await this._bee.put(`file:${path}`, { contentHash: meta.contentHash || null, size: meta.size, mtime: meta.mtime, hashing: meta.hashing || false, executable: meta.executable || false, linkname: meta.linkname || null }) } /** * Get file metadata * @param {string} path * @returns {{ contentHash: string|null, size: number, mtime: number, hashing: boolean, executable: boolean, linkname: string|null } | null} */ async getFile (path) { const entry = await this._bee.get(`file:${path}`) return entry ? entry.value : null } /** * Check if file exists in the index * @param {string} path * @returns {boolean} */ async hasFile (path) { const entry = await this._bee.get(`file:${path}`) return entry !== null } /** * Remove a file entry and its chunk map * @param {string} path */ async delFile (path) { await this._bee.del(`file:${path}`) await this._delPagedValue(`chunkmap:${path}`) } /** * List files under a directory prefix * @param {string} [dir=''] - directory prefix * @returns {Array<{ path: string, contentHash: string|null, size: number, mtime: number }>} */ async listFiles (dir = '') { const prefix = dir ? `file:${dir}` : 'file:' const files = [] for await (const entry of this._bee.createReadStream({ gt: prefix, lt: prefix + '\xff' })) { files.push({ path: entry.key.slice('file:'.length), ...entry.value }) } return files } // ── Index meta (from hyper-overlay 0.2.14; carried in v3) ─── // Small key/value bag on the main bee under `meta:` — used by the fast // manifest-diff boot path (e.g. hyper-deploy). compact() keeps these // (contentHashOfKey returns null for `meta:` → not droppable). async putIndexMeta (key, value) { await this._bee.put(`meta:${key}`, value) } async getIndexMeta (key) { const entry = await this._bee.get(`meta:${key}`) return entry ? entry.value : null } // ── Chunk maps ────────────────────────────────────────────── /** * Store a chunk map for a file (hash + offset + length per chunk, no data). * Large maps are paged transparently (see the header note) so they never exceed the * Hypercore block limit. * @param {string} path - file path * @param {Array<{ hash: string, offset: number, length: number }>} chunks */ async putChunkMap (path, chunks) { await this._putPagedValue(`chunkmap:${path}`, chunks) } /** * Get the chunk map for a file * @param {string} path * @returns {Array<{ hash: string, offset: number, length: number }> | null} */ async getChunkMap (path) { return this._getPagedValue(`chunkmap:${path}`) } /** * Check if a chunk map exists for a file * @param {string} path * @returns {boolean} */ async hasChunkMap (path) { const entry = await this._bee.get(`chunkmap:${path}`) return entry !== null } /** * Remove a chunk map * @param {string} path */ async delChunkMap (path) { await this._delPagedValue(`chunkmap:${path}`) } // Paged-value storage. Small maps stay inline as a plain array // (unchanged on disk, back-compatible); maps over CHUNKS_PER_PAGE entries are // split into a { __paged: N } header + N `\x00` page values, written // in one Hyperbee batch so the whole map commits atomically. Stale pages from // a previously-larger map at the same key are deleted in the same batch. async _putPagedValue (baseKey, chunks) { const prevPages = await this._pagedCount(baseKey) if (chunks.length <= CHUNKS_PER_PAGE) { if (prevPages === 0) { await this._bee.put(baseKey, chunks) return } await this._batched(async (b) => { await b.put(baseKey, chunks) for (let i = 0; i < prevPages; i++) await b.del(`${baseKey}\x00${i}`) }) return } const pageCount = Math.ceil(chunks.length / CHUNKS_PER_PAGE) await this._batched(async (b) => { await b.put(baseKey, { __paged: pageCount }) for (let i = 0; i < pageCount; i++) { await b.put(`${baseKey}\x00${i}`, chunks.slice(i * CHUNKS_PER_PAGE, (i + 1) * CHUNKS_PER_PAGE)) } for (let i = pageCount; i < prevPages; i++) await b.del(`${baseKey}\x00${i}`) }) } async _getPagedValue (baseKey) { const entry = await this._bee.get(baseKey) if (!entry) return null if (Array.isArray(entry.value)) return entry.value // inline / legacy const pageCount = entry.value.__paged if (!pageCount) return null const chunks = [] for (let i = 0; i < pageCount; i++) { const page = await this._bee.get(`${baseKey}\x00${i}`) // The header + all pages commit in one atomic batch, so a missing or non-array // page means the value is corrupt/incomplete. Return null — a clean "miss" so the // caller re-chunks from the source file — never a silently truncated chunk map. if (!page || !Array.isArray(page.value)) return null for (const c of page.value) chunks.push(c) } return chunks } async _delPagedValue (baseKey) { const prevPages = await this._pagedCount(baseKey) if (prevPages === 0) { await this._bee.del(baseKey) return } await this._batched(async (b) => { await b.del(baseKey) for (let i = 0; i < prevPages; i++) await b.del(`${baseKey}\x00${i}`) }) } // Page count of an existing paged value, or 0 if the key is absent or inline. async _pagedCount (baseKey) { const entry = await this._bee.get(baseKey) if (!entry || Array.isArray(entry.value)) return 0 return entry.value.__paged || 0 } // Run ops in a Hyperbee batch, closing it on error (flush releases the lock // itself, even on append failure, via _appendBatch's finally). async _batched (fn) { const b = this._bee.batch() try { await fn(b) await b.flush() } catch (err) { try { await b.close() } catch {} throw err } } // Content-addressed chunk map. FastCDC is deterministic on bytes, so a // given content hash always chunks identically regardless of which overlay path // it was registered under. Keying by content hash lets the publish-time chunking // be reused at serve time (a synthetic 'content:' key) and across restarts, // instead of re-reading the whole file to re-chunk it before the first byte ships. async putChunkMapByHash (contentHash, chunks) { await this._putPagedValue(`chunkmap-oid:${contentHash}`, chunks) } async getChunkMapByHash (contentHash) { return this._getPagedValue(`chunkmap-oid:${contentHash}`) } async hasChunkMapByHash (contentHash) { return (await this._bee.get(`chunkmap-oid:${contentHash}`)) !== null } async delChunkMapByHash (contentHash) { await this._delPagedValue(`chunkmap-oid:${contentHash}`) } // Evict every durable entry a served content hash leaves behind: the content- // addressed map plus the deterministic owner-side synthetic paths (the serve // copy at content: and the register entry under CONTENT_REGISTER_PREFIX). // Peer-path-keyed receiver entries are unknowable from the hash — the host's // own index sweep handles those. async evictContent (contentHash) { await this.delChunkMapByHash(contentHash) await this.delChunkMap(`content:${contentHash}`) await this.delFile(`${CONTENT_REGISTER_PREFIX}${contentHash}`) } // ── Sync state ────────────────────────────────────────────── /** * Store sync state for a peer + file * @param {string} peerKey - hex peer key * @param {string} path - file path * @param {{ lastSeq: number, lastHash: string }} state */ async putSyncState (peerKey, path, state) { await this._bee.put(`sync:${peerKey}:${path}`, { lastSeq: state.lastSeq, lastHash: state.lastHash }) } /** * Get sync state for a peer + file * @param {string} peerKey * @param {string} path * @returns {{ lastSeq: number, lastHash: string } | null} */ async getSyncState (peerKey, path) { const entry = await this._bee.get(`sync:${peerKey}:${path}`) return entry ? entry.value : null } /** * Remove sync state for a peer + file * @param {string} peerKey * @param {string} path */ async delSyncState (peerKey, path) { await this._bee.del(`sync:${peerKey}:${path}`) } /** * List all sync states for a peer * @param {string} peerKey * @returns {Array<{ path: string, lastSeq: number, lastHash: string }>} */ async listSyncStates (peerKey) { const prefix = `sync:${peerKey}:` const states = [] for await (const entry of this._bee.createReadStream({ gt: prefix, lt: prefix + '\xff' })) { states.push({ path: entry.key.slice(prefix.length), ...entry.value }) } return states } // ── Sync config ───────────────────────────────────────────── /** * Store sync configuration * @param {{ folders: Array<{ path: string, strategy: string, quota?: string|null, peers?: string[] }> }} config */ async putSyncConfig (config) { await this._bee.put('config:sync', config) } /** * Get sync configuration * @returns {{ folders: Array } | null} */ async getSyncConfig () { const entry = await this._bee.get('config:sync') return entry ? entry.value : null } // ── Trees ─────────────────────────────────────────────────── /** * Store a tree by its content-addressed hash. * Same hash put twice is a no-op (content-addressed — bytes can't differ). * * @param {string} hash - hex-encoded blake2b-256 tree hash * @param {{ entries: Array, size: number }} tree */ async putTree (hash, tree) { await this._bee.put(`tree:${hash}`, { entries: tree.entries, size: tree.size }) } /** * Get a tree by its hash. * @param {string} hash * @returns {{ entries: Array, size: number } | null} */ async getTree (hash) { const entry = await this._bee.get(`tree:${hash}`) return entry ? entry.value : null } /** * Check if a tree is present. * @param {string} hash * @returns {boolean} */ async hasTree (hash) { const entry = await this._bee.get(`tree:${hash}`) return entry !== null } /** * Remove a tree. Only safe when no treepath entries reference this hash. * @param {string} hash */ async delTree (hash) { await this._bee.del(`tree:${hash}`) } /** * Record the current tree hash for a path (secondary index). * @param {string} path * @param {string} hash */ async putTreePath (path, hash) { await this._bee.put(`treepath:${path}`, hash) } /** * Look up the current tree hash for a path. * @param {string} path * @returns {string|null} */ async getTreePath (path) { const entry = await this._bee.get(`treepath:${path}`) return entry ? entry.value : null } /** * Remove the treepath entry. Does NOT delete the underlying tree — other * paths may still reference the same hash. * @param {string} path */ async delTreePath (path) { await this._bee.del(`treepath:${path}`) } /** * List all stored tree hashes. * @param {object} [opts] * @param {number} [opts.limit] - optional cap * @returns {Array<{ hash: string, entryCount: number, size: number }>} */ async listTrees (opts = {}) { const trees = [] for await (const entry of this._bee.createReadStream({ gt: 'tree:', lt: 'tree:\xff' })) { trees.push({ hash: entry.key.slice('tree:'.length), entryCount: entry.value.entries.length, size: entry.value.size }) if (opts.limit && trees.length >= opts.limit) break } return trees } // ── Stats ─────────────────────────────────────────────────── /** * Get index statistics * @returns {{ fileCount: number, chunkMapCount: number, syncStateCount: number, treeCount: number, treePathCount: number }} */ async stats () { let fileCount = 0 let chunkMapCount = 0 let syncStateCount = 0 let treeCount = 0 let treePathCount = 0 for await (const entry of this._bee.createReadStream()) { if (entry.key.startsWith('file:')) fileCount++ // Count one per file — skip the `\x00`-suffixed page values. else if (entry.key.startsWith('chunkmap:') && !entry.key.includes('\x00')) chunkMapCount++ else if (entry.key.startsWith('sync:')) syncStateCount++ else if (entry.key.startsWith('tree:')) treeCount++ else if (entry.key.startsWith('treepath:')) treePathCount++ } return { fileCount, chunkMapCount, syncStateCount, treeCount, treePathCount } } } /** * Wire Protocol Messages for hyper-overlay/v2 * * 13 message types for sync + transfer + trees (0.5a extension): * 0-2: Sync messages (state exchange, file offers/requests) * 3-8: Transfer messages (chunk hashes, data, completion) * 9-11: Tree messages (tree-request, tree-response, content-request) * 12: transfer-control (downloader→holder pause/stop notice) * * Messages 9-12 are backward-compatible additions — peers without * this code simply don't register the corresponding protomux slots, and * senders see no receiver for those messages. File-level sync (0-8) * keeps working unchanged. * * All use compact-encoding codecs with preencode/encode/decode. */ import c from 'compact-encoding' // ── Helpers ─────────────────────────────────────────────────── function toBuffer32 (hashOrBuf) { if (Buffer.isBuffer(hashOrBuf)) return hashOrBuf return Buffer.from(hashOrBuf, 'hex') } // Encode/decode an array of { hash (32-byte hex), length (uint) } const chunkInfoArray = { preencode (state, arr) { c.uint32.preencode(state, arr.length) for (const item of arr) { state.end += 32 c.uint.preencode(state, item.length) } }, encode (state, arr) { c.uint32.encode(state, arr.length) for (const item of arr) { toBuffer32(item.hash).copy(state.buffer, state.start, 0, 32) state.start += 32 c.uint.encode(state, item.length) } }, decode (state) { const len = c.uint32.decode(state) const arr = [] for (let i = 0; i < len; i++) { const hash = state.buffer.subarray(state.start, state.start + 32).toString('hex') state.start += 32 const length = c.uint.decode(state) arr.push({ hash, length }) } return arr } } // Encode/decode an array of uints const uintArray = { preencode (state, arr) { c.uint32.preencode(state, arr.length) for (const v of arr) c.uint.preencode(state, v) }, encode (state, arr) { c.uint32.encode(state, arr.length) for (const v of arr) c.uint.encode(state, v) }, decode (state) { const len = c.uint32.decode(state) const arr = [] for (let i = 0; i < len; i++) arr.push(c.uint.decode(state)) return arr } } // ── Handshake ───────────────────────────────────────────────── export const handshake = { preencode (state, m) { c.uint8.preencode(state, m.version) c.uint8.preencode(state, m.capabilities) }, encode (state, m) { c.uint8.encode(state, m.version) c.uint8.encode(state, m.capabilities) }, decode (state) { return { version: c.uint8.decode(state), capabilities: c.uint8.decode(state) } } } // ── Sync Messages (0-2) ────────────────────────────────────── // Message 0: sync-state — exchange last-synced sequence numbers export const syncState = { preencode (state, m) { c.buffer.preencode(state, toBuffer32(m.feedKey)) c.uint.preencode(state, m.localSeq) c.uint.preencode(state, m.remoteSeq) }, encode (state, m) { c.buffer.encode(state, toBuffer32(m.feedKey)) c.uint.encode(state, m.localSeq) c.uint.encode(state, m.remoteSeq) }, decode (state) { return { feedKey: c.buffer.decode(state).toString('hex'), localSeq: c.uint.decode(state), remoteSeq: c.uint.decode(state) } } } // Message 1: file-offer — announce a file change export const fileOffer = { preencode (state, m) { c.string.preencode(state, m.path) c.buffer.preencode(state, toBuffer32(m.contentHash)) c.uint.preencode(state, m.size) c.uint.preencode(state, m.mtime) c.uint8.preencode(state, m.op) }, encode (state, m) { c.string.encode(state, m.path) c.buffer.encode(state, toBuffer32(m.contentHash)) c.uint.encode(state, m.size) c.uint.encode(state, m.mtime) c.uint8.encode(state, m.op) }, decode (state) { return { path: c.string.decode(state), contentHash: c.buffer.decode(state).toString('hex'), size: c.uint.decode(state), mtime: c.uint.decode(state), op: c.uint8.decode(state) } } } // Message 2: file-request — request a file transfer export const fileRequest = { preencode (state, m) { c.string.preencode(state, m.path) c.buffer.preencode(state, toBuffer32(m.contentHash)) c.buffer.preencode(state, m.chunksHave || Buffer.alloc(0)) }, encode (state, m) { c.string.encode(state, m.path) c.buffer.encode(state, toBuffer32(m.contentHash)) c.buffer.encode(state, m.chunksHave || Buffer.alloc(0)) }, decode (state) { return { path: c.string.decode(state), contentHash: c.buffer.decode(state).toString('hex'), chunksHave: c.buffer.decode(state) } } } // ── Transfer Messages (3-8) ────────────────────────────────── // Message 3: chunk-hashes — chunk hash list for a requested file // // `more` (paging flag) is appended last. A very large file's // chunk list serializes past the 16 MiB-1 Noise frame limit // (@hyperswarm/secret-stream MAX_ATOMIC_WRITE), so the protocol splits it into // several chunkHashes frames: every page but the last sets more:1, the final // page sets more:0. The receiver concatenates pages (in arrival order, keyed by // path) before dispatching. Appended last so a pre-paging peer that omits it // decodes more:0 — i.e. as a single, complete page (back-compatible). export const chunkHashes = { preencode (state, m) { c.string.preencode(state, m.path) c.uint8.preencode(state, m.tier) chunkInfoArray.preencode(state, m.chunks) c.uint8.preencode(state, m.more || 0) }, encode (state, m) { c.string.encode(state, m.path) c.uint8.encode(state, m.tier) chunkInfoArray.encode(state, m.chunks) c.uint8.encode(state, m.more || 0) }, decode (state) { const path = c.string.decode(state) const tier = c.uint8.decode(state) const chunks = chunkInfoArray.decode(state) // A frame from a pre-paging peer has no trailing byte → more:0. const more = state.start < state.end ? c.uint8.decode(state) : 0 return { path, tier, chunks, more } } } // Message 4: chunk-need — tell sender which chunks to send export const chunkNeed = { preencode (state, m) { c.string.preencode(state, m.path) uintArray.preencode(state, m.indices) }, encode (state, m) { c.string.encode(state, m.path) uintArray.encode(state, m.indices) }, decode (state) { return { path: c.string.decode(state), indices: uintArray.decode(state) } } } // Message 5: chunk-data — send chunk bytes export const chunkData = { preencode (state, m) { c.string.preencode(state, m.path) c.uint.preencode(state, m.index) c.buffer.preencode(state, m.data) }, encode (state, m) { c.string.encode(state, m.path) c.uint.encode(state, m.index) c.buffer.encode(state, m.data) }, decode (state) { return { path: c.string.decode(state), index: c.uint.decode(state), data: c.buffer.decode(state) } } } // Message 6: chunk-cancel — cancel a pending transfer export const chunkCancel = { preencode (state, m) { c.string.preencode(state, m.path) // P5 hotswap: optional per-chunk cancel. Appended so pre-0.3.0 peers still // decode {path} and ignore the trailing bytes; absent = whole-transfer cancel. if (m.indices && m.indices.length) c.array(c.uint).preencode(state, m.indices) }, encode (state, m) { c.string.encode(state, m.path) if (m.indices && m.indices.length) c.array(c.uint).encode(state, m.indices) }, decode (state) { const path = c.string.decode(state) // Keep the pre-0.3.0 {path} shape byte-for-byte when no indices trail, so a // whole-transfer cancel decodes identically on old and new peers. if (state.start < state.end) return { path, indices: c.array(c.uint).decode(state) } return { path } } } // Message 7: transfer-complete — confirm file fully received export const transferComplete = { preencode (state, m) { c.string.preencode(state, m.path) c.buffer.preencode(state, toBuffer32(m.contentHash)) }, encode (state, m) { c.string.encode(state, m.path) c.buffer.encode(state, toBuffer32(m.contentHash)) }, decode (state) { return { path: c.string.decode(state), contentHash: c.buffer.decode(state).toString('hex') } } } // Message 8: conflict — notify peer of a detected conflict export const conflict = { preencode (state, m) { c.string.preencode(state, m.path) c.buffer.preencode(state, toBuffer32(m.myHash)) c.buffer.preencode(state, toBuffer32(m.theirHash)) c.buffer.preencode(state, toBuffer32(m.ancestorHash || Buffer.alloc(32))) }, encode (state, m) { c.string.encode(state, m.path) c.buffer.encode(state, toBuffer32(m.myHash)) c.buffer.encode(state, toBuffer32(m.theirHash)) c.buffer.encode(state, toBuffer32(m.ancestorHash || Buffer.alloc(32))) }, decode (state) { return { path: c.string.decode(state), myHash: c.buffer.decode(state).toString('hex'), theirHash: c.buffer.decode(state).toString('hex'), ancestorHash: c.buffer.decode(state).toString('hex') } } } // ── Tree Messages (9-11) — 0.5a extension ──────────────────── // Encode/decode an array of tree entries: { kind, exec, name, childHash, size } const treeEntryArray = { preencode (state, arr) { c.uint32.preencode(state, arr.length) for (const e of arr) { c.uint8.preencode(state, e.kind) c.uint8.preencode(state, e.exec || 0) c.string.preencode(state, e.name) state.end += 32 // childHash fixed32 c.uint.preencode(state, e.size || 0) } }, encode (state, arr) { c.uint32.encode(state, arr.length) for (const e of arr) { c.uint8.encode(state, e.kind) c.uint8.encode(state, e.exec || 0) c.string.encode(state, e.name) toBuffer32(e.childHash).copy(state.buffer, state.start, 0, 32) state.start += 32 c.uint.encode(state, e.size || 0) } }, decode (state) { const len = c.uint32.decode(state) const arr = [] for (let i = 0; i < len; i++) { const kind = c.uint8.decode(state) const exec = c.uint8.decode(state) const name = c.string.decode(state) const childHash = state.buffer.subarray(state.start, state.start + 32).toString('hex') state.start += 32 const size = c.uint.decode(state) arr.push({ kind, exec, name, childHash, size }) } return arr } } // Message 9: tree-request — ask peer for a tree by its content hash // // `nonce` (per-request id) is appended last; the holder echoes it in every // treeResponse page so the requester can drop pages from a superseded attempt. // A pre-nonce peer omits it and decodes 0, which the requester treats as // "unverifiable". export const treeRequest = { preencode (state, m) { c.buffer.preencode(state, toBuffer32(m.hash)) c.uint.preencode(state, m.nonce || 0) }, encode (state, m) { c.buffer.encode(state, toBuffer32(m.hash)) c.uint.encode(state, m.nonce || 0) }, decode (state) { const hash = c.buffer.decode(state).toString('hex') const nonce = state.start < state.end ? c.uint.decode(state) : 0 return { hash, nonce } } } // Message 10: tree-response — return a tree's entries to the requester // // `more` (paging flag) mirrors chunkHashes: a tree too large for one 16 MiB-1 // Noise frame is split into several frames, every page but the last more:1. // `nonce` echoes the requester's per-request id so pages from a superseded // attempt are dropped. Both are appended last; a pre-paging peer omits them and // decodes 0. export const treeResponse = { preencode (state, m) { c.buffer.preencode(state, toBuffer32(m.hash)) treeEntryArray.preencode(state, m.entries) c.uint8.preencode(state, m.more || 0) c.uint.preencode(state, m.nonce || 0) }, encode (state, m) { c.buffer.encode(state, toBuffer32(m.hash)) treeEntryArray.encode(state, m.entries) c.uint8.encode(state, m.more || 0) c.uint.encode(state, m.nonce || 0) }, decode (state) { const hash = c.buffer.decode(state).toString('hex') const entries = treeEntryArray.decode(state) const more = state.start < state.end ? c.uint8.decode(state) : 0 const nonce = state.start < state.end ? c.uint.decode(state) : 0 return { hash, entries, more, nonce } } } // Message 11: content-request — fetch a file by its content hash (not path) // Sender locates any local file matching the hash and serves its chunks. // `from` carries the requester's profile-key (hex) so the // holder's serveAuthorizer can authenticate the asker. Appended last → an // overlay peer that predates this field decodes '' (empty), never crashes. export const contentRequest = { preencode (state, m) { c.buffer.preencode(state, toBuffer32(m.contentHash)) c.buffer.preencode(state, m.chunksHave || Buffer.alloc(0)) c.string.preencode(state, m.from || '') }, encode (state, m) { c.buffer.encode(state, toBuffer32(m.contentHash)) c.buffer.encode(state, m.chunksHave || Buffer.alloc(0)) c.string.encode(state, m.from || '') }, decode (state) { return { contentHash: c.buffer.decode(state).toString('hex'), chunksHave: c.buffer.decode(state), from: c.string.decode(state) } } } // Message 12: transfer-control — downloader→holder pause/stop notice for a // content-addressed fetch. state: 0 = paused, 1 = stopped. Appended last so a // holder that predates this never registers slot 12 and silently ignores it. export const transferControl = { preencode (state, m) { c.buffer.preencode(state, toBuffer32(m.contentHash)) c.uint8.preencode(state, m.state) }, encode (state, m) { c.buffer.encode(state, toBuffer32(m.contentHash)) c.uint8.encode(state, m.state) }, decode (state) { return { contentHash: c.buffer.decode(state).toString('hex'), state: c.uint8.decode(state) } } } // Message 13: transfer-progress — downloader→holder one-shot have-baseline for a // resumed content-addressed fetch. `have` = bytes the downloader already holds on // disk at resume, so the holder's "who is downloading" bar reflects the downloader's // TRUE completion, not only the bytes it re-serves. Appended last so a holder that // predates this never registers slot 13 and silently ignores it. export const transferProgress = { preencode (state, m) { c.buffer.preencode(state, toBuffer32(m.contentHash)) c.uint.preencode(state, m.have || 0) }, encode (state, m) { c.buffer.encode(state, toBuffer32(m.contentHash)) c.uint.encode(state, m.have || 0) }, decode (state) { return { contentHash: c.buffer.decode(state).toString('hex'), have: c.uint.decode(state) } } } /** * OverlayProtocol — Protomux channel for sync + transfer * * Sync approach: each side sends its local feed entries directly via * file-offer messages. No Hypercore feed replication needed — the feed * entries are small JSON objects sent over our own Protomux channel. * * Flow: * 1. Channel opens → both send sync-state (feed length) * 2. Side with more entries sends file-offers for each change * 3. Receiver auto-requests files it doesn't have * 4. Sender chunks on demand → streams chunks → receiver writes to disk */ import path from 'bare-path' import * as messages from './messages.js' import { hashChunk, selectTier } from './chunker.js' import { ChunkScheduler } from './chunk-scheduler.js' import fs from 'bare-fs' const PROTOCOL = 'hyper-overlay/v2' const VERSION = 2 const CAP_LOCAL_FILES = 0x01 const CAP_ADAPTIVE_CHUNKS = 0x02 // A file's chunk list, shipped in one frame, can exceed the // 16 MiB-1 Noise transport limit (@hyperswarm/secret-stream MAX_ATOMIC_WRITE): // a 1.25 TB file at tier 3 is ~1.2M entries ≈ ~44 MB, which the secret-stream // rejects ("Message is too large for an atomic write"), dropping the connection // before a byte ships. So chunkHashes is paged into frames of ≤ this many // entries. Each wire entry is 32 B (hash) + ≤5 B (varint length) ≈ 37 B, so // 100k entries ≈ 3.7 MB/frame — well under the limit even after Protomux's // ≤8 MiB send-batching. const MAX_CHUNKS_PER_MSG = 100000 // F2: hard ceiling on chunk-hash entries accumulated across a paged chunkHashes // stream. Far above any real file's chunk count (a 1.25 TB tier-3 file is ~1.2M // entries), so it never trips legitimately — but it bounds an authorized-but-rogue // seeder that streams `more:1` pages forever (each buffered page re-arms the idle // watchdog, so the stall timer never fires). Unlike treeResponse, chunkHashes had // no such cap. ~16M entries ≈ a few hundred MB worst case before we drop the list. const MAX_CHUNK_HASHES_ACCUM = 16 * 1024 * 1024 // Tree entries are variable length (name is a var-string), unlike the fixed-width // chunkHashes entries, so treeResponse pages by an encoded-byte budget rather than // a fixed count. 4 MiB keeps each frame well under the atomic-write limit even // after Protomux's ≤8 MiB send-batching. const MAX_TREE_BYTES_PER_MSG = 4 * 1024 * 1024 // Defensive ceiling on the bytes a requester will accumulate across a paged // treeResponse. A single-directory tree is orders of magnitude smaller; this only // bounds memory so a peer streaming pages endlessly rejects the request instead // of OOMing. const MAX_TREE_RESPONSE_BYTES = 256 * 1024 * 1024 // transfer-control (message 12) states, downloader→holder. const CONTROL_PAUSED = 0 const CONTROL_STOPPED = 1 // Abandon a serve loop whose stream neither drains nor closes within // this window (a wedged-but-TCP-alive peer); the receiver re-requests, so it self-heals. const DRAIN_TIMEOUT_MS = 60000 export class OverlayProtocol { constructor (syncEngine, transferManager, opts = {}) { this._syncEngine = syncEngine this._transferManager = transferManager this._corestore = opts.corestore || null this._overlayKey = opts.key || null this._peers = new Map() // Muxes we've registered a pair() callback on, so we register exactly one per mux. See attach(). this._paired = new Set() this._filePaths = opts.filePaths || new Map() this._syncBaseDirs = opts.syncBaseDirs || [] this._defaultStrategy = opts.defaultStrategy || 'prompt' this._autoSync = opts.autoSync !== false this._conflictCb = opts.onConflict || null this._syncedCb = opts.onSynced || null this._fileOfferCb = opts.onFileOffer || null // Called for every chunk that arrives on this peer. Lets callers // (e.g. NetworkFetcher) implement silent-peer watchdogs by resetting // an idle timer on every chunk. Receives { path, index, bytes, peer }. this._chunkProgressCb = opts.onChunkProgress || null // serve-side telemetry, symmetric to onChunkProgress — fired when WE // serve a peer (the sender-side download indicator). onServeStart({ path, peer, // from, total }) once a peer is authorized to fetch; onChunkServe({ path, peer, // from, bytes }) per served chunk; onServeEnd({ path, peer, from }) on close. this._serveStartCb = opts.onServeStart || null this._chunkServeCb = opts.onChunkServe || null this._serveEndCb = opts.onServeEnd || null // A downloader paused/stopped a hash WE serve. { path, peer, from, state }. this._serveControlCb = opts.onServeControl || null // A downloader reported its on-disk have-bytes for a hash WE serve (resume // baseline). { path, peer, from, have }. this._serveProgressCb = opts.onServeProgress || null // 0.5a: content-hash → local disk path, for responding to content-requests this._contentHashPaths = opts.contentHashPaths || new Map() // 0.5a: tree-request timeout (ms) this._treeRequestTimeout = opts.treeRequestTimeout || 30000 // Cap on bytes accumulated across a paged treeResponse. this._maxTreeResponseBytes = opts.maxTreeResponseBytes || MAX_TREE_RESPONSE_BYTES // Multi-source: synthetic path 'content:' → ChunkScheduler. When set, // _onChunkHashes/_onChunkData delegate to the scheduler (parallel fetch // across peers) instead of the legacy single-peer auto-flow. this._schedulers = new Map() // 'content:' cancelled before its scheduler existed (the caller's // peer-wait window) — fetchContent honors it the moment it creates the scheduler. this._cancelPending = new Set() // serve authorization. _serveAuthorizer(peer, from, hash) → // boolean gates every inbound content-request; deny is a silent drop // (indistinguishable from "I don't hold it" — no membership oracle). // _localProfileKey is stamped on outbound content-requests as msg.from. this._serveAuthorizer = opts.serveAuthorizer || null this._localProfileKey = opts.localProfileKey || null } /** * Multi-source fetch of a file by content hash from several peers in * parallel (torrent-style). The caller pre-registers _filePaths['content:' * + contentHash] = destPath. Resolves when the file is assembled + verified. * * @param {string} contentHash * @param {Array} peers peer objects to fan the request to * @param {object} [opts] { destPath, cap, timeout, onProgress } * @returns {Promise} */ fetchContent (contentHash, peers, opts = {}) { const p = 'content:' + contentHash // Content-addressed dedup: a concurrent fetch of the SAME hash (a // different file/transfer with identical bytes) joins the in-flight one instead // of failing — await its verified bytes, then copy to our destPath. If the leader // was cancelled, re-issue our own fetch (the scheduler entry is already gone). const inflight = this._schedulers.get(p) if (inflight) { return inflight.shared.then( (res) => { if (opts.destPath && opts.destPath !== inflight.destPath) { try { fs.copyFileSync(inflight.destPath, opts.destPath) } catch (err) { // The leader's shared temp is already gone — the leader's caller // (e.g. pgh NetworkFetcher) unlinks its destPath as soon as it has // read+verified the bytes, which can race ahead of this joiner's // copy. Re-issue our own fetch, mirroring the ECANCELLED path. if (err?.code === 'ENOENT') return this.fetchContent(contentHash, peers, opts) throw err } } return res }, (err) => { if (err?.code === 'ECANCELLED') return this.fetchContent(contentHash, peers, opts); throw err }, ) } const sched = new ChunkScheduler({ path: p, destPath: opts.destPath, transfer: this._transferManager, sendNeed: (peer, indices) => peer.msgs.chunkNeed.send({ path: p, indices }), // P5 hotswap: best-effort tell a slow peer to stop serving reassigned chunks. sendCancel: (peer, indices) => { try { peer.msgs.chunkCancel.send({ path: p, indices }) } catch {} }, cap: opts.cap, timeout: opts.timeout, onProgress: opts.onProgress, onVerify: opts.onVerify, onEnd: opts.onEnd, onBaseline: (have) => this.sendTransferProgress(contentHash, have), contentHash // verify the whole-file hash incrementally during the transfer }) this._schedulers.set(p, sched) // shared promise so joiners (above) can await the same completion — // calling sched.promise() twice would overwrite its resolve/reject handlers. sched.shared = sched.promise().finally(() => { this._schedulers.delete(p) // F2: drop any half-accumulated paged chunk list for this path across peers, so a // same-key retry (content: reused after a cancel mid-paging) can't append // fresh pages onto a stale partial list. for (const pr of this._peers.values()) if (pr._chunkHashPages) pr._chunkHashPages.delete(p) }) // honor a cancel/pause that arrived before this scheduler existed. if (this._cancelPending.delete(p)) { sched.cancel(); return sched.shared } for (const peer of peers) this.requestContent(peer, contentHash, null) return sched.shared } // Stop an in-flight multi-source fetch. discardPartial:true unlinks the // partial (cancel); false keeps it for resume (pause). The scheduler's promise // rejects with ECANCELLED and its .finally() removes it from _schedulers. When no // scheduler exists yet (the caller is still in its peer-wait window), remember the // intent so fetchContent cancels the scheduler the instant it is created. async cancelContent (contentHash, { discardPartial = false, signal = true } = {}) { const p = 'content:' + contentHash const sched = this._schedulers.get(p) // No scheduler → the fetch never sent a content-request, so no holder has a serve // row for us; skip the (wasted) broadcast and just record the pre-scheduler cancel. if (!sched) { this._cancelPending.add(p); return false } // Tell holders we paused (keep partial) or stopped (discard) BEFORE local teardown, // so their sender-side indicator reacts now, not after the idle sweep. signal:false // suppresses it (a supersede is a restart, not a user stop). if (signal) this._sendTransferControl(contentHash, discardPartial ? CONTROL_STOPPED : CONTROL_PAUSED) // Stop accepting chunks first so the pause hash-drain converges on a stable frontier. sched.cancel() if (discardPartial) this._transferManager.cancel(sched.destPath) else await this._transferManager.pause(sched.destPath) return true } // Tell holders we stopped pulling a hash whose local fetch is already gone (e.g. // discarding an already-paused transfer) — no scheduler to tear down here. sendStopControl (contentHash) { this._sendTransferControl(contentHash, CONTROL_STOPPED) } // Best-effort broadcast to all connected holders. A holder with no serve-ledger entry // for us (or no slot for this message) just drops it; wrapped per-peer so a closing // channel or an old peer can't throw. _broadcast (msgName, payload) { for (const [, peer] of this._peers) { try { peer.msgs[msgName]?.send(payload) } catch {} } } _sendTransferControl (contentHash, state) { this._broadcast('transferControl', { contentHash, state }) } // Tell holders our current on-disk have-bytes for a hash we're (re)fetching, so their // sender-side bar mirrors our TRUE progress rather than only the bytes they re-serve. sendTransferProgress (contentHash, have) { this._broadcast('transferProgress', { contentHash, have }) } // Drop a cancel recorded before a scheduler existed when the fetch is // abandoned without ever reaching fetchContent (no peer connected) — otherwise the // marker would cancel the next fetch of the same content. clearCancelPending (contentHash) { this._cancelPending.delete('content:' + contentHash) } setContentHashPaths (map) { this._contentHashPaths = map } attach (mux) { if (this._peers.has(mux)) return this._peers.get(mux) const self = this // Attach used to be ONE-SHOT and order-sensitive, which silently killed byte transfer for the life // of a connection. If the remote has no matching (protocol, id) channel at the moment we attach — // it hasn't booted this DID's overlay yet, or is mid-restart — protomux tears our channel down, // onclose drops the peer, and NOTHING ever re-created it. The remote attaching a second later did // not help: `createChannel` then returns null ("the remote has already closed this one") and there // was no path back. Meanwhile the connection stays perfectly healthy for everything else, so // corestore keeps replicating and the pointers keep converging while the BYTES never move again — // which is precisely the fault seen in production (overlayPeers:0, forever, on a live connection). // // mux.pair() is protomux's mechanism for exactly this race: it fires whenever the remote REQUESTS // this (protocol, id), so a late or restarted peer gets a channel created on demand. Registered // once per mux, and left registered after a close so re-pairing keeps working for the connection's // whole life. if (!this._paired.has(mux)) { this._paired.add(mux) try { mux.pair({ protocol: PROTOCOL, id: this._overlayKey || null }, () => { try { self.attach(mux) } catch {} }) } catch { this._paired.delete(mux) } } const channel = mux.createChannel({ protocol: PROTOCOL, id: this._overlayKey || null, onopen () { const peer = self._peers.get(mux) if (peer) self._onOpen(peer) }, onclose () { const peer = self._peers.get(mux) self._peers.delete(mux) // Failover: let any active multi-source fetch reassign this peer's // inflight chunks to the remaining peers. if (peer) for (const sched of self._schedulers.values()) sched.removePeer(peer) // Fail in-flight tree requests now, so a mid-stream disconnect rejects // promptly instead of stranding the request (and its buffered pages) // until the idle timeout fires. if (peer) self._failPendingTrees(peer, new Error('channel closed')) // tell the sender-side indicator this peer is gone for every file // it was pulling, so a disconnect mid-download clears its row promptly. if (peer && self._serveEndCb) { for (const [synthPath, from] of peer.authorizedServe) { try { self._serveEndCb({ path: synthPath, peer, from }) } catch {} } } } }) if (!channel) return null // protomux returns null for a duplicate channel, or one the remote has already closed. Before the // pair() registration above this could not be recovered from; now the pair callback will re-drive // attach() when the remote asks again, so returning cleanly here is the correct behaviour. It also // stops a null-deref on the addMessage calls below, which the consumer's try/catch would have // swallowed into a silent "this DID has no byte transfer". if (!channel) return null const peer = { mux, channel, remoteFeedKey: null, remoteSeq: 0, msgs: {}, pendingTrees: new Map(), // hash → { resolve, reject, timer, timeout, nonce, pages, pageBytes } // synthetic serve-paths this peer was authorized for via a // GATED _onContentRequest, mapped to the requester profileKey (msg.from). // _onChunkNeed serves bytes only for paths in here, so a peer cannot pull // bytes by sending chunkNeed/fileRequest directly for a registered path it // was never authorized to fetch; the value flows the requester identity to // the serve telemetry. authorizedServe: new Map() } peer.msgs.syncState = channel.addMessage({ encoding: messages.syncState, onmessage: (msg) => self._onSyncState(peer, msg) }) peer.msgs.fileOffer = channel.addMessage({ encoding: messages.fileOffer, onmessage: (msg) => self._onFileOffer(peer, msg) }) peer.msgs.fileRequest = channel.addMessage({ encoding: messages.fileRequest, onmessage: (msg) => self._onFileRequest(peer, msg) }) peer.msgs.chunkHashes = channel.addMessage({ encoding: messages.chunkHashes, onmessage: (msg) => self._onChunkHashes(peer, msg) }) peer.msgs.chunkNeed = channel.addMessage({ encoding: messages.chunkNeed, onmessage: (msg) => self._onChunkNeed(peer, msg) }) peer.msgs.chunkData = channel.addMessage({ encoding: messages.chunkData, onmessage: (msg) => self._onChunkData(peer, msg) }) peer.msgs.chunkCancel = channel.addMessage({ encoding: messages.chunkCancel, onmessage: (msg) => self._onChunkCancel(peer, msg) }) peer.msgs.transferComplete = channel.addMessage({ encoding: messages.transferComplete, onmessage: (msg) => self._onTransferComplete(peer, msg) }) peer.msgs.conflict = channel.addMessage({ encoding: messages.conflict, onmessage: (msg) => self._onConflictMsg(peer, msg) }) // 0.5a — tree messages (backward-compatible additions) peer.msgs.treeRequest = channel.addMessage({ encoding: messages.treeRequest, onmessage: (msg) => self._onTreeRequest(peer, msg) }) peer.msgs.treeResponse = channel.addMessage({ encoding: messages.treeResponse, onmessage: (msg) => self._onTreeResponse(peer, msg) }) peer.msgs.contentRequest = channel.addMessage({ encoding: messages.contentRequest, onmessage: (msg) => self._onContentRequest(peer, msg) }) // Appended-last slots: ids 0-11 stay fixed for peers without 12/13, which just // never register these channels and ignore the frames. peer.msgs.transferControl = channel.addMessage({ encoding: messages.transferControl, onmessage: (msg) => self._onTransferControl(peer, msg) }) peer.msgs.transferProgress = channel.addMessage({ encoding: messages.transferProgress, onmessage: (msg) => self._onTransferProgress(peer, msg) }) this._peers.set(mux, peer) channel.open({ version: VERSION, capabilities: CAP_LOCAL_FILES | CAP_ADAPTIVE_CHUNKS }) return peer } // Explicit teardown — unlike an incidental channel close (where the pair callback must SURVIVE so a // returning peer can re-pair), detach means we are done with this mux, so drop the pairing too. detach (mux) { if (this._paired.delete(mux)) { try { mux.unpair({ protocol: PROTOCOL, id: this._overlayKey || null }) } catch {} } const peer = this._peers.get(mux) if (!peer) return peer.channel.close() this._peers.delete(mux) } setFilePaths (map) { this._filePaths = map } broadcastOffer (overlayPath, meta, op) { const msg = { path: overlayPath, contentHash: meta.contentHash || '0'.repeat(64), size: meta.size || 0, mtime: meta.mtime || 0, op } for (const [, peer] of this._peers) { peer.msgs.fileOffer.send(msg) } } requestFile (peer, overlayPath, contentHash, chunksHave) { peer.msgs.fileRequest.send({ path: overlayPath, contentHash, chunksHave: chunksHave || null }) } /** * 0.5a: Request a tree by its hash. Returns a promise resolving to * the entries array (or [] if the peer doesn't have it). * * @param {object} peer * @param {string} hash - hex tree hash * @param {object} [opts] * @param {number} [opts.timeout] - override default timeout (ms) * @returns {Promise>} */ requestTree (peer, hash, opts = {}) { return new Promise((resolve, reject) => { // If a prior request is already in-flight for the same hash, reject // this caller rather than silently overwrite. if (peer.pendingTrees.has(hash)) { return reject(new Error('tree request already pending for hash: ' + hash)) } // Per-request nonce (per-peer monotonic, non-zero) lets the requester drop // pages echoed for a superseded attempt. pages/pageBytes buffer this // request's own paged response, so a fresh attempt never inherits an old one. const nonce = peer._treeReqSeq = (peer._treeReqSeq || 0) + 1 const timeout = opts.timeout || this._treeRequestTimeout const pending = { resolve, reject, timer: null, timeout, nonce, pages: null, pageBytes: 0 } this._armTreeTimeout(peer, hash, pending) peer.pendingTrees.set(hash, pending) peer.msgs.treeRequest.send({ hash, nonce }) }) } // Arm (or re-arm) a pending tree request's idle timeout. Every buffered page // re-arms it (a large tree on a slow link mustn't time out mid-stream); the // request still settles because the accumulator is byte-capped in _onTreeResponse. _armTreeTimeout (peer, hash, pending) { pending.timer = setTimeout(() => { if (peer.pendingTrees.get(hash) === pending) { peer.pendingTrees.delete(hash) pending.reject(new Error('tree request timed out: ' + hash)) } }, pending.timeout) } // Reject every in-flight tree request on this peer (channel close / destroy), // clearing timers so the promise fails promptly and its buffered pages release. _failPendingTrees (peer, err) { for (const [hash, pending] of peer.pendingTrees) { clearTimeout(pending.timer) peer.pendingTrees.delete(hash) pending.reject(err) } } /** * 0.5a: Request a file by its content hash. Peer looks up any file * matching that hash locally and streams chunks via the existing flow * (chunkHashes → chunkNeed → chunkData). Returns immediately; chunks * arrive asynchronously. * * Note: receiver must pre-register a target path mapping via * _filePaths keyed by the contentHash before calling, OR this method * is a no-op on the receive side. Full wiring deferred to 0.5c. */ requestContent (peer, contentHash, chunksHave) { peer.msgs.contentRequest.send({ contentHash, chunksHave: chunksHave || null, from: this._localProfileKey || '' // authenticate the asker to the serve gate }) } get peerCount () { return this._peers.size } destroy () { for (const [, peer] of this._peers) { this._failPendingTrees(peer, new Error('protocol destroyed')) peer.channel.close() } this._peers.clear() } // ── Handlers ──────────────────────────────────────────────── _onOpen (peer) { peer.msgs.syncState.send({ feedKey: this._syncEngine.feedKey, localSeq: this._syncEngine.feed.length, remoteSeq: 0 }) } async _onSyncState (peer, msg) { peer.remoteFeedKey = msg.feedKey peer.remoteSeq = msg.localSeq if (!this._autoSync) return try { await this._offerLocalFiles(peer) } catch { // ignore — the HyperOverlay facade runs with autoSync off, so this path is dormant } } async _onFileOffer (peer, msg) { // In gated mode the overlay flow is contentRequest→scheduler ONLY; gated // consumers never act on path-based file-offers (autoSync is off). Ignoring // them closes the offer→requestFile→legacy-receive path a peer could drive. if (this._serveAuthorizer) return if (this._fileOfferCb) this._fileOfferCb(peer, msg) if (msg.op === 0) { const local = await this._syncEngine._fileIndex.getFile(msg.path) if (!local || local.contentHash !== msg.contentHash) { const diskPath = this._resolveFilePath(msg.path) if (diskPath) { this._filePaths.set(msg.path, diskPath) this.requestFile(peer, msg.path, msg.contentHash) } } } } async _onFileRequest (peer, msg) { // path-based serve is UNGATED and would bypass the serve gate (the only // gated entry point is _onContentRequest). Gated consumers never send // fileRequest, so refuse it outright in gated mode. if (this._serveAuthorizer) return const diskPath = this._filePaths.get(msg.path) if (!diskPath) return const prepared = await this._transferManager.prepareFile(diskPath, msg.path) if (!prepared) return if (!await this._transferManager._fileIndex.hasChunkMap(msg.path)) { await this._transferManager._fileIndex.putChunkMap(msg.path, prepared.chunks) } this._sendChunkHashes(peer, msg.path, prepared.tier, prepared.chunks) } // Send a file's chunk list, paged so no single frame exceeds // the Noise transport's 16 MiB-1 atomic-write limit. A list that fits in one // frame ships as one (more:0) — identical on the wire to the pre-paging format // bar a trailing 0 byte. _onChunkHashes reassembles the pages on the receiver. _sendChunkHashes (peer, filePath, tier, chunks) { const total = chunks.length if (total <= MAX_CHUNKS_PER_MSG) { peer.msgs.chunkHashes.send({ path: filePath, tier, chunks, more: 0 }) return } for (let i = 0; i < total; i += MAX_CHUNKS_PER_MSG) { const more = i + MAX_CHUNKS_PER_MSG < total ? 1 : 0 peer.msgs.chunkHashes.send({ path: filePath, tier, chunks: chunks.slice(i, i + MAX_CHUNKS_PER_MSG), more }) } } // Reassemble a paged chunk list. Returns the full list once // the final page (more:0) arrives, or null while pages are still pending. A // lone complete frame passes straight through (no copy) — the small-file norm. // Pages for a path arrive in order on this channel, so arrival-order // concatenation is correct even when several files interleave on it. _reassembleChunkHashes (peer, msg) { const buffered = peer._chunkHashPages && peer._chunkHashPages.get(msg.path) if (!buffered && !msg.more) return msg.chunks if (!peer._chunkHashPages) peer._chunkHashPages = new Map() let acc = buffered if (!acc) { acc = []; peer._chunkHashPages.set(msg.path, acc) } for (const ch of msg.chunks) acc.push(ch) if (acc.length > MAX_CHUNK_HASHES_ACCUM) { // F2: drop an over-long accumulator (adversarial more:1 flood) instead of // OOMing — the fetch fails and the scheduler retries/fails over to another peer. peer._chunkHashPages.delete(msg.path) return null } if (msg.more) return null peer._chunkHashPages.delete(msg.path) return acc } // Upper-bound wire size of one tree entry: kind(1)+exec(1) + string(len-prefix ≤4 // + utf8 name bytes) + childHash(32) + size varint(≤9, c.uint is 9 bytes for a // >4 GiB size). _treeEntryWireSize (e) { return 1 + 1 + 4 + Buffer.byteLength(e.name || '', 'utf8') + 32 + 9 } // Send a tree's entries, paged so no single frame exceeds the Noise atomic-write // limit; every page but the last is more:1. A tree that fits in one frame ships // as a single more:0 frame. `nonce` echoes the requester's per-request id. _sendTreeResponse (peer, hash, entries, nonce) { let page = [] let bytes = 40 // hash(32) + uint32 count prefix + more/nonce + slack for (const e of entries) { const sz = this._treeEntryWireSize(e) if (page.length && bytes + sz > MAX_TREE_BYTES_PER_MSG) { peer.msgs.treeResponse.send({ hash, entries: page, more: 1, nonce }) page = [] bytes = 40 } page.push(e) bytes += sz } peer.msgs.treeResponse.send({ hash, entries: page, more: 0, nonce }) } async _onChunkHashes (peer, msg) { // Reassemble paged chunkHashes frames before dispatching. const chunks = this._reassembleChunkHashes(peer, msg) if (chunks === null) { // A buffered page is forward progress — keep the scheduler's no-progress // watchdog from tripping while a large map streams across several frames. const pending = this._schedulers.get(msg.path) if (pending && pending.notePageProgress) pending.notePageProgress() return } // Multi-source: if a scheduler owns this path, let it distribute chunk // requests across peers instead of the legacy single-peer auto-flow. const sched = this._schedulers.get(msg.path) if (sched) { Promise.resolve(sched.onChunkHashes(peer, chunks)).catch(() => {}); return } // the legacy single-peer receive below writes incoming bytes // to _filePaths.get(path) and finalizes a rename OVER it. For a path that // maps to one of OUR own files (e.g. a content-register entry), an // unsolicited chunkHashes would let a peer overwrite the owner's source // file. Gated consumers only ever receive via a scheduler (the branch // above), so refuse any other receive. if (this._serveAuthorizer) return const diskPath = this._filePaths.get(msg.path) if (!diskPath) return // Empty-file fast path: a 0-byte file has no chunks to fetch, but we // still need to materialize it on disk and fire the same completion // flow as _onChunkData's "transfer complete" branch — otherwise the // requester (e.g. NetworkFetcher.getContent) never resolves and times // out. Empty files are common in practice: .keep, __init__.py, build // stamps, touch'd markers. Bug symptom before this: node-gyp's // postinstall.stamp (0 bytes, hash 5187b7a8…) hung every install. if (chunks.length === 0) { try { fs.mkdirSync(path.dirname(diskPath), { recursive: true }) fs.writeFileSync(diskPath, Buffer.alloc(0)) } catch { return } const contentHash = hashChunk(Buffer.alloc(0)) const stat = fs.statSync(diskPath) await this._syncEngine._fileIndex.putFile(msg.path, { contentHash, size: 0, mtime: stat.mtimeMs }) await this._syncEngine.logPut(msg.path, { contentHash, size: 0, mtime: stat.mtimeMs }) if (peer.remoteFeedKey) { await this._syncEngine.markSynced(peer.remoteFeedKey, msg.path, contentHash, this._syncEngine.feed.length - 1) } peer.msgs.transferComplete.send({ path: msg.path, contentHash }) if (this._syncedCb) { this._syncedCb({ path: msg.path, contentHash, size: 0, direction: 'pull' }) } return } const needed = this._transferManager.computeNeeded(chunks, new Set()) if (needed.length === 0) return let size = 0 for (const c of chunks) size += c.length // startReceive can throw (fd open, partial recovery) — drop this transfer // instead of rejecting protomux's onmessage promise, which would destroy the // whole Noise stream. try { await this._transferManager.startReceive(diskPath, { size, chunks: chunks.map((c, i) => { let offset = 0 for (let j = 0; j < i; j++) offset += chunks[j].length return { hash: c.hash, offset, length: c.length } }) }) } catch { return } peer.msgs.chunkNeed.send({ path: msg.path, indices: needed }) } async _onChunkNeed (peer, msg) { // Serve bytes ONLY for a synthetic path THIS peer was // authorized for via a gated _onContentRequest. Blocks a peer pulling bytes // by sending chunkNeed directly for a registered path (e.g. a content- // register entry) without passing the serve gate. if (this._serveAuthorizer && !peer.authorizedServe.has(msg.path)) return const diskPath = this._filePaths.get(msg.path) if (!diskPath) return const fileIndex = this._transferManager._fileIndex let chunkMap try { chunkMap = msg.path.startsWith('content:') ? await fileIndex.getChunkMapByHash(msg.path.slice('content:'.length)) : await fileIndex.getChunkMap(msg.path) } catch { // A chunk-map lookup that rejects (index I/O error) must not escape: the // onmessage dispatch is fire-and-forget, so a throw here becomes an // unhandled rejection that tears down the whole Noise/replication stream // (the S1 malformed-frame hardening theme). Drop the request — the receiver // re-requests and the transfer self-heals. return } if (!chunkMap) return // Single-flight serve pump per peer (mirrors hypercore's `receiverBusy`). // Enqueue this request; if no pump is running for this peer, drain the queue // one job at a time. protomux dispatches every frame of a socket read // synchronously, so two chunkNeed frames from the same peer would otherwise // start rival serve loops — interleaving sends and admitting N chunks per // drain instead of honouring backpressure once (the discipline our 0.2.13 // serialized pump had, which Ok's inline loop dropped). if (!peer._serveQueue) peer._serveQueue = [] peer._serveQueue.push({ path: msg.path, diskPath, chunkMap, indices: msg.indices }) if (peer._serving) return peer._serving = true // Kick the pump fire-and-forget: _onChunkNeed is the onmessage dispatch and // must return promptly, NOT stay pending for the whole multi-chunk serve // (which, under backpressure, spans the entire transfer). A second chunkNeed // from this peer just enqueues above; the single-flight guard (_serving) means // this already-running pump picks it up. This is our 0.2.13 contract — Ok's // inline drain loop awaited the whole serve, which the unit test rejects. this._drainServeQueue(peer) } // The per-peer single-flight serve pump. Drains _serveQueue one job at a time; // detached from _onChunkNeed so the message handler returns immediately. async _drainServeQueue (peer) { try { while (peer._serveQueue.length) { if (peer.channel && peer.channel.closed) { peer._serveQueue.length = 0; break } try { await this._serveJob(peer, peer._serveQueue.shift()) } catch {} } } finally { peer._serving = false } } // Serve one chunkNeed job: stream the requested chunk indices, honouring // stream backpressure — stop producing when send() reports the write buffer is // full and resume on drain, so sibling protocols multiplexed on the same Noise // stream (Corestore replication, app handshakes; protomux MAX_BACKLOG is // Infinity) aren't starved. Runs under the per-peer single-flight guard in // _onChunkNeed, so exactly one job streams at a time per peer. async _serveJob (peer, job) { const { path, diskPath, chunkMap, indices } = job // P3: cork the mux so a run of chunkData frames coalesces into fewer stream // writes (hypercore's replicator corks around each request/response batch, // replicator.js:722/738). Uncork before parking on drain (flush the batch) and // in the finally. The `corked` guard keeps cork/uncork balanced across the early // returns, and no-ops when the mux stub has no cork (unit tests). const mux = peer.mux let corked = false const cork = () => { if (mux && mux.cork && !corked) { mux.cork(); corked = true } } const uncork = () => { if (mux && mux.uncork && corked) { mux.uncork(); corked = false } } cork() try { for (let i = 0; i < indices.length; i++) { const index = indices[i] if (index >= chunkMap.length) continue // P5: skip a chunk the downloader hotswapped away (one-shot). if (peer._cancelledServe && peer._cancelledServe.delete(path + '\x00' + index)) continue const c = chunkMap[index] const data = this._transferManager.readChunk(diskPath, c.offset, c.length) if (!data) continue const flushed = peer.msgs.chunkData.send({ path, index, data }) if (this._chunkServeCb) { try { this._chunkServeCb({ path, index, bytes: data.length, peer, from: peer.authorizedServe.get(path) || null }) } catch {} } if (flushed === false && i < indices.length - 1) { uncork() // flush the corked batch before we park on drain const alive = await this._waitForDrain(peer) if (!alive) return if (this._serveAuthorizer && !peer.authorizedServe.has(path)) return cork() // re-cork for the next run } } } finally { uncork() } } // One shared drain waiter per peer so concurrent serve loops (the // same peer pulling several files) don't each attach listeners and trip the stream's // max-listeners warning. Resolves true on drain, false if the channel closes first. _waitForDrain (peer) { const channel = peer.channel const stream = peer.mux && peer.mux.stream if (!stream || !channel || channel.closed) return Promise.resolve(false) if (channel.drained) return Promise.resolve(true) if (peer._drainWait) return peer._drainWait peer._drainWait = new Promise((resolve) => { let timer = null const done = (alive) => { if (timer) clearTimeout(timer) stream.removeListener('drain', onDrain) stream.removeListener('close', onClose) peer._drainWait = null resolve(alive) } const onDrain = () => done(!channel.closed) const onClose = () => done(false) timer = setTimeout(() => done(false), DRAIN_TIMEOUT_MS) stream.on('drain', onDrain) stream.on('close', onClose) }) return peer._drainWait } async _onChunkData (peer, msg) { // Silent-peer watchdog hook: fire BEFORE any processing so a slow disk // doesn't get blamed for a peer-side stall. if (this._chunkProgressCb) { try { this._chunkProgressCb({ path: msg.path, index: msg.index, bytes: msg.data ? msg.data.length : 0, peer }) } catch {} } // Multi-source: scheduler owns the write + reschedule + finalize. const sched = this._schedulers.get(msg.path) if (sched) { Promise.resolve(sched.onChunkData(peer, msg.index, msg.data)).catch(() => {}); return } // refuse the legacy single-peer receive (writes+renames over // _filePaths.get(path), i.e. potentially our own source file). Gated // consumers only receive via a scheduler (above). if (this._serveAuthorizer) return const diskPath = this._filePaths.get(msg.path) if (!diskPath) return const result = this._transferManager.writeChunk(diskPath, msg.index, msg.data) if (result.ok && this._transferManager.isComplete(diskPath)) { const fin = await this._transferManager.finalize(diskPath) if (fin.ok) { const fileData = fs.readFileSync(diskPath) const contentHash = hashChunk(fileData) const stat = fs.statSync(diskPath) await this._syncEngine._fileIndex.putFile(msg.path, { contentHash, size: stat.size, mtime: stat.mtimeMs }) await this._syncEngine.logPut(msg.path, { contentHash, size: stat.size, mtime: stat.mtimeMs }) if (peer.remoteFeedKey) { await this._syncEngine.markSynced(peer.remoteFeedKey, msg.path, contentHash, this._syncEngine.feed.length - 1) } peer.msgs.transferComplete.send({ path: msg.path, contentHash }) if (this._syncedCb) { this._syncedCb({ path: msg.path, contentHash, size: stat.size, direction: 'pull' }) } } } } _onChunkCancel (peer, msg) { if (msg.indices && msg.indices.length) { // P5 hotswap: the downloader reassigned these chunk indices to a faster peer. // Stop serving just them (bandwidth save); the rest of the transfer continues. // Consumed one-shot in _serveJob. if (!peer._cancelledServe) peer._cancelledServe = new Set() for (const i of msg.indices) peer._cancelledServe.add(msg.path + '\x00' + i) return } const diskPath = this._filePaths.get(msg.path) if (diskPath) this._transferManager.cancel(diskPath) } // Resolve a serve-message's downloader identity from the authenticated record we kept at // serve start (peer.authorizedServe), NOT the message — so a peer can only affect its own // ledger row, never spoof another. Returns null `from` when the peer was never authorized. _authorizedFrom (peer, contentHash) { const synthPath = 'content:' + contentHash return { synthPath, from: peer.authorizedServe.get(synthPath) || null } } // A downloader told us it paused/stopped pulling a hash WE serve. _onTransferControl (peer, msg) { if (!this._serveControlCb) return const { synthPath, from } = this._authorizedFrom(peer, msg.contentHash) if (!from) return const state = msg.state === CONTROL_STOPPED ? 'stopped' : 'paused' try { this._serveControlCb({ path: synthPath, peer, from, state }) } catch {} } // A downloader reported its on-disk have-bytes for a hash WE serve. _onTransferProgress (peer, msg) { if (!this._serveProgressCb) return const { synthPath, from } = this._authorizedFrom(peer, msg.contentHash) if (!from) return try { this._serveProgressCb({ path: synthPath, peer, from, have: msg.have || 0 }) } catch {} } async _onTransferComplete (peer, msg) { if (peer.remoteFeedKey) { await this._syncEngine.markSynced(peer.remoteFeedKey, msg.path, msg.contentHash, this._syncEngine.feed.length - 1) } if (this._syncedCb) { this._syncedCb({ path: msg.path, contentHash: msg.contentHash, direction: 'push' }) } } _onConflictMsg (peer, msg) { if (this._conflictCb) this._conflictCb(msg, peer) } // ── Tree handlers (0.5a) ──────────────────────────────────── async _onTreeRequest (peer, msg) { // ungated metadata oracle (returns fileIndex tree entries to // any peer). Gated consumers never use tree-requests; refuse in gated mode. if (this._serveAuthorizer) return let entries = [] try { const fileIndex = this._syncEngine && this._syncEngine._fileIndex if (fileIndex && typeof fileIndex.getTree === 'function') { const tree = await fileIndex.getTree(msg.hash) if (tree && Array.isArray(tree.entries)) entries = tree.entries } } catch { // fall through — reply with empty entries on lookup failure } this._sendTreeResponse(peer, msg.hash, entries, msg.nonce || 0) } _onTreeResponse (peer, msg) { const pending = peer.pendingTrees.get(msg.hash) if (!pending) return // no request in flight — drop // Drop a page echoing a superseded request's nonce (a stale page from a // timed-out attempt must not settle a later same-hash retry). nonce 0 = a // pre-nonce holder that can't echo it, so fall through (unverifiable, // best-effort). if (msg.nonce && msg.nonce !== pending.nonce) return const settle = (fn, arg) => { clearTimeout(pending.timer); peer.pendingTrees.delete(msg.hash); fn(arg) } // Lone complete frame (the small-tree norm) resolves with no accumulation. if (!pending.pages && !msg.more) return settle(pending.resolve, msg.entries) // Accumulate into THIS request's own buffer, bounding total bytes so a peer // streaming pages endlessly rejects the request instead of growing memory // without limit. if (!pending.pages) pending.pages = [] for (const e of msg.entries) { pending.pages.push(e); pending.pageBytes += this._treeEntryWireSize(e) } if (pending.pageBytes > this._maxTreeResponseBytes) { return settle(pending.reject, new Error('tree response too large: ' + msg.hash)) } if (msg.more) { // Forward progress — re-arm the idle timeout so a legitimately large // multi-page tree on a slow link doesn't time out mid-stream. clearTimeout(pending.timer) this._armTreeTimeout(peer, msg.hash, pending) return } settle(pending.resolve, pending.pages) } async _onContentRequest (peer, msg) { // serve gate. BEFORE any path resolution or streaming, // ask the injected authorizer whether this peer may receive this hash. // Deny == silent return (same observable behavior as "I don't hold it" // below), so a non-member cannot distinguish denial from absence. if (this._serveAuthorizer) { let ok = false try { ok = await this._serveAuthorizer(peer, msg.from || null, msg.contentHash) } catch { ok = false } if (!ok) return } // Resolve msg.contentHash → an on-disk path. Three lookup paths, in order: // 1. Fast path: _contentHashPaths map (warm — just-registered / consumer-set) // 2. Content-addressed spool (RESTART-DURABLE): / // 3. Slow path: scan fileIndex for any file:* entry with that hash let diskPath = this._contentHashPaths.get(msg.contentHash) if (diskPath && !fileExists(diskPath)) diskPath = null if (!diskPath) { // Content-addressed spool fallback. The canonical bytes are stored at // / (fetchFile's mirrorSpool option writes them // there). The in-memory map is empty after a restart and FileIndex // persists no disk path, so resolve the hash straight from the // content-addressed spool — a pure function of the hash + dir, like a // git object store's blobs/. This is what lets a node keep serving // its spooled files across restarts with no rehydration step. for (const baseDir of this._syncBaseDirs) { const candidate = path.join(baseDir, msg.contentHash) if (fileExists(candidate)) { diskPath = candidate this._contentHashPaths.set(msg.contentHash, candidate) // warm the map break } } } if (!diskPath) { // Scan fileIndex for a file whose contentHash matches. const fileIndex = this._syncEngine && this._syncEngine._fileIndex if (fileIndex && typeof fileIndex.listFiles === 'function') { try { const files = await fileIndex.listFiles() for (const f of files) { if (f.contentHash === msg.contentHash) { diskPath = this._filePaths.get(f.path) if ((!diskPath || !fileExists(diskPath)) && f.path) diskPath = f.path break } } } catch { // fall through } } } if (!diskPath) { // Don't have it. Silently drop; requester will time out. return } // Use a SYNTHETIC path keyed by contentHash so the requester can // pre-register a destPath and the chunk flow routes correctly on // both sides. Temporarily populate _filePaths so _onChunkNeed + // chunkmap lookups resolve under this synthetic key. const syntheticPath = 'content:' + msg.contentHash this._filePaths.set(syntheticPath, diskPath) peer.authorizedServe.set(syntheticPath, msg.from || null) // _onChunkNeed will now serve this path to THIS peer // The chunk map is content-addressed — identical bytes always chunk // identically. Reuse one computed at publish (or a prior serve, or before a // restart) instead of re-reading the whole file to re-chunk it: re-chunking a // multi-GB file adds a full-file-read of latency before the first byte ships. const fileIndex = this._transferManager._fileIndex let chunks = await fileIndex.getChunkMapByHash(msg.contentHash) let tier if (chunks) { let size = 0 try { size = fs.statSync(diskPath).size } catch {} tier = selectTier(size) } else { const prepared = await this._transferManager.prepareFile(diskPath, syntheticPath, { byHashOnly: true }) if (!prepared) { this._filePaths.delete(syntheticPath) peer.authorizedServe.delete(syntheticPath) // keep the authorize map in lockstep with _filePaths return } chunks = prepared.chunks tier = prepared.tier // prepareFile persists the hash-keyed map only for large files; ensure it exists // for small ones too, since _onChunkNeed resolves content: by that map. if (!await fileIndex.hasChunkMapByHash(msg.contentHash)) await fileIndex.putChunkMapByHash(msg.contentHash, chunks) } this._sendChunkHashes(peer, syntheticPath, tier, chunks) if (this._serveStartCb) { let total = 0 for (const c of chunks) total += c.length || 0 try { this._serveStartCb({ path: syntheticPath, peer, from: msg.from || null, total }) } catch {} } } // ── Sync logic ────────────────────────────────────────────── /** * Offer all local files to a peer. * Reads from the local feed and sends file-offers for each entry. * The peer will request any files it doesn't have. */ async _offerLocalFiles (peer) { const feed = this._syncEngine.feed if (feed.length === 0) return for (let i = 0; i < feed.length; i++) { try { const entry = await feed.get(i) if (!entry) continue // Register the file path mapping so _onFileRequest can find it if (entry.op === 0) { const diskPath = this._resolveFilePath(entry.path) if (diskPath) this._filePaths.set(entry.path, diskPath) } peer.msgs.fileOffer.send({ path: entry.path, contentHash: entry.hash || '0'.repeat(64), size: entry.size || 0, mtime: entry.mtime || 0, op: entry.op }) } catch { // skip unreadable entries } } } /** * Resolve an overlay path to a disk path. */ _resolveFilePath (overlayPath) { if (this._filePaths.has(overlayPath)) return this._filePaths.get(overlayPath) for (const baseDir of this._syncBaseDirs) { return path.join(baseDir, overlayPath) } return null } } // True iff `p` is an existing regular file. Used to validate a resolved disk path // before serving (a cold-restart map entry or an overlay-path masquerading as a // disk path won't exist) and to probe the content-addressed spool. function fileExists (p) { try { return fs.statSync(p).isFile() } catch { return false } } /** * TransferManager — On-demand chunking and streaming file transfer * * Sender side: * 1. Read file from disk * 2. Chunk on demand (adaptive FastCDC) * 3. Send chunk hashes → peer says which it needs → stream those chunks * 4. Release chunks from memory after send * * Receiver side: * 1. Receive chunk hashes, respond with which are missing * 2. Receive chunks, write to .overlay-partial * 3. Verify each chunk hash * 4. Atomic rename on completion * * No blob storage. Chunks exist in memory during transfer only. */ import fs from 'bare-fs' import path from 'bare-path' import os from 'bare-os' import c from 'compact-encoding' import sodium from 'sodium-universal' import { chunk as chunkBuffer, chunkStream, hashChunk, createStreamingHasher, selectTier, getTierParams } from './chunker.js' export const PARTIAL_SUFFIX = '.overlay-partial' export const partialPathFor = (targetPath) => path.join(path.dirname(targetPath), path.basename(targetPath) + PARTIAL_SUFFIX) // Resume verification + whole-file hashing run async + yielding so a multi-GB pass // never blocks the event loop (IPC, pause/cancel, progress stay live). const VERIFY_YIELD_EVERY = 64 const yieldToLoop = () => new Promise((resolve) => setTimeout(resolve, 0)) // Receive journal: bitmap + whole-file hash snapshot, stored in app-private storage // (opts.journalDir) keyed by a digest of the destination path — never next to the // download — so resume is O(1) and the incremental verify continues with no re-read. const JOURNAL_SUFFIX = '.journal' const JOURNAL_MAGIC = 0x4d4a5633 const JOURNAL_FLUSH_EVERY = 512 const JOURNAL_FLUSH_INTERVAL_MS = 1500 export const journalNameFor = (targetPath) => hashChunk(Buffer.from(targetPath)) + JOURNAL_SUFFIX // Block-read prepare — host-adaptive read block size. const READ_BLOCK_DEFAULT = 8 * 1024 * 1024 const READ_BLOCK_LOW_RAM = 4 * 1024 * 1024 const LOW_RAM_THRESHOLD = 6 * 1024 * 1024 * 1024 // Cap on stashed just-received chunk buffers (per transfer, insert-refusal), and the // hash pump's yield budget — stash-fed iterations never await, so the pump yields by // bytes hashed, not chunk count. const MEM_STASH_BYTES_DEFAULT = 16 * 1024 * 1024 const DRAIN_YIELD_BYTES = 2 * 1024 * 1024 // Emit file blocks >= tier maxSize so chunkStream drains every block // instead of re-copying a growing pending buffer (64 KiB createReadStream reads force // ~56x memcpy at tier 3). Owns its fd and closes it on every terminal path: normal // end, consumer break/throw (for-await calls .return() → finally), read error. async function * readFileBlocks (filePath, size, blockSize) { const fd = await fs.open(filePath, 'r') try { let pos = 0 while (pos < size) { const want = Math.min(blockSize, size - pos) const buf = Buffer.allocUnsafe(want) let filled = 0 while (filled < want) { const n = await fs.read(fd, buf, filled, want - filled, pos + filled) if (n <= 0) break filled += n } if (filled === 0) break pos += filled yield filled === buf.length ? buf : buf.subarray(0, filled) } } finally { try { await fs.close(fd) } catch {} } } function bitmapOf (received, total) { const bm = Buffer.alloc((total + 7) >> 3) for (const i of received) bm[i >> 3] |= 1 << (i & 7) return bm } // Drop journals whose partial is gone, are stale, or are corrupt/foreign. Each // journal self-describes its partial path (read cheaply from the header). Standalone // (no TransferManager instance) so a boot-time sweep can reclaim orphans without // the overlay stack being live. export function cleanupOrphanedJournals (journalDir, maxAge = 7 * 86400000) { const cleaned = [] if (!journalDir) return cleaned let entries try { entries = fs.readdirSync(journalDir) } catch { return cleaned } const now = Date.now() for (const entry of entries) { if (!entry.endsWith(JOURNAL_SUFFIX)) continue const full = path.join(journalDir, entry) let remove = false try { const raw = fs.readFileSync(full) const s = { start: 0, end: raw.length, buffer: raw } if (c.uint32.decode(s) !== JOURNAL_MAGIC) remove = true else { c.uint32.decode(s) const partialPath = c.string.decode(s) if (!fs.existsSync(partialPath)) remove = true else if (now - fs.statSync(full).mtimeMs > maxAge) remove = true } } catch { remove = true } if (remove) { try { fs.unlinkSync(full); cleaned.push(full) } catch {} } } return cleaned } export class TransferManager { constructor (fileIndex, opts = {}) { this._fileIndex = fileIndex this._maxConcurrency = opts.maxConcurrency || 4 this._active = new Map() // path → transfer state this._memStashBytes = opts.memStashBytes ?? MEM_STASH_BYTES_DEFAULT this._journalDir = opts.journalDir || null if (this._journalDir) { try { fs.mkdirSync(this._journalDir, { recursive: true }) } catch {} } } _journalPathFor (targetPath) { if (!this._journalDir) return null return path.join(this._journalDir, journalNameFor(targetPath)) } // ── Sender side ───────────────────────────────────────────── /** * Prepare a file for sending — read from disk, chunk, return hashes. * Chunk map is persisted for large files (>1MB). * * @param {string} filePath - absolute path on disk * @param {string} overlayPath - path in the overlay namespace * @returns {{ tier: number, chunks: Array<{ hash, offset, length }>, size: number } | null} */ async prepareFile (filePath, overlayPath, opts = {}) { // Check file exists and get stats let stat try { stat = fs.statSync(filePath) } catch { return null } if (!stat.isFile()) return null const mtimeBefore = stat.mtimeMs // Check for existing chunk map (skip re-chunking if valid) const existing = await this._fileIndex.getChunkMap(overlayPath) const fileMeta = await this._fileIndex.getFile(overlayPath) if (existing && fileMeta && fileMeta.mtime === mtimeBefore) { // Chunk map still valid — file hasn't changed. // Backfill the content-addressed alias so the serve path (a // different overlay key) reuses this map instead of re-reading the file — // covers maps chunked before content-addressed caching existed. if (fileMeta.contentHash && stat.size >= 1048576 && !await this._fileIndex.hasChunkMapByHash(fileMeta.contentHash)) { await this._fileIndex.putChunkMapByHash(fileMeta.contentHash, existing) } return { tier: selectTier(stat.size), chunks: existing, size: stat.size, contentHash: fileMeta.contentHash // surfaced so the publish path gets the hash from one pass } } // Read in blocks >= tier maxSize and chunk from views (copy:false). // Cut points are content-stable across block sizes, so peers still match hashes. // size is passed to the hasher so the streaming digest matches hashChunk(buffer). const tier = selectTier(stat.size) const blockSize = Math.max( getTierParams(tier).maxSize, os.totalmem() < LOW_RAM_THRESHOLD ? READ_BLOCK_LOW_RAM : READ_BLOCK_DEFAULT ) const fileHasher = createStreamingHasher({ size: stat.size }) const chunks = [] for await (const c of chunkStream(readFileBlocks(filePath, stat.size, blockSize), { tier, copy: false })) { // honor a publish-cancel signal (per-chunk granularity); on throw the // for-await calls readFileBlocks.return() which closes the fd. if (opts.signal?.aborted) { const e = new Error('publish aborted'); e.code = 'ECANCELLED'; throw e } fileHasher.update(c.data) chunks.push({ hash: c.hash, offset: c.offset, length: c.length }) opts.onProgress?.(c.length) } // mtime guard — abort if file changed during the streaming read. A // vanished source (moved out of the folder mid-read) is just another "changed // during read" case — the open fd kept the read alive after a same-volume // rename, so it is this path-resolving stat that trips ENOENT. Guard it like // the pre-read stat above and re-queue rather than throw. let statAfter try { statAfter = fs.statSync(filePath) } catch { return null // source vanished during read, caller should re-queue } if (statAfter.mtimeMs !== mtimeBefore) { return null // file changed during read, caller should re-queue } // Post-read guard: a mid-read shrink can feed the digest fewer bytes than the // size baked into its leaf prefix — re-queue instead of persisting a bad hash. if (fileHasher.bytes !== stat.size) return null // Update file index const contentHash = fileHasher.digest() // Persist chunk map for large files — both path-keyed (legacy serve lookups) // and content-addressed, so the serve path reuses it across keys. // byHashOnly (the publish prepareForServe pass) keeps ONLY the // content-addressed map — the serve path resolves by hash, so the path-keyed map // + putFile under a throwaway overlay key would be dead, never-read state. if (stat.size >= 1048576) { if (!opts.byHashOnly) await this._fileIndex.putChunkMap(overlayPath, chunks) if (!await this._fileIndex.hasChunkMapByHash(contentHash)) await this._fileIndex.putChunkMapByHash(contentHash, chunks) } if (!opts.byHashOnly) { await this._fileIndex.putFile(overlayPath, { contentHash, size: stat.size, mtime: mtimeBefore }) } return { tier, chunks, size: stat.size, contentHash } } /** * Read a specific chunk from disk by its offset and length. * Returns raw bytes — caller sends them to the peer. * * @param {string} filePath - absolute path on disk * @param {number} offset - byte offset * @param {number} length - bytes to read * @returns {Buffer | null} */ readChunk (filePath, offset, length) { try { const fd = fs.openSync(filePath, 'r') const buf = Buffer.alloc(length) const bytesRead = fs.readSync(fd, buf, 0, length, offset) fs.closeSync(fd) if (bytesRead !== length) return null return buf } catch { return null } } /** * Determine which chunks a peer needs (chunks they don't already have). * * @param {Array<{ hash, offset, length }>} offered - chunks the sender has * @param {Set} peerHas - set of chunk hashes the peer already has * @returns {number[]} indices of chunks the peer needs */ computeNeeded (offered, peerHas) { const needed = [] for (let i = 0; i < offered.length; i++) { if (!peerHas.has(offered[i].hash)) { needed.push(i) } } return needed } // ── Receiver side ─────────────────────────────────────────── // Start receiving a file. A same-size partial is resumed: the journal restores the // received-set + whole-file hash snapshot in O(1) (no re-read); failing that, an // async, yielding re-verify rebuilds them without blocking the event loop. // opts.isCancelled aborts a long re-verify; opts.onVerifyProgress(0..1) drives the UI. async startReceive (targetPath, meta, opts = {}) { const isCancelled = opts.isCancelled || (() => false) const dir = path.dirname(targetPath) const base = path.basename(targetPath) // Visible partial (no leading dot) so an in-progress download shows in the // destination folder; the distinct ".overlay-partial" suffix keeps host-app // sweeps keyed on a plain ".partial" suffix from deleting a paused overlay // partial. const partialPath = path.join(dir, base + PARTIAL_SUFFIX) const journalPath = this._journalPathFor(targetPath) fs.mkdirSync(dir, { recursive: true }) let resumed = false try { resumed = fs.statSync(partialPath).size === meta.size } catch {} let received = new Set() let hasher = meta.contentHash ? createStreamingHasher({ size: meta.size }) : null let hashFrontier = 0 if (resumed) { const j = journalPath ? this._loadJournal(journalPath, partialPath, meta) : null if (j) { received = j.received hashFrontier = j.hashFrontier if (meta.contentHash) hasher = createStreamingHasher({ size: meta.size, restore: { state: j.hasherState, bytes: j.hasherBytes } }) } else { const rec = await this._recoverPartialAsync(partialPath, meta, isCancelled, opts.onVerifyProgress) received = rec.received; hasher = rec.hasher; hashFrontier = rec.hashFrontier } } else { if (journalPath) { try { fs.unlinkSync(journalPath) } catch {} } } if (isCancelled()) { const e = new Error('receive cancelled during setup'); e.code = 'ECANCELLED'; throw e } // ONE persistent fd for the whole transfer — positioned writeSync/fs.read never // move a shared cursor, so a single handle serves the chunk writes, the hash // pump's gap read-back, and the journal fsync. Replaces an openSync+closeSync per // chunk; 'w+' creates+truncates the fresh partial in the same open. const fd = fs.openSync(partialPath, resumed ? 'r+' : 'w+') if (!resumed) { try { fs.ftruncateSync(fd, meta.size) } catch (err) { try { fs.closeSync(fd) } catch {}; throw err } } const total = meta.chunks.length const state = { partialPath, targetPath, journalPath, chunks: meta.chunks, received, bitmap: bitmapOf(received, total), total, size: meta.size, contentHash: meta.contentHash || null, hasher, hashFrontier, advancePromise: null, draining: false, sinceFlush: 0, lastFlush: 0, flushing: false, flushPending: false, fd, // Bounded stash of just-received verified chunk buffers so the hash pump feeds // from memory instead of reading the bytes back off disk. Never load-bearing: // bytes hit disk first; a miss falls back to read-back. memChunks: new Map(), memBytes: 0, stats: { readbacks: 0, stashHits: 0 } } // A prior transfer for this path that ended via _fail (stall / all-peers- // gone / disk error) leaves its state here with an open fd — close it before // overwriting so a retry/resume of the same file can't orphan the fd. const prev = this._active.get(targetPath) if (prev) this._closeFd(prev) this._active.set(targetPath, state) // A fresh transfer has nothing worth journaling yet; a resume that recovered // chunks persists them now so an immediate re-pause is O(1). if (received.size > 0) this._flushJournal(state) return state } // Rebuild the received-set from a same-size partial without blocking the loop: // async reads, a yield every VERIFY_YIELD_EVERY chunks, feeding the contiguous // prefix into the whole-file hasher inline (single pass, no second read). async _recoverPartialAsync (partialPath, meta, isCancelled, onVerifyProgress) { const received = new Set() const hasher = meta.contentHash ? createStreamingHasher({ size: meta.size }) : null let hashFrontier = 0 const total = meta.chunks.length const maxLen = meta.chunks.reduce((m, c) => (c.length > m ? c.length : m), 0) const buf = Buffer.allocUnsafe(maxLen) let lastPct = -1 onVerifyProgress?.(0) const fd = await fs.open(partialPath, 'r') try { for (let i = 0; i < total; i++) { if (isCancelled()) { const e = new Error('receive recovery cancelled'); e.code = 'ECANCELLED'; throw e } const ci = meta.chunks[i] let n = 0 try { n = await fs.read(fd, buf, 0, ci.length, ci.offset) } catch {} const view = buf.subarray(0, ci.length) if (n === ci.length && hashChunk(view) === ci.hash) { received.add(i) if (hasher && i === hashFrontier) { hasher.update(view); hashFrontier++ } } if ((i & (VERIFY_YIELD_EVERY - 1)) === VERIFY_YIELD_EVERY - 1) { const pct = Math.floor(((i + 1) / total) * 100) if (pct !== lastPct) { lastPct = pct; onVerifyProgress?.(pct / 100) } await yieldToLoop() } } } finally { try { await fs.close(fd) } catch {} } onVerifyProgress?.(1) return { received, hasher, hashFrontier } } _encodeJournal (state) { const total = state.total const bm = state.bitmap const ch = state.contentHash ? Buffer.from(state.contentHash, 'hex') : Buffer.alloc(32) const snap = state.hasher ? state.hasher.snapshot() : { state: Buffer.alloc(0), bytes: 0 } const s = { start: 0, end: 0, buffer: null } c.uint32.preencode(s, JOURNAL_MAGIC) c.uint32.preencode(s, sodium.crypto_generichash_STATEBYTES) c.string.preencode(s, state.partialPath) c.uint64.preencode(s, state.size) c.uint32.preencode(s, total) c.fixed32.preencode(s, ch) c.uint32.preencode(s, state.hashFrontier) c.uint64.preencode(s, snap.bytes) c.buffer.preencode(s, snap.state) c.buffer.preencode(s, bm) s.buffer = Buffer.allocUnsafe(s.end) c.uint32.encode(s, JOURNAL_MAGIC) c.uint32.encode(s, sodium.crypto_generichash_STATEBYTES) c.string.encode(s, state.partialPath) c.uint64.encode(s, state.size) c.uint32.encode(s, total) c.fixed32.encode(s, ch) c.uint32.encode(s, state.hashFrontier) c.uint64.encode(s, snap.bytes) c.buffer.encode(s, snap.state) c.buffer.encode(s, bm) return s.buffer } // Returns the resume state only when the journal is for this partial, binds to // this content, and its snapshot is restorable on this libsodium build; else null // so the caller falls back to the async re-verify. _loadJournal (journalPath, partialPath, meta) { let raw try { raw = fs.readFileSync(journalPath) } catch { return null } try { const s = { start: 0, end: raw.length, buffer: raw } if (c.uint32.decode(s) !== JOURNAL_MAGIC) return null const stateBytes = c.uint32.decode(s) const storedPartial = c.string.decode(s) const size = c.uint64.decode(s) const total = c.uint32.decode(s) const ch = c.fixed32.decode(s).toString('hex') const hashFrontier = c.uint32.decode(s) const hasherBytes = c.uint64.decode(s) const hasherState = c.buffer.decode(s) const bm = c.buffer.decode(s) // F1: never trust a journal we cannot whole-file-verify. Both finalize and the // legacy receive path skip the whole-file hash when contentHash is absent, so a // FOREIGN journal with a matching size + chunk-count (a stale .overlay-partial // for different content the CDC split into the same number of chunks) would be // trusted and finalized as merged old+new bytes, undetected. Require a content // hash to resume from a journal; without one the caller falls back to // _recoverPartialAsync, which re-verifies every chunk by its per-chunk hash. if (!meta.contentHash) return null if (storedPartial !== partialPath) return null if (size !== meta.size || total !== meta.chunks.length) return null if (ch !== meta.contentHash) return null if (meta.contentHash) { if (stateBytes !== sodium.crypto_generichash_STATEBYTES) return null if (hasherState.length !== sodium.crypto_generichash_STATEBYTES) return null } const received = new Set() for (let i = 0; i < total; i++) if (bm[i >> 3] & (1 << (i & 7))) received.add(i) return { received, hashFrontier, hasherState, hasherBytes } } catch { return null } } // Best-effort async crash-hedge flush: never blocks the receive loop, single-flight // (a flush requested while one runs coalesces into one more pass). fsync the partial // BEFORE the journal references it so a power-loss can never leave the journal // marking a chunk received whose bytes aren't durable. _flushJournal (state) { if (!state.contentHash || !state.journalPath || state.fd == null) return if (state.flushing) { state.flushPending = true; return } if (Date.now() - state.lastFlush < JOURNAL_FLUSH_INTERVAL_MS) return state.flushing = true this._drainFlush(state) } async _drainFlush (state) { do { state.flushPending = false state.lastFlush = Date.now() if (state.fd == null) break let buf try { buf = this._encodeJournal(state) } catch { break } const tmp = state.journalPath + '.tmp' try { // fsync is best-effort and swallowed on purpose: on Windows, fsync // (FlushFileBuffers) on a read-only handle throws EPERM benignly, and we still // want the journal to persist so resume stays O(1). The EIO write-back hazard // this could mask is already closed upstream — F1 refuses to trust a journal // without a contentHash, and the finalize whole-file hash re-verifies the // gated flow — so skipping the commit here (former "F3") only regressed Windows. try { await fs.fsync(state.fd) } catch {} await fs.writeFile(tmp, buf) if (state.fd == null) break // paused/cancelled mid-flush — don't re-create the journal await fs.rename(tmp, state.journalPath) } catch { try { await fs.unlink(tmp) } catch {} } } while (state.flushPending && state.fd != null && state.contentHash) try { await fs.unlink(state.journalPath + '.tmp') } catch {} state.flushing = false } // Synchronous durable flush for pause/shutdown, where the app may quit before an // async flush would land. _flushJournalSync (state) { if (!state.contentHash || !state.journalPath) return let buf try { buf = this._encodeJournal(state) } catch { return } // fsync swallowed on purpose (Windows read-only-handle EPERM) — see _drainFlush. if (state.fd != null) { try { fs.fsyncSync(state.fd) } catch {} } try { const tmp = state.journalPath + '.tmp' fs.writeFileSync(tmp, buf) fs.renameSync(tmp, state.journalPath) state.lastFlush = Date.now() } catch { try { fs.unlinkSync(state.journalPath + '.tmp') } catch {} } } cleanJournals (maxAge) { return cleanupOrphanedJournals(this._journalDir, maxAge) } async _hashWholeFileAsync (filePath, size) { const h = createStreamingHasher({ size }) for await (const buf of readFileBlocks(filePath, size, 8 * 1024 * 1024)) { h.update(buf) await yieldToLoop() } return h.digest() } // Advance the whole-file hash over the contiguous run of received chunks // as a single-flight BACKGROUND pump: chunk index order == file offset order, so // once chunk `hashFrontier` is present we feed its bytes and move on. The drain is // async + yielding so a large contiguous run that suddenly becomes available (a // gap filling after a low-frontier resume) cannot block the event loop. // Single-flight is `state.draining`, set/cleared SYNCHRONOUSLY inside _drainHash — // a stash-fed drain completes without awaiting, so a promise-based gate would stay // stale until its microtask clear and block same-macrotask restarts (protomux // delivers frame bursts synchronously). advancePromise is only the awaitable // handle for finalize/pause; its clear is guarded against nulling a newer drain. _advanceHash (state) { if (!state.hasher || state.draining) return if (!(state.hashFrontier < state.chunks.length && state.received.has(state.hashFrontier))) return const p = this._drainHash(state) state.advancePromise = p p.catch(() => {}).then(() => { if (state.advancePromise === p) state.advancePromise = null }) } async _drainHash (state) { state.draining = true try { let sinceYield = 0 while (state.fd != null && state.hashFrontier < state.chunks.length && state.received.has(state.hashFrontier)) { const i = state.hashFrontier const c = state.chunks[i] let buf = state.memChunks.get(i) if (buf !== undefined) { state.memChunks.delete(i) state.memBytes -= buf.length state.stats.stashHits++ } else { buf = Buffer.alloc(c.length) try { await fs.read(state.fd, buf, 0, c.length, c.offset) } catch { return } state.stats.readbacks++ } state.hasher.update(buf) state.hashFrontier++ // Yield by BYTE volume: the stash path has no awaits, so a chunk-count // cadence would let a gap-fill hash the whole stash synchronously inside // the network event that delivered the gap chunk. sinceYield += buf.length if (sinceYield >= DRAIN_YIELD_BYTES) { sinceYield = 0; await yieldToLoop() } } } finally { state.draining = false } } // Close the persistent fd — MUST run before finalize's rename (an open handle // blocks the rename on Windows) — and drop the chunk stash. _closeFd (state) { if (state.fd != null) { try { fs.closeSync(state.fd) } catch {} state.fd = null } state.memChunks.clear() state.memBytes = 0 } /** * Write a received chunk to the partial file. Verifies the hash. * * @param {string} targetPath - the final file path (used as key) * @param {number} index - chunk index * @param {Buffer} data - raw chunk bytes * @returns {{ ok: boolean, error?: string }} */ writeChunk (targetPath, index, data) { const state = this._active.get(targetPath) if (!state) return { ok: false, error: 'no active transfer' } if (index < 0 || index >= state.chunks.length) return { ok: false, error: 'index out of range' } // Terminal race (chunk landed after close) — codeless so the scheduler // re-assigns instead of failing the fetch. if (state.fd == null) return { ok: false, error: 'transfer closed' } const expected = state.chunks[index] // Verify hash const actual = hashChunk(data) if (actual !== expected.hash) { return { ok: false, error: `hash mismatch at index ${index}: expected ${expected.hash.slice(0, 16)}... got ${actual.slice(0, 16)}...` } } // Verify length if (data.length !== expected.length) { return { ok: false, error: `length mismatch at index ${index}: expected ${expected.length} got ${data.length}` } } // Write to partial at the chunk's offset through the persistent fd. A local // I/O failure here (ENOSPC / EACCES / EROFS) is fatal and non-retryable — // return its code so the scheduler fails the fetch instead of looping over // other peers. Loop on a SHORT count: libuv swallows an error after partial // progress and returns short without throwing; retrying the remainder // surfaces the real coded error instead of leaving a silent hole the // stash-fed digest would never see. try { let written = 0 while (written < data.length) { const n = fs.writeSync(state.fd, data, written, data.length - written, expected.offset + written) if (!(n > 0)) { const e = new Error(`short write at index ${index}: ${written}/${data.length} bytes`); e.code = 'EIO'; throw e } written += n } } catch (err) { return { ok: false, error: err.message, code: err.code } } state.received.add(index) state.bitmap[index >> 3] |= 1 << (index & 7) // Stash only what the pump can consume cleanly: skip when already hashed or // stashed, when the pump is mid-drain on exactly this index, or over cap. // Copied, not aliased — wire buffers are views into shared network slabs (udx // read slab, decrypted in place by secret-stream), so retaining `data` would // pin whole slabs and bet the digest on their write-once behavior. if (state.hasher && !state.memChunks.has(index) && state.memBytes + data.length <= this._memStashBytes && (index > state.hashFrontier || (index === state.hashFrontier && !state.draining))) { state.memChunks.set(index, Buffer.from(data)) state.memBytes += data.length } this._advanceHash(state) if (++state.sinceFlush >= JOURNAL_FLUSH_EVERY) { state.sinceFlush = 0; this._flushJournal(state) } return { ok: true } } /** * Check if a transfer is complete (all chunks received). * * @param {string} targetPath * @returns {boolean} */ isComplete (targetPath) { const state = this._active.get(targetPath) if (!state) return false return state.received.size === state.total } /** * Finalize a completed transfer — atomic rename from partial to target. * * @param {string} targetPath * @returns {{ ok: boolean, error?: string }} */ async finalize (targetPath) { const state = this._active.get(targetPath) if (!state) return { ok: false, error: 'no active transfer' } if (state.received.size !== state.total) { return { ok: false, error: `incomplete: ${state.received.size}/${state.total} chunks` } } // whole-file integrity — computed incrementally by the background hash // pump during the transfer. Kick the pump and await it to quiescence, then read // the digest (no full re-read). On a mismatch, drop the corrupt partial so a // retry starts clean. if (state.hasher) { this._advanceHash(state) while (state.advancePromise) { try { await state.advancePromise } catch {} } } if (state.contentHash) { const actual = state.hashFrontier === state.chunks.length ? state.hasher.digest() : null if (actual !== state.contentHash) { this._closeFd(state) try { fs.unlinkSync(state.partialPath) } catch {} if (state.journalPath) { try { fs.unlinkSync(state.journalPath) } catch {} } this._active.delete(targetPath) return { ok: false, error: 'content-hash mismatch', code: 'EHASHMISMATCH' } } } this._closeFd(state) try { fs.renameSync(state.partialPath, state.targetPath) } catch (err) { // Carry the code (routes through the coded local-I/O rethrow) and clear the // state — the partial + journal stay for a clean resume-retry. this._active.delete(targetPath) return { ok: false, error: 'rename failed: ' + err.message, code: err.code } } if (state.journalPath) { try { fs.unlinkSync(state.journalPath) } catch {} } this._active.delete(targetPath) return { ok: true } } // Stop receiving but KEEP the partial on disk so a later startReceive // verifies and resumes it. Distinct from cancel(), which unlinks the partial. // Drains the in-flight hash advance to the full contiguous frontier first, so the // journal captures it and resume stays O(1) (no re-read) and deterministic. async pause (targetPath) { const state = this._active.get(targetPath) if (!state) return if (state.hasher) { this._advanceHash(state) while (state.advancePromise) { try { await state.advancePromise } catch {} } } this._flushJournalSync(state) this._closeFd(state) this._active.delete(targetPath) } /** * Cancel an active transfer and clean up the partial file. * * @param {string} targetPath */ cancel (targetPath) { const state = this._active.get(targetPath) if (!state) return this._closeFd(state) try { fs.unlinkSync(state.partialPath) } catch { // partial file may not exist } if (state.journalPath) { try { fs.unlinkSync(state.journalPath) } catch {} } this._active.delete(targetPath) } /** * Get transfer progress for an active transfer. * * @param {string} targetPath * @returns {{ received: number, total: number, percentage: number } | null} */ getProgress (targetPath) { const state = this._active.get(targetPath) if (!state) return null return { received: state.received.size, total: state.total, percentage: state.total > 0 ? Math.round(state.received.size / state.total * 100) : 0 } } /** * List all active transfers. * * @returns {Array<{ path: string, received: number, total: number, percentage: number }>} */ listActive () { const result = [] for (const [targetPath, state] of this._active) { result.push({ path: targetPath, received: state.received.size, total: state.total, percentage: state.total > 0 ? Math.round(state.received.size / state.total * 100) : 0 }) } return result } /** * Clean up stale partial files in a directory (older than maxAge). * * @param {string} dir - directory to scan * @param {number} [maxAge=86400000] - max age in ms (default 24h) * @returns {string[]} paths of cleaned files */ cleanPartials (dir, maxAge = 86400000) { const cleaned = [] try { const entries = fs.readdirSync(dir) const now = Date.now() for (const entry of entries) { if (!entry.endsWith(PARTIAL_SUFFIX)) continue const full = path.join(dir, entry) try { const stat = fs.statSync(full) if (now - stat.mtimeMs > maxAge) { fs.unlinkSync(full) cleaned.push(full) } } catch { // skip unreadable files } } } catch { // directory may not exist } return cleaned } } /** * Tree — content-addressable directory hashing for hyper-overlay * * A tree is a canonical serialization of a directory's immediate entries. * Each entry is one of: file, subdirectory, symlink. The tree's identity * is blake2b-256 of its canonical bytes. * * Format (P.10 Phase 0.5a): * * tree := "pgh-tree-1\n" || * varint(n_entries) || * entry[0] || ... || entry[n-1] * * entry := u8(kind) || // 0=file, 1=dir, 2=symlink * u8(exec) || // 0 or 1; always 0 for dir/symlink * varint(name_len) || name || // UTF-8 NFC, no NUL, no "/" * 32_bytes(child_hash) * * tree_hash := blake2b-256(tree_bytes) * * Identity fields (in the hash): kind, exec-bit, name, child_hash. * Explicitly excluded: mtime, size, uid/gid, full mode. * * Entries MUST be sorted byte-wise by name (after NFC normalization). * Encoders emit sorted; decoders reject unsorted trees. * * Symlinks: child_hash = blake2b-256 of the target path bytes (not followed). * Empty directories: zero-entry tree, valid, deterministic. */ import fs from '#fs' import path from '#path' import crypto from 'hypercore-crypto' import c from 'compact-encoding' // ── Constants ───────────────────────────────────────────────── export const MAGIC = Buffer.from('pgh-tree-1\n', 'utf8') export const KIND_FILE = 0 export const KIND_DIR = 1 export const KIND_SYMLINK = 2 // Windows reserved device names (case-insensitive, with or without extension) const WINDOWS_RESERVED = new Set([ 'CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9' ]) // Chars forbidden in filenames on Windows (beyond format-layer rules) // eslint-disable-next-line no-control-regex const WINDOWS_FORBIDDEN = /[\\:*?"<>|\x00-\x1f]/ // Default skip list for walkTree — minimal, just obvious platform cruft. // Consumers that want more (e.g. .git for pgh publish) pass their own. export const DEFAULT_SKIP = new Set(['.DS_Store', 'Thumbs.db']) // ── Name validation (format layer) ──────────────────────────── /** * Normalize a filename for hashing and validate format-layer rules. * Throws on unrepresentable names. Returns the canonical form. * * @param {string} name - single path component (no "/") * @returns {string} NFC-normalized name */ export function normalizeName (name) { if (typeof name !== 'string') { throw new Error('tree entry name must be string, got ' + typeof name) } if (name.length === 0) { throw new Error('tree entry name cannot be empty') } if (name === '.' || name === '..') { throw new Error('tree entry name cannot be "." or ".."') } if (name.indexOf('/') !== -1) { throw new Error('tree entry name cannot contain "/": ' + JSON.stringify(name)) } if (name.indexOf('\x00') !== -1) { throw new Error('tree entry name cannot contain NUL: ' + JSON.stringify(name)) } const normalized = name.normalize('NFC') // Verify the normalized form is valid UTF-8 that round-trips through // Buffer (catches lone surrogates and other malformed sequences). const asBytes = Buffer.from(normalized, 'utf8') if (asBytes.toString('utf8') !== normalized) { throw new Error('tree entry name is not valid UTF-8: ' + JSON.stringify(name)) } return normalized } // ── Consumer-policy layer ───────────────────────────────────── /** * Check a name against Windows compatibility rules. * Does NOT throw — returns a reason string (or null if the name is OK). * Used by pgh publish for strict cross-platform validation. * * @param {string} name * @returns {string|null} reason if incompatible, null if OK */ export function windowsIncompatibleReason (name) { if (WINDOWS_FORBIDDEN.test(name)) { return 'contains Windows-forbidden character (\\:*?"<>| or control code)' } const trimmed = name.replace(/\.+$/, '').replace(/ +$/, '') if (trimmed !== name) { return 'trailing "." or space (Windows strips these silently)' } // Reserved device names apply with any extension: AUX.log, PRN.txt etc. const base = name.split('.')[0].toUpperCase() if (WINDOWS_RESERVED.has(base)) { return `"${base}" is a reserved Windows device name (even with extension)` } return null } // ── Canonical encoding ──────────────────────────────────────── /** * Encode a single entry to its canonical byte representation. * * @param {object} state - compact-encoding state * @param {{kind: number, exec: number, name: string, childHash: Buffer|string}} e */ function encodeEntry (state, e) { if (e.kind !== KIND_FILE && e.kind !== KIND_DIR && e.kind !== KIND_SYMLINK) { throw new Error('invalid entry kind: ' + e.kind) } if (e.exec !== 0 && e.exec !== 1) { throw new Error('entry exec must be 0 or 1') } if (e.kind !== KIND_FILE && e.exec !== 0) { throw new Error('non-file entry must have exec=0') } const hash = toBuffer32(e.childHash) c.uint8.encode(state, e.kind) c.uint8.encode(state, e.exec) c.string.encode(state, e.name) // compact-encoding: varint len + utf8 bytes state.buffer.set(hash, state.start) state.start += 32 } function preencodeEntry (state, e) { c.uint8.preencode(state, e.kind) c.uint8.preencode(state, e.exec) c.string.preencode(state, e.name) state.end += 32 } /** * Serialize a list of entries to canonical tree bytes. * Entries are sorted + normalized as a side-effect of the call. * * @param {Array<{kind: number, exec: number, name: string, childHash: Buffer|string}>} entries * @returns {Buffer} */ export function encodeTree (entries) { const normalized = entries.map(e => ({ kind: e.kind, exec: e.exec || 0, name: normalizeName(e.name), childHash: e.childHash })) normalized.sort(compareEntries) // Sanity: no duplicate names after normalization for (let i = 1; i < normalized.length; i++) { if (normalized[i].name === normalized[i - 1].name) { throw new Error('duplicate entry name after NFC normalization: ' + normalized[i].name) } } const state = { start: 0, end: 0, buffer: null } state.end += MAGIC.length c.uint.preencode(state, normalized.length) for (const e of normalized) preencodeEntry(state, e) state.buffer = Buffer.alloc(state.end) state.buffer.set(MAGIC, state.start) state.start += MAGIC.length c.uint.encode(state, normalized.length) for (const e of normalized) encodeEntry(state, e) return state.buffer } /** * Byte-wise comparator for entry names (after NFC normalization). */ function compareEntries (a, b) { const ab = Buffer.from(a.name, 'utf8') const bb = Buffer.from(b.name, 'utf8') return Buffer.compare(ab, bb) } /** * Decode canonical tree bytes back to an entries list. * Rejects unsorted or malformed trees. * * @param {Buffer} buf * @returns {Array<{kind: number, exec: number, name: string, childHash: string}>} */ export function decodeTree (buf) { if (!Buffer.isBuffer(buf)) throw new Error('decodeTree expects a Buffer') if (buf.length < MAGIC.length) throw new Error('tree too short') if (buf.compare(MAGIC, 0, MAGIC.length, 0, MAGIC.length) !== 0) { throw new Error('tree magic mismatch (expected "pgh-tree-1")') } const state = { start: MAGIC.length, end: buf.length, buffer: buf } const count = c.uint.decode(state) const entries = [] let prevName = null for (let i = 0; i < count; i++) { const kind = c.uint8.decode(state) const exec = c.uint8.decode(state) const name = c.string.decode(state) if (state.start + 32 > state.end) throw new Error('truncated tree: missing hash bytes') const childHash = buf.subarray(state.start, state.start + 32).toString('hex') state.start += 32 // Validate format rules on read — reject invalid trees rather than silently accept const normalized = normalizeName(name) if (normalized !== name) { throw new Error('tree entry name not NFC-normalized: ' + JSON.stringify(name)) } if (kind !== KIND_FILE && exec !== 0) { throw new Error('non-file entry with exec=1 is invalid') } if (prevName !== null) { const cmp = Buffer.compare(Buffer.from(prevName, 'utf8'), Buffer.from(name, 'utf8')) if (cmp === 0) throw new Error('tree has duplicate entry: ' + name) if (cmp > 0) throw new Error('tree entries not sorted: ' + prevName + ' before ' + name) } prevName = name entries.push({ kind, exec, name, childHash }) } if (state.start !== state.end) throw new Error('tree has trailing bytes after entries') return entries } /** * Compute the tree hash of an entries list. * * @param {Array<{kind: number, exec: number, name: string, childHash: Buffer|string}>} entries * @returns {string} hex-encoded blake2b-256 */ export function computeTreeHash (entries) { const buf = encodeTree(entries) return crypto.data(buf).toString('hex') } // ── Helpers ─────────────────────────────────────────────────── function toBuffer32 (hashOrBuf) { if (Buffer.isBuffer(hashOrBuf)) { if (hashOrBuf.length !== 32) throw new Error('childHash buffer must be 32 bytes') return hashOrBuf } if (typeof hashOrBuf !== 'string') { throw new Error('childHash must be Buffer or hex string') } if (hashOrBuf.length !== 64) throw new Error('childHash hex string must be 64 chars') return Buffer.from(hashOrBuf, 'hex') } // ── Filesystem walk ─────────────────────────────────────────── /** * Walk a directory recursively, producing tree hashes bottom-up. * * Returns a nested object keyed by path, where each entry has: * { hash: hex, entries: [{kind, exec, name, childHash, size?}] } * * File entries carry their content hash as childHash (blake2b of bytes). * Dir entries carry the subtree hash. * Symlink entries carry blake2b of the link target bytes. * * @param {string} rootDir - absolute path to scan * @param {object} [opts] * @param {Set} [opts.skip] - basenames to skip (default: DEFAULT_SKIP) * @param {(relPath: string, baseName: string) => boolean} [opts.matcher] * Optional gitignore-style matcher. Returns true to EXCLUDE an entry. * Receives the path relative to rootDir plus the basename. Applies to * all kinds (file/dir/symlink). Used by `pgh publish` for publishIgnore. * @returns {Map} * map keyed by relative path ('' = root); root tree is at key '' */ export function walkTree (rootDir, opts = {}) { const skip = opts.skip || DEFAULT_SKIP const matcher = opts.matcher || null const trees = new Map() function visit (relPath) { const absPath = relPath === '' ? rootDir : path.join(rootDir, relPath) const raw = fs.readdirSync(absPath) const entries = [] let totalSize = 0 for (const name of raw) { if (skip.has(name)) continue const entryAbs = path.join(absPath, name) const entryRel = relPath === '' ? name : relPath + '/' + name if (matcher && matcher(entryRel, name)) continue let stat try { stat = fs.lstatSync(entryAbs) } catch { continue } if (stat.isSymbolicLink()) { const target = fs.readlinkSync(entryAbs) const targetBytes = Buffer.from(target, 'utf8') const childHash = crypto.data(targetBytes).toString('hex') entries.push({ kind: KIND_SYMLINK, exec: 0, name: normalizeName(name), childHash, size: targetBytes.length, linkTarget: target }) totalSize += targetBytes.length } else if (stat.isDirectory()) { visit(entryRel) const sub = trees.get(entryRel) if (!sub) continue entries.push({ kind: KIND_DIR, exec: 0, name: normalizeName(name), childHash: sub.hash, size: sub.size }) totalSize += sub.size } else if (stat.isFile()) { const content = fs.readFileSync(entryAbs) const childHash = crypto.data(content).toString('hex') // Executable bit from stat.mode — works on POSIX; Windows always 0 const exec = (stat.mode & 0o100) ? 1 : 0 entries.push({ kind: KIND_FILE, exec, name: normalizeName(name), childHash, size: stat.size }) totalSize += stat.size } // device files, sockets, fifos: silently skipped (unrepresentable) } entries.sort(compareEntries) const hash = computeTreeHash(entries) trees.set(relPath, { hash, entries, size: totalSize }) } visit('') return trees } // ── Publish-time validation (consumer policy) ───────────────── /** * Scan entries (recursively via walkTree output) for cross-platform-hostile * names. Returns an array of {path, name, reason} for every problem found. * Does NOT throw — caller decides how to present. * * @param {Map} trees - from walkTree * @returns {Array<{path: string, name: string, reason: string}>} */ export function validateForPublish (trees) { const problems = [] for (const [relPath, tree] of trees) { for (const e of tree.entries) { const reason = windowsIncompatibleReason(e.name) if (reason) { problems.push({ path: relPath ? relPath + '/' + e.name : e.name, name: e.name, reason }) } } } return problems } function isBuffer(value) { return Buffer.isBuffer(value) || value instanceof Uint8Array } function isEncoding(encoding) { return Buffer.isEncoding(encoding) } function alloc(size, fill, encoding) { return Buffer.alloc(size, fill, encoding) } function allocUnsafe(size) { return Buffer.allocUnsafe(size) } function allocUnsafeSlow(size) { return Buffer.allocUnsafeSlow(size) } function byteLength(string, encoding) { return Buffer.byteLength(string, encoding) } function compare(a, b) { return Buffer.compare(a, b) } function concat(buffers, totalLength) { return Buffer.concat(buffers, totalLength) } function copy(source, target, targetStart, start, end) { return toBuffer(source).copy(target, targetStart, start, end) } function equals(a, b) { return toBuffer(a).equals(b) } function fill(buffer, value, offset, end, encoding) { return toBuffer(buffer).fill(value, offset, end, encoding) } function from(value, encodingOrOffset, length) { return Buffer.from(value, encodingOrOffset, length) } function includes(buffer, value, byteOffset, encoding) { return toBuffer(buffer).includes(value, byteOffset, encoding) } function indexOf(buffer, value, byfeOffset, encoding) { return toBuffer(buffer).indexOf(value, byfeOffset, encoding) } function lastIndexOf(buffer, value, byteOffset, encoding) { return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding) } function swap16(buffer) { return toBuffer(buffer).swap16() } function swap32(buffer) { return toBuffer(buffer).swap32() } function swap64(buffer) { return toBuffer(buffer).swap64() } function toBuffer(buffer) { if (Buffer.isBuffer(buffer)) return buffer return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength) } function toString(buffer, encoding, start, end) { return toBuffer(buffer).toString(encoding, start, end) } function write(buffer, string, offset, length, encoding) { return toBuffer(buffer).write(string, offset, length, encoding) } function readDoubleBE(buffer, offset) { return toBuffer(buffer).readDoubleBE(offset) } function readDoubleLE(buffer, offset) { return toBuffer(buffer).readDoubleLE(offset) } function readFloatBE(buffer, offset) { return toBuffer(buffer).readFloatBE(offset) } function readFloatLE(buffer, offset) { return toBuffer(buffer).readFloatLE(offset) } function readInt32BE(buffer, offset) { return toBuffer(buffer).readInt32BE(offset) } function readInt32LE(buffer, offset) { return toBuffer(buffer).readInt32LE(offset) } function readUInt32BE(buffer, offset) { return toBuffer(buffer).readUInt32BE(offset) } function readUInt32LE(buffer, offset) { return toBuffer(buffer).readUInt32LE(offset) } function writeDoubleBE(buffer, value, offset) { return toBuffer(buffer).writeDoubleBE(value, offset) } function writeDoubleLE(buffer, value, offset) { return toBuffer(buffer).writeDoubleLE(value, offset) } function writeFloatBE(buffer, value, offset) { return toBuffer(buffer).writeFloatBE(value, offset) } function writeFloatLE(buffer, value, offset) { return toBuffer(buffer).writeFloatLE(value, offset) } function writeInt32BE(buffer, value, offset) { return toBuffer(buffer).writeInt32BE(value, offset) } function writeInt32LE(buffer, value, offset) { return toBuffer(buffer).writeInt32LE(value, offset) } function writeUInt32BE(buffer, value, offset) { return toBuffer(buffer).writeUInt32BE(value, offset) } function writeUInt32LE(buffer, value, offset) { return toBuffer(buffer).writeUInt32LE(value, offset) } module.exports = { isBuffer, isEncoding, alloc, allocUnsafe, allocUnsafeSlow, byteLength, compare, concat, copy, equals, fill, from, includes, indexOf, lastIndexOf, swap16, swap32, swap64, toBuffer, toString, write, readDoubleBE, readDoubleLE, readFloatBE, readFloatLE, readInt32BE, readInt32LE, readUInt32BE, readUInt32LE, writeDoubleBE, writeDoubleLE, writeFloatBE, writeFloatLE, writeInt32BE, writeInt32LE, writeUInt32BE, writeUInt32LE } { "name": "b4a", "version": "1.8.1", "description": "Bridging the gap between buffers and typed arrays", "exports": { "./package": "./package.json", ".": { "react-native": "./react-native.js", "browser": "./browser.js", "default": "./index.js" } }, "files": [ "browser.js", "index.js", "react-native.js", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.mjs", "test:node": "brittle-node --coverage test.mjs" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/b4a.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/b4a/issues" }, "homepage": "https://github.com/holepunchto/b4a#readme", "devDependencies": { "brittle": "^3.5.2", "lunte": "^1.7.0", "nanobench": "^3.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "react-native-b4a": "*" }, "peerDependenciesMeta": { "react-native-b4a": { "optional": true } } } const ESC = '\x1b' const CSI = ESC + '[' const SGR = (n) => CSI + n + 'm' exports.constants = { ESC, CSI, SGR } // https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_(Control_Sequence_Introducer)_sequences exports.cursorHide = CSI + '?25l' exports.cursorShow = CSI + '?25h' exports.cursorUp = function cursorUp(n = 1) { return CSI + n + 'A' } exports.cursorDown = function cursorDown(n = 1) { return CSI + n + 'B' } exports.cursorForward = function cursorForward(n = 1) { return CSI + n + 'C' } exports.cursorBack = function cursorBack(n = 1) { return CSI + n + 'D' } exports.cursorNextLine = function cursorNextLine(n = 1) { return CSI + n + 'E' } exports.cursorPreviousLine = function cursorPreviousLine(n = 1) { return CSI + n + 'F' } exports.cursorPosition = function cursorPosition(column, row = 0) { if (row === 0) return CSI + (column + 1) + 'G' return CSI + (row + 1) + ';' + (column + 1) + 'H' } exports.eraseDisplayEnd = CSI + 'J' exports.eraseDisplayStart = CSI + '1J' exports.eraseDisplay = CSI + '2J' exports.eraseLineEnd = CSI + 'K' exports.eraseLineStart = CSI + '1K' exports.eraseLine = CSI + '2K' exports.scrollUp = function scrollUp(n = 1) { return CSI + n + 'S' } exports.scrollDown = function scrollDown(n = 1) { return CSI + n + 'T' } // https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters exports.modifierReset = SGR(0) exports.modifierBold = SGR(1) exports.modifierDim = SGR(2) exports.modifierItalic = SGR(3) exports.modifierUnderline = SGR(4) exports.modifierNormal = SGR(22) exports.modifierNotItalic = SGR(23) exports.modifierNotUnderline = SGR(24) // https://en.wikipedia.org/wiki/ANSI_escape_code#Colors exports.colorBlack = SGR(30) exports.colorRed = SGR(31) exports.colorGreen = SGR(32) exports.colorYellow = SGR(33) exports.colorBlue = SGR(34) exports.colorMagenta = SGR(35) exports.colorCyan = SGR(36) exports.colorWhite = SGR(37) exports.colorDefault = SGR(39) exports.colorBrightBlack = SGR(90) exports.colorBrightRed = SGR(91) exports.colorBrightGreen = SGR(92) exports.colorBrightYellow = SGR(93) exports.colorBrightBlue = SGR(94) exports.colorBrightMagenta = SGR(95) exports.colorBrightCyan = SGR(96) exports.colorBrightWhite = SGR(97) { "name": "bare-ansi-escapes", "version": "2.2.3", "description": "Parse and produce ANSI escape sequences", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./key-decoder": { "types": "./key-decoder.d.ts", "default": "./key-decoder.js" } }, "files": [ "index.js", "index.d.ts", "key-decoder.js", "key-decoder.d.ts" ], "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-ansi-escapes.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-ansi-escapes/issues" }, "homepage": "https://github.com/holepunchto/bare-ansi-escapes#readme", "dependencies": { "bare-stream": "^2.6.5" }, "devDependencies": { "bare-buffer": "^3.0.2", "brittle": "^3.3.2", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" }, "peerDependencies": { "bare-buffer": "*" }, "peerDependenciesMeta": { "bare-buffer": { "optional": true } } } const inspect = require('bare-inspect') class AssertionError extends Error { constructor(opts = {}) { let { message = null, actual, expected, operator } = opts if (message === null) { message = `${inspect(actual)} ${operator} ${inspect(expected)}` } super(message) this.actual = actual this.expected = expected this.operator = operator } get name() { return 'AssertionError' } get code() { 'ASSERTION' } } function assertFail(opts, fn) { if (opts.message instanceof Error) throw opts.message const err = new AssertionError(opts) if (Error.captureStackTrace) Error.captureStackTrace(err, fn) throw err } module.exports = exports = function assert(actual, message) { if (actual) return assertFail({ message, actual, expected: true, operator: '==' }, assert) } exports.AssertionError = AssertionError exports.fail = function fail(message) { if (message === undefined) message = 'Failed' assertFail({ message, operator: 'fail' }, fail) } exports.ok = function ok(actual, message) { if (actual) return assertFail({ message, actual, expected: true, operator: '==' }, ok) } exports.notOk = function ok(actual, message) { if (!actual) return assertFail({ message, actual, expected: false, operator: '==' }, ok) } exports.equal = function equal(actual, expected, message) { if (actual == expected || (actual !== actual && expected !== expected)) { return } assertFail({ message, actual, expected, operator: '==' }, equal) } exports.notEqual = function notEqual(actual, expected, message) { if (actual != expected && (actual === actual || expected === expected)) { return } assertFail({ message, actual, expected, operator: '!=' }, notEqual) } exports.strictEqual = function strictEqual(actual, expected, message) { if (Object.is(actual, expected)) return assertFail( { message, actual, expected, operator: 'strictEqual' }, strictEqual ) } exports.notStrictEqual = function notStrictEqual(actual, expected, message) { if (!Object.is(actual, expected)) return assertFail( { message, actual, expected, operator: 'notStrictEqual' }, notStrictEqual ) } { "name": "bare-assert", "version": "1.2.0", "description": "Assertion library for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts" ], "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-assert.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-assert/issues" }, "homepage": "https://github.com/holepunchto/bare-assert#readme", "dependencies": { "bare-inspect": "^3.1.2" }, "devDependencies": { "brittle": "^3.1.1", "prettier": "^3.4.2", "prettier-config-standard": "^7.0.0" } } const errors = require('./lib/errors') class EventListener { constructor() { this.list = [] this.count = 0 } append(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.push([fn, once]) } prepend(ctx, name, fn, once) { this.count++ ctx.emit('newListener', name, fn) // Emit BEFORE adding this.list.unshift([fn, once]) } remove(ctx, name, fn) { for (let i = 0, n = this.list.length; i < n; i++) { const l = this.list[i] if (l[0] === fn) { this.list.splice(i, 1) if (this.count === 1) delete ctx._events[name] ctx.emit('removeListener', name, fn) // Emit AFTER removing this.count-- return } } } removeAll(ctx, name) { const list = [...this.list] this.list = [] if (this.count === list.length) delete ctx._events[name] for (let i = list.length - 1; i >= 0; i--) { ctx.emit('removeListener', name, list[i][0]) // Emit AFTER removing } this.count -= list.length } emit(ctx, name, ...args) { const list = [...this.list] for (let i = 0, n = list.length; i < n; i++) { const l = list[i] if (l[1] === true) this.remove(ctx, name, l[0]) Reflect.apply(l[0], ctx, args) } return list.length > 0 } } function appendListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.append(ctx, name, fn, once) return ctx } function prependListener(ctx, name, fn, once) { if (ctx._events === undefined) ctx._events = Object.create(null) const e = ctx._events[name] || (ctx._events[name] = new EventListener()) e.prepend(ctx, name, fn, once) return ctx } function removeListener(ctx, name, fn) { if (ctx._events === undefined) return ctx const e = ctx._events[name] if (e !== undefined) e.remove(ctx, name, fn) return ctx } function throwUnhandledError(...args) { let err if (args.length > 0) err = args[0] if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err) if (Error.captureStackTrace) { Error.captureStackTrace(err, exports.prototype.emit) } queueMicrotask(() => { throw err }) } module.exports = exports = class EventEmitter { constructor() { this._events = Object.create(null) } addListener(name, fn) { return appendListener(this, name, fn, false) } addOnceListener(name, fn) { return appendListener(this, name, fn, true) } prependListener(name, fn) { return prependListener(this, name, fn, false) } prependOnceListener(name, fn) { return prependListener(this, name, fn, true) } removeListener(name, fn) { return removeListener(this, name, fn) } on(name, fn) { return appendListener(this, name, fn, false) } once(name, fn) { return appendListener(this, name, fn, true) } off(name, fn) { return removeListener(this, name, fn) } emit(name, ...args) { if (name === 'error' && this._events !== undefined && this._events.error === undefined) { throwUnhandledError(...args) } if (this._events === undefined) return false const e = this._events[name] return e === undefined ? false : e.emit(this, name, ...args) } listeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : [...e.list] } rawListeners(name) { if (this._events === undefined) return [] const e = this._events[name] return e === undefined ? [] : e.list.map((l) => l[0]) } eventNames() { if (this._events === undefined) return [] return Reflect.ownKeys(this._events) } listenerCount(name) { if (this._events === undefined) return 0 const e = this._events[name] return e === undefined ? 0 : e.list.length } getMaxListeners() { return EventEmitter.defaultMaxListeners } setMaxListeners(n) {} removeAllListeners(name) { if (arguments.length === 0) { for (const key of Reflect.ownKeys(this._events)) { if (key === 'removeListener') continue this.removeAllListeners(key) } this.removeAllListeners('removeListener') } else { const e = this._events[name] if (e !== undefined) e.removeAll(this, name) } return this } } exports.EventEmitter = exports exports.errors = errors exports.defaultMaxListeners = 10 exports.on = function on(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { throw errors.OPERATION_ABORTED(signal.reason) } let error = null let done = false const events = [] const promises = [] if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.on(name, onevent) return { next() { if (events.length) { return Promise.resolve({ value: events.shift(), done: false }) } if (error) { const err = error error = null return Promise.reject(err) } if (done) return onclose() return new Promise((resolve, reject) => promises.push({ resolve, reject })) }, return() { return onclose() }, throw(err) { return onerror(err) }, [Symbol.asyncIterator]() { return this } } function onevent(...args) { if (promises.length) { promises.shift().resolve({ value: args, done: false }) } else { events.push(args) } } function onerror(err) { emitter.off(name, onevent).off('error', onerror) if (promises.length) { promises.shift().reject(err) } else { error = err } return Promise.resolve({ done: true }) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } function onclose() { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) done = true if (promises.length) promises.shift().resolve({ done: true }) return Promise.resolve({ done: true }) } } exports.once = function once(emitter, name, opts = {}) { const { signal } = opts if (signal && signal.aborted) { return Promise.reject(errors.OPERATION_ABORTED(signal.reason)) } return new Promise((resolve, reject) => { if (name !== 'error') emitter.on('error', onerror) if (signal) signal.addEventListener('abort', onabort) emitter.once(name, onevent) function onevent(...args) { if (name !== 'error') emitter.off('error', onerror) if (signal) signal.removeEventListener('abort', onabort) resolve(args) } function onerror(err) { emitter.off(name, onevent) if (name !== 'error') emitter.off('error', onerror) reject(err) } function onabort() { signal.removeEventListener('abort', onabort) onerror(errors.OPERATION_ABORTED(signal.reason)) } }) } exports.forward = function forward(from, to, names, opts = {}) { if (typeof names === 'string') names = [names] const { emit = to.emit.bind(to) } = opts const listeners = names.map( (name) => function onevent(...args) { emit(name, ...args) } ) to.on('newListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.on(name, listeners[i]) } }).on('removeListener', (name) => { const i = names.indexOf(name) if (i !== -1 && to.listenerCount(name) === 0) { from.off(name, listeners[i]) } }) } exports.listenerCount = function listenerCount(emitter, name) { return emitter.listenerCount(name) } exports.getMaxListeners = function getMaxListeners(emitter) { if (typeof emitter.getMaxListeners === 'function') { return emitter.getMaxListeners() } return exports.defaultMaxListeners } exports.setMaxListeners = function setMaxListeners(n, ...emitters) { if (emitters.length === 0) exports.defaultMaxListeners = n else { for (const emitter of emitters) { if (typeof emitter.setMaxListeners === 'function') { emitter.setMaxListeners(n) } } } } module.exports = class EventEmitterError extends Error { constructor(msg, code, fn = EventEmitterError, opts) { super(`${code}: ${msg}`, opts) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'EventEmitterError' } static OPERATION_ABORTED(cause, msg = 'Operation aborted') { return new EventEmitterError(msg, 'OPERATION_ABORTED', EventEmitterError.OPERATION_ABORTED, { cause }) } static UNHANDLED_ERROR(cause, msg = 'Unhandled error') { return new EventEmitterError(msg, 'UNHANDLED_ERROR', EventEmitterError.UNHANDLED_ERROR, { cause }) } } { "name": "bare-events", "version": "2.9.1", "description": "Event emitters for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" }, "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./errors": "./lib/errors.js" }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "web.js", "web.d.ts", "lib" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "npm run test:bare && npm run test:node", "test:bare": "brittle-bare --coverage test.js", "test:node": "brittle-node --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-events.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-events/issues" }, "homepage": "https://github.com/holepunchto/bare-events#readme", "devDependencies": { "bare-abort-controller": "^1.0.0", "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0", "uncaughts": "^1.1.1" }, "peerDependencies": { "bare-abort-controller": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true } } } module.exports = require.addon() const FIFO = require('fast-fifo') const EventEmitter = require('bare-events') const path = require('bare-path') const { isURL, fileURLToPath } = require('bare-url') const { Readable, Writable } = require('bare-stream') const binding = require('./binding') const constants = require('./lib/constants') const FileError = require('./lib/errors') const isWindows = Bare.platform === 'win32' exports.constants = constants class FileRequest { static borrow() { if (this._free.length > 0) return this._free.pop() return new FileRequest() } static return(req) { if (this._free.length < 32) this._free.push(req.reset()) else req.destroy() } constructor() { this._reset() this._handle = binding.requestInit(this, this._onresult) } get handle() { return this._handle } retain(value) { this._retain = value // Tie the lifetime of `value` to the lifetime of `this` } reset() { if (this._handle === null) return this binding.requestReset(this._handle) this._reset() return this } destroy() { if (this._handle === null) return this binding.requestDestroy(this._handle) this._reset() this._handle = null return this } then(resolve, reject) { return this._promise.then(resolve, reject) } return() { if (this._handle === null) return this FileRequest.return(this) return this } _reset() { this._promise = new Promise((resolve, reject) => { this._resolve = resolve this._reject = reject }) this._retain = null } _onresult(err, status) { if (err) this._reject(err) else this._resolve(status) } } FileRequest._free = [] function ok(result, cb) { if (typeof result === 'function') { cb = result result = undefined } if (cb) cb(null, result) else return result } function fail(err, cb) { if (cb) cb(err) else throw err } function done(err, result, cb) { if (typeof result === 'function') { cb = result result = undefined } if (err) fail(err, cb) else return ok(result, cb) } async function open(filepath, flags = 'r', mode = 0o666, cb) { if (typeof flags === 'function') { cb = flags flags = 'r' mode = 0o666 } else if (typeof mode === 'function') { cb = mode mode = 0o666 } if (typeof flags === 'string') flags = toFlags(flags) if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let fd let err = null try { binding.open(req.handle, filepath, flags, mode) fd = await req } catch (e) { err = new FileError(e.message, { operation: 'open', code: e.code, path: filepath }) } finally { req.return() } return done(err, fd, cb) } function openSync(filepath, flags = 'r', mode = 0o666) { if (typeof flags === 'string') flags = toFlags(flags) if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { return binding.openSync(req.handle, filepath, flags, mode) } catch (e) { throw new FileError(e.message, { operation: 'open', code: e.code, path: filepath }) } finally { req.return() } } async function close(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.close(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'close', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function closeSync(fd) { const req = FileRequest.borrow() try { binding.closeSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'close', code: e.code, fd }) } finally { req.return() } } async function access(filepath, mode = constants.F_OK, cb) { if (typeof mode === 'function') { cb = mode mode = constants.F_OK } filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.access(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'access', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function accessSync(filepath, mode = constants.F_OK) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.accessSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'access', code: e.code, path: filepath }) } finally { req.return() } } async function exists(filepath, cb) { let ok = true try { await access(filepath) } catch { ok = false } return done(null, ok, cb) } function existsSync(filepath) { try { accessSync(filepath) } catch { return false } return true } async function read(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1, cb) { if (typeof offset === 'function') { cb = offset offset = 0 len = buffer.byteLength pos = -1 } else if (typeof len === 'function') { cb = len len = buffer.byteLength - offset pos = -1 } else if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.read(req.handle, fd, buffer, offset, len, pos) req.retain(buffer) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'read', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function readSync(fd, buffer, offset = 0, len = buffer.byteLength - offset, pos = -1) { const req = FileRequest.borrow() try { return binding.readSync(req.handle, fd, buffer, offset, len, pos) } catch (e) { throw new FileError(e.message, { operation: 'read', code: e.code, fd }) } finally { req.return() } } async function readv(fd, buffers, pos = -1, cb) { if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.readv(req.handle, fd, buffers, pos) req.retain(buffers) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'readv', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function readvSync(fd, buffers, pos = -1) { if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.readvSync(req.handle, fd, buffers, pos) } catch (e) { throw new FileError(e.message, { operation: 'readv', code: e.code, fd }) } finally { req.return() } } async function write(fd, data, offset, len, pos = -1, cb) { if (typeof data === 'string') { let encoding = len cb = pos pos = offset if (typeof pos === 'function') { cb = pos pos = -1 encoding = 'utf8' } else if (typeof encoding === 'function') { cb = encoding encoding = 'utf8' } if (typeof pos === 'string') { encoding = pos pos = -1 } data = Buffer.from(data, encoding) offset = 0 len = data.byteLength } else if (typeof offset === 'function') { cb = offset offset = 0 len = data.byteLength pos = -1 } else if (typeof len === 'function') { cb = len len = data.byteLength - offset pos = -1 } else if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof offset !== 'number') offset = 0 if (typeof len !== 'number') len = data.byteLength - offset if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.write(req.handle, fd, data, offset, len, pos) req.retain(data) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'write', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function writeSync(fd, data, offset, len, pos = -1) { if (typeof data === 'string') { let encoding = len pos = offset if (typeof pos === 'string') { encoding = pos pos = -1 } data = Buffer.from(data, encoding) offset = 0 len = data.byteLength } if (typeof offset !== 'number') offset = 0 if (typeof len !== 'number') len = data.byteLength - offset if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.writeSync(req.handle, fd, data, offset, len, pos) } catch (e) { throw new FileError(e.message, { operation: 'write', code: e.code, fd }) } finally { req.return() } } async function writev(fd, buffers, pos = -1, cb) { if (typeof pos === 'function') { cb = pos pos = -1 } if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() let bytes let err = null try { binding.writev(req.handle, fd, buffers, pos) req.retain(buffers) bytes = await req } catch (e) { err = new FileError(e.message, { operation: 'writev', code: e.code, fd }) } finally { req.return() } return done(err, bytes, cb) } function writevSync(fd, buffers, pos = -1) { if (typeof pos !== 'number') pos = -1 const req = FileRequest.borrow() try { return binding.writevSync(req.handle, fd, buffers, pos) } catch (e) { throw new FileError(e.message, { operation: 'writev', code: e.code, fd }) } finally { req.return() } } async function stat(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.stat(req.handle, filepath) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'stat', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function statSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.statSync(req.handle, filepath) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'stat', code: e.code, path: filepath }) } finally { req.return() } } async function lstat(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.lstat(req.handle, filepath) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'lstat', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function lstatSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lstatSync(req.handle, filepath) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'lstat', code: e.code, path: filepath }) } finally { req.return() } } async function fstat(fd, cb) { const req = FileRequest.borrow() let st let err = null try { binding.fstat(req.handle, fd) await req st = new Stats(...binding.requestResultStat(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'fstat', code: e.code, fd }) } finally { req.return() } return done(err, st, cb) } function fstatSync(fd) { const req = FileRequest.borrow() try { binding.fstatSync(req.handle, fd) return new Stats(...binding.requestResultStat(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'fstat', code: e.code, fd }) } finally { req.return() } } async function statfs(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let st let err = null try { binding.statfs(req.handle, filepath) await req st = new StatFs(...binding.requestResultStatfs(req.handle)) } catch (e) { err = new FileError(e.message, { operation: 'statfs', code: e.code, path: filepath }) } finally { req.return() } return done(err, st, cb) } function statfsSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.statfsSync(req.handle, filepath) return new StatFs(...binding.requestResultStatfs(req.handle)) } catch (e) { throw new FileError(e.message, { operation: 'statfs', code: e.code, path: filepath }) } finally { req.return() } } async function ftruncate(fd, len = 0, cb) { if (typeof len === 'function') { cb = len len = 0 } if (typeof len !== 'number') len = 0 const req = FileRequest.borrow() let err = null try { binding.ftruncate(req.handle, fd, len) await req } catch (e) { err = new FileError(e.message, { operation: 'ftruncate', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function ftruncateSync(fd, len = 0) { if (typeof len !== 'number') len = 0 const req = FileRequest.borrow() try { binding.ftruncateSync(req.handle, fd, len) } catch (e) { throw new FileError(e.message, { operation: 'ftruncate', code: e.code, fd }) } finally { req.return() } } async function truncate(filepath, len, cb) { let fd = -1 let err try { fd = await open(filepath, 'r+') await ftruncate(fd, len) } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, cb) } function truncateSync(filepath, len) { let fd = -1 let err try { fd = openSync(filepath, 'r+') ftruncateSync(fd, len) } catch (e) { err = e } finally { if (fd !== -1) closeSync(fd) } } async function chmod(filepath, mode, cb) { if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.chmod(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'chmod', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function chmodSync(filepath, mode) { if (typeof mode === 'string') mode = toMode(mode) filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.chmodSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'chmod', code: e.code, path: filepath }) } finally { req.return() } } async function fchmod(fd, mode, cb) { if (typeof mode === 'string') mode = toMode(mode) const req = FileRequest.borrow() let err = null try { binding.fchmod(req.handle, fd, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'fchmod', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fchmodSync(fd, mode) { if (typeof mode === 'string') mode = toMode(mode) const req = FileRequest.borrow() try { binding.fchmodSync(req.handle, fd, mode) } catch (e) { throw new FileError(e.message, { operation: 'fchmod', code: e.code, fd }) } finally { req.return() } } async function chown(filepath, uid, gid, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.chown(req.handle, filepath, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'chown', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function chownSync(filepath, uid, gid) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.chownSync(req.handle, filepath, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'chownSync', code: e.code, path: filepath }) } finally { req.return() } } async function lchown(filepath, uid, gid, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.lchown(req.handle, filepath, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'lchown', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function lchownSync(filepath, uid, gid) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lchownSync(req.handle, filepath, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'lchownSync', code: e.code, path: filepath }) } finally { req.return() } } async function fchown(fd, uid, gid, cb) { const req = FileRequest.borrow() let err = null try { binding.fchown(req.handle, fd, uid, gid) await req } catch (e) { err = new FileError(e.message, { operation: 'fchown', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fchownSync(fd, uid, gid) { const req = FileRequest.borrow() try { binding.fchownSync(req.handle, fd, uid, gid) } catch (e) { throw new FileError(e.message, { operation: 'fchownSync', code: e.code, fd }) } finally { req.return() } } async function utimes(filepath, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.utimes(req.handle, filepath, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'utimes', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function utimesSync(filepath, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.utimesSync(req.handle, filepath, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'utimes', code: e.code, path: filepath }) } finally { req.return() } } async function lutimes(filepath, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.lutimes(req.handle, filepath, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'lutimes', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function lutimesSync(filepath, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.lutimesSync(req.handle, filepath, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'lutimes', code: e.code, path: filepath }) } finally { req.return() } } async function futimes(fd, atime, mtime, cb) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 const req = FileRequest.borrow() let err = null try { binding.futimes(req.handle, fd, atime, mtime) await req } catch (e) { err = new FileError(e.message, { operation: 'futimes', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function futimesSync(fd, atime, mtime) { if (typeof atime !== 'number') atime = atime.getTime() / 1000 if (typeof mtime !== 'number') mtime = mtime.getTime() / 1000 const req = FileRequest.borrow() try { binding.futimesSync(req.handle, fd, atime, mtime) } catch (e) { throw new FileError(e.message, { operation: 'futimesSync', code: e.code, fd }) } finally { req.return() } } async function link(src, dst, cb) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.link(req.handle, src, dst) await req } catch (e) { err = new FileError(e.message, { operation: 'link', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function linkSync(src, dst) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.linkSync(req.handle, src, dst) } catch (e) { throw new FileError(e.message, { operation: 'linkSync', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function mkdir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = { mode: 0o777 } } if (typeof opts === 'number') opts = { mode: opts } else if (!opts) opts = {} const mode = typeof opts.mode === 'number' ? opts.mode : 0o777 filepath = toNamespacedPath(filepath) if (opts.recursive) { let err = null try { try { await mkdir(filepath, { mode }) } catch (err) { if (err.code !== 'ENOENT') { if (!(await stat(filepath)).isDirectory()) throw err } else { while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1) const i = filepath.lastIndexOf(path.sep) if (i <= 0) throw err await mkdir(filepath.slice(0, i), { mode, recursive: true }) try { await mkdir(filepath, { mode }) } catch (err) { if (!(await stat(filepath)).isDirectory()) throw err } } } } catch (e) { err = e } return done(err, cb) } const req = FileRequest.borrow() let err = null try { binding.mkdir(req.handle, filepath, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'mkdir', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function mkdirSync(filepath, opts) { if (typeof opts === 'number') opts = { mode: opts } else if (!opts) opts = {} const mode = typeof opts.mode === 'number' ? opts.mode : 0o777 filepath = toNamespacedPath(filepath) if (opts.recursive) { try { mkdirSync(filepath, { mode }) } catch (err) { if (err.code !== 'ENOENT') { if (!statSync(filepath).isDirectory()) throw err } else { while (filepath.endsWith(path.sep)) filepath = filepath.slice(0, -1) const i = filepath.lastIndexOf(path.sep) if (i <= 0) throw err mkdirSync(filepath.slice(0, i), { mode, recursive: true }) try { mkdirSync(filepath, { mode }) } catch (err) { if (!statSync(filepath).isDirectory()) throw err } } } return } const req = FileRequest.borrow() try { binding.mkdirSync(req.handle, filepath, mode) } catch (e) { throw new FileError(e.message, { operation: 'mkdir', code: e.code, path: filepath }) } finally { req.return() } } async function mkdtemp(prefix, cb) { prefix = toNamespacedPath(prefix) const req = FileRequest.borrow() let res let err = null try { binding.mkdtemp(req.handle, prefix + 'XXXXXX') await req res = binding.requestResultPath(req.handle) } catch (e) { err = new FileError(e.message, { operation: 'mkdtemp', code: e.code, path: prefix }) } finally { req.return() } return done(err, res, cb) } function mkdtempSync(prefix) { prefix = toNamespacedPath(prefix) const req = FileRequest.borrow() try { binding.mkdtempSync(req.handle, prefix + 'XXXXXX') return binding.requestResultPath(req.handle) } catch (e) { throw new FileError(e.message, { operation: 'mkdtempSync', code: e.code, path: prefix }) } finally { req.return() } } async function rmdir(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.rmdir(req.handle, filepath) await req } catch (e) { err = new FileError(e.message, { operation: 'rmdir', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function rmdirSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.rmdirSync(req.handle, filepath) } catch (e) { throw new FileError(e.message, { operation: 'rmdir', code: e.code, path: filepath }) } finally { req.return() } } async function rm(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} filepath = toNamespacedPath(filepath) let err = null try { const st = await lstat(filepath) if (st.isDirectory()) { if (opts.recursive) { try { await rmdir(filepath) } catch (err) { if (err.code !== 'ENOTEMPTY') throw err const files = await readdir(filepath) for (const file of files) { await rm(filepath + path.sep + file, opts) } await rmdir(filepath) } } else { throw new FileError('is a directory', { operation: 'rm', code: 'EISDIR', path: filepath }) } } else { await unlink(filepath) } } catch (e) { if (e.code !== 'ENOENT' || !opts.force) err = e } return done(err, cb) } function rmSync(filepath, opts) { if (!opts) opts = {} filepath = toNamespacedPath(filepath) try { const st = lstatSync(filepath) if (st.isDirectory()) { if (opts.recursive) { try { rmdirSync(filepath) } catch (err) { if (err.code !== 'ENOTEMPTY') throw err const files = readdirSync(filepath) for (const file of files) { rmSync(filepath + path.sep + file, opts) } rmdirSync(filepath) } } else { throw new FileError('is a directory', { operation: 'rm', code: 'EISDIR', path: filepath }) } } else { unlinkSync(filepath) } } catch (err) { if (err.code !== 'ENOENT' || !opts.force) throw err } } async function unlink(filepath, cb) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let err = null try { binding.unlink(req.handle, filepath) await req } catch (e) { err = new FileError(e.message, { operation: 'unlink', code: e.code, path: filepath }) } finally { req.return() } return done(err, cb) } function unlinkSync(filepath) { filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.unlinkSync(req.handle, filepath) } catch (e) { throw new FileError(e.message, { operation: 'unlink', code: e.code, path: filepath }) } finally { req.return() } } async function rename(src, dst, cb) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.rename(req.handle, src, dst) await req } catch (e) { err = new FileError(e.message, { operation: 'rename', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function renameSync(src, dst) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.renameSync(req.handle, src, dst) } catch (e) { throw new FileError(e.message, { operation: 'rename', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function copyFile(src, dst, mode = 0, cb) { if (typeof mode === 'function') { cb = mode mode = 0 } src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() let err = null try { binding.copyfile(req.handle, src, dst, mode) await req } catch (e) { err = new FileError(e.message, { operation: 'copyfile', code: e.code, path: src, destination: dst }) } finally { req.return() } return done(err, cb) } function copyFileSync(src, dst, mode = 0) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const req = FileRequest.borrow() try { binding.copyfileSync(req.handle, src, dst, mode) } catch (e) { throw new FileError(e.message, { operation: 'copyfile', code: e.code, path: src, destination: dst }) } finally { req.return() } } async function cp(src, dst, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} src = toNamespacedPath(src) dst = toNamespacedPath(dst) let err = null try { const st = await lstat(src) if (st.isDirectory()) { if (opts.recursive !== true) { throw new FileError('is a directory', { operation: 'cp', code: 'EISDIR', path: src }) } try { await lstat(dst) } catch (e) { if (e.code !== 'ENOENT') throw e await mkdir(dst, { mode: st.mode, recursive: true }) } const dir = await opendir(src) for await (const { name } of dir) { await cp(path.join(src, name), path.join(dst, name), opts) } } else if (st.isFile()) { await copyFile(src, dst) await chmod(dst, st.mode) } } catch (e) { err = e } return done(err, cb) } function cpSync(src, dst, opts = {}) { src = toNamespacedPath(src) dst = toNamespacedPath(dst) const st = lstatSync(src) if (st.isDirectory()) { if (opts.recursive !== true) { throw new FileError('is a directory', { operation: 'cp', code: 'EISDIR', path: src }) } try { lstatSync(dst) } catch (e) { if (e.code !== 'ENOENT') throw e mkdirSync(dst, { mode: st.mode, recursive: true }) } const dir = opendirSync(src) for (const { name } of dir) { cpSync(path.join(src, name), path.join(dst, name), opts) } } else if (st.isFile()) { copyFileSync(src, dst) chmodSync(dst, st.mode) } } async function realpath(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let res let err = null try { binding.realpath(req.handle, filepath) await req res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) } catch (e) { err = new FileError(e.message, { operation: 'realpath', code: e.code, path: filepath }) } finally { req.return() } return done(err, res, cb) } function realpathSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.realpathSync(req.handle, filepath) let res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) return res } catch (e) { throw new FileError(e.message, { operation: 'realpath', code: e.code, path: filepath }) } finally { req.return() } } async function readlink(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let res let err = null try { binding.readlink(req.handle, filepath) await req res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) } catch (e) { err = new FileError(e.message, { operation: 'readlink', code: e.code, path: filepath }) } finally { req.return() } return done(err, res, cb) } function readlinkSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'utf8' } = opts filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.readlinkSync(req.handle, filepath) let res = Buffer.from(binding.requestResultString(req.handle)) if (encoding !== 'buffer') res = res.toString(encoding) return res } catch (e) { throw new FileError(e.message, { operation: 'readlink', code: e.code, path: filepath }) } finally { req.return() } } async function fsync(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.fsync(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'fsync', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fsyncSync(fd) { const req = FileRequest.borrow() try { binding.fsyncSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'fsyncSync', code: e.code, fd }) } finally { req.return() } } async function fdatasync(fd, cb) { const req = FileRequest.borrow() let err = null try { binding.fdatasync(req.handle, fd) await req } catch (e) { err = new FileError(e.message, { operation: 'fdatasync', code: e.code, fd }) } finally { req.return() } return done(err, cb) } function fdatasyncSync(fd) { const req = FileRequest.borrow() try { binding.fdatasyncSync(req.handle, fd) } catch (e) { throw new FileError(e.message, { operation: 'fdatasyncSync', code: e.code, fd }) } finally { req.return() } } function normalizeSymlinkTarget(target, type, filepath) { if (isWindows) { if (type === constants.UV_FS_SYMLINK_JUNCTION) target = path.resolve(filepath, '..', target) if (path.isAbsolute(target)) return path.toNamespacedPath(target) return target.replace(/\//g, path.sep) } return target } async function symlink(target, filepath, type, cb) { if (typeof type === 'function') { cb = type type = null } filepath = toNamespacedPath(filepath) if (typeof type === 'string') { switch (type) { case 'dir': type = constants.UV_FS_SYMLINK_DIR break case 'junction': type = constants.UV_FS_SYMLINK_JUNCTION break case 'file': default: type = 0 break } } else if (typeof type !== 'number') { if (isWindows) { target = path.resolve(filepath, '..', target) try { type = (await stat(target)).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION } catch { type = 0 } } else { type = 0 } } target = normalizeSymlinkTarget(target, type, filepath) const req = FileRequest.borrow() let err = null try { binding.symlink(req.handle, target, filepath, type) await req } catch (e) { err = new FileError(e.message, { operation: 'symlink', code: e.code, path: target, destination: filepath }) } finally { req.return() } return done(err, cb) } function symlinkSync(target, filepath, type) { filepath = toNamespacedPath(filepath) if (typeof type === 'string') { switch (type) { case 'dir': type = constants.UV_FS_SYMLINK_DIR break case 'junction': type = constants.UV_FS_SYMLINK_JUNCTION break case 'file': default: type = 0 break } } else if (typeof type !== 'number') { if (isWindows) { target = path.resolve(filepath, '..', target) try { type = statSync(target).isDirectory() ? constants.UV_FS_SYMLINK_DIR : constants.UV_FS_SYMLINK_JUNCTION } catch { type = 0 } } else { type = 0 } } target = normalizeSymlinkTarget(target, type, filepath) const req = FileRequest.borrow() try { binding.symlinkSync(req.handle, target, filepath, type) } catch (e) { throw new FileError(e.message, { operation: 'symlink', code: e.code, path: target, destination: filepath }) } finally { req.return() } } async function opendir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() let dir let err = null try { binding.opendir(req.handle, filepath) await req dir = new Dir(filepath, binding.requestResultDir(req.handle), opts) } catch (e) { err = new FileError(e.message, { operation: 'opendir', code: e.code, path: filepath }) } finally { req.return() } return done(err, dir, cb) } function opendirSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) const req = FileRequest.borrow() try { binding.opendirSync(req.handle, filepath) return new Dir(filepath, binding.requestResultDir(req.handle), opts) } catch (e) { throw new FileError(e.message, { operation: 'opendir', code: e.code, path: filepath }) } finally { req.return() } } async function readdir(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { withFileTypes = false, recursive = false } = opts filepath = toNamespacedPath(filepath) const queue = [filepath] let result = [] let err = null try { while (queue.length !== 0) { const dir = await opendir(queue.pop()) for await (const entry of dir) { const entryPath = path.join(entry.parentPath, entry.name) if (withFileTypes) { result.push(entry) } else { result.push(path.relative(filepath, entryPath)) } if (recursive && entry.isDirectory()) queue.push(entryPath) } } } catch (e) { result = [] err = e } return done(err, result, cb) } function readdirSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { withFileTypes = false, recursive = false } = opts filepath = toNamespacedPath(filepath) const queue = [filepath] const result = [] while (queue.length !== 0) { const dir = opendirSync(queue.pop(), opts) for (const entry of dir) { const entryPath = path.join(entry.parentPath, entry.name) if (withFileTypes) { result.push(entry) } else { result.push(path.relative(filepath, entryPath)) } if (recursive && entry.isDirectory()) queue.push(entryPath) } } return result } async function readFile(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'buffer' } = opts let fd = -1 let buffer = null let err = null try { fd = await open(filepath, opts.flag || 'r') const st = await fstat(fd) let len = 0 if (st.size === 0) { const buffers = [] while (true) { buffer = Buffer.allocUnsafe(8192) const r = await read(fd, buffer) len += r if (r === 0) break buffers.push(buffer.subarray(0, r)) } buffer = Buffer.concat(buffers) } else { buffer = Buffer.allocUnsafe(st.size) while (true) { const r = await read(fd, len ? buffer.subarray(len) : buffer) len += r if (r === 0 || len === buffer.byteLength) break } if (len !== buffer.byteLength) buffer = buffer.subarray(0, len) } if (encoding !== 'buffer') buffer = buffer.toString(encoding) } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, buffer, cb) } function readFileSync(filepath, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} const { encoding = 'buffer' } = opts let fd = -1 try { fd = openSync(filepath, opts.flag || 'r') const st = fstatSync(fd) let buffer let len = 0 if (st.size === 0) { const buffers = [] while (true) { buffer = Buffer.allocUnsafe(8192) const r = readSync(fd, buffer) len += r if (r === 0) break buffers.push(buffer.subarray(0, r)) } buffer = Buffer.concat(buffers) } else { buffer = Buffer.allocUnsafe(st.size) while (true) { const r = readSync(fd, len ? buffer.subarray(len) : buffer) len += r if (r === 0 || len === buffer.byteLength) break } if (len !== buffer.byteLength) buffer = buffer.subarray(0, len) } if (encoding !== 'buffer') buffer = buffer.toString(encoding) return buffer } finally { if (fd !== -1) closeSync(fd) } } async function writeFile(filepath, data, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (typeof data === 'string') data = Buffer.from(data, opts.encoding) let fd = -1 let len = 0 let err = null try { fd = await open(filepath, opts.flag || 'w', opts.mode || 0o666) while (true) { len += await write(fd, len ? data.subarray(len) : data) if (len === data.byteLength) break } } catch (e) { err = e } finally { if (fd !== -1) await close(fd) } return done(err, len, cb) } function writeFileSync(filepath, data, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (typeof data === 'string') data = Buffer.from(data, opts.encoding) let fd = -1 try { fd = openSync(filepath, opts.flag || 'w', opts.mode || 0o666) let len = 0 while (true) { len += writeSync(fd, len ? data.subarray(len) : data) if (len === data.byteLength) break } } finally { if (fd !== -1) closeSync(fd) } } function appendFile(filepath, data, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (!opts.flag) opts = { ...opts, flag: 'a' } return writeFile(filepath, data, opts, cb) } function appendFileSync(filepath, data, opts) { if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} if (!opts.flag) opts = { ...opts, flag: 'a' } return writeFileSync(filepath, data, opts) } function watch(filepath, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (typeof opts === 'string') opts = { encoding: opts } else if (!opts) opts = {} filepath = toNamespacedPath(filepath) return new Watcher(filepath, opts, cb) } class Stats { constructor( dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs ) { this.dev = dev this.mode = mode this.nlink = nlink this.uid = uid this.gid = gid this.rdev = rdev this.blksize = blksize this.ino = ino this.size = size this.blocks = blocks this.atimeMs = atimeMs this.mtimeMs = mtimeMs this.ctimeMs = ctimeMs this.birthtimeMs = birthtimeMs this.atime = new Date(atimeMs) this.mtime = new Date(mtimeMs) this.ctime = new Date(ctimeMs) this.birthtime = new Date(birthtimeMs) } isDirectory() { return (this.mode & constants.S_IFMT) === constants.S_IFDIR } isFile() { return (this.mode & constants.S_IFMT) === constants.S_IFREG } isBlockDevice() { return (this.mode & constants.S_IFMT) === constants.S_IFBLK } isCharacterDevice() { return (this.mode & constants.S_IFMT) === constants.S_IFCHR } isFIFO() { return (this.mode & constants.S_IFMT) === constants.S_IFIFO } isSymbolicLink() { return (this.mode & constants.S_IFMT) === constants.S_IFLNK } isSocket() { return (this.mode & constants.S_IFMT) === constants.S_IFSOCK } } class StatFs { constructor(type, bsize, blocks, bfree, bavail, files, ffree) { this.type = type this.bsize = bsize this.blocks = blocks this.bfree = bfree this.bavail = bavail this.files = files this.ffree = ffree } } class Dir { constructor(path, handle, opts = {}) { const { encoding = 'utf8', bufferSize = 32 } = opts this.path = path this._encoding = encoding this._capacity = bufferSize this._buffer = new FIFO() this._ended = false this._handle = handle } async read(cb) { if (this._buffer.length) return ok(this._buffer.shift(), cb) if (this._ended) return ok(null, cb) const req = FileRequest.borrow() let entries let err = null try { req.retain(binding.readdir(req.handle, this._handle, this._capacity)) await req entries = binding.requestResultDirents(req.handle) } catch (e) { err = new FileError(e.message, { operation: 'readdir', code: e.code, path: this.path }) } finally { req.return() } if (err) return fail(err, cb) if (entries.length === 0) { this._ended = true return ok(null, cb) } for (const entry of entries) { let name = Buffer.from(entry.name) if (this._encoding !== 'buffer') name = name.toString(this._encoding) this._buffer.push(new Dirent(this.path, name, entry.type)) } return ok(this._buffer.shift(), cb) } readSync() { if (this._buffer.length) return this._buffer.shift() if (this._ended) return null const req = FileRequest.borrow() let entries try { req.retain(binding.readdirSync(req.handle, this._handle, this._capacity)) entries = binding.requestResultDirents(req.handle) } catch (e) { throw new FileError(e.message, { operation: 'readdir', code: e.code, path: this.path }) } finally { req.return() } if (entries.length === 0) { this._ended = true return null } for (const entry of entries) { let name = Buffer.from(entry.name) if (this._encoding !== 'buffer') name = name.toString(this._encoding) this._buffer.push(new Dirent(this.path, name, entry.type)) } return this._buffer.shift() } async close(cb) { const req = FileRequest.borrow() let err = null try { binding.closedir(req.handle, this._handle) await req } catch (e) { err = new FileError(e.message, { operation: 'closedir', code: e.code, path: this.path }) } finally { req.return() } this._handle = null return done(err, cb) } closeSync() { const req = FileRequest.borrow() try { binding.closedirSync(req.handle, this._handle) } catch (e) { throw new FileError(e.message, { operation: 'closedir', code: e.code, path: this.path }) } finally { req.return() } this._handle = null } [Symbol.dispose]() { this.closeSync() } async [Symbol.asyncDispose]() { await this.close() } *[Symbol.iterator]() { while (true) { const entry = this.readSync() if (entry === null) break yield entry } this.closeSync() } async *[Symbol.asyncIterator]() { while (true) { const entry = await this.read() if (entry === null) break yield entry } await this.close() } } class Dirent { constructor(parentPath, name, type) { this.parentPath = parentPath this.name = name this.type = type } isFile() { return this.type === constants.UV_DIRENT_FILE } isDirectory() { return this.type === constants.UV_DIRENT_DIR } isSymbolicLink() { return this.type === constants.UV_DIRENT_LINK } isFIFO() { return this.type === constants.UV_DIRENT_FIFO } isSocket() { return this.type === constants.UV_DIRENT_SOCKET } isCharacterDevice() { return this.type === constants.UV_DIRENT_CHAR } isBlockDevice() { return this.type === constants.UV_DIRENT_BLOCK } } class FileReadStream extends Readable { constructor(path, opts = {}) { const { eagerOpen = true } = opts super({ eagerOpen, ...opts }) this.path = path this.fd = typeof opts.fd === 'number' ? opts.fd : -1 this.flags = opts.flags || 'r' this.mode = opts.mode || 0o666 this._offset = opts.start || 0 this._missing = 0 if (opts.length) { this._missing = opts.length } else if (typeof opts.end === 'number') { this._missing = opts.end - this._offset + 1 } else { this._missing = -1 } } async _open(cb) { let err if (this.fd === -1) { err = null try { this.fd = await open(this.path, this.flags, this.mode) } catch (e) { err = e } if (err) return cb(err) } let st err = null try { st = await fstat(this.fd) } catch (e) { err = e } if (err) return cb(err) if (this._missing === -1) this._missing = st.size if (st.size < this._offset) { this._offset = st.size this._missing = 0 } else if (st.size < this._offset + this._missing) { this._missing = st.size - this._offset } cb(null) } async _read(size) { if (this._missing <= 0) return this.push(null) const data = Buffer.allocUnsafe(Math.min(this._missing, size)) let len let err = null try { len = await read(this.fd, data, 0, data.byteLength, this._offset) } catch (e) { err = e } if (err) return this.destroy(err) if (len === 0) return this.push(null) if (this._missing < len) len = this._missing this._missing -= len this._offset += len this.push(data.subarray(0, len)) } async _destroy(err, cb) { if (this.fd === -1) return cb(err) try { await close(this.fd) } catch (e) { err = err || e } cb(err) } } class FileWriteStream extends Writable { constructor(path, opts = {}) { const { eagerOpen = true } = opts super({ eagerOpen, ...opts }) this.path = path this.fd = typeof opts.fd === 'number' ? opts.fd : -1 this.flags = opts.flags || 'w' this.mode = opts.mode || 0o666 } async _open(cb) { if (this.fd !== -1) return cb(null) let err = null try { this.fd = await open(this.path, this.flags, this.mode) } catch (e) { err = e } cb(err) } async _writev(batch, cb) { let err = null try { await writev( this.fd, batch.map(({ chunk }) => chunk) ) } catch (e) { err = e } cb(err) } async _destroy(err, cb) { if (this.fd === -1) return cb(err) try { await close(this.fd) } catch (e) { err = err || e } cb(err) } } class Watcher extends EventEmitter { constructor(path, opts, onchange) { if (typeof opts === 'function') { onchange = opts opts = {} } if (!opts) opts = {} const { persistent = true, recursive = false, encoding = 'utf8' } = opts super() this._closed = false this._encoding = encoding this._handle = binding.watcherInit(path, recursive, this, this._onevent, this._onclose) if (!persistent) this.unref() if (onchange) this.on('change', onchange) } close() { if (this._closed) return this._closed = true binding.watcherClose(this._handle) } ref() { if (this._handle) binding.watcherRef(this._handle) return this } unref() { if (this._handle) binding.watcherUnref(this._handle) return this } [Symbol.asyncIterator]() { const buffer = [] let done = false let error = null let next = null this.on('change', (eventType, filename) => { if (next) { next.resolve({ done: false, value: { eventType, filename } }) next = null } else { buffer.push({ eventType, filename }) } }) .on('error', (err) => { done = true error = err if (next) { next.reject(error) next = null } }) .on('close', () => { done = true if (next) { next.resolve({ done }) next = null } }) return { next: () => new Promise((resolve, reject) => { if (error) return reject(error) if (buffer.length) return resolve({ done: false, value: buffer.shift() }) if (done) return resolve({ done }) next = { resolve, reject } }) } } _onevent(err, events, filename) { if (err) { this.close() this.emit('error', err) } else { const path = this._encoding === 'buffer' ? Buffer.from(filename) : Buffer.from(filename).toString(this._encoding) if (events & binding.UV_RENAME) { this.emit('change', 'rename', path) } if (events & binding.UV_CHANGE) { this.emit('change', 'change', path) } } } _onclose() { this._handle = null this.emit('close') } } exports.access = access exports.appendFile = appendFile exports.chmod = chmod exports.chown = chown exports.close = close exports.copyFile = copyFile exports.cp = cp exports.exists = exists exports.fchmod = fchmod exports.fchown = fchown exports.fdatasync = fdatasync exports.fstat = fstat exports.fsync = fsync exports.ftruncate = ftruncate exports.futimes = futimes exports.lchown = lchown exports.lutimes = lutimes exports.link = link exports.lstat = lstat exports.mkdir = mkdir exports.mkdtemp = mkdtemp exports.open = open exports.opendir = opendir exports.read = read exports.readFile = readFile exports.readdir = readdir exports.readlink = readlink exports.readv = readv exports.realpath = realpath exports.rename = rename exports.rm = rm exports.rmdir = rmdir exports.stat = stat exports.statfs = statfs exports.symlink = symlink exports.truncate = truncate exports.unlink = unlink exports.utimes = utimes exports.watch = watch exports.write = write exports.writeFile = writeFile exports.writev = writev exports.accessSync = accessSync exports.appendFileSync = appendFileSync exports.chmodSync = chmodSync exports.chownSync = chownSync exports.closeSync = closeSync exports.copyFileSync = copyFileSync exports.cpSync = cpSync exports.existsSync = existsSync exports.fchmodSync = fchmodSync exports.fchownSync = fchownSync exports.fdatasyncSync = fdatasyncSync exports.fstatSync = fstatSync exports.fsyncSync = fsyncSync exports.ftruncateSync = ftruncateSync exports.futimesSync = futimesSync exports.lchownSync = lchownSync exports.lutimesSync = lutimesSync exports.linkSync = linkSync exports.lstatSync = lstatSync exports.mkdirSync = mkdirSync exports.mkdtempSync = mkdtempSync exports.openSync = openSync exports.opendirSync = opendirSync exports.readFileSync = readFileSync exports.readSync = readSync exports.readdirSync = readdirSync exports.readlinkSync = readlinkSync exports.readvSync = readvSync exports.realpathSync = realpathSync exports.renameSync = renameSync exports.rmSync = rmSync exports.rmdirSync = rmdirSync exports.statSync = statSync exports.statfsSync = statfsSync exports.symlinkSync = symlinkSync exports.truncateSync = truncateSync exports.unlinkSync = unlinkSync exports.utimesSync = utimesSync exports.writeFileSync = writeFileSync exports.writeSync = writeSync exports.writevSync = writevSync exports.promises = require('./promises') exports.Stats = Stats exports.StatFs = StatFs exports.Dir = Dir exports.Dirent = Dirent exports.Watcher = Watcher exports.ReadStream = FileReadStream exports.createReadStream = function createReadStream(path, opts) { return new FileReadStream(path, opts) } exports.WriteStream = FileWriteStream exports.createWriteStream = function createWriteStream(path, opts) { return new FileWriteStream(path, opts) } function toNamespacedPath(filepath) { if (typeof filepath !== 'string') { if (isURL(filepath)) filepath = fileURLToPath(filepath) else filepath = filepath.toString() } return path.toNamespacedPath(filepath) } function toFlags(flags) { switch (flags) { case 'r': return constants.O_RDONLY case 'rs': // Fall through. case 'sr': return constants.O_RDONLY | constants.O_SYNC case 'r+': return constants.O_RDWR case 'rs+': // Fall through. case 'sr+': return constants.O_RDWR | constants.O_SYNC case 'w': return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY case 'wx': // Fall through. case 'xw': return constants.O_TRUNC | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL case 'w+': return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR case 'wx+': // Fall through. case 'xw+': return constants.O_TRUNC | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL case 'a': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY case 'ax': // Fall through. case 'xa': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_EXCL case 'as': // Fall through. case 'sa': return constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | constants.O_SYNC case 'a+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR case 'ax+': // Fall through. case 'xa+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_EXCL case 'as+': // Fall through. case 'sa+': return constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_SYNC default: return 0 } } function toMode(mode) { return parseInt(mode, 8) } const binding = require('../binding') module.exports = { O_RDWR: binding.O_RDWR, O_RDONLY: binding.O_RDONLY, O_WRONLY: binding.O_WRONLY, O_CREAT: binding.O_CREAT, O_TRUNC: binding.O_TRUNC, O_APPEND: binding.O_APPEND, F_OK: binding.F_OK || 0, R_OK: binding.R_OK || 0, W_OK: binding.W_OK || 0, X_OK: binding.X_OK || 0, S_IFMT: binding.S_IFMT, S_IFREG: binding.S_IFREG, S_IFDIR: binding.S_IFDIR, S_IFCHR: binding.S_IFCHR, S_IFLNK: binding.S_IFLNK, S_IFBLK: binding.S_IFBLK || 0, S_IFIFO: binding.S_IFIFO || 0, S_IFSOCK: binding.S_IFSOCK || 0, S_IRUSR: binding.S_IRUSR || 0, S_IWUSR: binding.S_IWUSR || 0, S_IXUSR: binding.S_IXUSR || 0, S_IRGRP: binding.S_IRGRP || 0, S_IWGRP: binding.S_IWGRP || 0, S_IXGRP: binding.S_IXGRP || 0, S_IROTH: binding.S_IROTH || 0, S_IWOTH: binding.S_IWOTH || 0, S_IXOTH: binding.S_IXOTH || 0, UV_DIRENT_UNKNOWN: binding.UV_DIRENT_UNKNOWN, UV_DIRENT_FILE: binding.UV_DIRENT_FILE, UV_DIRENT_DIR: binding.UV_DIRENT_DIR, UV_DIRENT_LINK: binding.UV_DIRENT_LINK, UV_DIRENT_FIFO: binding.UV_DIRENT_FIFO, UV_DIRENT_SOCKET: binding.UV_DIRENT_SOCKET, UV_DIRENT_CHAR: binding.UV_DIRENT_CHAR, UV_DIRENT_BLOCK: binding.UV_DIRENT_BLOCK, COPYFILE_EXCL: binding.UV_FS_COPYFILE_EXCL, COPYFILE_FICLONE: binding.UV_FS_COPYFILE_FICLONE, COPYFILE_FICLONE_FORCE: binding.UV_FS_COPYFILE_FICLONE_FORCE, UV_FS_SYMLINK_DIR: binding.UV_FS_SYMLINK_DIR, UV_FS_SYMLINK_JUNCTION: binding.UV_FS_SYMLINK_JUNCTION } const os = require('bare-os') module.exports = class FileError extends Error { constructor(msg, opts = {}) { const { code, operation = null, path = null, destination = null, fd = -1 } = opts if (operation !== null) msg += describe(operation, opts) super(`${code}: ${msg}`) this.code = code if (operation !== null) this.operation = operation if (path !== null) this.path = path if (destination !== null) this.destination = destination if (fd !== -1) this.fd = fd } get name() { return 'FileError' } // For Node.js compatibility get errno() { return os.constants.errnos[this.code] } // For Node.js compatibility get syscall() { return this.operation } // For Node.js compatibility get dest() { return this.destination } } function describe(operation, opts) { const { path = null, destination = null, fd = -1 } = opts let result = `, ${operation}` if (path !== null) { result += ` ${JSON.stringify(path)}` if (destination !== null) { result += ` -> ${JSON.stringify(destination)}` } } else if (fd !== -1) { result += ` ${fd}` } return result } { "name": "bare-fs", "version": "4.7.2", "description": "Native file system operations for Bare", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./promises": { "types": "./promises.d.ts", "default": "./promises.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" } }, "files": [ "index.js", "index.d.ts", "promises.js", "promises.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-fs.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-fs/issues" }, "homepage": "https://github.com/holepunchto/bare-fs#readme", "engines": { "bare": ">=1.16.0" }, "dependencies": { "bare-events": "^2.5.4", "bare-path": "^3.0.0", "bare-stream": "^2.6.4", "bare-url": "^2.2.2", "fast-fifo": "^1.3.2" }, "devDependencies": { "bare-buffer": "^3.0.2", "bare-crypto": "^1.11.2", "brittle": "^3.1.1", "cmake-bare": "^1.1.7", "lunte": "^1.6.0", "prettier": "^3.4.1", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "bare-buffer": "*" }, "peerDependenciesMeta": { "bare-buffer": { "optional": true } } } const EventEmitter = require('bare-events') const fs = require('.') class FileHandle extends EventEmitter { constructor(fd) { super() this.fd = fd } async close() { await fs.close(this.fd) this.fd = -1 this.emit('close') } async read(buffer, ...args) { return { bytesRead: await fs.read(this.fd, buffer, ...args), buffer } } async readv(buffers, ...args) { return { bytesRead: await fs.readv(this.fd, buffers, ...args), buffers } } async write(buffer, ...args) { return { bytesWritten: await fs.write(this.fd, buffer, ...args), buffer } } async writev(buffers, ...args) { return { bytesWritten: await fs.writev(this.fd, buffers, ...args), buffers } } async stat() { return fs.fstat(this.fd) } async chmod(mode) { await fs.fchmod(this.fd, mode) } async chown(uid, gid) { await fs.fchown(this.fd, uid, gid) } async datasync() { return fs.fdatasync(this.fd) } async sync() { return fs.fsync(this.fd) } async truncate(len) { await fs.ftruncate(this.fd, len) } async utimes(atime, mtime) { await fs.futimes(this.fd, atime, mtime) } createReadStream(opts) { return fs.createReadStream(null, { ...opts, fd: this.fd }) } createWriteStream(opts) { return fs.createWriteStream(null, { ...opts, fd: this.fd }) } async [Symbol.asyncDispose]() { await this.close() } } exports.open = async function open(filepath, flags, mode) { return new FileHandle(await fs.open(filepath, flags, mode)) } exports.access = fs.access exports.appendFile = fs.appendFile exports.chmod = fs.chmod exports.chown = fs.chown exports.constants = fs.constants exports.copyFile = fs.copyFile exports.cp = fs.cp exports.lchown = fs.lchown exports.lutimes = fs.lutimes exports.link = fs.link exports.lstat = fs.lstat exports.mkdir = fs.mkdir exports.mkdtemp = fs.mkdtemp exports.opendir = fs.opendir exports.readFile = fs.readFile exports.readdir = fs.readdir exports.readlink = fs.readlink exports.realpath = fs.realpath exports.rename = fs.rename exports.rm = fs.rm exports.rmdir = fs.rmdir exports.stat = fs.stat exports.statfs = fs.statfs exports.truncate = fs.truncate exports.symlink = fs.symlink exports.unlink = fs.unlink exports.utimes = fs.utimes exports.watch = fs.watch exports.writeFile = fs.writeFile module.exports = require.addon() const ansiEscapes = require('bare-ansi-escapes') const getType = require('bare-type') const binding = require('./binding') const PLAIN_KEY = /^[a-zA-Z_][a-zA-Z_0-9]*$/ const defaultDepth = 2 const defaultBreakLength = 80 const defaultMaxArrayLength = 40 module.exports = exports = function inspect(value, opts = {}) { const { colors = false, depth = defaultDepth, breakLength = defaultBreakLength, stylize = defaultStylize(colors) } = opts const references = new InspectRefMap() const tree = inspectValue(value, 0, { colors, depth, breakLength, stylize, references }) return tree.toString() } exports.styles = { bigint: ansiEscapes.colorYellow, boolean: ansiEscapes.colorYellow, date: ansiEscapes.colorMagenta, module: ansiEscapes.modifierUnderline, name: ansiEscapes.modifierReset, null: ansiEscapes.modifierBold, number: ansiEscapes.colorYellow, regexp: ansiEscapes.colorRed, special: ansiEscapes.colorCyan, string: ansiEscapes.colorGreen, symbol: ansiEscapes.colorGreen, undefined: ansiEscapes.colorBrightBlack } const styles = exports.styles function defaultStylize(colors) { return function stylize(value, style) { const color = colors && styles[style] if (color) return color + value + ansiEscapes.modifierReset return value } } class InspectRefMap { constructor() { this.refs = new WeakMap() this.ids = new WeakMap() this.nextId = 1 } has(object) { return this.refs.has(object) } get(object) { return this.refs.get(object) || null } set(object, ref) { this.refs.set(object, ref) } id(object) { let id = this.ids.get(object) if (id) return id id = this.nextId++ this.ids.set(object, id) return id } } class InspectNode { constructor(depth, length, opts) { const { breakLength = defaultBreakLength, breakAlways = false } = opts this.depth = depth this.length = length this.breakLength = breakLength this.breakAlways = breakAlways } pad(n, string) { return string.padStart(n, ' ') } indent(n, string) { return ' '.repeat(n) + string } } class InspectRef extends InspectNode { constructor(depth, opts) { super(depth, '[circular *]'.length, opts) this.refs = opts.references this.count = 0 this.circular = false this.color = opts.colors && styles.special } get id() { return this.refs.id(this) } increment() { return ++this.count } decrement() { return --this.count } toString(opts = {}) { const { offset = 0, pad = 0, indent = 0 } = opts let value = this.pad(pad, '[circular *' + this.id + ']') if (this.color) value = this.color + value + ansiEscapes.modifierReset return offset ? value : this.indent(indent, value) } } class InspectLeaf extends InspectNode { constructor(value, color, depth, opts) { const length = value.length if (value.includes('\n')) { value = value.replaceAll('\n', '\n' + ' '.repeat(depth)) opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.value = value this.color = opts.colors && color } toString(opts = {}) { const { offset = 0, pad = 0, indent = 0 } = opts let value = this.pad(pad, this.value) if (this.color) value = this.color + value + ansiEscapes.modifierReset return offset ? value : this.indent(indent, value) } } class InspectPair extends InspectNode { constructor(delim, left, right, depth, opts) { const length = left.length + delim.length + right.length if (left.breakAlways || right.breakAlways) { opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.delim = delim this.left = left this.right = right } toString(opts = {}) { const { indent = 0 } = opts return this.indent( indent, this.left + this.delim + this.right.toString({ indent, offset: this.left.length + this.delim.length }) ) } } class InspectSuspension extends InspectNode { constructor(overflow, depth, opts) { const label = `... ${overflow} more` super(depth, label.length, opts) this.label = label } toString(opts = {}) { const { indent = 0 } = opts return this.indent(indent, this.label) } } class InspectSequence extends InspectNode { constructor(header, footer, delim, values, ref, depth, opts) { const { tabulate = false } = opts const length = (ref.circular ? ''.length + 1 : 0) + header.length + values.reduce( (length, value, i) => length + value.length + (i === 0 ? 0 : delim.length), 0 ) + footer.length if (values.some((value) => value.breakAlways)) { opts = { ...opts, breakAlways: true } } super(depth, length, opts) this.header = header this.footer = footer this.delim = delim this.values = values this.ref = ref this.tabulate = tabulate } toString(opts = {}) { const { offset = 0, indent = 0 } = opts const split = this.breakAlways || (this.values.length && (offset + this.length > this.breakLength || indent * 2 + this.length > this.breakLength)) let header = this.header if (this.ref.circular) { header = ' ' + header } if (this.values.length === 0) { header = header.trimEnd() } if (offset === 0) { header = this.indent(indent, header) } if (split) { header = header.trimEnd() + '\n' } let string = header let columns = 1 let pad = 0 if (this.tabulate) { const widest = this.values.reduce( (length, value) => value.breakAlways ? length : Math.max(length, value.length), 0 ) if (widest) { columns = Math.max( columns, Math.floor( (this.breakLength - indent * 2) / (widest + this.delim.length) ) ) if (columns > 1) pad = widest } } for (let i = 0, n = this.values.length, offset = 0; i < n; i++) { const value = this.values[i] if (split) { let part if (i % columns === 0 || value.breakAlways) { part = value.toString({ indent: indent + 1, pad }) } else { part = value.toString({ pad }) } string += part if (i < n - 1) { if (i % columns === columns - 1 || this.values[i + 1].breakAlways) { string += this.delim.trimEnd() + '\n' } else { string += this.delim } } } else { if (i > 0) string += this.delim string += value.toString({ offset }) offset += value.length } } let footer = this.footer if (this.values.length === 0) { footer = footer.trimStart() } if (split) { string += '\n' + this.indent(indent, footer.trimStart()) } else { string += footer } return string } } function inspectValue(value, depth, opts) { const type = getType(value) if (type.isUndefined()) return inspectUndefined(depth, opts) if (type.isNull()) return inspectNull(depth, opts) if (type.isBoolean()) return inspectBoolean(value, depth, opts) if (type.isNumber()) return inspectNumber(value, depth, opts) if (type.isBigInt()) return inspectBigInt(value, depth, opts) if (type.isString()) return inspectString(value, depth, opts) if (type.isSymbol()) return inspectSymbol(value, depth, opts) if (type.isObject()) return inspectObject(type, value, depth, opts) if (type.isFunction()) return inspectFunction(type, value, depth, opts) if (type.isExternal()) return inspectExternal(value, opts, opts) } function inspectUndefined(depth, opts) { return new InspectLeaf('undefined', styles.undefined, depth, opts) } function inspectNull(depth, opts) { return new InspectLeaf('null', styles.null, depth, opts) } function inspectBoolean(value, depth, opts) { return new InspectLeaf(value.toString(), styles.boolean, depth, opts) } function inspectNumber(value, depth, opts) { let string if (Object.is(value, -0)) { string = '-0' } else { string = value.toString(10) } return new InspectLeaf(string, styles.number, depth, opts) } function inspectBigInt(value, depth, opts) { return new InspectLeaf(value.toString(10) + 'n', styles.bigint, depth, opts) } const STRING_ESCAPES = /[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f'\\\ud800-\udfff]/g function inspectString(value, depth, opts) { // https://tc39.es/ecma262/multipage/structured-data.html#sec-quotejsonstring const string = value.replace(STRING_ESCAPES, (match) => { if (match.length === 2) return match switch (match) { case "'": return "\\'" case '\\': return '\\\\' case '\b': return '\\b' case '\t': return '\\t' case '\n': return '\\n' case '\f': return '\\f' case '\r': return '\\r' default: return '\\u' + match.charCodeAt(0).toString(16).padStart(4, '0') } }) return new InspectLeaf("'" + string + "'", styles.string, depth, opts) } function inspectSymbol(value, depth, opts) { return new InspectLeaf(value.toString(), styles.symbol, depth, opts) } function inspectKey(value, depth, opts) { if (PLAIN_KEY.test(value)) { return new InspectLeaf(value, null, depth, opts) } else { return inspectValue(value, depth, opts) } } function inspectObject(type, object, depth, opts) { const refs = opts.references let ref = refs.get(object) if (ref === null) { ref = new InspectRef(depth, opts) refs.set(object, ref) } else if (ref.count) { ref.circular = true return ref } const maxDepth = typeof opts.depth === 'number' ? opts.depth : Infinity if (maxDepth < depth) { const constructor = object.constructor return new InspectLeaf( '[' + (constructor && constructor.name ? constructor.name : 'Object') + ']', styles.special, depth, opts ) } const inspect = object[Symbol.for('bare.inspect')] || object[Symbol.for('nodejs.util.inspect.custom')] if (typeof inspect === 'function') { const value = inspect.call( object, typeof opts.depth === 'number' ? opts.depth - depth : null, { colors: opts.colors, breakLength: opts.breakLength, stylize: opts.stylize }, exports ) if (typeof value === 'object' && value !== null) { refs.set(value, ref) } if (typeof value !== 'string') { return inspectValue(value, depth, opts) } return new InspectLeaf(value, null, depth, opts) } if (type.isArray()) return inspectArray(object, ref, depth, opts) if (type.isDate()) return inspectDate(object, ref, depth, opts) if (type.isRegExp()) return inspectRegExp(object, ref, depth, opts) if (type.isError()) return inspectError(object, ref, depth, opts) if (type.isPromise()) return inspectPromise(object, ref, depth, opts) if (type.isMap()) return inspectMap(object, ref, depth, opts) if (type.isSet()) return inspectSet(object, ref, depth, opts) if (type.isWeakMap()) return inspectWeakMap(object, ref, depth, opts) if (type.isWeakSet()) return inspectWeakSet(object, ref, depth, opts) if (type.isWeakRef()) return inspectWeakRef(object, ref, depth, opts) if (type.isArrayBuffer()) return inspectArrayBuffer(object, ref, depth, opts) if (type.isSharedArrayBuffer()) return inspectSharedArrayBuffer(object, ref, depth, opts) if (type.isTypedArray()) return inspectTypedArray(object, ref, depth, opts) if (type.isDataView()) return inspectDataView(object, ref, depth, opts) ref.increment() const values = [] for (const key in object) { if (key === 'constructor') continue values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(object[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() let header = '{ ' const tag = object[Symbol.toStringTag] if (tag) header = '[' + tag + '] ' + header if (object.constructor) { const name = object.constructor.name if (name && name !== 'Object') { header = object.constructor.name + ' ' + header } } return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectArray(array, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxArrayLength, 0) for (let i = 0, n = array.length; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(array.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(array[i], depth + 1, opts)) } for (const key of binding.getOwnNonIndexPropertyNames(array)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(array[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() let header = '[ ' if (array.constructor.name !== 'Array') { header = array.constructor.name + '(' + array.length + ') ' + header } return new InspectSequence(header, ' ]', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectDate(date, ref, depth, opts) { return new InspectLeaf(date.toISOString(), styles.date, depth, opts) } function inspectRegExp(regExp, ref, depth, opts) { return new InspectLeaf(regExp.toString(), styles.regexp, depth, opts) } function inspectError(error, ref, depth, opts) { let header if ('stack' in error) { header = error.stack if (depth > 0) { header = header.replaceAll('\n', '\n' + ' '.repeat(depth)) } } else { header = error.toString() } const builtins = ['cause'] if (error.name === 'AggregateError') { builtins.push('errors') } else if (error.name === 'SuppressedError') { builtins.push('error', 'suppressed') } const values = [] for (const key of builtins) { if (key in error === false) continue values.push( new InspectPair( ': ', new InspectLeaf('[' + key + ']', null, depth + 1, opts), inspectValue(error[key], depth + 1, opts), depth + 1, opts ) ) } for (const key in error) { if (key === 'constructor' || builtins.includes(key)) continue values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(error[key], depth + 1, opts), depth + 1, opts ) ) } if (values.length === 0) return new InspectLeaf(header, null, depth, opts) return new InspectSequence( header + ' {', ' }', ', ', values, ref, depth, opts ) } function inspectPromise(promise, ref, depth, opts) { ref.increment() const state = binding.getPromiseState(promise) const values = [] switch (state) { case 0: // Pending values.push(new InspectLeaf('', styles.special, depth, opts)) break case 1: // Fulfilled values.push(inspectValue(binding.getPromiseResult(promise), depth, opts)) break case 2: // Rejected values.push( new InspectLeaf('', styles.special, depth, opts), inspectValue(binding.getPromiseResult(promise), depth, opts) ) } ref.decrement() const header = promise.constructor.name + ' { ' return new InspectSequence(header, ' }', ' ', values, ref, depth, opts) } function inspectMap(map, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxMapLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = maxMapLength for (const entry of map) { if (remaining-- === 0) { values.push( new InspectSuspension(map.size - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push( new InspectPair( ' => ', inspectValue(entry[0], depth + 1, opts), inspectValue(entry[1], depth + 1, opts), depth + 1, opts ) ) } for (const key in map) { if (key === 'constructor') continue const value = inspectValue(map[key], depth + 1, opts) values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), value, depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = map.constructor.name + '(' + map.size + ') { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectSet(set, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxSetLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = maxSetLength for (const entry of set) { if (remaining-- === 0) { values.push( new InspectSuspension(set.size - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(entry, depth + 1, opts)) } for (const key in set) { if (key === 'constructor') continue const value = inspectValue(set[key], depth + 1, opts) values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), value, depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = set.constructor.name + '(' + set.size + ') { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectWeakMap(weakMap, ref, depth, opts) { const header = weakMap.constructor.name + ' { ' return new InspectSequence( header, ' }', ' ', [new InspectLeaf('', styles.special, depth + 1, opts)], ref, depth, opts ) } function inspectWeakSet(weakSet, ref, depth, opts) { const header = weakSet.constructor.name + ' { ' return new InspectSequence( header, ' }', ' ', [new InspectLeaf('', styles.special, depth + 1, opts)], ref, depth, opts ) } function inspectWeakRef(weakRef, ref, depth, opts) { const target = weakRef.deref() let value if (target === undefined) { value = new InspectLeaf('', styles.special, depth + 1, opts) } else { value = inspectValue(target, depth + 1, opts) } const header = weakRef.constructor.name + ' { ' return new InspectSequence(header, ' }', ' ', [value], ref, depth, opts) } function inspectArrayBuffer(arrayBuffer, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(arrayBuffer[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = arrayBuffer.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectSharedArrayBuffer(sharedArrayBuffer, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(sharedArrayBuffer[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = sharedArrayBuffer.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectTypedArray(typedArray, ref, depth, opts) { if (Buffer.isBuffer(typedArray)) { return inspectBuffer(typedArray, ref, depth, opts) } const { maxArrayLength = defaultMaxArrayLength, maxTypedArrayLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxTypedArrayLength, 0) for (let i = 0, n = typedArray.length; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(typedArray.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push(inspectValue(typedArray[i], depth + 1, opts)) } for (const key of binding.getOwnNonIndexPropertyNames(typedArray)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(typedArray[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() const header = typedArray.constructor.name + '(' + typedArray.length + ') [ ' return new InspectSequence(header, ' ]', ', ', values, ref, depth, { ...opts, tabulate: true }) } function inspectBuffer(buffer, ref, depth, opts) { const { maxArrayLength = defaultMaxArrayLength, maxBufferLength = maxArrayLength } = opts ref.increment() const values = [] let remaining = Math.max(maxBufferLength, 0) for (let i = 0, n = buffer.byteLength; i < n; i++) { if (remaining-- === 0) { values.push( new InspectSuspension(buffer.length - values.length, depth + 1, { ...opts, breakAlways: true }) ) break } values.push( new InspectLeaf( buffer[i].toString(16).padStart(2, '0'), null, depth + 1, opts ) ) } for (const key of binding.getOwnNonIndexPropertyNames(buffer)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(buffer[key], depth + 1, opts), depth + 1, { ...opts, breakAlways: remaining < 0 } ) ) } ref.decrement() return new InspectSequence('', ' ', values, ref, depth, { ...opts, tabulate: true }) } function inspectDataView(dataView, ref, depth, opts) { ref.increment() const values = [] for (const key of ['byteLength', 'byteOffset', 'buffer']) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(dataView[key], depth + 1, opts), depth + 1, opts ) ) } for (const key of binding.getOwnNonIndexPropertyNames(dataView)) { values.push( new InspectPair( ': ', inspectKey(key, depth + 1, opts), inspectValue(dataView[key], depth + 1, opts), depth + 1, opts ) ) } ref.decrement() const header = dataView.constructor.name + ' { ' return new InspectSequence(header, ' }', ', ', values, ref, depth, opts) } function inspectFunction(type, fn, depth, opts) { if (fn.toString().startsWith('class')) return inspectClass(fn, depth, opts) let tag = 'function' if (type.isGeneratorFunction()) tag = 'generator ' + tag if (type.isAsyncFunction()) tag = 'async ' + tag return new InspectLeaf( '[' + tag + ' ' + (fn.name ? fn.name : '(anonymous)') + ']', styles.special, depth, opts ) } function inspectClass(ctor, depth, opts) { return new InspectLeaf( '[class ' + (ctor.name ? ctor.name : '(anonymous)') + ']', styles.special, depth, opts ) } function inspectExternal(external, depth, opts) { return new InspectLeaf( '[external 0x' + binding.getExternal(external).toString(16) + ']', styles.special, depth, opts ) } { "name": "bare-inspect", "version": "3.1.4", "description": "Inspect objects as strings for debugging", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-inspect.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-inspect/issues" }, "homepage": "https://github.com/holepunchto/bare-inspect#readme", "engines": { "bare": ">=1.18.0" }, "dependencies": { "bare-ansi-escapes": "^2.1.0", "bare-type": "^1.0.0" }, "devDependencies": { "brittle": "^3.3.2", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const binding = require('./binding') const errors = require('./lib/errors') const constants = require('./lib/constants') exports.constants = constants exports.errors = errors exports.EOL = binding.platform === 'win32' ? '\r\n' : '\n' exports.devNull = binding.platform === 'win32' ? '\\\\.\\nul' : '/dev/null' exports.platform = function platform() { return binding.platform } exports.arch = function arch() { return binding.arch } exports.type = binding.type exports.version = binding.version exports.release = binding.release exports.machine = binding.machine exports.execPath = binding.execPath exports.pid = binding.pid exports.ppid = binding.ppid exports.cwd = binding.cwd exports.chdir = binding.chdir exports.tmpdir = binding.tmpdir exports.homedir = binding.homedir exports.hostname = binding.hostname exports.userInfo = binding.userInfo exports.groupInfo = binding.groupInfo exports.networkInterfaces = function networkInterfaces() { const result = {} for (const entry of binding.networkInterfaces()) { const { name, ...properties } = entry if (result[name]) result[name].push(properties) else result[name] = [properties] } return result } exports.kill = function kill(pid, signal = constants.signals.SIGTERM) { if (typeof signal === 'string') { if (signal in constants.signals === false) { throw errors.UNKNOWN_SIGNAL('Unknown signal: ' + signal) } signal = constants.signals[signal] } binding.kill(pid, signal) } exports.endianness = function endianness() { return binding.isLittleEndian ? 'LE' : 'BE' } exports.availableParallelism = binding.availableParallelism exports.cpuUsage = function cpuUsage(previous) { const current = binding.cpuUsage() if (previous) { return { user: current.user - previous.user, system: current.system - previous.system } } return current } exports.threadCpuUsage = function threadCpuUsage(previous) { const current = binding.threadCpuUsage() if (previous) { return { user: current.user - previous.user, system: current.system - previous.system } } return current } exports.resourceUsage = binding.resourceUsage exports.memoryUsage = binding.memoryUsage exports.freemem = binding.freemem exports.totalmem = binding.totalmem exports.availableMemory = binding.availableMemory exports.constrainedMemory = binding.constrainedMemory exports.uptime = binding.uptime exports.loadavg = binding.loadavg exports.cpus = binding.cpus exports.getProcessTitle = binding.getProcessTitle exports.setProcessTitle = function setProcessTitle(title) { if (typeof title !== 'string') title = title.toString() if (title.length >= 256) { throw errors.TITLE_OVERFLOW('Process title is too long') } binding.setProcessTitle(title) } exports.getPriority = function getPriority(pid = 0) { return binding.getPriority(pid) } exports.setPriority = function setPriority(pid, priority) { if (priority === undefined) { priority = pid pid = 0 } binding.setPriority(pid, priority) } exports.getEnvKeys = binding.getEnvKeys exports.getEnv = binding.getEnv exports.hasEnv = binding.hasEnv exports.setEnv = binding.setEnv exports.unsetEnv = binding.unsetEnv const binding = require('../binding') module.exports = { signals: binding.signals, errnos: binding.errnos, priority: binding.priority } module.exports = class OSError extends Error { constructor(msg, fn = OSError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name() { return 'OSError' } static UNKNOWN_SIGNAL(msg) { return new OSError(msg, OSError.UNKNOWN_SIGNAL) } static TITLE_OVERFLOW(msg) { return new OSError(msg, OSError.TITLE_OVERFLOW) } } { "name": "bare-os", "version": "3.9.1", "description": "Operating system utilities for Bare", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./constants": { "types": "./lib/constants.d.ts", "default": "./lib/constants.js" }, "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors.js" } }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-os.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-os/issues" }, "homepage": "https://github.com/holepunchto/bare-os#readme", "engines": { "bare": ">=1.14.0" }, "devDependencies": { "brittle": "^3.1.1", "cmake-bare": "^1.1.6", "lunte": "^1.6.0", "prettier": "^3.4.2", "prettier-config-holepunch": "^2.0.0" } } // This export SHOULD NOT be shortened in any way as having the full // `module.exports = require(...)` statement is crucial for synthesizing // ESM exports. if (Bare.platform === 'win32') { module.exports = require('./lib/win32') } else { module.exports = require('./lib/posix') } module.exports = { CHAR_UPPERCASE_A: 0x41, CHAR_LOWERCASE_A: 0x61, CHAR_UPPERCASE_Z: 0x5a, CHAR_LOWERCASE_Z: 0x7a, CHAR_DOT: 0x2e, CHAR_FORWARD_SLASH: 0x2f, CHAR_BACKWARD_SLASH: 0x5c, CHAR_COLON: 0x3a, CHAR_QUESTION_MARK: 0x3f } const os = require('bare-os') const { normalizeString } = require('./shared') const { CHAR_DOT, CHAR_FORWARD_SLASH } = require('./constants') function isPosixPathSeparator(code) { return code === CHAR_FORWARD_SLASH } exports.win32 = require('./win32') exports.posix = exports exports.sep = '/' exports.delimiter = ':' exports.resolve = function resolve(...args) { let resolvedPath = '' let resolvedAbsolute = false for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) { const path = i >= 0 ? args[i] : os.cwd() if (path.length === 0) { continue } resolvedPath = `${path}/${resolvedPath}` resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH } resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator) if (resolvedAbsolute) { return `/${resolvedPath}` } return resolvedPath.length > 0 ? resolvedPath : '.' } exports.normalize = function normalize(path) { if (path.length === 0) return '.' const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator) if (path.length === 0) { if (isAbsolute) return '/' return trailingSeparator ? './' : '.' } if (trailingSeparator) path += '/' return isAbsolute ? `/${path}` : path } exports.isAbsolute = function isAbsolute(path) { return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH } exports.join = function join(...args) { if (args.length === 0) return '.' let joined for (let i = 0; i < args.length; ++i) { const arg = args[i] if (arg.length > 0) { if (joined === undefined) joined = arg else joined += `/${arg}` } } if (joined === undefined) return '.' return exports.normalize(joined) } exports.relative = function relative(from, to) { if (from === to) return '' from = exports.resolve(from) to = exports.resolve(to) if (from === to) return '' const fromStart = 1 const fromEnd = from.length const fromLen = fromEnd - fromStart const toStart = 1 const toLen = to.length - toStart const length = fromLen < toLen ? fromLen : toLen let lastCommonSep = -1 let i = 0 for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i) if (fromCode !== to.charCodeAt(toStart + i)) { break } else if (fromCode === CHAR_FORWARD_SLASH) { lastCommonSep = i } } if (i === length) { if (toLen > length) { if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) { return to.substring(toStart + i + 1) } if (i === 0) { return to.substring(toStart + i) } } else if (fromLen > length) { if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) { lastCommonSep = i } else if (i === 0) { lastCommonSep = 0 } } } let out = '' for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { out += out.length === 0 ? '..' : '/..' } } return `${out}${to.substring(toStart + lastCommonSep)}` } exports.toNamespacedPath = function toNamespacedPath(path) { return path } exports.dirname = function dirname(path) { if (path.length === 0) return '.' const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH let end = -1 let matchedSlash = true for (let i = path.length - 1; i >= 1; --i) { if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { if (!matchedSlash) { end = i break } } else { matchedSlash = false } } if (end === -1) return hasRoot ? '/' : '.' if (hasRoot && end === 1) return '//' return path.substring(0, end) } exports.basename = function basename(path, suffix) { let start = 0 let end = -1 let matchedSlash = true if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) { return '' } let extIdx = suffix.length - 1 let firstNonSlashEnd = -1 for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i) if (code === CHAR_FORWARD_SLASH) { if (!matchedSlash) { start = i + 1 break } } else { if (firstNonSlashEnd === -1) { matchedSlash = false firstNonSlashEnd = i + 1 } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) { end = i } } else { extIdx = -1 end = firstNonSlashEnd } } } } if (start === end) end = firstNonSlashEnd else if (end === -1) end = path.length return path.substring(start, end) } for (let i = path.length - 1; i >= 0; --i) { if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { if (!matchedSlash) { start = i + 1 break } } else if (end === -1) { matchedSlash = false end = i + 1 } } if (end === -1) return '' return path.substring(start, end) } exports.extname = function extname(path) { let startDot = -1 let startPart = 0 let end = -1 let matchedSlash = true let preDotState = 0 for (let i = path.length - 1; i >= 0; --i) { const code = path.charCodeAt(i) if (code === CHAR_FORWARD_SLASH) { if (!matchedSlash) { startPart = i + 1 break } continue } if (end === -1) { matchedSlash = false end = i + 1 } if (code === CHAR_DOT) { if (startDot === -1) startDot = i else if (preDotState !== 1) preDotState = 1 } else if (startDot !== -1) { preDotState = -1 } } if ( startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return '' } return path.substring(startDot, end) } const { CHAR_DOT, CHAR_FORWARD_SLASH } = require('./constants') exports.normalizeString = function normalizeString( path, allowAboveRoot, separator, isPathSeparator ) { let res = '' let lastSegmentLength = 0 let lastSlash = -1 let dots = 0 let code = 0 for (let i = 0; i <= path.length; ++i) { if (i < path.length) { code = path.charCodeAt(i) } else if (isPathSeparator(code)) { break } else { code = CHAR_FORWARD_SLASH } if (isPathSeparator(code)) { if (lastSlash === i - 1 || dots === 1); else if (dots === 2) { if ( res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT ) { if (res.length > 2) { const lastSlashIndex = res.lastIndexOf(separator) if (lastSlashIndex === -1) { res = '' lastSegmentLength = 0 } else { res = res.substring(0, lastSlashIndex) lastSegmentLength = res.length - 1 - res.lastIndexOf(separator) } lastSlash = i dots = 0 continue } else if (res.length !== 0) { res = '' lastSegmentLength = 0 lastSlash = i dots = 0 continue } } if (allowAboveRoot) { res += res.length > 0 ? `${separator}..` : '..' lastSegmentLength = 2 } } else { if (res.length > 0) { res += `${separator}${path.substring(lastSlash + 1, i)}` } else { res = path.substring(lastSlash + 1, i) } lastSegmentLength = i - lastSlash - 1 } lastSlash = i dots = 0 } else if (code === CHAR_DOT && dots !== -1) { ++dots } else { dots = -1 } } return res } const os = require('bare-os') const { normalizeString } = require('./shared') const { CHAR_UPPERCASE_A, CHAR_LOWERCASE_A, CHAR_UPPERCASE_Z, CHAR_LOWERCASE_Z, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_QUESTION_MARK } = require('./constants') function isWindowsPathSeparator(code) { return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH } function isWindowsDeviceRoot(code) { return ( (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) || (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ) } exports.posix = require('./posix') exports.win32 = exports exports.sep = '\\' exports.delimiter = ';' exports.resolve = function resolve(...args) { let resolvedDevice = '' let resolvedTail = '' let resolvedAbsolute = false for (let i = args.length - 1; i >= -1; i--) { let path if (i >= 0) { path = args[i] if (path.length === 0) continue } else if (resolvedDevice.length === 0) { path = os.cwd() } else { path = os.getEnv(`=${resolvedDevice}`) || os.cwd() if ( path === undefined || (path.substring(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH) ) { path = `${resolvedDevice}\\` } } const len = path.length let rootEnd = 0 let device = '' let isAbsolute = false const code = path.charCodeAt(0) if (len === 1) { if (isWindowsPathSeparator(code)) { rootEnd = 1 isAbsolute = true } } else if (isWindowsPathSeparator(code)) { isAbsolute = true if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { const firstPart = path.substring(last, j) last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len || j !== last) { device = `\\\\${firstPart}\\${path.substring(last, j)}` rootEnd = j } } } } else { rootEnd = 1 } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.substring(0, 2) rootEnd = 2 if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) { isAbsolute = true rootEnd = 3 } } if (device.length > 0) { if (resolvedDevice.length > 0) { if (device.toLowerCase() !== resolvedDevice.toLowerCase()) { continue } } else { resolvedDevice = device } } if (resolvedAbsolute) { if (resolvedDevice.length > 0) { break } } else { resolvedTail = `${path.substring(rootEnd)}\\${resolvedTail}` resolvedAbsolute = isAbsolute if (isAbsolute && resolvedDevice.length > 0) { break } } } resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\', isWindowsPathSeparator) return resolvedAbsolute ? `${resolvedDevice}\\${resolvedTail}` : `${resolvedDevice}${resolvedTail}` || '.' } exports.normalize = function normalize(path) { const len = path.length if (len === 0) return '.' let rootEnd = 0 let device let isAbsolute = false const code = path.charCodeAt(0) if (len === 1) { return code === CHAR_FORWARD_SLASH ? '\\' : path } if (isWindowsPathSeparator(code)) { isAbsolute = true if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { const firstPart = path.substring(last, j) last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len) { return `\\\\${firstPart}\\${path.substring(last)}\\` } if (j !== last) { device = `\\\\${firstPart}\\${path.substring(last, j)}` rootEnd = j } } } } else { rootEnd = 1 } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.substring(0, 2) rootEnd = 2 if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) { isAbsolute = true rootEnd = 3 } } let tail = rootEnd < len ? normalizeString(path.substring(rootEnd), !isAbsolute, '\\', isWindowsPathSeparator) : '' if (tail.length === 0 && !isAbsolute) { tail = '.' } if (tail.length > 0 && isWindowsPathSeparator(path.charCodeAt(len - 1))) { tail += '\\' } if (device === undefined) { return isAbsolute ? `\\${tail}` : tail } return isAbsolute ? `${device}\\${tail}` : `${device}${tail}` } exports.isAbsolute = function isAbsolute(path) { const len = path.length if (len === 0) return false const code = path.charCodeAt(0) return ( isWindowsPathSeparator(code) || (len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isWindowsPathSeparator(path.charCodeAt(2))) ) } exports.join = function join(...args) { if (args.length === 0) return '.' let joined let firstPart for (let i = 0; i < args.length; ++i) { const arg = args[i] if (arg.length > 0) { if (joined === undefined) joined = firstPart = arg else joined += `\\${arg}` } } if (joined === undefined) return '.' let needsReplace = true let slashCount = 0 if (isWindowsPathSeparator(firstPart.charCodeAt(0))) { ++slashCount const firstLen = firstPart.length if (firstLen > 1 && isWindowsPathSeparator(firstPart.charCodeAt(1))) { ++slashCount if (firstLen > 2) { if (isWindowsPathSeparator(firstPart.charCodeAt(2))) { ++slashCount } else { needsReplace = false } } } } if (needsReplace) { while (slashCount < joined.length && isWindowsPathSeparator(joined.charCodeAt(slashCount))) { slashCount++ } if (slashCount >= 2) { joined = `\\${joined.substring(slashCount)}` } } return exports.normalize(joined) } exports.relative = function relative(from, to) { if (from === to) return '' const fromOrig = exports.resolve(from) const toOrig = exports.resolve(to) if (fromOrig === toOrig) return '' from = fromOrig.toLowerCase() to = toOrig.toLowerCase() if (from === to) return '' let fromStart = 0 while (fromStart < from.length && from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) { fromStart++ } let fromEnd = from.length while (fromEnd - 1 > fromStart && from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) { fromEnd-- } const fromLen = fromEnd - fromStart let toStart = 0 while (toStart < to.length && to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { toStart++ } let toEnd = to.length while (toEnd - 1 > toStart && to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) { toEnd-- } const toLen = toEnd - toStart const length = fromLen < toLen ? fromLen : toLen let lastCommonSep = -1 let i = 0 for (; i < length; i++) { const fromCode = from.charCodeAt(fromStart + i) if (fromCode !== to.charCodeAt(toStart + i)) { break } else if (fromCode === CHAR_BACKWARD_SLASH) { lastCommonSep = i } } if (i !== length) { if (lastCommonSep === -1) return toOrig } else { if (toLen > length) { if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { return toOrig.substring(toStart + i + 1) } if (i === 2) { return toOrig.substring(toStart + i) } } if (fromLen > length) { if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { lastCommonSep = i } else if (i === 2) { lastCommonSep = 3 } } if (lastCommonSep === -1) lastCommonSep = 0 } let out = '' for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) { out += out.length === 0 ? '..' : '\\..' } } toStart += lastCommonSep if (out.length > 0) { return `${out}${toOrig.substring(toStart, toEnd)}` } if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) { ++toStart } return toOrig.substring(toStart, toEnd) } exports.toNamespacedPath = function toNamespacedPath(path) { if (path.length === 0) return path const resolvedPath = exports.resolve(path) if (resolvedPath.length <= 2) return path if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { const code = resolvedPath.charCodeAt(2) if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { return `\\\\?\\UNC\\${resolvedPath.substring(2)}` } } } else if ( isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH ) { return `\\\\?\\${resolvedPath}` } return path } exports.dirname = function dirname(path) { const len = path.length if (len === 0) return '.' let rootEnd = -1 let offset = 0 const code = path.charCodeAt(0) if (len === 1) { return isWindowsPathSeparator(code) ? path : '.' } if (isWindowsPathSeparator(code)) { rootEnd = offset = 1 if (isWindowsPathSeparator(path.charCodeAt(1))) { let j = 2 let last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j < len && j !== last) { last = j while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) { j++ } if (j === len) { return path } if (j !== last) { rootEnd = offset = j + 1 } } } } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { rootEnd = len > 2 && isWindowsPathSeparator(path.charCodeAt(2)) ? 3 : 2 offset = rootEnd } let end = -1 let matchedSlash = true for (let i = len - 1; i >= offset; --i) { if (isWindowsPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { end = i break } } else { matchedSlash = false } } if (end === -1) { if (rootEnd === -1) return '.' end = rootEnd } return path.substring(0, end) } exports.basename = function basename(path, suffix) { let start = 0 let end = -1 let matchedSlash = true if ( path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON ) { start = 2 } if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) return '' let extIdx = suffix.length - 1 let firstNonSlashEnd = -1 for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i) if (isWindowsPathSeparator(code)) { if (!matchedSlash) { start = i + 1 break } } else { if (firstNonSlashEnd === -1) { matchedSlash = false firstNonSlashEnd = i + 1 } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) { end = i } } else { extIdx = -1 end = firstNonSlashEnd } } } } if (start === end) end = firstNonSlashEnd else if (end === -1) end = path.length return path.substring(start, end) } for (let i = path.length - 1; i >= start; --i) { if (isWindowsPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { start = i + 1 break } } else if (end === -1) { matchedSlash = false end = i + 1 } } if (end === -1) return '' return path.substring(start, end) } exports.extname = function extname(path) { let start = 0 let startDot = -1 let startPart = 0 let end = -1 let matchedSlash = true let preDotState = 0 if ( path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0)) ) { start = startPart = 2 } for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i) if (isWindowsPathSeparator(code)) { if (!matchedSlash) { startPart = i + 1 break } continue } if (end === -1) { matchedSlash = false end = i + 1 } if (code === CHAR_DOT) { if (startDot === -1) startDot = i else if (preDotState !== 1) preDotState = 1 } else if (startDot !== -1) { preDotState = -1 } } if ( startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) ) { return '' } return path.substring(startDot, end) } { "name": "bare-path", "version": "3.0.1", "description": "Path manipulation library for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./posix": "./lib/posix.js", "./win32": "./lib/win32.js" }, "files": [ "index.js", "index.d.ts", "lib", "NOTICE" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-path.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-path/issues" }, "homepage": "https://github.com/holepunchto/bare-path#readme", "dependencies": { "bare-os": "^3.0.1" }, "devDependencies": { "brittle": "^3.3.2", "lunte": "^1.8.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } const b4a = require('b4a') const stream = require('streamx') const { ReadableStream, WritableStream } = require('./web') const defaultEncoding = 'utf8' module.exports = exports = stream.Stream exports.pipeline = stream.pipeline exports.isStream = stream.isStream exports.isEnding = stream.isEnding exports.isEnded = stream.isEnded exports.isFinishing = stream.isFinishing exports.isFinished = stream.isFinished exports.isDisturbed = stream.isDisturbed exports.isErrored = function isErrored(stream) { return exports.getStreamError(stream) !== null } exports.isReadable = function isReadable(stream) { return stream.readable && !stream.destroying && !exports.isEnded(stream) } exports.isWritable = function isWritable(stream) { return stream.writable && !stream.destroying && !exports.isFinishing(stream) } exports.getStreamError = stream.getStreamError exports.addAbortSignal = function addAbortSignal(signal, stream) { function onAbort() { stream.destroy(signal.reason) } if (signal.aborted) onAbort() else signal.addEventListener('abort', onAbort) return stream } exports.Stream = exports exports.Readable = class Readable extends stream.Readable { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, map: null, mapReadable: null }) if (this._construct) this._open = this._construct if (this._read !== stream.Readable.prototype._read) { this._read = read.bind(this, this._read) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } get closed() { return !exports.isReadable(this) } get errored() { return stream.getStreamError(this) } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } static fromWeb(readableStream, opts = {}) { const stream = readableStream._stream if (opts.encoding) stream.setEncoding(opts.encoding) if (opts.signal) exports.addAbortSignal(opts.signal, stream) return stream } static toWeb(readable, opts = {}) { return new ReadableStream(readable, opts.strategy) } async [Symbol.asyncDispose]() { if (!this.destroyed) this.destroy() await new Promise((resolve) => exports.finished(this, resolve)) } } exports.Writable = class Writable extends stream.Writable { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthWritable, map: null, mapWritable: null }) if (this._construct) this._open = this._construct if (this._write !== stream.Writable.prototype._write) { this._write = write.bind(this, this._write) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } get closed() { return !exports.isWritable(this) } get errored() { return stream.getStreamError(this) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding || defaultEncoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } static fromWeb(writableStream, opts = {}) { const stream = writableStream._stream if (opts.signal) exports.addAbortSignal(opts.signal, stream) return stream } static toWeb(writable) { return new WritableStream(writable) } async [Symbol.asyncDispose]() { if (!this.destroyed) this.destroy() await new Promise((resolve) => exports.finished(this, resolve)) } } exports.Duplex = class Duplex extends stream.Duplex { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, byteLengthWritable, map: null, mapReadable: null, mapWritable: null }) if (this._construct) this._open = this._construct if (this._read !== stream.Readable.prototype._read) { this._read = read.bind(this, this._read) } if (this._write !== stream.Duplex.prototype._write) { this._write = write.bind(this, this._write) } if (this._destroy !== stream.Stream.prototype._destroy) { this._destroy = destroy.bind(this, this._destroy) } } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } static fromWeb({ readable: readableStream, writable: writableStream }, opts) { const readable = exports.Readable.fromWeb(readableStream, opts) const writable = exports.Writable.fromWeb(writableStream, opts) const duplex = new exports.Duplex({ write(data, encoding, cb) { writable.write(data, encoding, cb) } }) readable .on('data', (data) => duplex.push(data)) .on('end', () => duplex.push(null)) .on('error', (err) => duplex.destroy(err)) writable.on('finish', () => duplex.end()).on('error', (err) => duplex.destroy(err)) return duplex } static toWeb(duplex) { const readableStream = exports.Readable.toWeb(duplex) const writableStream = exports.Writable.toWeb(duplex) return { readable: readableStream, writable: writableStream } } } class DuplexSide extends exports.Duplex { constructor(opts) { super(opts) this._otherSide = null this._cb = null } _read() { const cb = this._cb if (!cb) return this._cb = null cb() } _write(chunk, encoding, cb) { this._otherSide.push(chunk, encoding) this._otherSide._cb = cb } _final(cb) { this._otherSide.on('end', cb) this._otherSide.push(null) } } exports.duplexPair = function duplexPair(opts) { const sideA = new DuplexSide(opts) const sideB = new DuplexSide(opts) sideA._otherSide = sideB sideB._otherSide = sideA return [sideA, sideB] } exports.Transform = class Transform extends stream.Transform { constructor(opts = {}) { super({ ...opts, byteLength: null, byteLengthReadable: null, byteLengthWritable, map: null, mapReadable: null, mapWritable: null }) if (this._transform !== stream.Transform.prototype._transform) { this._transform = transform.bind(this, this._transform) } else { this._transform = passthrough } } push(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } return super.push(chunk) } unshift(chunk, encoding) { if (typeof chunk === 'string') { chunk = b4a.from(chunk, encoding || defaultEncoding) } super.unshift(chunk) } write(chunk, encoding, cb) { if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = super.write({ chunk, encoding }) if (cb) stream.Writable.drained(this).then(() => cb(null), cb) return result } end(chunk, encoding, cb) { if (typeof chunk === 'function') { cb = chunk chunk = null } else if (typeof encoding === 'function') { cb = encoding encoding = null } if (typeof chunk === 'string') { encoding = encoding || defaultEncoding chunk = b4a.from(chunk, encoding) } else { encoding = 'buffer' } const result = chunk !== undefined && chunk !== null ? super.end({ chunk, encoding }) : super.end() if (cb) this.once('finish', () => cb(null)) return result } } exports.PassThrough = class PassThrough extends exports.Transform {} exports.finished = function finished(stream, opts, cb) { if (typeof opts === 'function') { cb = opts opts = {} } if (!opts) opts = {} const { cleanup = false } = opts const done = () => { cb(exports.getStreamError(stream, { all: true })) if (cleanup) detach() } const detach = () => { stream.off('close', done) stream.off('error', noop) } if (stream.destroyed) { done() } else { stream.on('close', done) stream.on('error', noop) } return detach } function read(read, cb) { read.call(this, 65536) cb(null) } function write(write, data, cb) { write.call(this, data.chunk, data.encoding, cb) } function transform(transform, data, cb) { transform.call(this, data.chunk, data.encoding, cb) } function destroy(destroy, cb) { destroy.call(this, exports.getStreamError(this), cb) } function passthrough(data, cb) { cb(null, data.chunk) } function byteLengthWritable(data) { return data.chunk.byteLength } function noop() {} { "name": "bare-stream", "version": "2.13.3", "description": "Streaming data for JavaScript", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./promises": "./promises.js", "./web": { "types": "./web.d.ts", "default": "./web.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" } }, "files": [ "index.js", "index.d.ts", "promises.js", "web.js", "web.d.ts", "global.js", "global.d.ts" ], "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-stream.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-stream/issues" }, "homepage": "https://github.com/holepunchto/bare-stream#readme", "dependencies": { "b4a": "^1.8.1", "streamx": "^2.25.0", "teex": "^1.0.1" }, "devDependencies": { "bare-abort-controller": "^1.1.0", "bare-buffer": "^3.0.0", "bare-events": "^2.5.4", "brittle": "^3.5.2", "lunte": "^1.6.0", "prettier": "^3.3.3", "prettier-config-holepunch": "^2.0.0" }, "peerDependencies": { "bare-abort-controller": "*", "bare-buffer": "*", "bare-events": "*" }, "peerDependenciesMeta": { "bare-abort-controller": { "optional": true }, "bare-buffer": { "optional": true }, "bare-events": { "optional": true } } } const { Readable, Writable, Transform, getStreamError, isStreamx, isDisturbed } = require('streamx') const tee = require('teex') const readableKind = Symbol.for('bare.stream.readable.kind') const writableKind = Symbol.for('bare.stream.writable.kind') const transformKind = Symbol.for('bare.stream.transform.kind') // https://streams.spec.whatwg.org/#readablestreamdefaultreader exports.ReadableStreamDefaultReader = class ReadableStreamDefaultReader { constructor(stream) { this._stream = stream this._stream._stream.once('close', onclose).once('error', onerror) const closed = Promise.withResolvers() // Avoid unhandled exceptions closed.promise.catch(noop) this._closed = closed function onclose() { closed.resolve() } function onerror(err) { closed.reject(err) } } get closed() { return this._closed.promise } read() { const stream = this._stream._stream return new Promise((resolve, reject) => { const err = getStreamError(stream) if (err) return reject(err) if (stream.destroyed) { return resolve({ value: undefined, done: true }) } const value = stream.read() if (value !== null) { return resolve({ value, done: false }) } stream.once('readable', onreadable).once('close', onclose).once('error', onerror) function onreadable() { const value = stream.read() ondone(null, value === null ? { value: undefined, done: true } : { value, done: false }) } function onclose() { ondone(null, { value: undefined, done: true }) } function onerror(err) { ondone(err, null) } function ondone(err, value) { stream.off('readable', onreadable).off('close', onclose).off('error', onerror) if (err) reject(err) else resolve(value) } }) } releaseLock() { this._closed.reject(new TypeError('Reader was released')) this._stream._releaseLock() this._stream = null } cancel(reason = new TypeError('Stream was cancelled')) { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).once('error', noop).destroy(reason) ) } } // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller exports.ReadableStreamDefaultController = class ReadableStreamDefaultController { constructor(stream) { this._stream = stream } get desiredSize() { const stream = this._stream._stream return stream._readableState.highWaterMark - stream._readableState.buffered } enqueue(data) { this._stream._stream.push(data) } close() { this._stream._stream.push(null) } error(err) { this._stream._stream.destroy(err) } } // https://streams.spec.whatwg.org/#readablestream class ReadableStream { static get [readableKind]() { return 0 // Compatibility version } static from(iterable) { return new ReadableStream(Readable.from(iterable)) } constructor(underlyingSource = {}, queuingStrategy) { if (isStreamx(underlyingSource)) { this._stream = underlyingSource } else { if (queuingStrategy === undefined) { queuingStrategy = new exports.CountQueuingStrategy() } const { start, pull, cancel } = underlyingSource const { highWaterMark = 1, size = defaultSize } = queuingStrategy this._stream = new Readable({ highWaterMark, byteLength: size }) const controller = new exports.ReadableStreamDefaultController(this) try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (pull) { this._stream._read = this._read.bind(this, starting, pull.bind(this, controller)) } if (cancel) { this._stream.once('error', cancel.bind(this)) } } catch (err) { controller.error(err) } } this._reader = null } get [readableKind]() { return ReadableStream[readableKind] } get locked() { return this._reader !== null } getReader() { if (this.locked) throw new TypeError('Stream is locked') this._reader = new exports.ReadableStreamDefaultReader(this) return this._reader } cancel(reason = new TypeError('Stream was cancelled')) { const stream = this._stream if (stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => stream.once('close', resolve).once('error', noop).destroy(reason) ) } tee() { const [a, b] = tee(this._stream) return [new ReadableStream(a), new ReadableStream(b)] } pipeTo(destination) { return new Promise((resolve, reject) => this._stream.pipe(destination._stream, (err) => { err ? reject(err) : resolve() }) ) } [Symbol.asyncIterator]() { return this._stream[Symbol.asyncIterator]() } _releaseLock() { this._reader = null } async _read(starting, pull, cb) { await starting let err = null try { await pull() } catch (e) { err = e } cb(err) } } function defaultSize() { return 1 } exports.ReadableStream = ReadableStream // https://streams.spec.whatwg.org/#countqueuingstrategy exports.CountQueuingStrategy = class CountQueuingStrategy { constructor(opts = {}) { const { highWaterMark = 1 } = opts this.highWaterMark = highWaterMark } size(chunk) { return 1 } } // https://streams.spec.whatwg.org/#bytelengthqueuingstrategy exports.ByteLengthQueuingStrategy = class ByteLengthQueuingStrategy { constructor(opts = {}) { const { highWaterMark = 16384 } = opts this.highWaterMark = highWaterMark } size(chunk) { return chunk.byteLength } } exports.isReadableStream = function isReadableStream(value) { if (value instanceof ReadableStream) return true return ( typeof value === 'object' && value !== null && value[readableKind] === ReadableStream[readableKind] ) } // https://streams.spec.whatwg.org/#readablestream-errored exports.isReadableStreamErrored = function isReadableStreamErrored(stream) { return getStreamError(stream._stream) !== null } // https://streams.spec.whatwg.org/#is-readable-stream-disturbed exports.isReadableStreamDisturbed = function isReadableStreamDisturbed(stream) { return isDisturbed(stream._stream) } // https://streams.spec.whatwg.org/#writablestreamdefaultwriter exports.WritableStreamDefaultWriter = class WritableStreamDefaultWriter { constructor(stream) { this._stream = stream this._stream._stream.once('close', onclose).once('error', onerror) const closed = Promise.withResolvers() // Avoid unhandled exceptions closed.promise.catch(noop) this._closed = closed function onclose() { closed.resolve() } function onerror(err) { closed.reject(err) } } get desiredSize() { const stream = this._stream._stream return stream._writableState.highWaterMark - stream._writableState.buffered } get closed() { return this._closed.promise } get ready() { const stream = this._stream._stream if (getStreamError(stream)) return Promise.reject() return Writable.drained(stream).then() } async write(chunk) { const stream = this._stream._stream let err = getStreamError(stream) if (err) return Promise.reject(err) stream.write(chunk) await Writable.drained(stream) err = getStreamError(stream) if (err) return Promise.reject(err) } releaseLock() { this._closed.reject(new TypeError('Writer was released')) this._stream._releaseLock() this._stream = null } close() { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).end()) } abort(reason = new TypeError('Stream was aborted')) { const stream = this._stream._stream if (stream.destroyed) return Promise.resolve() return new Promise((resolve) => stream.once('close', resolve).destroy(reason)) } } // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller exports.WritableStreamDefaultController = class WritableStreamDefaultController { constructor(stream) { this._stream = stream } error(err) { this._stream._stream.destroy(err) } } // https://streams.spec.whatwg.org/#writablestream class WritableStream { static get [writableKind]() { return 0 // Compatibility version } constructor(underlyingSink = {}, queuingStrategy = {}) { if (isStreamx(underlyingSink)) { this._stream = underlyingSink } else { if (queuingStrategy === undefined) { queuingStrategy = new exports.CountQueuingStrategy() } const { start, write, close, abort } = underlyingSink const { highWaterMark = 1, size = defaultSize } = queuingStrategy this._stream = new Writable({ highWaterMark, byteLength: size }) const controller = new exports.WritableStreamDefaultController(this) this._controller = controller try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (write) { this._stream._write = this._write.bind(this, starting, write.bind(this)) } if (close) { this._stream._destroy = this._destroy.bind(this, close.call(this)) } if (abort) { this._stream.once('error', abort.bind(this)) } } catch (err) { controller.error(err) } } this._writer = null } get [writableKind]() { return WritableStream[writableKind] } get locked() { return this._writer !== null } getWriter() { if (this.locked) throw new TypeError('Stream is locked') this._writer = new exports.WritableStreamDefaultWriter(this) return this._writer } abort(reason = new TypeError('Stream was aborted')) { if (this._stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => this._stream.once('close', resolve).destroy(reason)) } close() { if (this._stream.destroyed) return Promise.resolve() if (this.locked) return Promise.reject(new TypeError('Stream is locked')) return new Promise((resolve) => this._stream.once('close', resolve).end()) } _releaseLock() { this._writer = null } async _write(starting, write, data, cb) { await starting let err = null try { await write(data, this._controller) } catch (e) { err = e } cb(err) } async _destroy(closing, cb) { let err = null try { await closing } catch (e) { err = e } cb(err) } } exports.WritableStream = WritableStream exports.isWritableStream = function isWritableStream(value) { if (value instanceof WritableStream) return true return ( typeof value === 'object' && value !== null && value[writableKind] === WritableStream[writableKind] ) } // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller exports.TransformStreamDefaultController = class TransformStreamDefaultController { constructor(stream) { this._stream = stream } get desiredSize() { const stream = this._stream._stream return stream._readableState.highWaterMark - stream._readableState.buffered } enqueue(data) { this._stream._stream.push(data) } error(err) { this._stream._stream.destroy(err) } terminate() { const stream = this._stream._stream stream.push(null) stream.destroy(new TypeError('Stream has been terminated')) } } // https://streams.spec.whatwg.org/#transformstream class TransformStream { static get [transformKind]() { return 0 // Compatibility version } constructor(transformer = {}, writableStrategy = {}, readableStrategy = {}) { if (isStreamx(transformer)) { this._stream = transformer } else { const { start, transform, flush } = transformer this._stream = new Transform({ ...writableStrategy, ...readableStrategy }) const controller = new exports.TransformStreamDefaultController(this) this._controller = controller try { let starting = Promise.resolve() if (start) starting = forwardError(start.call(this, controller), controller) if (transform) { this._stream._transform = this._transform.bind(this, starting, transform.bind(this)) } if (flush) { this._stream._flush = this._flush.bind(this, flush.call(this, this._controller)) } } catch (err) { controller.error(err) } } this._writable = new WritableStream(this._stream) this._readable = new ReadableStream(this._stream) } get [transformKind]() { return TransformStream[transformKind] } get writable() { return this._writable } get readable() { return this._readable } async _transform(starting, transform, data, cb) { await starting let err = null try { await transform(data, this._controller) } catch (e) { err = e } cb(err) } async _flush(flush, cb) { let err = null try { await flush } catch (e) { err = e } cb(err) } } exports.TransformStream = TransformStream exports.isTransformStream = function isTransformStream(value) { if (value instanceof TransformStream) return true return ( typeof value === 'object' && value !== null && value[transformKind] === TransformStream[transformKind] ) } async function forwardError(promise, controller) { try { await promise } catch (err) { controller.error(err) } } function noop() {} module.exports = require.addon() const binding = require('./binding') const t = binding.constants class Type { constructor(type) { this._type = type } isUndefined() { return this._type === t.UNDEFINED } isNull() { return this._type === t.NULL } isBoolean() { return this._type === t.BOOLEAN } isNumber() { return (this._type & 0xff) === t.NUMBER } isInt32() { return (this._type & (0xff | t.INT32)) === (t.NUMBER | t.INT32) } isUint32() { return (this._type & (0xff | t.UINT32)) === (t.NUMBER | t.UINT32) } isString() { return this._type === t.STRING } isSymbol() { return this._type === t.SYMBOL } isObject() { return (this._type & 0xff) === t.OBJECT } isArray() { return this._type === (t.OBJECT | t.ARRAY) } isArguments() { return this._type === (t.OBJECT | t.ARGUMENTS) } isDate() { return this._type === (t.OBJECT | t.DATE) } isRegExp() { return this._type === (t.OBJECT | t.REGEXP) } isError() { return this._type === (t.OBJECT | t.ERROR) } isPromise() { return this._type === (t.OBJECT | t.PROMISE) } isProxy() { return this._type === (t.OBJECT | t.PROXY) } isGenerator() { return this._type === (t.OBJECT | t.GENERATOR) } isMap() { return this._type === (t.OBJECT | t.MAP) } isSet() { return this._type === (t.OBJECT | t.SET) } isWeakMap() { return this._type === (t.OBJECT | t.WEAK_MAP) } isWeakSet() { return this._type === (t.OBJECT | t.WEAK_SET) } isWeakRef() { return this._type === (t.OBJECT | t.WEAK_REF) } isArrayBuffer() { return this._type === (t.OBJECT | t.ARRAYBUFFER) } isSharedArrayBuffer() { return this._type === (t.OBJECT | t.SHAREDARRAYBUFFER) } isTypedArray() { return (this._type & 0xffff) === (t.OBJECT | t.TYPEDARRAY) } isInt8Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT8ARRAY) } isUint8Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8ARRAY) } isUint8ClampedArray() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8CLAMPEDARRAY) } isInt16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT16ARRAY) } isUint16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT16ARRAY) } isInt32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT32ARRAY) } isUint32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT32ARRAY) } isFloat16Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT16ARRAY) } isFloat32Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT32ARRAY) } isFloat64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT64ARRAY) } isBigInt64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGINT64ARRAY) } isBigUint64Array() { return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGUINT64ARRAY) } isDataView() { return this._type === (t.OBJECT | t.DATAVIEW) } isModuleNamespace() { return this._type === (t.OBJECT | t.MODULE_NAMESPACE) } isFunction() { return (this._type & 0xff) === t.FUNCTION } isAsyncFunction() { return ( (this._type & (0xff | t.ASYNC_FUNCTION)) === (t.FUNCTION | t.ASYNC_FUNCTION) ) } isGeneratorFunction() { return ( (this._type & (0xff | t.GENERATOR_FUNCTION)) === (t.FUNCTION | t.GENERATOR_FUNCTION) ) } isExternal() { return this._type === t.EXTERNAL } isBigInt() { return this._type === t.BIGINT } } module.exports = exports = function type(value) { switch (typeof value) { case 'undefined': return new Type(t.UNDEFINED) case 'boolean': return new Type(t.BOOLEAN) case 'number': return new Type( Number.isSafeInteger(value) ? binding.type(value) : t.NUMBER ) case 'string': return new Type(t.STRING) case 'symbol': return new Type(t.SYMBOL) case 'object': return new Type(value === null ? t.NULL : binding.type(value)) case 'function': return new Type(binding.type(value)) case 'bigint': return new Type(t.BIGINT) } } exports.createTag = function createTag(...components) { const tag = new Uint32Array(4) for (let i = 0; i < 4; i++) tag[i] = components[i] || 0 return tag } exports.addTag = function addTag(object, tag) { binding.addTag(object, tag) } exports.checkTag = function checkTag(object, tag) { return binding.checkTag(object, tag) } { "name": "bare-type", "version": "1.1.0", "description": "Cross-realm type predicates for Bare", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json" }, "files": [ "index.js", "index.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "prebuilds" ], "addon": true, "scripts": { "test": "prettier . --check && bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-type.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-type/issues" }, "homepage": "https://github.com/holepunchto/bare-type#readme", "engines": { "bare": ">=1.2.0" }, "devDependencies": { "brittle": "^3.4.0", "cmake-bare": "^1.1.6", "prettier": "^3.4.1", "prettier-config-standard": "^7.0.0" } } module.exports = require.addon() const path = require('bare-path') const binding = require('./binding') const errors = require('./lib/errors') const URLSearchParams = require('./lib/url-search-params') const kind = Symbol.for('bare.url.kind') const isWindows = Bare.platform === 'win32' class URL { static get [kind]() { return 0 // Compatibility version } constructor(input, base, opts = {}) { if (arguments.length === 0) throw errors.INVALID_URL() input = String(input) if (base !== undefined) base = String(base) this._components = new Uint32Array(8) this._parse(input, base, opts.throw !== false) if (this._href) this._params = new URLSearchParams(this.search, this) } get [kind]() { return URL[kind] } // https://url.spec.whatwg.org/#dom-url-href get href() { return this._href } set href(value) { this._update(value) this._params._parse(this.search) } // https://url.spec.whatwg.org/#dom-url-protocol get protocol() { return this._slice(0, this._components[0]) + ':' } set protocol(value) { this._update(this._replace(value.replace(/:+$/, ''), 0, this._components[0])) } // https://url.spec.whatwg.org/#dom-url-username get username() { return this._slice(this._components[0] + 3 /* :// */, this._components[1]) } set username(value) { if (cannotHaveCredentialsOrPort(this)) { return } if (this.username === '') value += '@' this._update(this._replace(value, this._components[0] + 3 /* :// */, this._components[1])) } // https://url.spec.whatwg.org/#dom-url-password get password() { return this._href.slice(this._components[1] + 1 /* : */, this._components[2] - 1 /* @ */) } set password(value) { if (cannotHaveCredentialsOrPort(this)) { return } let start = this._components[1] + 1 /* : */ let end = this._components[2] - 1 /* @ */ if (this.password === '') { value = ':' + value start-- } if (this.username === '') { value += '@' end++ } this._update(this._replace(value, start, end)) } // https://url.spec.whatwg.org/#dom-url-host get host() { return this._slice(this._components[2], this._components[5]) } set host(value) { if (hasOpaquePath(this)) { return } this._update( this._replace(value, this._components[2], this._components[value.includes(':') ? 5 : 3]) ) } // https://url.spec.whatwg.org/#dom-url-hostname get hostname() { return this._slice(this._components[2], this._components[3]) } set hostname(value) { if (hasOpaquePath(this)) { return } this._update(this._replace(value, this._components[2], this._components[3])) } // https://url.spec.whatwg.org/#dom-url-port get port() { return this._slice(this._components[3] + 1 /* : */, this._components[5]) } set port(value) { if (cannotHaveCredentialsOrPort(this)) { return } let start = this._components[3] + 1 /* : */ if (this.port === '') { value = ':' + value start-- } this._update(this._replace(value, start, this._components[5])) } // https://url.spec.whatwg.org/#dom-url-pathname get pathname() { return this._slice(this._components[5], this._components[6] - 1 /* ? */) } set pathname(value) { if (hasOpaquePath(this)) { return } if (value[0] !== '/' && value[0] !== '\\') { value = '/' + value } this._update(this._replace(value, this._components[5], this._components[6] - 1 /* ? */)) } // https://url.spec.whatwg.org/#dom-url-search get search() { return this._slice(this._components[6] - 1 /* ? */, this._components[7] - 1 /* # */) } set search(value) { if (value && value[0] !== '?') value = '?' + value this._update( this._replace(value, this._components[6] - 1 /* ? */, this._components[7] - 1 /* # */) ) this._params._parse(this.search) } // https://url.spec.whatwg.org/#dom-url-searchparams get searchParams() { return this._params } // https://url.spec.whatwg.org/#dom-url-hash get hash() { return this._slice(this._components[7] - 1 /* # */) } set hash(value) { if (value && value[0] !== '#') value = '#' + value this._update(this._replace(value, this._components[7] - 1 /* # */)) } toString() { return this._href } toJSON() { return this._href } [Symbol.for('bare.inspect')]() { return { __proto__: { constructor: URL }, href: this.href, protocol: this.protocol, username: this.username, password: this.password, host: this.host, hostname: this.hostname, port: this.port, pathname: this.pathname, search: this.search, searchParams: this.searchParams, hash: this.hash } } _slice(start, end = this._href.length) { return this._href.slice(start, end) } _replace(replacement, start, end = this._href.length) { return this._slice(0, start) + replacement + this._slice(end) } _parse(input, base, shouldThrow) { try { this._href = binding.parse( String(input), base ? String(base) : null, this._components, shouldThrow ) } catch (err) { if (err instanceof TypeError) throw err throw errors.INVALID_URL(`Invalid URL '${input}'`, input) } } _update(input) { try { this._parse(input, null, true) } catch (err) { if (err instanceof TypeError) throw err } } } module.exports = exports = URL // https://url.spec.whatwg.org/#url-opaque-path function hasOpaquePath(url) { return url.pathname[0] !== '/' } // https://url.spec.whatwg.org/#cannot-have-a-username-password-port function cannotHaveCredentialsOrPort(url) { return url.hostname === '' || url.protocol === 'file:' } exports.URL = URL exports.URLSearchParams = URLSearchParams exports.errors = errors exports.isURL = function isURL(value) { if (value instanceof URL) return true return typeof value === 'object' && value !== null && value[kind] === URL[kind] } exports.isURLSearchParams = URLSearchParams.isURLSearchParams // https://url.spec.whatwg.org/#dom-url-parse exports.parse = function parse(input, base) { const url = new URL(input, base, { throw: false }) return url._href ? url : null } // https://url.spec.whatwg.org/#dom-url-canparse exports.canParse = function canParse(input, base) { return binding.canParse(String(input), base ? String(base) : null) } exports.fileURLToPath = function fileURLToPath(url) { if (typeof url === 'string') { url = new URL(url) } if (url.protocol !== 'file:') { throw errors.INVALID_URL_SCHEME('The URL must use the file: protocol') } if (isWindows) { if (/%2f|%5c/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH( 'The file: URL path must not include encoded \\ or / characters' ) } } else { if (url.hostname) { throw errors.INVALID_FILE_URL_HOST("The file: URL host must be 'localhost' or empty") } if (/%2f/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must not include encoded / characters') } } if (/%00/i.test(url.pathname)) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must not include encoded NUL characters') } const pathname = path.normalize(decodeURIComponent(url.pathname)) if (isWindows) { if (url.hostname) return '\\\\' + url.hostname + pathname const letter = pathname.charCodeAt(1) | 0x20 if (letter < 0x61 /* a */ || letter > 0x7a /* z */ || pathname.charCodeAt(2) !== 0x3a /* : */) { throw errors.INVALID_FILE_URL_PATH('The file: URL path must be absolute') } return pathname.slice(1) } return pathname } exports.pathToFileURL = function pathToFileURL(pathname) { let resolved = path.resolve(pathname) if (pathname[pathname.length - 1] === '/') { resolved += '/' } else if (isWindows && pathname[pathname.length - 1] === '\\') { resolved += '\\' } resolved = resolved .replaceAll('%', '%25') // Must be first .replaceAll('#', '%23') .replaceAll('?', '%3f') .replaceAll('\n', '%0a') .replaceAll('\r', '%0d') .replaceAll('\t', '%09') if (!isWindows) { resolved = resolved.replaceAll('\\', '%5c') } return new URL('file:' + resolved) } exports.format = function format(parts) { const { protocol, auth, host, hostname, port, pathname, search, query, hash, slashes } = parts let result = '' if (typeof protocol === 'string') { result += protocol if (protocol[protocol.length - 1] !== ':') { result += ':' } if (slashes === true || /https?|ftp|gopher|file/.test(protocol)) { result += '//' } } if (typeof auth === 'string') { if (host || hostname) result += auth + '@' } if (typeof host === 'string') result += host else { result += hostname if (port) result += ':' + port } if (typeof pathname === 'string' && pathname !== '') { if (pathname[0] !== '/') result += '/' result += pathname } if (typeof search === 'string') { if (search[0] !== '?') result += '?' result += search } else if (typeof query === 'object' && query !== null) { result += '?' + new URLSearchParams(query) } if (typeof hash === 'string') { if (hash[0] !== '#') result += '#' result += hash } return result } module.exports = class URLError extends Error { constructor(msg, fn = URLError, code = fn.name) { super(`${code}: ${msg}`) this.code = code if (Error.captureStackTrace) Error.captureStackTrace(this, fn) } get name() { return 'URLError' } static INVALID_URL(msg, input) { const err = new URLError(msg, URLError.INVALID_URL) err.input = input return err } static INVALID_URL_SCHEME(msg = 'Invalid URL') { return new URLError(msg, URLError.INVALID_URL_SCHEME) } static INVALID_FILE_URL_HOST(msg = 'Invalid file: URL host') { return new URLError(msg, URLError.INVALID_FILE_URL_HOST) } static INVALID_FILE_URL_PATH(msg = 'Invalid file: URL path') { return new URLError(msg, URLError.INVALID_FILE_URL_PATH) } } const kind = Symbol.for('bare.url.search-params.kind') class URLSearchParams { static _urls = new WeakMap() static get [kind]() { return 0 // Compatibility version } // https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams constructor(init, url = null) { this._params = new Map() if (url) URLSearchParams._urls.set(this, url) if (typeof init === 'string') { this._parse(init) } else if (init) { for (const [name, value] of typeof init[Symbol.iterator] === 'function' ? init : Object.entries(init)) { this.append(name, value) } } } get [kind]() { return URLSearchParams[kind] } // https://url.spec.whatwg.org/#dom-urlsearchparams-size get size() { return this._params.length } // https://url.spec.whatwg.org/#dom-urlsearchparams-append append(name, value = null) { if (value === null) return let list = this._params.get(name) if (list === undefined) { list = [] this._params.set(name, list) } list.push(value) this._update() } // https://url.spec.whatwg.org/#dom-urlsearchparams-delete delete(name, value = null) { if (value === null) this._params.delete(name) else { let list = this._params.get(name) if (list === undefined) return list = list.filter((found) => found !== value) if (list.length === 0) this._params.delete(name) else this._params.set(name, list) } this._update() } // https://url.spec.whatwg.org/#dom-urlsearchparams-get get(name) { const list = this._params.get(name) if (list === undefined) return null return list[0] } // https://url.spec.whatwg.org/#dom-urlsearchparams-getall getAll(name) { const list = this._params.get(name) if (list === undefined) return [] return Array.from(list) } // https://url.spec.whatwg.org/#dom-urlsearchparams-has has(name, value = null) { const list = this._params.get(name) if (list === undefined) return false if (value === null) return true return list.includes(value) } // https://url.spec.whatwg.org/#dom-urlsearchparams-set set(name, value = null) { if (value === null) this._params.delete(name) else this._params.set(name, [value]) this._update() } toString() { return this._serialize() } toJSON() { return [...this] } *[Symbol.iterator]() { for (const [name, values] of this._params) { for (const value of values) yield [name, value] } } [Symbol.for('bare.inspect')]() { const object = { __proto__: { constructor: URLSearchParams } } for (const [name, values] of this._params) { if (values.length === 1) object[name] = values[0] else object[name] = values } return object } // https://url.spec.whatwg.org/#concept-urlsearchparams-update _update() { const url = URLSearchParams._urls.get(this) if (url === undefined) return url.search = this._serialize() } // https://url.spec.whatwg.org/#concept-urlencoded-parser _parse(input) { if (input[0] === '?') input = input.substring(1) this._params = new Map() for (let sequence of input.split('&')) { if (sequence.length === 0) continue sequence = sequence.replace(/\+/g, ' ') let i = sequence.indexOf('=') if (i === -1) i = sequence.length const name = decodeURIComponent(sequence.substring(0, i)) const value = decodeURIComponent(sequence.substring(i + 1, sequence.length)) let list = this._params.get(name) if (list === undefined) { list = [] this._params.set(name, list) } list.push(value) } } // https://url.spec.whatwg.org/#concept-urlencoded-serializer _serialize() { let output = '' for (let [name, values] of this._params) { name = encodeURIComponent(name) for (const value of values) { if (output) output += '&' output += name + '=' + encodeURIComponent(value) } } return output } } module.exports = exports = URLSearchParams exports.isURLSearchParams = function isURLSearchParams(value) { if (value instanceof URLSearchParams) return true return typeof value === 'object' && value !== null && value[kind] === URLSearchParams[kind] } { "name": "bare-url", "version": "2.4.5", "description": "WHATWG URL implementation for JavaScript", "exports": { "./package": "./package.json", ".": { "types": "./index.d.ts", "default": "./index.js" }, "./global": { "types": "./global.d.ts", "default": "./global.js" } }, "files": [ "index.js", "index.d.ts", "global.js", "global.d.ts", "binding.c", "binding.js", "CMakeLists.txt", "lib", "prebuilds" ], "addon": true, "scripts": { "format": "prettier --write . && lunte --fix", "lint": "prettier --check . && lunte", "test": "brittle-bare --coverage test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/bare-url.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/bare-url/issues" }, "homepage": "https://github.com/holepunchto/bare-url", "dependencies": { "bare-path": "^3.0.0" }, "devDependencies": { "brittle": "^3.3.2", "cmake-bare": "^1.1.6", "cmake-fetch": "^1.0.0", "lunte": "^1.6.0", "prettier": "^3.3.3", "prettier-config-holepunch": "^2.0.0" } } const b4a = require('b4a') module.exports = codecs codecs.ascii = createString('ascii') codecs.utf8 = createString('utf-8') codecs.hex = createString('hex') codecs.base64 = createString('base64') codecs.ucs2 = createString('ucs2') codecs.utf16le = createString('utf16le') codecs.ndjson = createJSON(true) codecs.json = createJSON(false) codecs.binary = { name: 'binary', encode: function encodeBinary (obj) { return typeof obj === 'string' ? b4a.from(obj, 'utf-8') : b4a.toBuffer(obj) }, decode: function decodeBinary (buf) { return b4a.toBuffer(buf) } } function isCompactEncoding (c) { return !!(c.encode && c.decode && c.preencode) } function fromCompactEncoding (c) { return { name: 'compact-encoding', encode: function encodeWithCompact (value) { const state = { start: 0, end: 0, buffer: null, cache: null } c.preencode(state, value) state.buffer = b4a.allocUnsafe(state.end) c.encode(state, value) return state.buffer }, decode: function decodeWithCompact (buffer) { return c.decode({ start: 0, end: buffer.byteLength, buffer, cache: null }) } } } function codecs (fmt, fallback) { if (typeof fmt === 'object' && fmt) { return isCompactEncoding(fmt) ? fromCompactEncoding(fmt) : fmt } switch (fmt) { case 'ndjson': return codecs.ndjson case 'json': return codecs.json case 'ascii': return codecs.ascii case 'utf-8': case 'utf8': return codecs.utf8 case 'hex': return codecs.hex case 'base64': return codecs.base64 case 'ucs-2': case 'ucs2': return codecs.ucs2 case 'utf16-le': case 'utf16le': return codecs.utf16le } return fallback !== undefined ? fallback : codecs.binary } function createJSON (newline) { return { name: newline ? 'ndjson' : 'json', encode: newline ? encodeNDJSON : encodeJSON, decode: function decodeJSON (buf) { return JSON.parse(b4a.toString(buf)) } } function encodeJSON (val) { return b4a.from(JSON.stringify(val)) } function encodeNDJSON (val) { return b4a.from(JSON.stringify(val) + '\n') } } function createString (type) { return { name: type, encode: function encodeString (val) { if (typeof val !== 'string') val = val.toString() return b4a.from(val, type) }, decode: function decodeString (buf) { return b4a.toString(buf, type) } } } { "name": "codecs", "version": "3.1.0", "description": "Create an binary encoder/decoder for json, utf-8 or custom types", "main": "index.js", "dependencies": { "b4a": "^1.6.3" }, "devDependencies": { "brittle": "^3.2.1", "compact-encoding": "^2.11.0", "standard": "^17.0.0" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/codecs.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/codecs/issues" }, "homepage": "https://github.com/mafintosh/codecs" } const LE = (exports.LE = new Uint8Array(new Uint16Array([0xff]).buffer)[0] === 0xff) exports.BE = !LE const b4a = require('b4a') const { BE } = require('./endian') exports.state = function (start = 0, end = 0, buffer = null) { return { start, end, buffer } } const raw = (exports.raw = require('./raw')) const uint = (exports.uint = { preencode(state, n) { state.end += n <= 0xfc ? 1 : n <= 0xffff ? 3 : n <= 0xffffffff ? 5 : 9 }, encode(state, n) { if (n <= 0xfc) uint8.encode(state, n) else if (n <= 0xffff) { state.buffer[state.start++] = 0xfd uint16.encode(state, n) } else if (n <= 0xffffffff) { state.buffer[state.start++] = 0xfe uint32.encode(state, n) } else { state.buffer[state.start++] = 0xff uint64.encode(state, n) } }, decode(state) { const a = uint8.decode(state) if (a <= 0xfc) return a if (a === 0xfd) return uint16.decode(state) if (a === 0xfe) return uint32.decode(state) return uint64.decode(state) } }) const uint8 = (exports.uint8 = { preencode(state, n) { state.end += 1 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n }, decode(state) { if (state.start >= state.end) throw new Error('Out of bounds') return state.buffer[state.start++] } }) const uint16 = (exports.uint16 = { preencode(state, n) { state.end += 2 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 }, decode(state) { if (state.end - state.start < 2) throw new Error('Out of bounds') return state.buffer[state.start++] + state.buffer[state.start++] * 0x100 } }) const uint24 = (exports.uint24 = { preencode(state, n) { state.end += 3 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n >>> 16 }, decode(state) { if (state.end - state.start < 3) throw new Error('Out of bounds') return ( state.buffer[state.start++] + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] * 0x10000 ) } }) const uint32 = (exports.uint32 = { preencode(state, n) { state.end += 4 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n >>> 16 state.buffer[state.start++] = n >>> 24 }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] * 0x10000 + state.buffer[state.start++] * 0x1000000 ) } }) const uint32be = (exports.uint32be = { preencode(state, n) { state.end += 4 }, encode(state, n) { validateUint(n) state.buffer[state.start++] = n >>> 24 state.buffer[state.start++] = n >>> 16 state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] * 0x1000000 + state.buffer[state.start++] * 0x10000 + state.buffer[state.start++] * 0x100 + state.buffer[state.start++] ) } }) const uint40 = (exports.uint40 = { preencode(state, n) { state.end += 5 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100) uint8.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 5) throw new Error('Out of bounds') return uint8.decode(state) + 0x100 * uint32.decode(state) } }) const uint48 = (exports.uint48 = { preencode(state, n) { state.end += 6 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x10000) uint16.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 6) throw new Error('Out of bounds') return uint16.decode(state) + 0x10000 * uint32.decode(state) } }) const uint56 = (exports.uint56 = { preencode(state, n) { state.end += 7 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x1000000) uint24.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 7) throw new Error('Out of bounds') return uint24.decode(state) + 0x1000000 * uint32.decode(state) } }) const uint64 = (exports.uint64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100000000) uint32.encode(state, n) uint32.encode(state, r) }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') return uint32.decode(state) + 0x100000000 * uint32.decode(state) } }) exports.uint64be = { preencode(state, n) { state.end += 8 }, encode(state, n) { validateUint(n) const r = Math.floor(n / 0x100000000) uint32be.encode(state, r) uint32be.encode(state, n) }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') return 0x100000000 * uint32be.decode(state) + uint32be.decode(state) } } const int = (exports.int = zigZagInt(uint)) exports.int8 = zigZagInt(uint8) exports.int16 = zigZagInt(uint16) exports.int24 = zigZagInt(uint24) exports.int32 = zigZagInt(uint32) exports.int40 = zigZagInt(uint40) exports.int48 = zigZagInt(uint48) exports.int56 = zigZagInt(uint56) exports.int64 = zigZagInt(uint64) const biguint64 = (exports.biguint64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) view.setBigUint64(0, n, true) // little endian state.start += 8 }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) const n = view.getBigUint64(0, true) // little endian state.start += 8 return n } }) exports.bigint64 = zigZagBigInt(biguint64) const biguint = (exports.biguint = { preencode(state, n) { let len = 0 for (let m = n; m; m = m >> 64n) len++ uint.preencode(state, len) state.end += 8 * len }, encode(state, n) { let len = 0 for (let m = n; m; m = m >> 64n) len++ uint.encode(state, len) const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len ) for (let m = n, i = 0; m; m = m >> 64n, i += 8) { view.setBigUint64(i, BigInt.asUintN(64, m), true) // little endian } state.start += 8 * len }, decode(state) { const len = uint.decode(state) if (state.end - state.start < 8 * len) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len ) let n = 0n for (let i = len - 1; i >= 0; i--) n = (n << 64n) + view.getBigUint64(i * 8, true) // little endian state.start += 8 * len return n } }) exports.bigint = zigZagBigInt(biguint) exports.lexint = require('./lexint') exports.float32 = { preencode(state, n) { state.end += 4 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 4 ) view.setFloat32(0, n, true) // little endian state.start += 4 }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 4 ) const float = view.getFloat32(0, true) // little endian state.start += 4 return float } } exports.float64 = { preencode(state, n) { state.end += 8 }, encode(state, n) { const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) view.setFloat64(0, n, true) // little endian state.start += 8 }, decode(state) { if (state.end - state.start < 8) throw new Error('Out of bounds') const view = new DataView( state.buffer.buffer, state.start + state.buffer.byteOffset, 8 ) const float = view.getFloat64(0, true) // little endian state.start += 8 return float } } const buffer = (exports.buffer = { preencode(state, b) { uint8array.preencode(state, b) }, encode(state, b) { uint8array.encode(state, b) }, decode(state) { const len = uint.decode(state) if (state.end - state.start < len) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += len)) } }) exports.optionalBuffer = { preencode(state, b) { if (b) uint8array.preencode(state, b) else state.end++ }, encode(state, b) { if (b) uint8array.encode(state, b) else state.buffer[state.start++] = 0 }, decode(state) { const len = uint.decode(state) if (len === 0) return null if (state.end - state.start < len) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += len)) } } exports.binary = { ...buffer, preencode(state, b) { if (typeof b === 'string') utf8.preencode(state, b) else buffer.preencode(state, b) }, encode(state, b) { if (typeof b === 'string') utf8.encode(state, b) else buffer.encode(state, b) } } exports.arraybuffer = { preencode(state, b) { uint.preencode(state, b.byteLength) state.end += b.byteLength }, encode(state, b) { uint.encode(state, b.byteLength) const view = new Uint8Array(b) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const len = uint.decode(state) const b = new ArrayBuffer(len) const view = new Uint8Array(b) view.set(state.buffer.subarray(state.start, (state.start += len))) return b } } function typedarray(TypedArray, swap) { const n = TypedArray.BYTES_PER_ELEMENT return { preencode(state, b) { uint.preencode(state, b.length) state.end += b.byteLength }, encode(state, b) { uint.encode(state, b.length) const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength) if (BE && swap) swap(view) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const len = uint.decode(state) let b = state.buffer.subarray(state.start, (state.start += len * n)) if (b.byteLength !== len * n) throw new Error('Out of bounds') if (b.byteOffset % n !== 0) b = new Uint8Array(b) if (BE && swap) swap(b) return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n) } } } const uint8array = (exports.uint8array = typedarray(Uint8Array)) exports.uint16array = typedarray(Uint16Array, b4a.swap16) exports.uint32array = typedarray(Uint32Array, b4a.swap32) exports.int8array = typedarray(Int8Array) exports.int16array = typedarray(Int16Array, b4a.swap16) exports.int32array = typedarray(Int32Array, b4a.swap32) exports.biguint64array = typedarray(BigUint64Array, b4a.swap64) exports.bigint64array = typedarray(BigInt64Array, b4a.swap64) exports.float32array = typedarray(Float32Array, b4a.swap32) exports.float64array = typedarray(Float64Array, b4a.swap64) function string(encoding) { return { preencode(state, s) { const len = b4a.byteLength(s, encoding) uint.preencode(state, len) state.end += len }, encode(state, s) { const len = b4a.byteLength(s, encoding) uint.encode(state, len) b4a.write(state.buffer, s, state.start, encoding) state.start += len }, decode(state) { const len = uint.decode(state) if (state.end - state.start < len) throw new Error('Out of bounds') return b4a.toString( state.buffer, encoding, state.start, (state.start += len) ) }, fixed(n) { return { preencode(state) { state.end += n }, encode(state, s) { b4a.write(state.buffer, s, state.start, n, encoding) state.start += n }, decode(state) { if (state.end - state.start < n) throw new Error('Out of bounds') return b4a.toString( state.buffer, encoding, state.start, (state.start += n) ) } } } } } const utf8 = (exports.string = exports.utf8 = string('utf-8')) exports.ascii = string('ascii') exports.hex = string('hex') exports.base64 = string('base64') exports.ucs2 = exports.utf16le = string('utf16le') exports.bool = { preencode(state, b) { state.end++ }, encode(state, b) { state.buffer[state.start++] = b ? 1 : 0 }, decode(state) { if (state.start >= state.end) throw Error('Out of bounds') return state.buffer[state.start++] === 1 } } const fixed = (exports.fixed = function fixed(n) { return { preencode(state, s) { if (s.byteLength !== n) throw new Error('Incorrect buffer size') state.end += n }, encode(state, s) { state.buffer.set(s, state.start) state.start += n }, decode(state) { if (state.end - state.start < n) throw new Error('Out of bounds') return state.buffer.subarray(state.start, (state.start += n)) } } }) exports.fixed32 = fixed(32) exports.fixed64 = fixed(64) exports.array = function array(enc) { return { preencode(state, list) { uint.preencode(state, list.length) for (let i = 0; i < list.length; i++) enc.preencode(state, list[i]) }, encode(state, list) { uint.encode(state, list.length) for (let i = 0; i < list.length; i++) enc.encode(state, list[i]) }, decode(state) { const len = uint.decode(state) if (len > 0x100000) throw new Error('Array is too big') const arr = new Array(len) for (let i = 0; i < len; i++) arr[i] = enc.decode(state) return arr } } } exports.frame = function frame(enc) { const dummy = exports.state() return { preencode(state, m) { const end = state.end enc.preencode(state, m) uint.preencode(state, state.end - end) }, encode(state, m) { dummy.end = 0 enc.preencode(dummy, m) uint.encode(state, dummy.end) enc.encode(state, m) }, decode(state) { const end = state.end const len = uint.decode(state) state.end = state.start + len const m = enc.decode(state) state.start = state.end state.end = end return m } } } exports.date = { preencode(state, d) { int.preencode(state, d.getTime()) }, encode(state, d) { int.encode(state, d.getTime()) }, decode(state, d) { return new Date(int.decode(state)) } } exports.json = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v)) }, encode(state, v) { utf8.encode(state, JSON.stringify(v)) }, decode(state) { return JSON.parse(utf8.decode(state)) } } exports.ndjson = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v) + '\n') }, encode(state, v) { utf8.encode(state, JSON.stringify(v) + '\n') }, decode(state) { return JSON.parse(utf8.decode(state)) } } // simple helper for when you want to just express nothing exports.none = { preencode(state, n) { // do nothing }, encode(state, n) { // do nothing }, decode(state) { return null } } // "any" encoders here for helping just structure any object without schematising it const anyArray = { preencode(state, arr) { uint.preencode(state, arr.length) for (let i = 0; i < arr.length; i++) { any.preencode(state, arr[i]) } }, encode(state, arr) { uint.encode(state, arr.length) for (let i = 0; i < arr.length; i++) { any.encode(state, arr[i]) } }, decode(state) { const arr = [] let len = uint.decode(state) while (len-- > 0) { arr.push(any.decode(state)) } return arr } } const anyObject = { preencode(state, o) { const keys = Object.keys(o) uint.preencode(state, keys.length) for (const key of keys) { utf8.preencode(state, key) any.preencode(state, o[key]) } }, encode(state, o) { const keys = Object.keys(o) uint.encode(state, keys.length) for (const key of keys) { utf8.encode(state, key) any.encode(state, o[key]) } }, decode(state) { let len = uint.decode(state) const o = {} while (len-- > 0) { const key = utf8.decode(state) o[key] = any.decode(state) } return o } } const anyTypes = [ exports.none, exports.bool, exports.string, exports.buffer, exports.uint, exports.int, exports.float64, anyArray, anyObject, exports.date ] const any = (exports.any = { preencode(state, o) { const t = getType(o) uint.preencode(state, t) anyTypes[t].preencode(state, o) }, encode(state, o) { const t = getType(o) uint.encode(state, t) anyTypes[t].encode(state, o) }, decode(state) { const t = uint.decode(state) if (t >= anyTypes.length) throw new Error('Unknown type: ' + t) return anyTypes[t].decode(state) } }) const port = (exports.port = uint16) const address = (host, family) => { return { preencode(state, m) { host.preencode(state, m.host) port.preencode(state, m.port) }, encode(state, m) { host.encode(state, m.host) port.encode(state, m.port) }, decode(state) { return { host: host.decode(state), family, port: port.decode(state) } } } } const ipv4 = (exports.ipv4 = { preencode(state) { state.end += 4 }, encode(state, string) { const start = state.start const end = start + 4 let i = 0 while (i < string.length) { let n = 0 let c while ( i < string.length && (c = string.charCodeAt(i++)) !== /* . */ 0x2e ) { n = n * 10 + (c - /* 0 */ 0x30) } state.buffer[state.start++] = n } state.start = end }, decode(state) { if (state.end - state.start < 4) throw new Error('Out of bounds') return ( state.buffer[state.start++] + '.' + state.buffer[state.start++] + '.' + state.buffer[state.start++] + '.' + state.buffer[state.start++] ) } }) exports.ipv4Address = address(ipv4, 4) const ipv6 = (exports.ipv6 = { preencode(state) { state.end += 16 }, encode(state, string) { const start = state.start const end = start + 16 let i = 0 let split = null while (i < string.length) { let n = 0 let c while ( i < string.length && (c = string.charCodeAt(i++)) !== /* : */ 0x3a ) { if (c >= 0x30 && c <= 0x39) n = n * 0x10 + (c - /* 0 */ 0x30) else if (c >= 0x41 && c <= 0x46) n = n * 0x10 + (c - /* A */ 0x41 + 10) else if (c >= 0x61 && c <= 0x66) n = n * 0x10 + (c - /* a */ 0x61 + 10) } state.buffer[state.start++] = n >>> 8 state.buffer[state.start++] = n if (i < string.length && string.charCodeAt(i) === /* : */ 0x3a) { i++ split = state.start } } if (split !== null) { const offset = end - state.start state.buffer .copyWithin(split + offset, split) .fill(0, split, split + offset) } state.start = end }, decode(state) { if (state.end - state.start < 16) throw new Error('Out of bounds') return ( ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) + ':' + ( state.buffer[state.start++] * 256 + state.buffer[state.start++] ).toString(16) ) } }) exports.ipv6Address = address(ipv6, 6) const ip = (exports.ip = { preencode(state, string) { const family = string.includes(':') ? 6 : 4 uint8.preencode(state, family) if (family === 4) ipv4.preencode(state) else ipv6.preencode(state) }, encode(state, string) { const family = string.includes(':') ? 6 : 4 uint8.encode(state, family) if (family === 4) ipv4.encode(state, string) else ipv6.encode(state, string) }, decode(state) { const family = uint8.decode(state) if (family === 4) return ipv4.decode(state) else return ipv6.decode(state) } }) exports.ipAddress = { preencode(state, m) { ip.preencode(state, m.host) port.preencode(state, m.port) }, encode(state, m) { ip.encode(state, m.host) port.encode(state, m.port) }, decode(state) { const family = uint8.decode(state) return { host: family === 4 ? ipv4.decode(state) : ipv6.decode(state), family, port: port.decode(state) } } } const record = (exports.record = function (keyEncoding, valueEncoding) { return { preencode(state, v) { const keys = Object.keys(v) uint.preencode(state, keys.length) for (const k of keys) { keyEncoding.preencode(state, k) valueEncoding.preencode(state, v[k]) } }, encode(state, v) { const keys = Object.keys(v) uint.encode(state, keys.length) for (const k of keys) { keyEncoding.encode(state, k) valueEncoding.encode(state, v[k]) } }, decode(state) { const out = Object.create(null) const keys = uint.decode(state) for (let i = 0; i < keys; i++) { out[keyEncoding.decode(state)] = valueEncoding.decode(state) } return out } } }) exports.stringRecord = record(utf8, utf8) function getType(o) { if (o === null || o === undefined) return 0 if (typeof o === 'boolean') return 1 if (typeof o === 'string') return 2 if (b4a.isBuffer(o)) return 3 if (typeof o === 'number') { if (Number.isInteger(o)) return o >= 0 ? 4 : 5 return 6 } if (Array.isArray(o)) return 7 if (o instanceof Date) return 9 if (typeof o === 'object') return 8 throw new Error('Unsupported type for ' + o) } exports.from = function from(enc) { if (typeof enc === 'string') return fromNamed(enc) if (enc.preencode) return enc if (enc.encodingLength) return fromAbstractEncoder(enc) return fromCodec(enc) } function fromNamed(enc) { switch (enc) { case 'ascii': return raw.ascii case 'utf-8': case 'utf8': return raw.utf8 case 'hex': return raw.hex case 'base64': return raw.base64 case 'utf16-le': case 'utf16le': case 'ucs-2': case 'ucs2': return raw.ucs2 case 'ndjson': return raw.ndjson case 'json': return raw.json case 'binary': default: return raw.binary } } function fromCodec(enc) { let tmpM = null let tmpBuf = null return { preencode(state, m) { tmpM = m tmpBuf = enc.encode(m) state.end += tmpBuf.byteLength }, encode(state, m) { raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m)) tmpM = tmpBuf = null }, decode(state) { return enc.decode(raw.decode(state)) } } } function fromAbstractEncoder(enc) { return { preencode(state, m) { state.end += enc.encodingLength(m) }, encode(state, m) { enc.encode(m, state.buffer, state.start) state.start += enc.encode.bytes }, decode(state) { const m = enc.decode(state.buffer, state.start, state.end) state.start += enc.decode.bytes return m } } } exports.encode = function encode(enc, m) { const state = exports.state() enc.preencode(state, m) state.buffer = b4a.allocUnsafe(state.end) enc.encode(state, m) return state.buffer } exports.decode = function decode(enc, buffer) { return enc.decode(exports.state(0, buffer.byteLength, buffer)) } function zigZagInt(enc) { return { preencode(state, n) { enc.preencode(state, zigZagEncodeInt(n)) }, encode(state, n) { enc.encode(state, zigZagEncodeInt(n)) }, decode(state) { return zigZagDecodeInt(enc.decode(state)) } } } function zigZagDecodeInt(n) { return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2 } function zigZagEncodeInt(n) { // 0, -1, 1, -2, 2, ... return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n } function zigZagBigInt(enc) { return { preencode(state, n) { enc.preencode(state, zigZagEncodeBigInt(n)) }, encode(state, n) { enc.encode(state, zigZagEncodeBigInt(n)) }, decode(state) { return zigZagDecodeBigInt(enc.decode(state)) } } } function zigZagDecodeBigInt(n) { return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n } function zigZagEncodeBigInt(n) { // 0, -1, 1, -2, 2, ... return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n } function validateUint(n) { if (n >= 0 === false /* Handles NaN as well */) throw new Error('uint must be positive') // Beyond this, Number arithmetic loses precision and silently corrupts the // encoding. The zig-zag int codecs route through here too, so this also // guards int values whose doubled magnitude exceeds the safe range. if (n > Number.MAX_SAFE_INTEGER) throw new Error( 'integer is greater than the maximum safe integer, use biguint/bigint' ) } module.exports = { preencode, encode, decode } function preencode(state, num) { if (num < 251) { state.end++ } else if (num < 256) { state.end += 2 } else if (num < 0x10000) { state.end += 3 } else if (num < 0x1000000) { state.end += 4 } else if (num < 0x100000000) { state.end += 5 } else { state.end++ const exp = Math.floor(Math.log(num) / Math.log(2)) - 32 preencode(state, exp) state.end += 6 } } function encode(state, num) { const max = 251 const x = num - max if (num < max) { state.buffer[state.start++] = num } else if (num < 256) { state.buffer[state.start++] = max state.buffer[state.start++] = x } else if (num < 0x10000) { state.buffer[state.start++] = max + 1 state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else if (num < 0x1000000) { state.buffer[state.start++] = max + 2 state.buffer[state.start++] = x >> 16 state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else if (num < 0x100000000) { state.buffer[state.start++] = max + 3 state.buffer[state.start++] = x >> 24 state.buffer[state.start++] = (x >> 16) & 0xff state.buffer[state.start++] = (x >> 8) & 0xff state.buffer[state.start++] = x & 0xff } else { // need to use Math here as bitwise ops are 32 bit const exp = Math.floor(Math.log(x) / Math.log(2)) - 32 state.buffer[state.start++] = 0xff encode(state, exp) const rem = x / Math.pow(2, exp - 11) for (let i = 5; i >= 0; i--) { state.buffer[state.start++] = (rem / Math.pow(2, 8 * i)) & 0xff } } } function decode(state) { const max = 251 if (state.end - state.start < 1) throw new Error('Out of bounds') const flag = state.buffer[state.start++] if (flag < max) return flag if (state.end - state.start < flag - max + 1) { throw new Error('Out of bounds.') } if (flag < 252) { return state.buffer[state.start++] + max } if (flag < 253) { return ( (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } if (flag < 254) { return ( (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } // << 24 result may be interpreted as negative if (flag < 255) { return ( state.buffer[state.start++] * 0x1000000 + (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max ) } const exp = decode(state) if (state.end - state.start < 6) throw new Error('Out of bounds') let rem = 0 for (let i = 5; i >= 0; i--) { rem += state.buffer[state.start++] * Math.pow(2, 8 * i) } return rem * Math.pow(2, exp - 11) + max } { "name": "compact-encoding", "version": "3.2.0", "description": "A series of compact encoding schemes for building small and fast parsers and serializers", "main": "index.js", "files": [ "endian.js", "index.js", "lexint.js", "raw.js" ], "dependencies": { "b4a": "^1.3.0" }, "devDependencies": { "brittle": "^3.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" }, "scripts": { "format": "prettier . --write", "test": "prettier . --check && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/compact-encoding.git" }, "author": "Mathias Buus (@mafintosh)", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/compact-encoding/issues" }, "homepage": "https://github.com/holepunchto/compact-encoding" } const b4a = require('b4a') const { BE } = require('./endian') exports = module.exports = { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { state.buffer.set(b, state.start) state.start += b.byteLength }, decode(state) { const b = state.buffer.subarray(state.start, state.end) state.start = state.end return b } } const buffer = (exports.buffer = { preencode(state, b) { uint8array.preencode(state, b) }, encode(state, b) { uint8array.encode(state, b) }, decode(state) { const b = state.buffer.subarray(state.start) state.start = state.end return b } }) exports.binary = { ...buffer, preencode(state, b) { if (typeof b === 'string') utf8.preencode(state, b) else buffer.preencode(state, b) }, encode(state, b) { if (typeof b === 'string') utf8.encode(state, b) else buffer.encode(state, b) } } exports.arraybuffer = { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { const view = new Uint8Array(b) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { const b = new ArrayBuffer(state.end - state.start) const view = new Uint8Array(b) view.set(state.buffer.subarray(state.start)) state.start = state.end return b } } function typedarray(TypedArray, swap) { const n = TypedArray.BYTES_PER_ELEMENT return { preencode(state, b) { state.end += b.byteLength }, encode(state, b) { const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength) if (BE && swap) swap(view) state.buffer.set(view, state.start) state.start += b.byteLength }, decode(state) { let b = state.buffer.subarray(state.start) if (b.byteOffset % n !== 0) b = new Uint8Array(b) if (BE && swap) swap(b) state.start = state.end return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n) } } } const uint8array = (exports.uint8array = typedarray(Uint8Array)) exports.uint16array = typedarray(Uint16Array, b4a.swap16) exports.uint32array = typedarray(Uint32Array, b4a.swap32) exports.int8array = typedarray(Int8Array) exports.int16array = typedarray(Int16Array, b4a.swap16) exports.int32array = typedarray(Int32Array, b4a.swap32) exports.biguint64array = typedarray(BigUint64Array, b4a.swap64) exports.bigint64array = typedarray(BigInt64Array, b4a.swap64) exports.float32array = typedarray(Float32Array, b4a.swap32) exports.float64array = typedarray(Float64Array, b4a.swap64) function string(encoding) { return { preencode(state, s) { state.end += b4a.byteLength(s, encoding) }, encode(state, s) { state.start += b4a.write(state.buffer, s, state.start, encoding) }, decode(state) { const s = b4a.toString(state.buffer, encoding, state.start) state.start = state.end return s } } } const utf8 = (exports.string = exports.utf8 = string('utf-8')) exports.ascii = string('ascii') exports.hex = string('hex') exports.base64 = string('base64') exports.ucs2 = exports.utf16le = string('utf16le') exports.array = function array(enc) { return { preencode(state, list) { for (const value of list) enc.preencode(state, value) }, encode(state, list) { for (const value of list) enc.encode(state, value) }, decode(state) { const arr = [] while (state.start < state.end) arr.push(enc.decode(state)) return arr } } } exports.json = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v)) }, encode(state, v) { utf8.encode(state, JSON.stringify(v)) }, decode(state) { return JSON.parse(utf8.decode(state)) } } exports.ndjson = { preencode(state, v) { utf8.preencode(state, JSON.stringify(v) + '\n') }, encode(state, v) { utf8.encode(state, JSON.stringify(v) + '\n') }, decode(state) { return JSON.parse(utf8.decode(state)) } } module.exports = function debounce (worker, context = null) { debounced.running = null return debounced async function debounced () { if (debounced.running !== null) { try { await debounced.running } catch (_) { // ignore - do not fail on old errors } } // another "thread" beat us to it, just piggy pack on that one if (debounced.running !== null) return debounced.running debounced.running = worker.call(context) try { return await debounced.running } finally { debounced.running = null } } } { "name": "debounceify", "version": "1.1.0", "description": "Tiny async debouncer", "main": "index.js", "dependencies": {}, "devDependencies": { "standard": "^16.0.3", "tape": "^5.1.1" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/debounceify.git" }, "scripts": { "test": "standard && tape test.js" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/debounceify/issues" }, "homepage": "https://github.com/mafintosh/debounceify" } module.exports = require('bare-events') { "name": "events-universal", "version": "1.0.1", "description": "Universal wrapper for the Node.js events module", "exports": { "./package": "./package.json", ".": { "bare": "./bare.js", "react-native": "./react-native.js", "default": "./default.js" } }, "files": [ "index.js", "default.js", "bare.js", "react-native.js" ], "scripts": { "test": "prettier . --check" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/events-universal.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/events-universal/issues" }, "homepage": "https://github.com/holepunchto/events-universal#readme", "dependencies": { "bare-events": "^2.7.0" }, "devDependencies": { "prettier": "^3.4.2", "prettier-config-holepunch": "^1.0.0" } } module.exports = class FixedFIFO { constructor (hwm) { if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two') this.buffer = new Array(hwm) this.mask = hwm - 1 this.top = 0 this.btm = 0 this.next = null } clear () { this.top = this.btm = 0 this.next = null this.buffer.fill(undefined) } push (data) { if (this.buffer[this.top] !== undefined) return false this.buffer[this.top] = data this.top = (this.top + 1) & this.mask return true } shift () { const last = this.buffer[this.btm] if (last === undefined) return undefined this.buffer[this.btm] = undefined this.btm = (this.btm + 1) & this.mask return last } peek () { return this.buffer[this.btm] } isEmpty () { return this.buffer[this.btm] === undefined } } const FixedFIFO = require('./fixed-size') module.exports = class FastFIFO { constructor (hwm) { this.hwm = hwm || 16 this.head = new FixedFIFO(this.hwm) this.tail = this.head this.length = 0 } clear () { this.head = this.tail this.head.clear() this.length = 0 } push (val) { this.length++ if (!this.head.push(val)) { const prev = this.head this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length) this.head.push(val) } } shift () { if (this.length !== 0) this.length-- const val = this.tail.shift() if (val === undefined && this.tail.next) { const next = this.tail.next this.tail.next = null this.tail = next return this.tail.shift() } return val } peek () { const val = this.tail.peek() if (val === undefined && this.tail.next) return this.tail.next.peek() return val } isEmpty () { return this.length === 0 } } { "name": "fast-fifo", "version": "1.3.2", "description": "A fast fifo implementation similar to the one powering nextTick in Node.js core", "main": "index.js", "files": [ "./index.js", "./fixed-size.js" ], "dependencies": {}, "devDependencies": { "standard": "^17.1.0", "brittle": "^3.3.2" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/fast-fifo.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/fast-fifo/issues" }, "homepage": "https://github.com/mafintosh/fast-fifo" } const codecs = require('codecs') const { Readable } = require('streamx') const mutexify = require('mutexify/promise') const b4a = require('b4a') const safetyCatch = require('safety-catch') const ReadyResource = require('ready-resource') const debounce = require('debounceify') const Rache = require('rache') const rrp = require('resolve-reject-promise') const { all: unslabAll } = require('unslab') const RangeIterator = require('./iterators/range') const HistoryIterator = require('./iterators/history') const DiffIterator = require('./iterators/diff') const LocalBlockIterator = require('./iterators/local') const Extension = require('./lib/extension') const { YoloIndex, Node, Header } = require('./lib/messages') const { BLOCK_NOT_AVAILABLE, DECODING_ERROR } = require('hypercore-errors') const T = 5 const MIN_KEYS = T - 1 const MAX_CHILDREN = MIN_KEYS * 2 + 1 const SEP = b4a.alloc(1) const EMPTY = b4a.alloc(0) class Key { constructor(seq, value) { this.seq = seq this.value = value } } class Child { constructor(seq, offset, value) { this.seq = seq this.offset = offset this.value = value } } class Cache { constructor(rache) { this.keys = rache this.length = 0 } get(seq) { return this.keys.get(seq) || null } set(seq, key) { this.keys.set(seq, key) if (seq >= this.length) this.length = seq + 1 } gc(length) { // if we need to "work" more than 128 ticks, just bust the cache... if (this.length - length > 128) { this.keys.clear() } else { for (let i = length; i < this.length; i++) { this.keys.delete(i) } } this.length = length } clear() { this.keys.clear() } } class Pointers { constructor(decoded) { this.levels = decoded.levels.map((l) => { const children = [] const keys = [] for (let i = 0; i < l.keys.length; i++) { keys.push(new Key(l.keys[i], null)) } for (let i = 0; i < l.children.length; i += 2) { children.push(new Child(l.children[i], l.children[i + 1], null)) } return { keys, children } }) } get(i) { return this.levels[i] } hasKey(seq) { for (const lvl of this.levels) { for (const key of lvl.keys) { if (key.seq === seq) return true } } return false } } function inflate(entry) { if (entry.inflated === null) { entry.inflated = YoloIndex.decode(entry.index) entry.index = null } return new Pointers(entry.inflated) } function deflate(index) { const levels = index.map((l) => { const keys = [] const children = [] for (let i = 0; i < l.value.keys.length; i++) { keys.push(l.value.keys[i].seq) } for (let i = 0; i < l.value.children.length; i++) { children.push(l.value.children[i].seq, l.value.children[i].offset) } return { keys, children } }) return YoloIndex.encode({ levels }) } class TreeNode { constructor(block, keys, children, offset) { this.block = block this.offset = offset this.keys = keys this.children = children this.changed = false this.preload() } preload() { if (this.block === null) return const core = getBackingCore(this.block.tree.core) if (!core) return const bitfield = core.core.bitfield const blocks = [] for (let i = 0; i < this.keys.length; i++) { const k = this.keys[i] if (k.value) continue if (k.seq >= core.signedLength || (bitfield && bitfield.get(k.seq))) continue blocks.push(k.seq) } for (let i = 0; i < this.children.length; i++) { const c = this.children[i] if (c.value) continue if (c.seq >= core.signedLength || (bitfield && bitfield.get(c.seq))) continue blocks.push(c.seq) } if (blocks.length) core.download({ blocks }) } async insertKey(key, value, child, node, encoding, cas) { let s = 0 let e = this.keys.length let c while (s < e) { const mid = (s + e) >> 1 c = b4a.compare(key.value, await this.getKey(mid)) if (c === 0) { if (cas) { const prev = await this.getKeyNode(mid) if (!(await cas(prev.final(encoding), node))) return true } if (!this.block.tree.tree.alwaysDuplicate) { const prev = await this.getKeyNode(mid) if (sameValue(prev.value, value)) return true } this.changed = true this.keys[mid] = key return true } if (c < 0) e = mid else s = mid + 1 } const i = c < 0 ? e : s this.keys.splice(i, 0, key) if (child) this.children.splice(i + 1, 0, new Child(0, 0, child)) this.changed = true return this.keys.length < MAX_CHILDREN } removeKey(index) { this.keys.splice(index, 1) if (this.children.length) { this.children[index + 1].seq = 0 // mark as freed this.children.splice(index + 1, 1) } this.changed = true } async siblings(parent) { for (let i = 0; i < parent.children.length; i++) { if (parent.children[i].value === this) { const [left, right] = await Promise.all([ i ? parent.getChildNode(i - 1) : null, i < parent.children.length - 1 ? parent.getChildNode(i + 1) : null ]) return { left, index: i, right } } } throw new Error('Bad parent') } merge(node, median) { this.changed = true this.keys.push(median) for (let i = 0; i < node.keys.length; i++) this.keys.push(node.keys[i]) for (let i = 0; i < node.children.length; i++) this.children.push(node.children[i]) } async split() { const len = this.keys.length >> 1 const right = TreeNode.create(this.block) while (right.keys.length < len) right.keys.push(this.keys.pop()) right.keys.reverse() await this.getKey(this.keys.length - 1) // make sure the median is loaded const median = this.keys.pop() if (this.children.length) { while (right.children.length < len + 1) right.children.push(this.children.pop()) right.children.reverse() } this.changed = true return { left: this, median, right } } getKeyNode(index) { return this.block.tree.getBlock(this.keys[index].seq) } async getChildNode(index) { const child = this.children[index] if (child.value) return child.value const block = child.seq === this.block.seq ? this.block : await this.block.tree.getBlock(child.seq) return (child.value = block.getTreeNode(child.offset)) } setKey(index, key) { this.keys[index] = key this.changed = true } async getKey(index) { const key = this.keys[index] if (key.value) return key.value const k = key.seq === this.block.seq ? this.block.key : await this.block.tree.getKey(key.seq) return (key.value = k) } indexChanges(index, seq) { const offset = index.push(null) - 1 this.changed = false for (const child of this.children) { if (!child.value || !child.value.changed) continue child.seq = seq child.offset = child.value.indexChanges(index, seq) index[child.offset] = child } return offset } updateChildren(seq, block) { for (const child of this.children) { if (!child.value || child.seq !== seq) continue child.value.block = block child.value.updateChildren(seq, block) } } static create(block) { const node = new TreeNode(block, [], [], 0) node.changed = true return node } } class BlockEntry { constructor(seq, tree, entry) { this.seq = seq this.tree = tree this.index = null this.entry = entry this.key = entry.key this.value = entry.value } isTarget(key) { return b4a.equals(this.key, key) } inflate() { if (this.index === null) { this.index = inflate(this.entry) } } isDeletion() { if (this.value !== null) return false if (this.index === null) { this.index = inflate(this.entry) } return !this.index.hasKey(this.seq) } final(encoding) { return { seq: this.seq, key: encoding.key ? encoding.key.decode(this.key) : this.key, value: this.value && (encoding.value ? encoding.value.decode(this.value) : this.value) } } getTreeNode(offset) { if (this.index === null) { this.index = inflate(this.entry) } const entry = this.index.get(offset) return new TreeNode(this, entry.keys, entry.children, offset) } } class CacheLock { constructor() { this.map = new Map() } enter(seq) { const pending = this.map.get(seq) if (!pending) { this.map.set(seq, []) return Promise.resolve() } const { resolve, promise } = rrp() pending.push(resolve) return promise } exit(seq) { const pending = this.map.get(seq) if (!pending.length) { this.map.delete(seq) return } pending.pop()() } } class BatchEntry extends BlockEntry { constructor(seq, tree, key, value, index) { super(seq, tree, { key, value, index: null, inflated: null }) this.pendingIndex = index } isTarget(key) { return false } getTreeNode(offset) { return this.pendingIndex[offset].value } } class Hyperbee extends ReadyResource { constructor(core, opts = {}) { super() // this.feed is now deprecated, and will be this.core going forward this.feed = core this.core = core this.keyEncoding = opts.keyEncoding ? codecs(opts.keyEncoding) : null this.valueEncoding = opts.valueEncoding ? codecs(opts.valueEncoding) : null this.extension = opts.extension !== false ? getExtension(this, opts) : null this.metadata = opts.metadata || null this.lock = opts.lock || mutexify() this.sep = opts.sep || SEP this.readonly = !!opts.readonly this.prefix = opts.prefix || null // In a future version, this should be false by default this.alwaysDuplicate = opts.alwaysDuplicate !== false this._unprefixedKeyEncoding = this.keyEncoding this._sub = !!this.prefix this._checkout = opts.checkout || 0 this._view = !!opts._view this._onappendBound = this._view ? null : this._onappend.bind(this) this._ontruncateBound = this._view ? null : this._ontruncate.bind(this) this._watchers = this._onappendBound ? [] : null this._entryWatchers = this._onappendBound ? [] : null this._sessions = opts.sessions !== false this._keyCache = null this._nodeCache = null this._cacheLock = new CacheLock() this._batches = [] if (this._watchers) { this.core.on('append', this._onappendBound) this.core.on('truncate', this._ontruncateBound) } if (this.prefix && opts._sub) { this.keyEncoding = prefixEncoding(this.prefix, this.keyEncoding) } this.ready().catch(safetyCatch) } async _open() { if (this.core.opened === false) await this.core.ready() // bump the internal ranges since the nodes are small if (this._watchers && this.core.replicator.setInflightRange) { this.core.replicator.setInflightRange(256, 512) } // snapshot if (this._checkout === -1) this._checkout = Math.max(1, this.core.length) const baseCache = Rache.from(this.core.globalCache) this._keyCache = new Cache(baseCache) this._nodeCache = new Cache(Rache.from(baseCache)) } get version() { return Math.max(1, this._checkout || this.core.length) } get id() { return this.core.id } get key() { return this.core.key } get discoveryKey() { return this.core.discoveryKey } get writable() { return this.core.writable } get readable() { return this.core.readable } replicate(isInitiator, opts) { return this.core.replicate(isInitiator, opts) } update(opts) { return this.core.update(opts) } peek(range, opts) { return iteratorPeek(this.createRangeIterator(range, { ...opts, limit: 1 })) } createRangeIterator(range, opts = {}) { // backwards compat range arg opts = opts ? { ...opts, ...range } : range const extension = opts.extension === false && opts.limit !== 0 ? null : this.extension const keyEncoding = opts.keyEncoding ? codecs(opts.keyEncoding) : this.keyEncoding if (extension) { const { onseq, onwait } = opts let version = 0 let next = 0 opts = encRange(keyEncoding, { ...opts, sub: this._sub, onseq(seq) { if (!version) version = seq + 1 if (next) next-- if (onseq) onseq(seq) }, onwait(seq) { if (!next) { next = Extension.BATCH_SIZE extension.iterator(ite.snapshot(version)) } if (onwait) onwait(seq) } }) } else { opts = encRange(keyEncoding, { ...opts, sub: this._sub }) } const ite = new RangeIterator( new Batch(this, this._makeSnapshot(), null, false, opts), null, opts ) return ite } createReadStream(range, opts) { const signal = (opts && opts.signal) || null return iteratorToStream(this.createRangeIterator(range, opts), signal) } createHistoryStream(opts) { const session = opts && opts.live ? this.core.session() : this._makeSnapshot() const signal = (opts && opts.signal) || null return iteratorToStream( new HistoryIterator(new Batch(this, session, null, false, opts), opts), signal ) } createDiffStream(right, range, opts) { if (typeof right === 'number') right = this.checkout(Math.max(1, right), { reuseSession: true }) // backwards compat range arg opts = opts ? { ...opts, ...range } : range const signal = (opts && opts.signal) || null const keyEncoding = opts && opts.keyEncoding ? codecs(opts.keyEncoding) : this.keyEncoding if (keyEncoding) opts = encRange(keyEncoding, { ...opts, sub: this._sub }) let done let closing let ite const left = this const rs = new Readable({ signal, eagerOpen: true, async open(cb) { try { if (right.opened === false) await right.ready() if (left.opened === false) await left.ready() } catch (err) { cb(err) return } if (closing) { cb(null) return } if (left.core.closing || right.core.closing) { cb(new Error('Bee closed')) return } const snapshot = right.version > left.version ? right._makeSnapshot() : left._makeSnapshot() done = cb ite = new DiffIterator( new Batch(left, snapshot, null, false, opts), new Batch(right, snapshot, null, false, opts), opts ) ite.open().then(fin, fin) }, read(cb) { done = cb ite.next().then(push, fin) }, predestroy() { if (!ite) { closing = Promise.resolve() } else { closing = ite.close() closing.catch(noop) } }, destroy(cb) { done = cb if (!closing) closing = ite.close() closing.then(fin, fin) } }) return rs function fin(err) { done(err) } function push(val) { rs.push(val) done(null) } } get(key, opts) { const b = new Batch(this, this._makeSnapshot(), null, true, opts) return b.get(key) } getBySeq(seq, opts) { const b = new Batch(this, this._makeSnapshot(), null, true, opts) return b.getBySeq(seq) } put(key, value, opts) { const b = new Batch(this, this.core, null, true, opts) return b.put(key, value, opts) } batch(opts) { return new Batch(this, this.core, mutexify(), true, opts) } del(key, opts) { const b = new Batch(this, this.core, null, true, opts) return b.del(key, opts) } watch(range, opts) { if (!this._watchers) throw new Error('Can only watch the main bee instance') return new Watcher(this, range, opts) } async getAndWatch(key, opts) { if (!this._watchers) throw new Error('Can only watch the main bee instance') const watcher = new EntryWatcher(this, key, opts) await watcher._debouncedUpdate() if (this.closing) { await watcher.close() throw new Error('Bee closed') } return watcher } _onappend() { for (const watcher of this._watchers) { watcher._onappend() } for (const watcher of this._entryWatchers) { watcher._onappend() } } _ontruncate(length) { for (const watcher of this._watchers) { watcher._ontruncate() } for (const watcher of this._entryWatchers) { watcher._ontruncate() } this._nodeCache.gc(length) this._keyCache.gc(length) } _makeSnapshot() { if (this._sessions === false) return this.core // TODO: better if we could encapsulate this in hypercore in the future return this._checkout <= this.core.length || this._checkout <= 1 ? this.core.snapshot() : this.core.session({ snapshot: false }) } async clearUnlinked(options = {}) { await this.ready() const { gte = 0, lt = this.version - 1, batchSize = 4096, wait = true } = options const checkout = this.version let prev = this.batch({ wait: false, checkout: gte }) let b = this.batch({ wait, checkout }) const iteBatch = this.batch({ wait: false, checkout }) const ite = new LocalBlockIterator(iteBatch, { gte, lt }) await ite.open() let ticks = 0 while (true) { const data = await ite.next() if (!data) break if (!(await isLinked(b, data))) { if (b.core.closing || this.core.closing || this.closing) break await this.core.clear(data.seq) } const prevNode = await prev.get(data.key, { finalize: false }).catch(toNull) if (prevNode && !(await isLinked(b, prevNode))) { if (b.core.closing || this.core.closing || this.closing) break await this.core.clear(prevNode.seq) } if (ticks++ >= batchSize) { ticks = 0 await prev.close() await b.close() prev = this.batch({ wait: false, checkout: gte }) b = this.batch({ wait, checkout }) } } if (b.core.closing || this.core.closing || this.closing) throw new Error('Core is closed') await b.close() await prev.close() await ite.close() await iteBatch.close() return lt } checkout(version, opts = {}) { if (version === 0) version = 1 // same as above, just checkout isn't set yet... const snap = opts.reuseSession || this._sessions === false ? this.core : version <= this.core.length || version <= 1 ? this.core.snapshot() : this.core.session({ snapshot: false }) return new Hyperbee(snap, { _view: true, _sub: false, prefix: this.prefix, sep: this.sep, lock: this.lock, checkout: version, keyEncoding: opts.keyEncoding || this.keyEncoding, valueEncoding: opts.valueEncoding || this.valueEncoding, extension: this.extension !== null ? this.extension : false }) } snapshot(opts) { return this.checkout( this.core.opened === false || this._checkout <= 0 ? -1 : Math.max(1, this.version), opts ) } sub(prefix, opts = {}) { let sep = opts.sep || this.sep if (!b4a.isBuffer(sep)) sep = b4a.from(sep) prefix = b4a.concat([this.prefix || EMPTY, b4a.from(prefix), sep]) const valueEncoding = codecs(opts.valueEncoding || this.valueEncoding) const keyEncoding = codecs(opts.keyEncoding || this._unprefixedKeyEncoding) return new Hyperbee(this.core, { _view: true, _sub: true, prefix, sep: this.sep, lock: this.lock, checkout: this._checkout, valueEncoding, keyEncoding, extension: this.extension !== null ? this.extension : false, metadata: this.metadata }) } async getHeader(opts) { const blk = await this.core.get(0, opts) try { return blk && Header.decode(blk) } catch { throw DECODING_ERROR() } } async _close() { if (!this._view) { if (this._keyCache) this._keyCache.clear() if (this._nodeCache) this._nodeCache.clear() } if (this._watchers) { this.core.off('append', this._onappendBound) this.core.off('truncate', this._ontruncateBound) while (this._watchers.length) { await this._watchers[this._watchers.length - 1].close() } } if (this._entryWatchers) { while (this._entryWatchers.length) { await this._entryWatchers[this._entryWatchers.length - 1].close() } } while (this._batches.length) { await this._batches[this._batches.length - 1].close() } return this.core.close() } static async isHyperbee(core, opts) { await core.ready() const blk0 = await core.get(0, opts) if (blk0 === null) throw BLOCK_NOT_AVAILABLE() try { return Header.decode(blk0).protocol === 'hyperbee' } catch (err) { // undecodable return false } } } class Batch { constructor(tree, core, batchLock, cache, options = {}) { this.tree = tree // this.feed is now deprecated, and will be this.core going forward this.feed = core this.core = core this.index = tree._batches.push(this) - 1 this.blocks = cache ? new Map() : null this.autoFlush = !batchLock this.maxBlocksCached = options.maxBlocksCached || 128 this.rootSeq = 0 this.root = null this.length = 0 this.checkout = options.checkout === undefined ? -1 : options.checkout this.options = options this.locked = null this.batchLock = batchLock this.onseq = this.options.onseq || noop this.appending = null this.isSnapshot = this.core !== this.tree.core this.shouldUpdate = this.options.update !== false this.updating = null this.encoding = { key: options.keyEncoding ? codecs(options.keyEncoding) : tree.keyEncoding, value: options.valueEncoding ? codecs(options.valueEncoding) : tree.valueEncoding } } async ready() { if (this.core.opened === false) await this.core.ready() if (this.tree.opened === false) await this.tree.ready() } async lock() { if (this.tree.readonly) throw new Error('Hyperbee is marked as read-only') if (this.locked === null) this.locked = await this.tree.lock() } get version() { if (this.checkout !== -1) return Math.max(1, this.checkout) return Math.max(1, this.tree._checkout || this.core.length + this.length) } async getRoot(ensureHeader) { await this.ready() if (ensureHeader) { if (this.core.length === 0 && this.core.writable && !this.tree.readonly) { await this.core.append( Header.encode({ protocol: 'hyperbee', metadata: this.tree.metadata }) ) } } if (this.tree._checkout === 0 && this.checkout === -1 && this.shouldUpdate) { if (this.updating === null) this.updating = this.core.update() await this.updating } if (this.version < 2) return null return (await this.getBlock(this.version - 1)).getTreeNode(0) } async getKey(seq) { await this.tree._cacheLock.enter(seq) try { const k = this.core.fork === this.tree.core.fork ? this.tree._keyCache.get(seq) : null if (k !== null) return k const key = (await this._getBlock(seq)).key if (this.core.fork === this.tree.core.fork) this.tree._keyCache.set(seq, key) return key } finally { this.tree._cacheLock.exit(seq) } } async _getNode(seq) { const cached = this.tree._nodeCache !== null && this.core.fork === this.tree.core.fork ? this.tree._nodeCache.get(seq) : null if (cached !== null) return cached const entry = await this.core.get(seq, { ...this.options, valueEncoding: Node }) if (entry === null) throw BLOCK_NOT_AVAILABLE() const wrap = copyEntry(entry) if (this.core.fork === this.tree.core.fork && this.tree._nodeCache !== null) { this.tree._nodeCache.set(seq, wrap) } return wrap } async getBlock(seq) { if (this.rootSeq === 0) this.rootSeq = seq await this.tree._cacheLock.enter(seq) try { return await this._getBlock(seq) } finally { this.tree._cacheLock.exit(seq) } } async _getBlock(seq) { let b = this.blocks && this.blocks.get(seq) if (b) return b this.onseq(seq) const entry = await this._getNode(seq) b = this.blocks && this.blocks.get(seq) if (b) return b b = new BlockEntry(seq, this, entry) if (this.blocks && this.blocks.size - this.length < this.maxBlocksCached) { this.blocks.set(seq, b) } return b } _onwait(key) { this.options.onwait = null this.tree.extension.get(this.rootSeq + 1, key) } _getEncoding(opts) { if (!opts) return this.encoding return { key: opts.keyEncoding ? codecs(opts.keyEncoding) : this.encoding.key, value: opts.valueEncoding ? codecs(opts.valueEncoding) : this.encoding.value } } peek(range, opts) { return iteratorPeek(this.createRangeIterator(range, { ...opts, limit: 1 })) } createRangeIterator(range, opts = {}) { // backwards compat range arg opts = opts ? { ...opts, ...range } : range const encoding = this._getEncoding(opts) return new RangeIterator( this, encoding, encRange(encoding.key, { ...opts, sub: this.tree._sub }) ) } createReadStream(range, opts) { const signal = (opts && opts.signal) || null return iteratorToStream(this.createRangeIterator(range, opts), signal) } async getBySeq(seq, opts) { const encoding = this._getEncoding(opts) try { const block = (await this.getBlock(seq)).final(encoding) return { key: block.key, value: block.value } } finally { await this._closeSnapshot() } } async get(key, opts) { const encoding = this._getEncoding(opts) const finalize = opts ? opts.finalize !== false : true try { return await this._get(key, encoding, finalize) } finally { await this._closeSnapshot() } } async _get(key, encoding, finalize) { key = enc(encoding.key, key) if (this.tree.extension !== null && this.options.extension !== false) { this.options.onwait = this._onwait.bind(this, key) } let node = await this.getRoot(false) if (!node) return null while (true) { if (node.block.isTarget(key)) { return node.block.isDeletion() ? null : finalize ? node.block.final(encoding) : node.block } let s = 0 let e = node.keys.length let c while (s < e) { const mid = (s + e) >> 1 c = b4a.compare(key, await node.getKey(mid)) if (c === 0) { const block = await this.getBlock(node.keys[mid].seq) return finalize ? block.final(encoding) : block } if (c < 0) e = mid else s = mid + 1 } if (!node.children.length) return null const i = c < 0 ? e : s node = await node.getChildNode(i) } } async links(key, seq) { let node = await this.getRoot(false) if (!node) return false if (node.block.seq === seq) return true while (true) { if (node.block.isTarget(key)) return false let s = 0 let e = node.keys.length let c while (s < e) { const mid = (s + e) >> 1 if (node.keys[mid].seq === seq) return true c = b4a.compare(key, await node.getKey(mid)) if (c === 0) return false if (c < 0) e = mid else s = mid + 1 } if (!node.children.length) return false const i = c < 0 ? e : s node = await node.getChildNode(i) if (node.block.seq === seq) return true } } async put(key, value, opts) { const release = this.batchLock ? await this.batchLock() : null const cas = (opts && opts.cas) || null const encoding = this._getEncoding(opts) if (!this.locked) await this.lock() if (!release) return this._put(key, value, encoding, cas) try { return await this._put(key, value, encoding, cas) } finally { release() } } async _put(key, value, encoding, cas) { const newNode = { seq: 0, key, value } key = enc(encoding.key, key) value = enc(encoding.value, value) const stack = [] let root let node = (root = await this.getRoot(true)) if (!node) node = root = TreeNode.create(null) const seq = (newNode.seq = this.core.length + this.length) const target = new Key(seq, key) while (node.children.length) { stack.push(node) node.changed = true // changed, but compressible let s = 0 let e = node.keys.length let c while (s < e) { const mid = (s + e) >> 1 c = b4a.compare(target.value, await node.getKey(mid)) if (c === 0) { if (cas) { const prev = await node.getKeyNode(mid) if (!(await cas(prev.final(encoding), newNode))) return this._unlockMaybe() } if (!this.tree.alwaysDuplicate) { const prev = await node.getKeyNode(mid) if (sameValue(prev.value, value)) return this._unlockMaybe() } node.setKey(mid, target) return this._append(root, seq, key, value) } if (c < 0) e = mid else s = mid + 1 } const i = c < 0 ? e : s node = await node.getChildNode(i) } let needsSplit = !(await node.insertKey(target, value, null, newNode, encoding, cas)) if (!node.changed) return this._unlockMaybe() while (needsSplit) { const parent = stack.pop() const { median, right } = await node.split() if (parent) { needsSplit = !(await parent.insertKey(median, value, right, null, encoding, null)) node = parent } else { root = TreeNode.create(node.block) root.changed = true root.keys.push(median) root.children.push(new Child(0, 0, node), new Child(0, 0, right)) needsSplit = false } } return this._append(root, seq, key, value) } async del(key, opts) { const release = this.batchLock ? await this.batchLock() : null const cas = (opts && opts.cas) || null const encoding = this._getEncoding(opts) if (!this.locked) await this.lock() if (!release) return this._del(key, encoding, cas) try { return await this._del(key, encoding, cas) } finally { release() } } async _del(key, encoding, cas) { const delNode = { seq: 0, key, value: null } key = enc(encoding.key, key) const stack = [] let node = await this.getRoot(true) if (!node) return this._unlockMaybe() const seq = (delNode.seq = this.core.length + this.length) while (true) { stack.push(node) let s = 0 let e = node.keys.length let c while (s < e) { const mid = (s + e) >> 1 c = b4a.compare(key, await node.getKey(mid)) if (c === 0) { if (cas) { const prev = await node.getKeyNode(mid) if (!(await cas(prev.final(encoding), delNode))) return this._unlockMaybe() } if (node.children.length) await setKeyToNearestLeaf(node, mid, stack) else node.removeKey(mid) // we mark these as changed late, so we don't rewrite them if it is a 404 for (const node of stack) node.changed = true return this._append(await rebalance(stack), seq, key, null) } if (c < 0) e = mid else s = mid + 1 } if (!node.children.length) return this._unlockMaybe() const i = c < 0 ? e : s node = await node.getChildNode(i) } } async _closeSnapshot() { if (this.isSnapshot) { await this.core.close() this._finalize() } } async close() { if (this.isSnapshot) return this._closeSnapshot() this.root = null if (this.blocks) this.blocks.clear() this.length = 0 this._unlock() } destroy() { // compat, remove later this.close().catch(noop) } toBlocks() { if (this.appending) return this.appending const batch = new Array(this.length) for (let i = 0; i < this.length; i++) { const seq = this.core.length + i const { pendingIndex, key, value } = this.blocks.get(seq) if (i < this.length - 1) { pendingIndex[0] = null let j = 0 while (j < pendingIndex.length) { const idx = pendingIndex[j] if (idx !== null && idx.seq === seq) { idx.offset = j++ continue } if (j === pendingIndex.length - 1) pendingIndex.pop() else pendingIndex[j] = pendingIndex.pop() } } batch[i] = Node.encode({ key, value, index: deflate(pendingIndex) }) } this.appending = batch return batch } flush() { if (!this.length) return this.close() const batch = this.toBlocks() this.root = null this.blocks.clear() this.length = 0 return this._appendBatch(batch) } _unlockMaybe() { if (this.autoFlush) this._unlock() } _unlock() { const locked = this.locked this.locked = null if (locked !== null) locked() this._finalize() } _finalize() { // technically finalize can be called more than once, so here we just check if we already have been removed if (this.index >= this.tree._batches.length || this.tree._batches[this.index] !== this) return const top = this.tree._batches.pop() if (top === this) return top.index = this.index this.tree._batches[top.index] = top } _append(root, seq, key, value) { const index = [] root.indexChanges(index, seq) index[0] = new Child(seq, 0, root) if (!this.autoFlush) { const block = new BatchEntry(seq, this, key, value, index) root.block = block this.root = root this.length++ this.blocks.set(seq, block) root.updateChildren(seq, block) return } return this._appendBatch( Node.encode({ key, value, index: deflate(index) }) ) } async _appendBatch(raw) { try { await this.core.append(raw) } finally { this._unlock() } } } class EntryWatcher extends ReadyResource { constructor(bee, key, opts = {}) { super() this.keyEncoding = opts.keyEncoding || bee.keyEncoding this.valueEncoding = opts.valueEncoding || bee.valueEncoding this.index = bee._entryWatchers.push(this) - 1 this.bee = bee this.key = key this.node = null this._forceUpdate = false this._debouncedUpdate = debounce(this._processUpdate.bind(this)) } _close() { const top = this.bee._entryWatchers.pop() if (top !== this) { top.index = this.index this.bee._entryWatchers[top.index] = top } } _onappend() { this._debouncedUpdate() } _ontruncate() { this._forceUpdate = true this._debouncedUpdate() } async _processUpdate() { const force = this._forceUpdate this._forceUpdate = false let newNode try { newNode = await this.bee.get(this.key, { keyEncoding: this.keyEncoding, valueEncoding: this.valueEncoding }) } catch (e) { if (e.code === 'SNAPSHOT_NOT_AVAILABLE') { // There was a truncate event before the get resolved // So this handler will run again anyway return } else if (this.bee.closing) { this.close().catch(safetyCatch) return } this.emit('error', e) return } if (force || newNode?.seq !== this.node?.seq) { this.node = newNode this.emit('update') } } } class Watcher extends ReadyResource { constructor(bee, range, opts = {}) { super() this.keyEncoding = opts.keyEncoding || bee.keyEncoding this.valueEncoding = opts.valueEncoding || bee.valueEncoding this.index = bee._watchers.push(this) - 1 this.bee = bee this.core = bee.core this.latestDiff = 0 this.range = range this.map = opts.map || defaultWatchMap this.current = null this.previous = null this.currentMapped = null this.previousMapped = null this.stream = null this._lock = mutexify() this._flowing = false this._resolveOnChange = null this._differ = opts.differ || defaultDiffer this._eager = !!opts.eager this._onchange = opts.onchange || null this.on('newListener', autoFlowOnUpdate) this.ready().catch(safetyCatch) } async _consume() { if (this._flowing) return try { for await (const _ of this) { } // eslint-disable-line } catch {} } async _open() { await this.bee.ready() const opts = { keyEncoding: this.keyEncoding, valueEncoding: this.valueEncoding } // Point from which to start watching this.current = this._eager ? this.bee.checkout(1, opts) : this.bee.snapshot(opts) await this.current.ready() if (this._onchange) { if (this._eager) await this._onchange() this._consume() } } [Symbol.asyncIterator]() { this._flowing = true return this } _ontruncate() { this._onappend() } _onappend() { const resolve = this._resolveOnChange this._resolveOnChange = null if (resolve) resolve() } async _waitForChanges() { if (this.current.version < this.bee.version || this.closing) return await new Promise((resolve) => { this._resolveOnChange = resolve }) } async next() { try { return await this._next() } catch (err) { if (this.closing) return { value: undefined, done: true } await this.close() throw err } } async _next() { const release = await this._lock() try { if (this.closing) return { value: undefined, done: true } if (!this.opened) await this.ready() while (true) { await this._waitForChanges() if (this.closing) return { value: undefined, done: true } await this._closePrevious() this.previous = this.current.snapshot() await this._closeCurrent() this.current = this.bee.snapshot({ keyEncoding: this.keyEncoding, valueEncoding: this.valueEncoding }) await this.current.ready() await this.previous.ready() if (this.current.core.fork !== this.previous.core.fork) { return await this._yield() } this.stream = this._differ(this.current, this.previous, this.range) try { for await (const data of this.stream) { // eslint-disable-line return await this._yield() } } finally { this.stream = null } } } finally { release() } } async _yield() { this.currentMapped = this.map(this.current) this.previousMapped = this.map(this.previous) if (this._onchange) { try { await this._onchange() } catch (err) { safetyCatch(err) } } this.emit('update') return { done: false, value: [this.currentMapped, this.previousMapped] } } async return() { await this.close() return { done: true } } async _close() { const top = this.bee._watchers.pop() if (top !== this) { top.index = this.index this.bee._watchers[top.index] = top } if (this.stream && !this.stream.destroying) { this.stream.destroy() } this._onappend() // Continue execution being closed await this._closeCurrent().catch(safetyCatch) await this._closePrevious().catch(safetyCatch) const release = await this._lock() release() } destroy() { return this.close() } async _closeCurrent() { if (this.currentMapped) await this.currentMapped.close() if (this.current) await this.current.close() this.current = this.currentMapped = null } async _closePrevious() { if (this.previousMapped) await this.previousMapped.close() if (this.previous) await this.previous.close() this.previous = this.previousMapped = null } } function autoFlowOnUpdate(name) { if (name === 'update') this._consume() } function defaultWatchMap(snapshot) { return snapshot } async function leafSize(node, goLeft) { while (node.children.length) node = await node.getChildNode(goLeft ? 0 : node.children.length - 1) return node.keys.length } async function setKeyToNearestLeaf(node, index, stack) { let [left, right] = await Promise.all([node.getChildNode(index), node.getChildNode(index + 1)]) const [ls, rs] = await Promise.all([leafSize(left, false), leafSize(right, true)]) if (ls < rs) { // if fewer leaves on the left stack.push(right) while (right.children.length) stack.push((right = right.children[0].value)) node.keys[index] = right.keys.shift() } else { // if fewer leaves on the right stack.push(left) while (left.children.length) stack.push((left = left.children[left.children.length - 1].value)) node.keys[index] = left.keys.pop() } } async function rebalance(stack) { const root = stack[0] while (stack.length > 1) { const node = stack.pop() const parent = stack[stack.length - 1] if (node.keys.length >= MIN_KEYS) return root let { left, index, right } = await node.siblings(parent) // maybe borrow from left sibling? if (left && left.keys.length > MIN_KEYS) { left.changed = true node.keys.unshift(parent.keys[index - 1]) if (left.children.length) node.children.unshift(left.children.pop()) parent.keys[index - 1] = left.keys.pop() return root } // maybe borrow from right sibling? if (right && right.keys.length > MIN_KEYS) { right.changed = true node.keys.push(parent.keys[index]) if (right.children.length) node.children.push(right.children.shift()) parent.keys[index] = right.keys.shift() return root } // merge node with another sibling if (left) { index-- right = node } else { left = node } left.merge(right, parent.keys[index]) parent.removeKey(index) } // check if the tree shrunk if (!root.keys.length && root.children.length) return root.getChildNode(0) return root } function iteratorToStream(ite, signal) { let done let closing const rs = new Readable({ signal, open(cb) { done = cb ite.open().then(fin, fin) }, read(cb) { done = cb ite.next().then(push, fin) }, predestroy() { closing = ite.close() closing.catch(noop) }, destroy(cb) { done = cb if (!closing) closing = ite.close() closing.then(fin, fin) } }) return rs function fin(err) { done(err) } function push(val) { rs.push(val) done(null) } } async function iteratorPeek(ite) { try { await ite.open() return await ite.next() } finally { await ite.close() } } function encRange(e, opts) { if (!e) return opts if (e.encodeRange) { const r = e.encodeRange({ gt: opts.gt, gte: opts.gte, lt: opts.lt, lte: opts.lte }) opts.gt = r.gt opts.gte = r.gte opts.lt = r.lt opts.lte = r.lte return opts } if (opts.gt !== undefined) opts.gt = enc(e, opts.gt) if (opts.gte !== undefined) opts.gte = enc(e, opts.gte) if (opts.lt !== undefined) opts.lt = enc(e, opts.lt) if (opts.lte !== undefined) opts.lte = enc(e, opts.lte) if (opts.sub && !opts.gt && !opts.gte) opts.gt = enc(e, SEP) if (opts.sub && !opts.lt && !opts.lte) opts.lt = bump(enc(e, EMPTY)) return opts } function bump(key) { // key should have been copied by enc above before hitting this key[key.length - 1]++ return key } function enc(e, v) { if (v === undefined || v === null) return null if (e !== null) return e.encode(v) if (typeof v === 'string') return b4a.from(v) return v } function prefixEncoding(prefix, keyEncoding) { return { encode(key) { return b4a.concat([prefix, b4a.isBuffer(key) ? key : enc(keyEncoding, key)]) }, decode(key) { const sliced = key.slice(prefix.length, key.length) return keyEncoding ? keyEncoding.decode(sliced) : sliced } } } function copyEntry(entry) { let key = entry.key let value = entry.value let index = entry.index // key, value and index all refer to the same buffer (one hypercore block) // If together they are larger than half the buffer's byteLength, // this means that they got their own private slab (see Buffer.allocUnsafe docs) // so no need to unslab const size = key.byteLength + (value === null ? 0 : value.byteLength) + (index === null ? 0 : index.byteLength) if (2 * size < key.buffer.byteLength) { const [newKey, newValue, newIndex] = unslabAll([entry.key, entry.value, entry.index]) key = newKey value = newValue index = newIndex } return { key, value, index, inflated: null } } function defaultDiffer(currentSnap, previousSnap, opts) { return currentSnap.createDiffStream(previousSnap, opts) } function toNull() { return null } function getBackingCore(core) { if (core.core) return core if (core.getBackingCore) return core.getBackingCore().session return null } function sameValue(a, b) { return a === b || (a !== null && b !== null && b4a.equals(a, b)) } function noop() {} function getExtension(db, opts) { if (opts.extension === false) return null if (opts.extension && opts.extension !== true) return opts.extension return Extension.register(db) } async function isLinked(batch, block) { const seq = block.seq block.inflate() const keys = [block.key] const wait = batch.options.wait for (const l of block.index.levels) { if (!l.keys.length) continue batch.options.wait = false try { keys.push(await batch.getKey(l.keys[0].seq)) } catch {} batch.options.wait = wait } for (const k of keys) { if (await batch.links(k, seq)) return true } if (batch.core.closing) throw new Error('Core is closed') return false } module.exports = Hyperbee const b4a = require('b4a') class SubTree { constructor(node, parent) { this.node = node this.parent = parent this.isKey = node.children.length === 0 this.i = this.isKey ? 1 : 0 this.n = 0 const child = this.isKey ? null : this.node.children[0] this.seq = child !== null ? child.seq : this.node.keys[0].seq this.offset = child !== null ? child.offset : 0 } next() { this.i++ this.isKey = (this.i & 1) === 1 if (!this.isKey && !this.node.children.length) this.i++ return this.update() } async bisect(key, incl) { let s = 0 let e = this.node.keys.length let c while (s < e) { const mid = (s + e) >> 1 c = cmp(key, await this.node.getKey(mid)) if (c === 0) { if (incl) this.i = mid * 2 + 1 else this.i = mid * 2 + (this.node.children.length ? 2 : 3) return true } if (c < 0) e = mid else s = mid + 1 } const i = c < 0 ? e : s this.i = 2 * i + (this.node.children.length ? 0 : 1) return this.node.children.length === 0 } update() { this.isKey = (this.i & 1) === 1 this.n = this.i >> 1 if (this.n >= (this.isKey ? this.node.keys.length : this.node.children.length)) return false const child = this.isKey ? null : this.node.children[this.n] this.seq = child !== null ? child.seq : this.node.keys[this.n].seq this.offset = child !== null ? child.offset : 0 return true } async key() { return this.n < this.node.keys.length ? this.node.getKey(this.n) : this.parent && this.parent.key() } async compare(tree) { const [a, b] = await Promise.all([this.key(), tree.key()]) return cmp(a, b) } } class TreeIterator { constructor(batch, opts) { this.batch = batch this.stack = [] this.lt = opts.lt || opts.lte || null this.lte = !!opts.lte this.gt = opts.gt || opts.gte || null this.gte = !!opts.gte this.seeking = !!this.gt this.encoding = opts.encoding || batch.encoding } async open() { const node = await this.batch.getRoot(false) if (!node || !node.keys.length) return const tree = new SubTree(node, null) if (this.seeking && !(await this._seek(tree))) return this.stack.push(tree) } async _seek(tree) { const done = await tree.bisect(this.gt, this.gte) const oob = !tree.update() if (done || oob) { this.seeking = false if (oob) return false } return true } peek() { if (!this.stack.length) return null return this.stack[this.stack.length - 1] } skip() { if (!this.stack.length) return if (!this.stack[this.stack.length - 1].next()) this.stack.pop() } async nextKey() { let n = null while (this.stack.length && n === null) n = await this.next() if (n === null) return null if (!this.lt) return n.final(this.encoding) const c = cmp(n.key, this.lt) if (this.lte ? c <= 0 : c < 0) return n.final(this.encoding) this.stack = [] return null } async next() { if (!this.stack.length) return null const top = this.stack[this.stack.length - 1] const { isKey, n, seq } = top if (!top.next()) { this.stack.pop() } if (isKey) { this.seeking = false return this.batch.getBlock(seq) } const child = await top.node.getChildNode(n) top.node.children[n] = null // unlink to save memory const tree = new SubTree(child, top) if (this.seeking && !(await this._seek(tree))) return null this.stack.push(tree) return null } close() { return this.batch._closeSnapshot() } } module.exports = class DiffIterator { constructor(left, right, opts = {}) { this.left = new TreeIterator(left, opts) this.right = new TreeIterator(right, opts) this.limit = typeof opts.limit === 'number' ? opts.limit : -1 } async open() { await Promise.all([this.left.open(), this.right.open()]) } async next() { if (this.limit === 0) return null const res = await this._next() if (!res || (res.left === null && res.right === null)) return null this.limit-- return res } async _next() { const a = this.left const b = this.right while (true) { const [l, r] = await Promise.all([a.peek(), b.peek()]) if (!l && !r) return null if (!l) return { left: null, right: await b.nextKey() } if (!r) return { left: await a.nextKey(), right: null } if (l.seq === r.seq && l.isKey === r.isKey && l.offset === r.offset) { a.skip() b.skip() continue } const c = await l.compare(r) if (l.isKey && !r.isKey) { await b.next() continue } if (!l.isKey && r.isKey) { await a.next() continue } if (l.isKey && r.isKey) { if (c === 0) return { left: await a.nextKey(), right: await b.nextKey() } if (c < 0) return { left: await a.nextKey(), right: null } return { left: null, right: await b.nextKey() } } if (c === 0) await Promise.all([a.next(), b.next()]) else if (c < 0) await b.next() else await a.next() } } async close() { await Promise.all([this.left.close(), this.right.close()]) } } function cmp(a, b) { if (!a) return b ? 1 : 0 if (!b) return a ? -1 : 0 return b4a.compare(a, b) } module.exports = class HistoryIterator { constructor(batch, opts = {}) { this.batch = batch this.options = opts this.live = !!opts.live this.gte = 0 this.lt = 0 this.reverse = !!opts.reverse this.limit = typeof opts.limit === 'number' ? opts.limit : -1 this.encoding = opts.encoding || batch.encoding if (this.live && this.reverse) { throw new Error('Cannot have both live and reverse enabled') } } async open() { await this.batch.getRoot(false) // does the update dance this.gte = gte(this.options, this.batch.version) this.lt = this.live ? Infinity : lt(this.options, this.batch.version) } async next() { if (this.limit === 0) return null if (this.limit > 0) this.limit-- if (this.gte >= this.lt) return null if (this.reverse) { if (this.lt <= 1) return null return final(await this.batch.getBlock(--this.lt), this.encoding) } return final(await this.batch.getBlock(this.gte++), this.encoding) } close() { return this.batch._closeSnapshot() } } function final(node, encoding) { const type = node.isDeletion() ? 'del' : 'put' return { type, ...node.final(encoding) } } function gte(opts, version) { if (opts.gt) return (opts.gt < 0 ? opts.gt + version : opts.gt) + 1 const gte = opts.gte || opts.since || 1 return gte < 0 ? gte + version : gte } function lt(opts, version) { if (opts.lte === 0 || opts.lt === 0 || opts.end === 0) return 0 if (opts.lte) return (opts.lte < 0 ? opts.lte + version : opts.lte) + 1 const lt = opts.lt || opts.end || version return lt < 0 ? lt + version : lt } module.exports = class LocalBlocksIterator { constructor(batch, opts = {}) { this.batch = batch this.options = opts this.gte = 0 this.lt = 0 this.limit = typeof opts.limit === 'number' ? opts.limit : -1 } async open() { await this.batch.getRoot(false) // does the update dance this.gte = gte(this.options, this.batch.version) this.lt = lt(this.options, this.batch.version) } async next() { if (this.limit === 0) return null if (this.limit > 0) this.limit-- while (this.gte < this.lt) { try { return await this.batch.getBlock(this.gte++) } catch { continue } } return null } close() { return this.batch._closeSnapshot() } } function gte(opts, version) { if (opts.gt) return (opts.gt < 0 ? opts.gt + version : opts.gt) + 1 const gte = opts.gte || opts.since || 1 return gte < 0 ? gte + version : gte } function lt(opts, version) { if (opts.lte === 0 || opts.lt === 0 || opts.end === 0) return 0 if (opts.lte) return (opts.lte < 0 ? opts.lte + version : opts.lte) + 1 const lt = opts.lt || opts.end || version return lt < 0 ? lt + version : lt } const b4a = require('b4a') module.exports = class RangeIterator { constructor(batch, encoding, opts = {}) { this.batch = batch this.stack = [] this.opened = false this.encoding = encoding || batch.encoding this._limit = typeof opts.limit === 'number' ? opts.limit : -1 this._gIncl = !opts.gt this._gKey = opts.gt || opts.gte || null this._lIncl = !opts.lt this._lKey = opts.lt || opts.lte || null this._reverse = !!opts.reverse this._version = 0 this._checkpoint = opts.checkpoint && opts.checkpoint.length ? opts.checkpoint : null this._nexting = false this._closed = false } snapshot(version = this.batch.version) { const checkpoint = [] for (const s of this.stack) { let { node, i } = s if (this._nexting && s === this.stack[this.stack.length - 1]) { i = this._reverse ? i + 1 : i - 1 } if (!node.block) continue if (i < 0) continue checkpoint.push(node.block.seq, node.offset, i) } return { version, gte: this._gIncl ? this._gKey : null, gt: this._gIncl ? null : this._gKey, lte: this._lIncl ? this._lKey : null, lt: this._lIncl ? null : this._lKey, limit: this._limit, reverse: this._reverse, ended: this.opened && !checkpoint.length, checkpoint: this.opened ? checkpoint : [] } } async open() { await this._open() this.opened = true } async _open() { if (this._checkpoint) { for (let j = 0; j < this._checkpoint.length; j += 3) { const seq = this._checkpoint[j] const offset = this._checkpoint[j + 1] const i = this._checkpoint[j + 2] this.stack.push({ node: (await this.batch.getBlock(seq)).getTreeNode(offset), i }) } return } this._nexting = true let node = await this.batch.getRoot(false) if (!node) { this._nexting = false return } const incl = this._reverse ? this._lIncl : this._gIncl const start = this._reverse ? this._lKey : this._gKey if (!start) { this.stack.push({ node, i: this._reverse ? node.keys.length << 1 : 0 }) this._nexting = false this._preloadQuery() return } while (true) { const entry = { node, i: this._reverse ? node.keys.length << 1 : 0 } let s = 0 let e = node.keys.length let c while (s < e) { const mid = (s + e) >> 1 c = b4a.compare(start, await node.getKey(mid)) if (c === 0) { if (incl) entry.i = mid * 2 + 1 else entry.i = mid * 2 + (this._reverse ? 0 : 2) this.stack.push(entry) this._nexting = false this._preloadQuery() return } if (c < 0) e = mid else s = mid + 1 } const i = c < 0 ? e : s entry.i = 2 * i + (this._reverse ? -1 : 1) if (entry.i >= 0 && entry.i <= node.keys.length << 1) this.stack.push(entry) if (!node.children.length) { this._nexting = false this._preloadQuery() return } node = await node.getChildNode(i) } } _preloadQuery() { const max = { nodes: 0, max: 2048 } if (this._limit === -1 && !this._reverse && this.stack.length) { for (const s of this.stack) { const k = (s.i - (s.i & 1)) / 2 this._preload(s.node, k + 1, this._lKey, max).catch(noop) } } } async _preload(node, i, end, max) { for (; i < node.keys.length; i++) { const key = node.keys[i] const block = await this.batch.getBlock(key.seq) if (this._closed) return const c = end ? b4a.compare(block.key, end) : -1 if (c >= 0 || max.nodes >= max.max || i >= node.children.length) return max.nodes++ const next = await node.getChildNode(i) if (this._closed) return this._preload(next, 0, end, max).catch(noop) } if (node.children.length && max.nodes < max.max) { const next = await node.getChildNode(node.children.length - 1) if (this._closed) return this._preload(next, 0, end, max).catch(noop) } } async next() { // TODO: this nexting flag is only needed if someone asks for a snapshot during // a lookup (ie the extension, pretty important...). // A better solution would be to refactor this so top.i is incremented eagerly // to get the current block instead of the way it is done now (++i vs i++) this._nexting = true const end = this._reverse ? this._gKey : this._lKey const incl = this._reverse ? this._gIncl : this._lIncl while (this.stack.length && (this._limit === -1 || this._limit > 0)) { const top = this.stack[this.stack.length - 1] const isKey = (top.i & 1) === 1 const n = this._reverse ? (top.i < 0 ? top.node.keys.length : top.i-- >> 1) : top.i++ >> 1 if (!isKey) { if (!top.node.children.length) continue const node = await top.node.getChildNode(n) if (top.node.block.seq < this.batch.core.length) { top.node.children[n].value = null // unlink it to save memory } this.stack.push({ i: this._reverse ? node.keys.length << 1 : 0, node }) continue } if (n >= top.node.keys.length) { this.stack.pop() continue } const key = top.node.keys[n] const block = await this.batch.getBlock(key.seq) if (end) { const c = b4a.compare(block.key, end) if (c === 0 ? !incl : this._reverse ? c < 0 : c > 0) { this._limit = 0 break } } if (this._limit > 0) this._limit-- this._nexting = false return block.final(this.encoding) } this._nexting = false return null } close() { this._closed = true return this.batch._closeSnapshot() } } function noop() {} const { Extension } = require('./messages') // const MAX_ACTIVE = 32 const FLUSH_BATCH = 128 const MAX_PASSIVE_BATCH = 2048 const MAX_ACTIVE_BATCH = MAX_PASSIVE_BATCH + FLUSH_BATCH class Batch { constructor(outgoing, from) { this.blocks = [] this.start = 0 this.end = 0 this.outgoing = outgoing this.from = from } push(seq) { const len = this.blocks.push(seq) if (len === 1 || seq < this.start) this.start = seq if (len === 1 || seq >= this.end) this.end = seq + 1 if (len >= FLUSH_BATCH) { this.send() this.clear() } } send() { if (!this.blocks.length) return this.outgoing.send( Extension.encode({ cache: { blocks: this.blocks, start: this.start, end: this.end } }), this.from ) } clear() { this.start = this.end = 0 this.blocks = [] } } class HyperbeeExtension { constructor(db) { this.encoding = null this.outgoing = null this.db = db this.active = 0 } get(version, key) { this.outgoing.broadcast(Extension.encode({ get: { version, key } })) } iterator(snapshot) { if (snapshot.ended) return if (snapshot.limit === 0) return if (snapshot.limit === -1) snapshot.limit = 0 this.outgoing.broadcast(Extension.encode({ iterator: snapshot })) } onmessage(buf, from) { // TODO: handle max active extension messages // this.active++ const message = decode(buf) if (!message) return if (message.cache) this.oncache(message.cache, from) if (message.get) this.onget(message.get, from) if (message.iterator) this.oniterator(message.iterator, from) } oncache(message, from) { if (!message.blocks.length) return this.db.core.download(message) } onget(message, from) { if (!message.version || message.version > this.db.version) return const b = new Batch(this.outgoing, from) const db = this.db.checkout(message.version) db.get(message.key, { extension: false, wait: false, update: false, onseq }).then(done, done) function done() { db.close().catch(noop) b.send() } function onseq(seq) { b.push(seq) } } async oniterator(message, from) { if (!message.version || message.version > this.db.version) return const b = new Batch(this.outgoing, from) const seqs = new Set() let skip = message.checkpoint.length let work = 0 const db = this.db.checkout(message.version) const ite = db.createRangeIterator({ ...message, wait: false, extension: false, update: false, limit: message.limit === 0 ? -1 : message.limit, onseq(seq) { if (skip && skip--) return if (seqs.has(seq)) return work++ seqs.add(seq) b.push(seq) } }) try { await ite.open() // eslint-disable-next-line no-unmodified-loop-condition while (work < MAX_ACTIVE_BATCH) { if (!(await ite.next())) break } } catch (_) { // do nothing } finally { ite.close().catch(noop) db.close().catch(noop) b.send() } } static register(db) { const e = new this(db) e.outgoing = db.core.registerExtension('hyperbee', e) return e } } HyperbeeExtension.BATCH_SIZE = MAX_PASSIVE_BATCH module.exports = HyperbeeExtension function decode(buf) { try { return Extension.decode(buf) } catch (err) { return null } } function noop() {} // This file is auto generated by the protocol-buffers compiler /* eslint-disable quotes */ /* eslint-disable indent */ /* eslint-disable no-redeclare */ /* eslint-disable camelcase */ /* eslint-disable no-var */ // Remember to `npm install --save protocol-buffers-encodings` var encodings = require('protocol-buffers-encodings') var b4a = require('b4a') var varint = encodings.varint var skip = encodings.skip var YoloIndex = exports.YoloIndex = { buffer: true, encodingLength: null, encode: null, decode: null } var Header = exports.Header = { buffer: true, encodingLength: null, encode: null, decode: null } var Node = exports.Node = { buffer: true, encodingLength: null, encode: null, decode: null } var Extension = exports.Extension = { buffer: true, encodingLength: null, encode: null, decode: null } defineYoloIndex() defineHeader() defineNode() defineExtension() function defineYoloIndex () { var Level = YoloIndex.Level = { buffer: true, encodingLength: null, encode: null, decode: null } defineLevel() function defineLevel () { Level.encodingLength = encodingLength Level.encode = encode Level.decode = decode function encodingLength (obj) { var length = 0 if (defined(obj.keys)) { var packedLen = 0 for (var i = 0; i < obj.keys.length; i++) { if (!defined(obj.keys[i])) continue var len = encodings.varint.encodingLength(obj.keys[i]) packedLen += len } if (packedLen) { length += 1 + packedLen + varint.encodingLength(packedLen) } } if (defined(obj.children)) { var packedLen = 0 for (var i = 0; i < obj.children.length; i++) { if (!defined(obj.children[i])) continue var len = encodings.varint.encodingLength(obj.children[i]) packedLen += len } if (packedLen) { length += 1 + packedLen + varint.encodingLength(packedLen) } } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (defined(obj.keys)) { var packedLen = 0 for (var i = 0; i < obj.keys.length; i++) { if (!defined(obj.keys[i])) continue packedLen += encodings.varint.encodingLength(obj.keys[i]) } if (packedLen) { buf[offset++] = 10 varint.encode(packedLen, buf, offset) offset += varint.encode.bytes } for (var i = 0; i < obj.keys.length; i++) { if (!defined(obj.keys[i])) continue encodings.varint.encode(obj.keys[i], buf, offset) offset += encodings.varint.encode.bytes } } if (defined(obj.children)) { var packedLen = 0 for (var i = 0; i < obj.children.length; i++) { if (!defined(obj.children[i])) continue packedLen += encodings.varint.encodingLength(obj.children[i]) } if (packedLen) { buf[offset++] = 18 varint.encode(packedLen, buf, offset) offset += varint.encode.bytes } for (var i = 0; i < obj.children.length; i++) { if (!defined(obj.children[i])) continue encodings.varint.encode(obj.children[i], buf, offset) offset += encodings.varint.encode.bytes } } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { keys: [], children: [] } while (true) { if (end <= offset) { decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: var packedEnd = varint.decode(buf, offset) offset += varint.decode.bytes packedEnd += offset while (offset < packedEnd) { obj.keys.push(encodings.varint.decode(buf, offset)) offset += encodings.varint.decode.bytes } break case 2: var packedEnd = varint.decode(buf, offset) offset += varint.decode.bytes packedEnd += offset while (offset < packedEnd) { obj.children.push(encodings.varint.decode(buf, offset)) offset += encodings.varint.decode.bytes } break default: offset = skip(prefix & 7, buf, offset) } } } } YoloIndex.encodingLength = encodingLength YoloIndex.encode = encode YoloIndex.decode = decode function encodingLength (obj) { var length = 0 if (defined(obj.levels)) { for (var i = 0; i < obj.levels.length; i++) { if (!defined(obj.levels[i])) continue var len = Level.encodingLength(obj.levels[i]) length += varint.encodingLength(len) length += 1 + len } } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (defined(obj.levels)) { for (var i = 0; i < obj.levels.length; i++) { if (!defined(obj.levels[i])) continue buf[offset++] = 10 varint.encode(Level.encodingLength(obj.levels[i]), buf, offset) offset += varint.encode.bytes Level.encode(obj.levels[i], buf, offset) offset += Level.encode.bytes } } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { levels: [] } while (true) { if (end <= offset) { decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: var len = varint.decode(buf, offset) offset += varint.decode.bytes obj.levels.push(Level.decode(buf, offset, offset + len)) offset += Level.decode.bytes break default: offset = skip(prefix & 7, buf, offset) } } } } function defineHeader () { var Metadata = Header.Metadata = { buffer: true, encodingLength: null, encode: null, decode: null } defineMetadata() function defineMetadata () { Metadata.encodingLength = encodingLength Metadata.encode = encode Metadata.decode = decode function encodingLength (obj) { var length = 0 if (defined(obj.contentFeed)) { var len = encodings.bytes.encodingLength(obj.contentFeed) length += 1 + len } if (defined(obj.userData)) { var len = encodings.bytes.encodingLength(obj.userData) length += 1 + len } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (defined(obj.contentFeed)) { buf[offset++] = 10 encodings.bytes.encode(obj.contentFeed, buf, offset) offset += encodings.bytes.encode.bytes } if (defined(obj.userData)) { buf[offset++] = 18 encodings.bytes.encode(obj.userData, buf, offset) offset += encodings.bytes.encode.bytes } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { contentFeed: null, userData: null } while (true) { if (end <= offset) { decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: obj.contentFeed = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes break case 2: obj.userData = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes break default: offset = skip(prefix & 7, buf, offset) } } } } Header.encodingLength = encodingLength Header.encode = encode Header.decode = decode function encodingLength (obj) { var length = 0 if (!defined(obj.protocol)) throw new Error("protocol is required") var len = encodings.string.encodingLength(obj.protocol) length += 1 + len if (defined(obj.metadata)) { var len = Metadata.encodingLength(obj.metadata) length += varint.encodingLength(len) length += 1 + len } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (!defined(obj.protocol)) throw new Error("protocol is required") buf[offset++] = 10 encodings.string.encode(obj.protocol, buf, offset) offset += encodings.string.encode.bytes if (defined(obj.metadata)) { buf[offset++] = 18 varint.encode(Metadata.encodingLength(obj.metadata), buf, offset) offset += varint.encode.bytes Metadata.encode(obj.metadata, buf, offset) offset += Metadata.encode.bytes } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { protocol: "", metadata: null } var found0 = false while (true) { if (end <= offset) { if (!found0) throw new Error("Decoded message is not valid") decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: obj.protocol = encodings.string.decode(buf, offset) offset += encodings.string.decode.bytes found0 = true break case 2: var len = varint.decode(buf, offset) offset += varint.decode.bytes obj.metadata = Metadata.decode(buf, offset, offset + len) offset += Metadata.decode.bytes break default: offset = skip(prefix & 7, buf, offset) } } } } function defineNode () { Node.encodingLength = encodingLength Node.encode = encode Node.decode = decode function encodingLength (obj) { var length = 0 if (!defined(obj.index)) throw new Error("index is required") var len = encodings.bytes.encodingLength(obj.index) length += 1 + len if (!defined(obj.key)) throw new Error("key is required") var len = encodings.bytes.encodingLength(obj.key) length += 1 + len if (defined(obj.value)) { var len = encodings.bytes.encodingLength(obj.value) length += 1 + len } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (!defined(obj.index)) throw new Error("index is required") buf[offset++] = 10 encodings.bytes.encode(obj.index, buf, offset) offset += encodings.bytes.encode.bytes if (!defined(obj.key)) throw new Error("key is required") buf[offset++] = 18 encodings.bytes.encode(obj.key, buf, offset) offset += encodings.bytes.encode.bytes if (defined(obj.value)) { buf[offset++] = 26 encodings.bytes.encode(obj.value, buf, offset) offset += encodings.bytes.encode.bytes } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { index: null, key: null, value: null } var found0 = false var found1 = false while (true) { if (end <= offset) { if (!found0 || !found1) throw new Error("Decoded message is not valid") decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: obj.index = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes found0 = true break case 2: obj.key = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes found1 = true break case 3: obj.value = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes break default: offset = skip(prefix & 7, buf, offset) } } } } function defineExtension () { var Get = Extension.Get = { buffer: true, encodingLength: null, encode: null, decode: null } var Iterator = Extension.Iterator = { buffer: true, encodingLength: null, encode: null, decode: null } var Cache = Extension.Cache = { buffer: true, encodingLength: null, encode: null, decode: null } defineGet() defineIterator() defineCache() function defineGet () { Get.encodingLength = encodingLength Get.encode = encode Get.decode = decode function encodingLength (obj) { var length = 0 if (defined(obj.version)) { var len = encodings.varint.encodingLength(obj.version) length += 1 + len } if (defined(obj.key)) { var len = encodings.bytes.encodingLength(obj.key) length += 1 + len } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (defined(obj.version)) { buf[offset++] = 8 encodings.varint.encode(obj.version, buf, offset) offset += encodings.varint.encode.bytes } if (defined(obj.key)) { buf[offset++] = 18 encodings.bytes.encode(obj.key, buf, offset) offset += encodings.bytes.encode.bytes } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { version: 0, key: null } while (true) { if (end <= offset) { decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: obj.version = encodings.varint.decode(buf, offset) offset += encodings.varint.decode.bytes break case 2: obj.key = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes break default: offset = skip(prefix & 7, buf, offset) } } } } function defineIterator () { Iterator.encodingLength = encodingLength Iterator.encode = encode Iterator.decode = decode function encodingLength (obj) { var length = 0 if (defined(obj.version)) { var len = encodings.varint.encodingLength(obj.version) length += 1 + len } if (defined(obj.gte)) { var len = encodings.bytes.encodingLength(obj.gte) length += 1 + len } if (defined(obj.gt)) { var len = encodings.bytes.encodingLength(obj.gt) length += 1 + len } if (defined(obj.lte)) { var len = encodings.bytes.encodingLength(obj.lte) length += 1 + len } if (defined(obj.lt)) { var len = encodings.bytes.encodingLength(obj.lt) length += 1 + len } if (defined(obj.limit)) { var len = encodings.varint.encodingLength(obj.limit) length += 1 + len } if (defined(obj.reverse)) { var len = encodings.bool.encodingLength(obj.reverse) length += 1 + len } if (defined(obj.checkpoint)) { var packedLen = 0 for (var i = 0; i < obj.checkpoint.length; i++) { if (!defined(obj.checkpoint[i])) continue var len = encodings.varint.encodingLength(obj.checkpoint[i]) packedLen += len } if (packedLen) { length += 1 + packedLen + varint.encodingLength(packedLen) } } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (defined(obj.version)) { buf[offset++] = 8 encodings.varint.encode(obj.version, buf, offset) offset += encodings.varint.encode.bytes } if (defined(obj.gte)) { buf[offset++] = 18 encodings.bytes.encode(obj.gte, buf, offset) offset += encodings.bytes.encode.bytes } if (defined(obj.gt)) { buf[offset++] = 26 encodings.bytes.encode(obj.gt, buf, offset) offset += encodings.bytes.encode.bytes } if (defined(obj.lte)) { buf[offset++] = 34 encodings.bytes.encode(obj.lte, buf, offset) offset += encodings.bytes.encode.bytes } if (defined(obj.lt)) { buf[offset++] = 42 encodings.bytes.encode(obj.lt, buf, offset) offset += encodings.bytes.encode.bytes } if (defined(obj.limit)) { buf[offset++] = 48 encodings.varint.encode(obj.limit, buf, offset) offset += encodings.varint.encode.bytes } if (defined(obj.reverse)) { buf[offset++] = 56 encodings.bool.encode(obj.reverse, buf, offset) offset += encodings.bool.encode.bytes } if (defined(obj.checkpoint)) { var packedLen = 0 for (var i = 0; i < obj.checkpoint.length; i++) { if (!defined(obj.checkpoint[i])) continue packedLen += encodings.varint.encodingLength(obj.checkpoint[i]) } if (packedLen) { buf[offset++] = 66 varint.encode(packedLen, buf, offset) offset += varint.encode.bytes } for (var i = 0; i < obj.checkpoint.length; i++) { if (!defined(obj.checkpoint[i])) continue encodings.varint.encode(obj.checkpoint[i], buf, offset) offset += encodings.varint.encode.bytes } } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { version: 0, gte: null, gt: null, lte: null, lt: null, limit: 0, reverse: false, checkpoint: [] } while (true) { if (end <= offset) { decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: obj.version = encodings.varint.decode(buf, offset) offset += encodings.varint.decode.bytes break case 2: obj.gte = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes break case 3: obj.gt = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes break case 4: obj.lte = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes break case 5: obj.lt = encodings.bytes.decode(buf, offset) offset += encodings.bytes.decode.bytes break case 6: obj.limit = encodings.varint.decode(buf, offset) offset += encodings.varint.decode.bytes break case 7: obj.reverse = encodings.bool.decode(buf, offset) offset += encodings.bool.decode.bytes break case 8: var packedEnd = varint.decode(buf, offset) offset += varint.decode.bytes packedEnd += offset while (offset < packedEnd) { obj.checkpoint.push(encodings.varint.decode(buf, offset)) offset += encodings.varint.decode.bytes } break default: offset = skip(prefix & 7, buf, offset) } } } } function defineCache () { Cache.encodingLength = encodingLength Cache.encode = encode Cache.decode = decode function encodingLength (obj) { var length = 0 if (!defined(obj.start)) throw new Error("start is required") var len = encodings.varint.encodingLength(obj.start) length += 1 + len if (!defined(obj.end)) throw new Error("end is required") var len = encodings.varint.encodingLength(obj.end) length += 1 + len if (defined(obj.blocks)) { var packedLen = 0 for (var i = 0; i < obj.blocks.length; i++) { if (!defined(obj.blocks[i])) continue var len = encodings.varint.encodingLength(obj.blocks[i]) packedLen += len } if (packedLen) { length += 1 + packedLen + varint.encodingLength(packedLen) } } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (!defined(obj.start)) throw new Error("start is required") buf[offset++] = 8 encodings.varint.encode(obj.start, buf, offset) offset += encodings.varint.encode.bytes if (!defined(obj.end)) throw new Error("end is required") buf[offset++] = 16 encodings.varint.encode(obj.end, buf, offset) offset += encodings.varint.encode.bytes if (defined(obj.blocks)) { var packedLen = 0 for (var i = 0; i < obj.blocks.length; i++) { if (!defined(obj.blocks[i])) continue packedLen += encodings.varint.encodingLength(obj.blocks[i]) } if (packedLen) { buf[offset++] = 26 varint.encode(packedLen, buf, offset) offset += varint.encode.bytes } for (var i = 0; i < obj.blocks.length; i++) { if (!defined(obj.blocks[i])) continue encodings.varint.encode(obj.blocks[i], buf, offset) offset += encodings.varint.encode.bytes } } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { start: 0, end: 0, blocks: [] } var found0 = false var found1 = false while (true) { if (end <= offset) { if (!found0 || !found1) throw new Error("Decoded message is not valid") decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: obj.start = encodings.varint.decode(buf, offset) offset += encodings.varint.decode.bytes found0 = true break case 2: obj.end = encodings.varint.decode(buf, offset) offset += encodings.varint.decode.bytes found1 = true break case 3: var packedEnd = varint.decode(buf, offset) offset += varint.decode.bytes packedEnd += offset while (offset < packedEnd) { obj.blocks.push(encodings.varint.decode(buf, offset)) offset += encodings.varint.decode.bytes } break default: offset = skip(prefix & 7, buf, offset) } } } } Extension.encodingLength = encodingLength Extension.encode = encode Extension.decode = decode function encodingLength (obj) { var length = 0 if (defined(obj.cache)) { var len = Cache.encodingLength(obj.cache) length += varint.encodingLength(len) length += 1 + len } if (defined(obj.get)) { var len = Get.encodingLength(obj.get) length += varint.encodingLength(len) length += 1 + len } if (defined(obj.iterator)) { var len = Iterator.encodingLength(obj.iterator) length += varint.encodingLength(len) length += 1 + len } return length } function encode (obj, buf, offset) { if (!offset) offset = 0 if (!buf) buf = b4a.allocUnsafe(encodingLength(obj)) var oldOffset = offset if (defined(obj.cache)) { buf[offset++] = 10 varint.encode(Cache.encodingLength(obj.cache), buf, offset) offset += varint.encode.bytes Cache.encode(obj.cache, buf, offset) offset += Cache.encode.bytes } if (defined(obj.get)) { buf[offset++] = 18 varint.encode(Get.encodingLength(obj.get), buf, offset) offset += varint.encode.bytes Get.encode(obj.get, buf, offset) offset += Get.encode.bytes } if (defined(obj.iterator)) { buf[offset++] = 26 varint.encode(Iterator.encodingLength(obj.iterator), buf, offset) offset += varint.encode.bytes Iterator.encode(obj.iterator, buf, offset) offset += Iterator.encode.bytes } encode.bytes = offset - oldOffset return buf } function decode (buf, offset, end) { if (!offset) offset = 0 if (!end) end = buf.length if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid") var oldOffset = offset var obj = { cache: null, get: null, iterator: null } while (true) { if (end <= offset) { decode.bytes = offset - oldOffset return obj } var prefix = varint.decode(buf, offset) offset += varint.decode.bytes var tag = prefix >> 3 switch (tag) { case 1: var len = varint.decode(buf, offset) offset += varint.decode.bytes obj.cache = Cache.decode(buf, offset, offset + len) offset += Cache.decode.bytes break case 2: var len = varint.decode(buf, offset) offset += varint.decode.bytes obj.get = Get.decode(buf, offset, offset + len) offset += Get.decode.bytes break case 3: var len = varint.decode(buf, offset) offset += varint.decode.bytes obj.iterator = Iterator.decode(buf, offset, offset + len) offset += Iterator.decode.bytes break default: offset = skip(prefix & 7, buf, offset) } } } } function defined (val) { return val !== null && val !== undefined && (typeof val !== 'number' || !isNaN(val)) } { "name": "hyperbee", "version": "2.27.3", "description": "An append-only B-tree running on a Hypercore.", "main": "index.js", "files": [ "index.js", "lib/**.js", "iterators/**.js" ], "dependencies": { "b4a": "^1.6.0", "codecs": "^3.0.0", "debounceify": "^1.0.0", "hypercore-errors": "^1.0.0", "mutexify": "^1.4.0", "protocol-buffers-encodings": "^1.2.0", "rache": "^1.0.0", "ready-resource": "^1.0.0", "resolve-reject-promise": "^1.1.0", "safety-catch": "^1.0.2", "streamx": "^2.12.4", "unslab": "^1.2.0" }, "devDependencies": { "bare-process": "^4.2.2", "brittle": "^3.1.0", "hypercore": "^11.0.0", "lunte": "^1.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0", "protocol-buffers": "^4.2.0", "sub-encoder": "^1.0.6", "tree-to-string": "^1.1.1" }, "imports": { "process": { "bare": "bare-process", "default": "process" } }, "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test/*.js", "test:bare": "brittle-bare test/*.js", "protobuf": "protocol-buffers schema.proto -o ./lib/messages.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/hyperbee.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/hyperbee/issues" }, "homepage": "https://github.com/holepunchto/hyperbee" } const sodium = require('sodium-universal') const c = require('compact-encoding') const b4a = require('b4a') // https://en.wikipedia.org/wiki/Merkle_tree#Second_preimage_attack const LEAF_TYPE = b4a.from([0]) const PARENT_TYPE = b4a.from([1]) const ROOT_TYPE = b4a.from([2]) const HYPERCORE = b4a.from('hypercore') exports.keyPair = function (seed) { // key pairs might stay around for a while, so better not to use a default slab to avoid retaining it completely const slab = b4a.allocUnsafeSlow( sodium.crypto_sign_PUBLICKEYBYTES + sodium.crypto_sign_SECRETKEYBYTES ) const publicKey = slab.subarray(0, sodium.crypto_sign_PUBLICKEYBYTES) const secretKey = slab.subarray(sodium.crypto_sign_PUBLICKEYBYTES) if (seed) sodium.crypto_sign_seed_keypair(publicKey, secretKey, seed) else sodium.crypto_sign_keypair(publicKey, secretKey) return { publicKey, secretKey } } exports.validateKeyPair = function (keyPair) { const pk = b4a.allocUnsafe(sodium.crypto_sign_PUBLICKEYBYTES) sodium.crypto_sign_ed25519_sk_to_pk(pk, keyPair.secretKey) return b4a.equals(pk, keyPair.publicKey) } exports.sign = function (message, secretKey) { // Dedicated slab for the signature, to avoid retaining unneeded mem and for security const signature = b4a.allocUnsafeSlow(sodium.crypto_sign_BYTES) sodium.crypto_sign_detached(signature, message, secretKey) return signature } exports.verify = function (message, signature, publicKey) { if (signature.byteLength !== sodium.crypto_sign_BYTES) return false if (publicKey.byteLength !== sodium.crypto_sign_PUBLICKEYBYTES) return false return sodium.crypto_sign_verify_detached(signature, message, publicKey) } exports.encrypt = function (message, publicKey) { const ciphertext = b4a.alloc(message.byteLength + sodium.crypto_box_SEALBYTES) sodium.crypto_box_seal(ciphertext, message, publicKey) return ciphertext } exports.decrypt = function (ciphertext, keyPair) { if (ciphertext.byteLength < sodium.crypto_box_SEALBYTES) return null const plaintext = b4a.alloc(ciphertext.byteLength - sodium.crypto_box_SEALBYTES) if (!sodium.crypto_box_seal_open(plaintext, ciphertext, keyPair.publicKey, keyPair.secretKey)) { return null } return plaintext } exports.encryptionKeyPair = function (seed) { const publicKey = b4a.alloc(sodium.crypto_box_PUBLICKEYBYTES) const secretKey = b4a.alloc(sodium.crypto_box_SECRETKEYBYTES) if (seed) { sodium.crypto_box_seed_keypair(publicKey, secretKey, seed) } else { sodium.crypto_box_keypair(publicKey, secretKey) } return { publicKey, secretKey } } exports.data = function (data) { const out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, [LEAF_TYPE, c.encode(c.uint64, data.byteLength), data]) return out } exports.parent = function (a, b) { if (a.index > b.index) { const tmp = a a = b b = tmp } const out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, [ PARENT_TYPE, c.encode(c.uint64, a.size + b.size), a.hash, b.hash ]) return out } exports.tree = function (roots, out) { const buffers = new Array(3 * roots.length + 1) let j = 0 buffers[j++] = ROOT_TYPE for (let i = 0; i < roots.length; i++) { const r = roots[i] buffers[j++] = r.hash buffers[j++] = c.encode(c.uint64, r.index) buffers[j++] = c.encode(c.uint64, r.size) } if (!out) out = b4a.allocUnsafe(32) sodium.crypto_generichash_batch(out, buffers) return out } exports.hash = function (data, out) { if (!out) out = b4a.allocUnsafe(32) if (!Array.isArray(data)) data = [data] sodium.crypto_generichash_batch(out, data) return out } exports.randomBytes = function (n) { const buf = b4a.allocUnsafe(n) sodium.randombytes_buf(buf) return buf } exports.discoveryKey = function (key) { if (!key || key.byteLength !== 32) throw new Error('Must pass a 32 byte buffer') // Discovery keys might stay around for a while, so better not to use slab memory (for better gc) const digest = b4a.allocUnsafeSlow(32) sodium.crypto_generichash(digest, HYPERCORE, key) return digest } if (sodium.sodium_free) { exports.free = function (secureBuf) { if (secureBuf.secure) sodium.sodium_free(secureBuf) } } else { exports.free = function () {} } exports.namespace = function (name, count) { const ids = typeof count === 'number' ? range(count) : count // Namespaces are long-lived, so better to use a dedicated slab const buf = b4a.allocUnsafeSlow(32 * ids.length) const list = new Array(ids.length) // ns is ephemeral, so default slab const ns = b4a.allocUnsafe(33) sodium.crypto_generichash(ns.subarray(0, 32), typeof name === 'string' ? b4a.from(name) : name) for (let i = 0; i < list.length; i++) { list[i] = buf.subarray(32 * i, 32 * i + 32) ns[32] = ids[i] sodium.crypto_generichash(list[i], ns) } return list } function range(count) { const arr = new Array(count) for (let i = 0; i < count; i++) arr[i] = i return arr } { "name": "hypercore-crypto", "version": "3.7.0", "description": "The crypto primitives used in hypercore, extracted into a separate module", "main": "index.js", "files": [ "index.js" ], "dependencies": { "b4a": "^1.6.6", "compact-encoding": "^3.0.0", "sodium-universal": "^5.0.0" }, "devDependencies": { "brittle": "^3.5.0", "lunte": "^1.0.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/hypercore-crypto.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/hypercore-crypto/issues" }, "homepage": "https://github.com/mafintosh/hypercore-crypto" } const IdEnc = require('hypercore-id-encoding') module.exports = class HypercoreError extends Error { constructor (msg, code, fn = HypercoreError, discoveryKey = null) { if (discoveryKey) msg = `${msg} (discovery key: ${IdEnc.normalize(discoveryKey)})` super(`${code}: ${msg}`) this.code = code this.discoveryKey = discoveryKey if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } get name () { return 'HypercoreError' } static ASSERTION (msg, discoveryKey = null) { // ERR_ASSERTION is picked up by safety-catch also return new HypercoreError(msg, 'ERR_ASSERTION', HypercoreError.ASSERT, discoveryKey) } static BAD_ARGUMENT (msg, discoveryKey = null) { return new HypercoreError(msg, 'BAD_ARGUMENT', HypercoreError.BAD_ARGUMENT, discoveryKey) } static STORAGE_EMPTY (msg, discoveryKey = null) { return new HypercoreError(msg, 'STORAGE_EMPTY', HypercoreError.STORAGE_EMPTY, discoveryKey) } static STORAGE_CONFLICT (msg, discoveryKey = null) { return new HypercoreError(msg, 'STORAGE_CONFLICT', HypercoreError.STORAGE_CONFLICT, discoveryKey) } static INVALID_SIGNATURE (msg, discoveryKey = null) { return new HypercoreError(msg, 'INVALID_SIGNATURE', HypercoreError.INVALID_SIGNATURE, discoveryKey) } static INVALID_CAPABILITY (msg, discoveryKey = null) { return new HypercoreError(msg, 'INVALID_CAPABILITY', HypercoreError.INVALID_CAPABILITY, discoveryKey) } static INVALID_CHECKSUM (msg = 'Invalid checksum', discoveryKey = null) { return new HypercoreError(msg, 'INVALID_CHECKSUM', HypercoreError.INVALID_CHECKSUM, discoveryKey) } static INVALID_OPERATION (msg, discoveryKey = null) { return new HypercoreError(msg, 'INVALID_OPERATION', HypercoreError.INVALID_OPERATION, discoveryKey) } static INVALID_PROOF (msg = 'Proof not verifiable', discoveryKey = null) { return new HypercoreError(msg, 'INVALID_PROOF', HypercoreError.INVALID_PROOF, discoveryKey) } static BLOCK_NOT_AVAILABLE (msg = 'Block is not available', discoveryKey = null) { return new HypercoreError(msg, 'BLOCK_NOT_AVAILABLE', HypercoreError.BLOCK_NOT_AVAILABLE, discoveryKey) } static SNAPSHOT_NOT_AVAILABLE (msg = 'Snapshot is not available', discoveryKey = null) { return new HypercoreError(msg, 'SNAPSHOT_NOT_AVAILABLE', HypercoreError.SNAPSHOT_NOT_AVAILABLE, discoveryKey) } static REQUEST_CANCELLED (msg = 'Request was cancelled', discoveryKey = null) { return new HypercoreError(msg, 'REQUEST_CANCELLED', HypercoreError.REQUEST_CANCELLED, discoveryKey) } static REQUEST_TIMEOUT (msg = 'Request timed out', discoveryKey = null) { return new HypercoreError(msg, 'REQUEST_TIMEOUT', HypercoreError.REQUEST_TIMEOUT, discoveryKey) } static SESSION_NOT_WRITABLE (msg = 'Session is not writable', discoveryKey = null) { return new HypercoreError(msg, 'SESSION_NOT_WRITABLE', HypercoreError.SESSION_NOT_WRITABLE, discoveryKey) } static SESSION_CLOSED (msg = 'Session is closed', discoveryKey = null) { return new HypercoreError(msg, 'SESSION_CLOSED', HypercoreError.SESSION_CLOSED, discoveryKey) } static BATCH_UNFLUSHED (msg = 'Batch not yet flushed', discoveryKey = null) { return new HypercoreError(msg, 'BATCH_UNFLUSHED', HypercoreError.BATCH_UNFLUSHED, discoveryKey) } static BATCH_ALREADY_EXISTS (msg = 'Batch already exists', discoveryKey = null) { return new HypercoreError(msg, 'BATCH_ALREADY_EXISTS', HypercoreError.BATCH_ALREADY_EXISTS, discoveryKey) } static BATCH_ALREADY_FLUSHED (msg = 'Batch has already been flushed', discoveryKey = null) { return new HypercoreError(msg, 'BATCH_ALREADY_FLUSHED', HypercoreError.BATCH_ALREADY_FLUSHED, discoveryKey) } static OPLOG_CORRUPT (msg = 'Oplog file appears corrupt or out of date', discoveryKey = null) { return new HypercoreError(msg, 'OPLOG_CORRUPT', HypercoreError.OPLOG_CORRUPT, discoveryKey) } static OPLOG_HEADER_OVERFLOW (msg = 'Oplog header exceeds page size', discoveryKey = null) { return new HypercoreError(msg, 'OPLOG_HEADER_OVERFLOW', HypercoreError.OPLOG_HEADER_OVERFLOW, discoveryKey) } static INVALID_OPLOG_VERSION (msg = 'Invalid header version', discoveryKey = null) { return new HypercoreError(msg, 'INVALID_OPLOG_VERSION', HypercoreError.INVALID_OPLOG_VERSION, discoveryKey) } static WRITE_FAILED (msg = 'Write to storage failed', discoveryKey = null) { return new HypercoreError(msg, 'WRITE_FAILED', HypercoreError.WRITE_FAILED, discoveryKey) } static DECODING_ERROR (msg = 'Decoding error', discoveryKey = null) { return new HypercoreError(msg, 'DECODING_ERROR', HypercoreError.DECODING_ERROR, discoveryKey) } static SESSION_MOVED (msg = 'Session moved', discoveryKey = null) { return new HypercoreError(msg, 'SESSION_MOVED', HypercoreError.SESSION_MOVED, discoveryKey) } } { "name": "hypercore-errors", "version": "1.5.0", "description": "Hypercore errors", "main": "index.js", "files": [ "index.js" ], "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/hypercore-errors.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/hypercore-errors/issues" }, "homepage": "https://github.com/holepunchto/hypercore-errors#readme", "devDependencies": { "b4a": "^1.6.7", "brittle": "^3.1.3", "standard": "^17.0.0" }, "dependencies": { "hypercore-id-encoding": "^1.3.0" } } const z32 = require('z32') const b4a = require('b4a') module.exports = { encode, decode, normalize, isValid } function encode (key) { if (!b4a.isBuffer(key)) throw new Error('Key must be a Buffer') if (key.byteLength !== 32) throw new Error('Key must be 32-bytes long') return z32.encode(key) } function decode (id) { if (b4a.isBuffer(id)) { if (id.byteLength !== 32) throw new Error('ID must be 32-bytes long') return id } if (typeof id === 'string') { if (id.startsWith('pear://')) id = id.slice(7).split('/')[0] if (id.length === 52) return z32.decode(id) if (id.length === 64) { const buf = b4a.from(id, 'hex') if (buf.byteLength === 32) return buf } } throw new Error('Invalid Hypercore key') } function normalize (any) { return encode(decode(any)) } function isValid (any) { try { decode(any) return true } catch { return false } } { "name": "hypercore-id-encoding", "version": "1.3.0", "description": "Convert Hypercore keys to/from z-base32 or hex", "main": "index.js", "scripts": { "test": "standard && brittle test.js" }, "files": [ "index.js" ], "dependencies": { "b4a": "^1.5.3", "z32": "^1.0.0" }, "devDependencies": { "brittle": "^3.1.1", "hypercore": "^10.0.0", "random-access-memory": "^6.0.0", "standard": "^17.1.0" }, "license": "Apache-2.0", "repository": { "type": "git", "url": "git+https://github.com/holepunchto/hypercore-id-encoding.git" }, "keywords": [], "author": "", "bugs": { "url": "https://github.com/holepunchto/hypercore-id-encoding/issues" }, "homepage": "https://github.com/holepunchto/hypercore-id-encoding#readme" } var queueTick = require('queue-tick') var mutexify = function () { var queue = [] var used = null var call = function () { used(release) } var acquire = function (fn) { if (used) return queue.push(fn) used = fn acquire.locked = true queueTick(call) return 0 } acquire.locked = false var release = function (fn, err, value) { used = null acquire.locked = false if (queue.length) acquire(queue.shift()) if (fn) fn(err, value) } return acquire } module.exports = mutexify { "name": "mutexify", "version": "1.4.0", "description": "mutex lock for javascript", "main": "index.js", "dependencies": { "queue-tick": "^1.0.0" }, "devDependencies": { "standard": "^14.3.3", "tape": "^3.0.2" }, "scripts": { "test": "tape test.js", "posttest": "npm run lint", "lint": "standard" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/mutexify.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/mutexify/issues" }, "keywords": [ "mutex", "lock" ], "homepage": "https://github.com/mafintosh/mutexify" } var mutexify = require('.') var mutexifyPromise = function () { var lock = mutexify() var acquire = function () { return new Promise(lock) } Object.defineProperty(acquire, 'locked', { get: function () { return lock.locked }, enumerable: true }) return acquire } module.exports = mutexifyPromise var varint = require('varint') var svarint = require('signed-varint') var b4a = require('b4a') exports.make = encoder exports.name = function (enc) { var keys = Object.keys(exports) for (var i = 0; i < keys.length; i++) { if (exports[keys[i]] === enc) return keys[i] } return null } exports.skip = function (type, buffer, offset) { switch (type) { case 0: varint.decode(buffer, offset) return offset + varint.decode.bytes case 1: return offset + 8 case 2: var len = varint.decode(buffer, offset) return offset + varint.decode.bytes + len case 3: case 4: throw new Error('Groups are not supported') case 5: return offset + 4 } throw new Error('Unknown wire type: ' + type) } exports.bytes = encoder(2, function encode (val, buffer, offset) { var oldOffset = offset var len = bufferLength(val) varint.encode(len, buffer, offset) offset += varint.encode.bytes if (b4a.isBuffer(val)) b4a.copy(val, buffer, offset) else b4a.write(buffer, val, offset, len) offset += len encode.bytes = offset - oldOffset return buffer }, function decode (buffer, offset) { var oldOffset = offset var len = varint.decode(buffer, offset) offset += varint.decode.bytes var val = buffer.subarray(offset, offset + len) offset += val.length decode.bytes = offset - oldOffset return val }, function encodingLength (val) { var len = bufferLength(val) return varint.encodingLength(len) + len } ) exports.string = encoder(2, function encode (val, buffer, offset) { var oldOffset = offset var len = b4a.byteLength(val) varint.encode(len, buffer, offset, 'utf-8') offset += varint.encode.bytes b4a.write(buffer, val, offset, len) offset += len encode.bytes = offset - oldOffset return buffer }, function decode (buffer, offset) { var oldOffset = offset var len = varint.decode(buffer, offset) offset += varint.decode.bytes var val = b4a.toString(buffer, 'utf-8', offset, offset + len) offset += len decode.bytes = offset - oldOffset return val }, function encodingLength (val) { var len = b4a.byteLength(val) return varint.encodingLength(len) + len } ) exports.bool = encoder(0, function encode (val, buffer, offset) { buffer[offset] = val ? 1 : 0 encode.bytes = 1 return buffer }, function decode (buffer, offset) { var bool = buffer[offset] > 0 decode.bytes = 1 return bool }, function encodingLength () { return 1 } ) exports.int32 = encoder(0, function encode (val, buffer, offset) { varint.encode(val < 0 ? val + 4294967296 : val, buffer, offset) encode.bytes = varint.encode.bytes return buffer }, function decode (buffer, offset) { var val = varint.decode(buffer, offset) decode.bytes = varint.decode.bytes return val > 2147483647 ? val - 4294967296 : val }, function encodingLength (val) { return varint.encodingLength(val < 0 ? val + 4294967296 : val) } ) exports.int64 = encoder(0, function encode (val, buffer, offset) { if (val < 0) { var last = offset + 9 varint.encode(val * -1, buffer, offset) offset += varint.encode.bytes - 1 buffer[offset] = buffer[offset] | 0x80 while (offset < last - 1) { offset++ buffer[offset] = 0xff } buffer[last] = 0x01 encode.bytes = 10 } else { varint.encode(val, buffer, offset) encode.bytes = varint.encode.bytes } return buffer }, function decode (buffer, offset) { var val = varint.decode(buffer, offset) if (val >= Math.pow(2, 63)) { var limit = 9 while (buffer[offset + limit - 1] === 0xff) limit-- limit = limit || 9 var subset = b4a.allocUnsafe(limit) b4a.copy(buffer, subset, 0, offset, offset + limit) subset[limit - 1] = subset[limit - 1] & 0x7f val = -1 * varint.decode(subset, 0) decode.bytes = 10 } else { decode.bytes = varint.decode.bytes } return val }, function encodingLength (val) { return val < 0 ? 10 : varint.encodingLength(val) } ) exports.sint32 = exports.sint64 = encoder(0, svarint.encode, svarint.decode, svarint.encodingLength ) exports.uint32 = exports.uint64 = exports.enum = exports.varint = encoder(0, varint.encode, varint.decode, varint.encodingLength ) // we cannot represent these in javascript so we just use buffers exports.fixed64 = exports.sfixed64 = encoder(1, function encode (val, buffer, offset) { b4a.copy(val, buffer, offset) encode.bytes = 8 return buffer }, function decode (buffer, offset) { var val = buffer.subarray(offset, offset + 8) decode.bytes = 8 return val }, function encodingLength () { return 8 } ) exports.double = encoder(1, function encode (val, buffer, offset) { b4a.writeDoubleLE(buffer, val, offset) encode.bytes = 8 return buffer }, function decode (buffer, offset) { var val = b4a.readDoubleLE(buffer, offset) decode.bytes = 8 return val }, function encodingLength () { return 8 } ) exports.fixed32 = encoder(5, function encode (val, buffer, offset) { b4a.writeUInt32LE(buffer, val, offset) encode.bytes = 4 return buffer }, function decode (buffer, offset) { var val = b4a.readUInt32LE(buffer, offset) decode.bytes = 4 return val }, function encodingLength () { return 4 } ) exports.sfixed32 = encoder(5, function encode (val, buffer, offset) { b4a.writeInt32LE(buffer, val, offset) encode.bytes = 4 return buffer }, function decode (buffer, offset) { var val = b4a.readInt32LE(buffer, offset) decode.bytes = 4 return val }, function encodingLength () { return 4 } ) exports.float = encoder(5, function encode (val, buffer, offset) { b4a.writeFloatLE(buffer, val, offset) encode.bytes = 4 return buffer }, function decode (buffer, offset) { var val = b4a.readFloatLE(buffer, offset) decode.bytes = 4 return val }, function encodingLength () { return 4 } ) function encoder (type, encode, decode, encodingLength) { encode.bytes = decode.bytes = 0 return { type: type, encode: encode, decode: decode, encodingLength: encodingLength } } function bufferLength (val) { return b4a.isBuffer(val) ? val.length : b4a.byteLength(val) } { "name": "protocol-buffers-encodings", "version": "1.2.0", "description": "Base encodings for protocol-buffers", "main": "index.js", "dependencies": { "b4a": "^1.6.0", "signed-varint": "^2.0.1", "varint": "5.0.0" }, "devDependencies": { "standard": "^14.3.4", "tape": "^5.0.1" }, "scripts": { "test": "standard && tape test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/protocol-buffers-encodings.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/protocol-buffers-encodings/issues" }, "homepage": "https://github.com/mafintosh/protocol-buffers-encodings" } { "name": "queue-tick", "version": "1.0.1", "description": "Next tick shim that prefers process.nextTick over queueMicrotask for compat", "main": "./process-next-tick.js", "browser": "./queue-microtask.js", "dependencies": {}, "devDependencies": { "standard": "^16.0.3", "tape": "^5.3.1" }, "scripts": { "test": "standard && tape test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/queue-tick.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/queue-tick/issues" }, "homepage": "https://github.com/mafintosh/queue-tick" } module.exports = (typeof process !== 'undefined' && typeof process.nextTick === 'function') ? process.nextTick.bind(process) : require('./queue-microtask') module.exports = typeof queueMicrotask === 'function' ? queueMicrotask : (fn) => Promise.resolve().then(fn) class CacheEntry { constructor (key, index, map) { this.key = key this.index = index this.map = map } } class CacheValue { constructor (entry, value) { this.entry = entry this.value = value } } class Rache { constructor ({ maxSize = 65536, parent = null } = {}) { this.maxSize = parent?.maxSize || maxSize this._array = parent?._array || [] this._map = new Map() } static from (cache) { return cache ? new this({ parent: cache }) : new this() } get globalSize () { return this._array.length } get size () { return this._map.size } sub () { return new Rache({ parent: this }) } set (key, value) { // ~constant time const existing = this._map.get(key) if (existing !== undefined) { existing.value = value return } if (this._array.length >= this.maxSize) this._gc() const entry = new CacheEntry(key, this._array.length, this._map) this._array.push(entry) const cacheValue = new CacheValue(entry, value) this._map.set(key, cacheValue) } delete (key) { const existing = this._map.get(key) if (existing === undefined) return false this._delete(existing.entry.index) return true } get (key) { const existing = this._map.get(key) return existing === undefined ? undefined : existing.value } * [Symbol.iterator] () { for (const [key, { value }] of this._map) { yield [key, value] } } keys () { return this._map.keys() } * values () { for (const { value } of this._map.values()) { yield value } } clear () { // The entries in map linger on in _array, // so on top of clearing the map, we also kill the ref, // so that any gc running later on the old map won't interfere // (in case a new entry was added with the same key as a cleared entry) this._map.clear() this._map = new Map() } destroy () { this._map = null this._array = null } _gc () { this._delete(Math.floor(Math.random() * this._array.length)) } _delete (index) { // ~constant time if (index >= this._array.length) throw new Error('Cannot delete unused index (logic bug?)') const head = this._array.pop() let removed = head if (index < this._array.length) { removed = this._array[index] head.index = index this._array[index] = head } removed.map.delete(removed.key) } } module.exports = Rache { "name": "rache", "version": "1.0.0", "description": "Random-eviction cache", "main": "index.js", "scripts": { "test": "standard && brittle test.js --coverage" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/rache.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/rache/issues" }, "homepage": "https://github.com/holepunchto/rache#readme", "files": [ "index.js" ], "dependencies": {}, "devDependencies": { "brittle": "^3.5.2", "standard": "^17.1.0" } } const EventEmitter = require('events') module.exports = class ReadyResource extends EventEmitter { constructor () { super() this.opening = null this.closing = null this.opened = false this.closed = false } ready () { if (this.opening !== null) return this.opening this.opening = open(this) return this.opening } close () { if (this.closing !== null) return this.closing this.closing = close(this) return this.closing } async _open () { // add impl here } async _close () { // add impl here } } async function open (self) { // open after close if (self.closing !== null) return try { await self._open() } catch (err) { self.close() // safe to run in bg throw err } self.opened = true self.emit('ready') } async function close (self) { try { if (self.opened === false && self.opening !== null) await self.opening } catch { // ignore errors on closing } if (self.opened === true || self.opening === null) await self._close() self.closed = true self.emit('close') } { "name": "ready-resource", "version": "1.2.0", "description": "Modern single resource management", "main": "index.js", "imports": { "events": { "bare": "bare-events", "default": "events" } }, "types": "index.d.ts", "files": [ "index.js", "index.d.ts" ], "scripts": { "test": "standard && brittle test.js" }, "devDependencies": { "brittle": "^3.1.0", "standard": "^17.0.0" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/ready-resource.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/ready-resource/issues" }, "homepage": "https://github.com/holepunchto/ready-resource", "dependencies": { "bare-events": "^2.2.0" } } module.exports = require.addon.bind(require) { "name": "require-addon", "version": "1.2.0", "description": "Import native addons across JavaScript runtimes", "exports": { "./package": "./package.json", ".": { "bare": "./lib/bare.js", "node": "./lib/node.js", "default": "./lib/default.js" } }, "imports": { "fs": { "bare": "bare-fs", "default": "fs" }, "path": { "bare": "bare-path", "default": "path" }, "url": { "bare": "bare-url", "default": "url" } }, "files": [ "lib" ], "scripts": { "test": "npm run lint && npm run test:bare && npm run test:node", "test:bare": "bare test.js", "test:node": "node test.js", "lint": "prettier --check .", "format": "prettier --write ." }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/require-addon.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/require-addon/issues" }, "homepage": "https://github.com/holepunchto/require-addon#readme", "engines": { "bare": ">=1.10.0" }, "dependencies": { "bare-addon-resolve": "^1.3.0" }, "devDependencies": { "bare-bundle": "^1.8.1", "bare-bundle-evaluate": "^1.1.0", "bare-fs": "^4.0.0", "bare-path": "^3.0.0", "bare-url": "^2.1.0", "brittle": "^3.7.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } let tmpResolve = null let tmpReject = null if (Promise.withResolvers) { module.exports = Promise.withResolvers.bind(Promise) } else { module.exports = function resolveRejectPromise () { const promise = new Promise(setTmp) const result = { promise, resolve: tmpResolve, reject: tmpReject } tmpResolve = tmpReject = null return result } } function setTmp (resolve, reject) { tmpResolve = resolve tmpReject = reject } { "name": "resolve-reject-promise", "version": "1.1.0", "description": "Create an inverted promise with no function allocs", "main": "index.js", "scripts": { "test": "standard" }, "devDependencies": { "standard": "^17.1.2" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/resolve-reject-promise.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/resolve-reject-promise/issues" }, "homepage": "https://github.com/mafintosh/resolve-reject-promise" } module.exports = safetyCatch function isActuallyUncaught (err) { if (!err) return false return err instanceof TypeError || err instanceof SyntaxError || err instanceof ReferenceError || err instanceof EvalError || err instanceof RangeError || err instanceof URIError || err.code === 'ERR_ASSERTION' || err.name === 'AssertionError' } function throwErrorNT (err) { queueMicrotask(() => { throw err }) } function safetyCatch (err) { if (isActuallyUncaught(err)) { throwErrorNT(err) throw err } } { "name": "safety-catch", "version": "1.0.3", "description": "Small module that makes sure your catch, caught an actual error and not a programming mistake or assertion", "main": "index.js", "dependencies": {}, "devDependencies": {}, "repository": { "type": "git", "url": "https://github.com/mafintosh/safety-catch.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/safety-catch/issues" }, "homepage": "https://github.com/mafintosh/safety-catch" } var varint = require('varint') exports.encode = function encode (v, b, o) { v = v >= 0 ? v*2 : v*-2 - 1 var r = varint.encode(v, b, o) encode.bytes = varint.encode.bytes return r } exports.decode = function decode (b, o) { var v = varint.decode(b, o) decode.bytes = varint.decode.bytes return v & 1 ? (v+1) / -2 : v / 2 } exports.encodingLength = function (v) { return varint.encodingLength(v >= 0 ? v*2 : v*-2 - 1) } { "name": "signed-varint", "description": "efficiently store signed integers in varint", "version": "2.0.1", "homepage": "https://github.com/dominictarr/signed-varint", "repository": { "type": "git", "url": "git://github.com/dominictarr/signed-varint.git" }, "dependencies": { "varint": "~5.0.0" }, "devDependencies": { "tape": "~2.12.3" }, "scripts": { "test": "node test.js" }, "author": "Dominic Tarr (http://dominictarr.com)", "license": "MIT" } require.addon = require('require-addon') module.exports = require.addon('.', __filename) const assert = require('assert') const binding = require('./binding') const { isNode } = require('which-runtime') const OPTIONAL = Buffer.from(new ArrayBuffer(0)) module.exports = exports = { ...binding } // memory exports.sodium_memzero = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') binding.sodium_memzero(buf) } exports.sodium_mlock = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') const res = binding.sodium_mlock(buf) if (res !== 0) throw new Error('memory lock failed') } exports.sodium_munlock = function (buf) { assert(ArrayBuffer.isView(buf), 'buf must be a typed array') const res = binding.sodium_munlock(buf) if (res !== 0) throw new Error('memory unlock failed') } exports.sodium_malloc = function (size) { assert(size >= 0, 'invalid size') const buf = Buffer.from(binding.sodium_malloc(size)) buf.secure = true return buf } exports.sodium_free = function (buf) { if (!buf || !buf.secure) return binding.sodium_free(buf.buffer) } exports.sodium_mprotect_noaccess = function (buf) { const res = binding.sodium_mprotect_noaccess(buf.buffer) if (res !== 0) throw new Error('failed to lock buffer') } exports.sodium_mprotect_readonly = function (buf) { const res = binding.sodium_mprotect_readonly(buf.buffer) if (res !== 0) throw new Error('failed to unlock buffer') } exports.sodium_mprotect_readwrite = function (buf) { const res = binding.sodium_mprotect_readwrite(buf.buffer) if (res !== 0) throw new Error('failed to unlock buffer') } // crypto_randombytes exports.randombytes_buf = function (buffer) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') binding.randombytes_buf(buffer.buffer, buffer.byteOffset, buffer.byteLength) } exports.randombytes_buf_deterministic = function (buffer, seed) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( seed.byteLength === binding.randombytes_SEEDBYTES, "seed must be 'randombytes_SEEDBYTES' bytes" ) binding.randombytes_buf_deterministic( buffer.buffer, buffer.byteOffset, buffer.byteLength, seed.buffer, seed.byteOffset, seed.byteLength ) } // sodium_helpers exports.sodium_memcmp = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') return binding.sodium_memcmp(a, b) } exports.sodium_add = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') binding.sodium_add(a, b) } exports.sodium_sub = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') binding.sodium_sub(a, b) } exports.sodium_compare = function (a, b) { assert(ArrayBuffer.isView(a), 'a must be a typed array') assert(ArrayBuffer.isView(b), 'b must be a typed array') assert(a.byteLength === b.byteLength, 'buffers must be of same length') return binding.sodium_compare(a, b) } exports.sodium_is_zero = function (buffer, length) { if (length === undefined) length = buffer.byteLength assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(length >= 0 && length <= buffer.byteLength, 'invalid length') return binding.sodium_is_zero(buffer, length) } exports.sodium_pad = function (buffer, unpaddedBuflen, blockSize) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(unpaddedBuflen <= buffer.byteLength, 'unpadded length cannot exceed buffer length') assert(blockSize <= buffer.byteLength, 'block size cannot exceed buffer length') assert(blockSize >= 1, 'block size must be at least 1 byte') assert( buffer.byteLength >= unpaddedBuflen + (blockSize - (unpaddedBuflen % blockSize)), 'buf not long enough' ) return binding.sodium_pad(buffer, unpaddedBuflen, blockSize) } exports.sodium_unpad = function (buffer, paddedBuflen, blockSize) { assert(ArrayBuffer.isView(buffer), 'buffer must be a typed array') assert(paddedBuflen <= buffer.byteLength, 'unpadded length cannot exceed buffer length') assert(blockSize <= buffer.byteLength, 'block size cannot exceed buffer length') assert(blockSize >= 1, 'block size must be at least 1 byte') return binding.sodium_unpad(buffer, paddedBuflen, blockSize) } // crypto_sign exports.crypto_sign_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) assert( seed.byteLength === binding.crypto_sign_SEEDBYTES, "seed must be 'crypto_sign_SEEDBYTES' bytes" ) const res = binding.crypto_sign_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign = function (sm, m, sk) { assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sm.byteLength === binding.crypto_sign_BYTES + m.byteLength, "sm must be 'm.byteLength + crypto_sign_BYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign(sm, m, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_open = function (m, sm, pk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sm.byteLength >= binding.crypto_sign_BYTES, "sm must be at least 'crypto_sign_BYTES' bytes" ) assert( m.byteLength === sm.byteLength - binding.crypto_sign_BYTES, "m must be 'sm.byteLength - crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_open(m, sm, pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_open = function (m, sm, pk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sm), 'sm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sm.byteLength >= binding.crypto_sign_BYTES, "sm must be at least 'crypto_sign_BYTES' bytes" ) assert( m.byteLength === sm.byteLength - binding.crypto_sign_BYTES, "m must be 'sm.byteLength - crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) return binding.crypto_sign_open(m, sm, pk) } exports.crypto_sign_detached = function (sig, m, sk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(sig.byteLength === binding.crypto_sign_BYTES, "sig must be 'crypto_sign_BYTES' bytes") assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_detached(sig, m, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_verify_detached = function (sig, m, pk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( sig.byteLength >= binding.crypto_sign_BYTES, "sig must be at least 'crypto_sign_BYTES' bytes" ) assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) return binding.crypto_sign_verify_detached( sig.buffer, sig.byteOffset, sig.byteLength, m.buffer, m.byteOffset, m.byteLength, pk.buffer, pk.byteOffset, pk.byteLength ) } exports.crypto_sign_ed25519_sk_to_pk = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_sk_to_pk(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_ed25519_pk_to_curve25519 = function (x25519pk, ed25519pk) { assert(ArrayBuffer.isView(x25519pk), 'x25519pk must be a typed array') assert(ArrayBuffer.isView(ed25519pk), 'ed25519pk must be a typed array') assert( x25519pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "x25519pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( ed25519pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "ed25519pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_pk_to_curve25519(x25519pk, ed25519pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_sign_ed25519_sk_to_curve25519 = function (x25519sk, ed25519sk) { assert(ArrayBuffer.isView(x25519sk), 'x25519sk must be a typed array') assert(ArrayBuffer.isView(ed25519sk), 'ed25519sk must be a typed array') assert( x25519sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "x25519sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const edLen = ed25519sk.byteLength assert( edLen === binding.crypto_sign_SECRETKEYBYTES || edLen === binding.crypto_box_SECRETKEYBYTES, "ed25519sk must be 'crypto_sign_SECRETKEYBYTES' or 'crypto_sign_SECRETKEYBYTES - crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_sign_ed25519_sk_to_curve25519(x25519sk, ed25519sk) if (res !== 0) throw new Error('status: ' + res) } // crypto_box exports.crypto_box_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( seed.byteLength === binding.crypto_box_SEEDBYTES, "seed must be 'crypto_box_SEEDBYTES' bytes" ) const res = binding.crypto_box_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_easy = function (c, m, n, pk, sk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength === m.byteLength + exports.crypto_box_MACBYTES, "c must be 'm.byteLength + crypto_box_MACBYTES' bytes" ) assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_easy(c, m, n, pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_detached = function (c, mac, m, n, pk, sk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(mac.byteLength === exports.crypto_box_MACBYTES, "mac must be 'crypto_box_MACBYTES' bytes") assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) const res = binding.crypto_box_detached(c, mac, m, n, pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_open_easy = function (m, c, n, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength >= exports.crypto_box_MACBYTES, "c must be at least 'crypto_box_MACBYTES' bytes" ) assert( m.byteLength === c.byteLength - exports.crypto_box_MACBYTES, "m must be 'c.byteLength - crypto_box_MACBYTES' bytes" ) assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_open_easy(m, c, n, pk, sk) } exports.crypto_box_open_detached = function (m, c, mac, n, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(mac.byteLength === exports.crypto_box_MACBYTES, "mac must be 'crypto_box_MACBYTES' bytes") assert(n.byteLength === exports.crypto_box_NONCEBYTES, "n must be 'crypto_box_NONCEBYTES' bytes") assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_open_detached(m, c, mac, n, pk, sk) } exports.crypto_box_seal = function (c, m, pk) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( c.byteLength === m.byteLength + exports.crypto_box_SEALBYTES, "c must be 'm.byteLength + crypto_box_SEALBYTES' bytes" ) assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_box_seal(c, m, pk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_box_seal_open = function (m, c, pk, sk) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( c.byteLength >= exports.crypto_box_SEALBYTES, "c must be at least 'crypto_box_SEALBYTES' bytes" ) assert( m.byteLength === c.byteLength - exports.crypto_box_SEALBYTES, "m must be 'c.byteLength - crypto_box_SEALBYTES' bytes" ) assert( pk.byteLength === exports.crypto_box_PUBLICKEYBYTES, "pk must be 'crypto_box_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === exports.crypto_box_SECRETKEYBYTES, "sk must be 'crypto_box_SECRETKEYBYTES' bytes" ) return binding.crypto_box_seal_open( m.buffer, m.byteOffset, m.byteLength, c.buffer, c.byteOffset, c.byteLength, pk.buffer, pk.byteOffset, pk.byteLength, sk.buffer, sk.byteOffset, sk.byteLength ) } // crypto_secretbox exports.crypto_secretbox_easy = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_secretbox_MACBYTES, "c must be 'm.byteLength + crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) const res = binding.crypto_secretbox_easy(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretbox_open_easy = function (m, c, n, k) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( c.byteLength >= binding.crypto_secretbox_MACBYTES, "c must be at least 'crypto_secretbox_MACBYTES' bytes" ) assert( m.byteLength === c.byteLength - binding.crypto_secretbox_MACBYTES, "m must be 'c.byteLength - crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) return binding.crypto_secretbox_open_easy(m, c, n, k) } exports.crypto_secretbox_detached = function (c, mac, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( mac.byteLength === binding.crypto_secretbox_MACBYTES, "mac must be 'crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) const res = binding.crypto_secretbox_detached(c, mac, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretbox_open_detached = function (m, c, mac, n, k) { assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert( mac.byteLength === binding.crypto_secretbox_MACBYTES, "mac must be 'crypto_secretbox_MACBYTES' bytes" ) assert( n.byteLength === binding.crypto_secretbox_NONCEBYTES, "n must be 'crypto_secretbox_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretbox_KEYBYTES, "k must be 'crypto_secretbox_KEYBYTES' bytes" ) return binding.crypto_secretbox_open_detached(m, c, mac, n, k) } // crypto_generichash exports.crypto_generichash = function (output, input, key) { if (!key) key = OPTIONAL assert(ArrayBuffer.isView(output), 'output must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( output.byteLength >= binding.crypto_generichash_BYTES_MIN && output.byteLength <= binding.crypto_generichash_BYTES_MAX, 'output must be between crypto_generichash_BYTES_MIN and crypto_generichash_BYTES_MAX bytes' ) if (key !== OPTIONAL) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert( key.byteLength >= binding.crypto_generichash_KEYBYTES_MIN && key.byteLength <= binding.crypto_generichash_KEYBYTES_MAX, 'key must be between crypto_generichash_KEYBYTES_MIN and crypto_generichash_KEYBYTES_MAX bytes' ) } const res = binding.crypto_generichash( output.buffer, output.byteOffset, output.byteLength, input.buffer, input.byteOffset, input.byteLength, key.buffer, key.byteOffset, key.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_batch = function (output, batch, key) { assert(ArrayBuffer.isView(output), 'output must be a typed array') if (isNode || batch.length < 4) { const res = binding.crypto_generichash_batch(output, batch, !!key, key || OPTIONAL) if (res !== 0) throw new Error('status: ' + res) } else { const state = Buffer.alloc(binding.crypto_generichash_STATEBYTES) exports.crypto_generichash_init(state, key, output.byteLength) for (const buf of batch) { exports.crypto_generichash_update(state, buf) } exports.crypto_generichash_final(state, output) } } exports.crypto_generichash_keygen = function (key) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert( key.byteLength === binding.crypto_generichash_KEYBYTES, "key must be 'crypto_generichash_KEYBYTES' bytes" ) const res = binding.crypto_generichash_keygen(key.buffer, key.byteOffset, key.byteLength) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_init = function (state, key, outputLength) { if (!key) key = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_init( state.buffer, state.byteOffset, state.byteLength, key.buffer, key.byteOffset, key.byteLength, outputLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_update( state.buffer, state.byteOffset, state.byteLength, input.buffer, input.byteOffset, input.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_generichash_final = function (state, output) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(output), 'output must be a typed array') assert( state.byteLength === binding.crypto_generichash_STATEBYTES, "state must be 'crypto_generichash_STATEBYTES' bytes" ) const res = binding.crypto_generichash_final( state.buffer, state.byteOffset, state.byteLength, output.buffer, output.byteOffset, output.byteLength ) if (res !== 0) throw new Error('status: ' + res) } // secretstream exports.crypto_secretstream_xchacha20poly1305_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) binding.crypto_secretstream_xchacha20poly1305_keygen(k.buffer, k.byteOffset, k.byteLength) } exports.crypto_secretstream_xchacha20poly1305_init_push = function (state, header, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(header), 'header must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( header.byteLength === binding.crypto_secretstream_xchacha20poly1305_HEADERBYTES, "header must be 'crypto_secretstream_xchacha20poly1305_HEADERBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_init_push( state.buffer, state.byteOffset, state.byteLength, header.buffer, header.byteOffset, header.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretstream_xchacha20poly1305_init_pull = function (state, header, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(header), 'header must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( header.byteLength === binding.crypto_secretstream_xchacha20poly1305_HEADERBYTES, "header must be 'crypto_secretstream_xchacha20poly1305_HEADERBYTES' bytes" ) assert( k.byteLength === binding.crypto_secretstream_xchacha20poly1305_KEYBYTES, "k must be 'crypto_secretstream_xchacha20poly1305_KEYBYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_init_pull( state.buffer, state.byteOffset, state.byteLength, header.buffer, header.byteOffset, header.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_secretstream_xchacha20poly1305_push = function (state, c, m, ad, tag) { if (!ad) ad = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert( c.byteLength === m.byteLength + binding.crypto_secretstream_xchacha20poly1305_ABYTES, "c must be 'm.byteLength + crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_push( state.buffer, state.byteOffset, state.byteLength, c.buffer, c.byteOffset, c.byteLength, m.buffer, m.byteOffset, m.byteLength, ad.buffer, ad.byteOffset, ad.byteLength, tag ) if (res < 0) throw new Error('push failed') return res } exports.crypto_secretstream_xchacha20poly1305_pull = function (state, m, tag, c, ad) { if (!ad) ad = OPTIONAL assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(tag), 'tag must be a typed array') assert(tag.byteLength === 1, 'tag must be 1 byte') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( c.byteLength >= binding.crypto_secretstream_xchacha20poly1305_ABYTES, "c must be at least 'crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_secretstream_xchacha20poly1305_ABYTES, "m must be 'c.byteLength - crypto_secretstream_xchacha20poly1305_ABYTES' bytes" ) const res = binding.crypto_secretstream_xchacha20poly1305_pull( state.buffer, state.byteOffset, state.byteLength, m.buffer, m.byteOffset, m.byteLength, tag.buffer, tag.byteOffset, tag.byteLength, c.buffer, c.byteOffset, c.byteLength, ad.buffer, ad.byteOffset, ad.byteLength ) if (res < 0) throw new Error('pull failed') return res } exports.crypto_secretstream_xchacha20poly1305_rekey = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_secretstream_xchacha20poly1305_STATEBYTES, "state must be 'crypto_secretstream_xchacha20poly1305_STATEBYTES' bytes" ) binding.crypto_secretstream_xchacha20poly1305_rekey( state.buffer, state.byteOffset, state.byteLength ) } // crypto_stream exports.crypto_stream = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) const res = binding.crypto_stream(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) const res = binding.crypto_stream_xor( c.buffer, c.byteOffset, c.byteLength, m.buffer, m.byteOffset, m.byteLength, n.buffer, n.byteOffset, n.byteLength, k.buffer, k.byteOffset, k.byteLength ) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_chacha20_ietf_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) const res = binding.crypto_stream_chacha20_ietf_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_xchacha20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) const res = binding.crypto_stream_xchacha20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20 = function (c, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20(c, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20_xor = function (c, m, n, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20_xor(c, m, n, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_stream_salsa20_xor_ic = function (c, m, n, ic, k) { assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(n), 'n must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) const res = binding.crypto_stream_salsa20_xor_ic(c, m, n, ic, k) if (res !== 0) throw new Error('status: ' + res) } // crypto_auth exports.crypto_auth = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(out.byteLength === binding.crypto_auth_BYTES, "out must be 'crypto_auth_BYTES' bytes") assert(k.byteLength === binding.crypto_auth_KEYBYTES, "k must be 'crypto_auth_KEYBYTES' bytes") const res = binding.crypto_auth(out, input, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_auth_verify = function (h, input, k) { assert(ArrayBuffer.isView(h), 'h must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert(h.byteLength === binding.crypto_auth_BYTES, "h must be 'crypto_auth_BYTES' bytes") assert(k.byteLength === binding.crypto_auth_KEYBYTES, "k must be 'crypto_auth_KEYBYTES' bytes") return binding.crypto_auth_verify(h, input, k) } // crypto_onetimeauth exports.crypto_onetimeauth = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( out.byteLength === binding.crypto_onetimeauth_BYTES, "out must be 'crypto_onetimeauth_BYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) const res = binding.crypto_onetimeauth(out, input, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_init = function (state, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) const res = binding.crypto_onetimeauth_init(state, k) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) const res = binding.crypto_onetimeauth_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( state.byteLength === binding.crypto_onetimeauth_STATEBYTES, "state must be 'crypto_onetimeauth_STATEBYTES' bytes" ) assert( out.byteLength === binding.crypto_onetimeauth_BYTES, "out must be 'crypto_onetimeauth_BYTES' bytes" ) const res = binding.crypto_onetimeauth_final(state, out) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_onetimeauth_verify = function (h, input, k) { assert(ArrayBuffer.isView(h), 'h must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( h.byteLength === binding.crypto_onetimeauth_BYTES, "h must be 'crypto_onetimeauth_BYTES' bytes" ) assert( k.byteLength === binding.crypto_onetimeauth_KEYBYTES, "k must be 'crypto_onetimeauth_KEYBYTES' bytes" ) return binding.crypto_onetimeauth_verify(h, input, k) } // crypto_pwhash exports.crypto_pwhash = function (out, passwd, salt, opslimit, memlimit, alg) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_BYTES_MIN, "out must be at least 'crypto_pwhash_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_BYTES_MAX, "out must be at most 'crypto_pwhash_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_SALTBYTES, "salt must be 'crypto_pwhash_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) assert(alg >= 1 && alg <= 2, 'alg must be either Argon2i 1.3 or Argon2id 1.3') const res = binding.crypto_pwhash(out, passwd, salt, opslimit, memlimit, alg) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_async = function ( out, passwd, salt, opslimit, memlimit, alg, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_BYTES_MIN, "out must be at least 'crypto_pwhash_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_BYTES_MAX, "out must be at most 'crypto_pwhash_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_SALTBYTES, "salt must be 'crypto_pwhash_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) assert(alg >= 1 && alg <= 2, 'alg must be either Argon2i 1.3 or Argon2id 1.3') const [done, promise] = checkStatus(callback) binding.crypto_pwhash_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, opslimit, memlimit, alg, done ) return promise } exports.crypto_pwhash_str = function (out, passwd, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_STRBYTES, "out must be 'crypto_pwhash_STRBYTES' bytes" ) assert(typeof opslimit === 'number', 'opslimit must be a number') assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert(typeof memlimit === 'number', 'memlimit must be a number') assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_str(out, passwd, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_str_async = function (out, passwd, opslimit, memlimit, callback = undefined) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_STRBYTES, "out must be 'crypto_pwhash_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert(typeof opslimit === 'number', 'opslimit must be a number') assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert(typeof memlimit === 'number', 'memlimit must be a number') assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_str_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_str_verify = function (str, passwd) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) return binding.crypto_pwhash_str_verify(str, passwd) } exports.crypto_pwhash_str_verify_async = function (str, passwd, callback = undefined) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') const [done, promise] = checkStatus(callback, true) binding.crypto_pwhash_str_verify_async( str.buffer, str.byteOffset, str.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, done ) return promise } exports.crypto_pwhash_str_needs_rehash = function (str, opslimit, memlimit) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert( str.byteLength === binding.crypto_pwhash_STRBYTES, "str must be 'crypto_pwhash_STRBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_MEMLIMIT_MAX'" ) return binding.crypto_pwhash_str_needs_rehash(str, opslimit, memlimit) } exports.crypto_pwhash_scryptsalsa208sha256 = function (out, passwd, salt, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN, "out must be at least 'crypto_pwhash_scryptsalsa208sha256_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX, "out must be at most 'crypto_pwhash_scryptsalsa208sha256_BYTES_MAX' bytes" ) assert( salt.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_SALTBYTES, "salt must be 'crypto_pwhash_scryptsalsa208sha256_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_scryptsalsa208sha256(out, passwd, salt, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_scryptsalsa208sha256_async = function ( out, passwd, salt, opslimit, memlimit, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert( out.byteLength >= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MIN, "out must be at least 'crypto_pwhash_scryptsalsa208sha256_BYTES_MIN' bytes" ) assert( out.byteLength <= binding.crypto_pwhash_scryptsalsa208sha256_BYTES_MAX, "out must be at most 'crypto_pwhash_scryptsalsa208sha256_BYTES_MAX' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( salt.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_SALTBYTES, "salt must be 'crypto_pwhash_scryptsalsa208sha256_SALTBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_scryptsalsa208sha256_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str_async = function ( out, passwd, opslimit, memlimit, callback = undefined ) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "out must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const [done, promise] = checkStatus(callback) binding.crypto_pwhash_scryptsalsa208sha256_str_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, opslimit, memlimit, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str = function (out, passwd, opslimit, memlimit) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( out.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "out must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) const res = binding.crypto_pwhash_scryptsalsa208sha256_str(out, passwd, opslimit, memlimit) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_pwhash_scryptsalsa208sha256_str_verify_async = function ( str, passwd, callback = undefined ) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') const [done, promise] = checkStatus(callback, true) binding.crypto_pwhash_scryptsalsa208sha256_str_verify_async( str.buffer, str.byteOffset, str.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, done ) return promise } exports.crypto_pwhash_scryptsalsa208sha256_str_verify = function (str, passwd) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert(passwd.byteLength > 0, 'passwd must not be empty') return binding.crypto_pwhash_scryptsalsa208sha256_str_verify(str, passwd) } exports.crypto_pwhash_scryptsalsa208sha256_str_needs_rehash = function (str, opslimit, memlimit) { assert(ArrayBuffer.isView(str), 'str must be a typed array') assert( str.byteLength === binding.crypto_pwhash_scryptsalsa208sha256_STRBYTES, "str must be 'crypto_pwhash_scryptsalsa208sha256_STRBYTES' bytes" ) assert( opslimit >= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN, "opslimit must be at least 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN'" ) assert( opslimit <= binding.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX, "opslimit must be at most 'crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX'" ) assert( memlimit >= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN, "memlimit must be at least 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN'" ) assert( memlimit <= binding.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX, "memlimit must be at most 'crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX'" ) return binding.crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(str, opslimit, memlimit) } // crypto_kx exports.crypto_kx_keypair = function (pk, sk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( pk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "pk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "sk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) const res = binding.crypto_kx_keypair(pk, sk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_seed_keypair = function (pk, sk, seed) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert(ArrayBuffer.isView(seed), 'seed must be a typed array') assert( pk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "pk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( sk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "sk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( seed.byteLength === binding.crypto_kx_SEEDBYTES, "seed must be 'crypto_kx_SEEDBYTES' bytes" ) const res = binding.crypto_kx_seed_keypair(pk, sk, seed) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_client_session_keys = function (rx, tx, clientPk, clientSk, serverPk) { if (!rx) rx = undefined if (!tx) tx = undefined assert(rx || tx, 'at least one session key must be specified') if (rx) { assert(ArrayBuffer.isView(rx), 'rx must be a typed array') assert( rx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "rx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } if (tx) { assert(ArrayBuffer.isView(tx), 'tx must be a typed array') assert( tx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "tx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } assert(ArrayBuffer.isView(clientPk), 'clientPk must be a typed array') assert(ArrayBuffer.isView(clientSk), 'clientSk must be a typed array') assert(ArrayBuffer.isView(serverPk), 'serverPk must be a typed array') assert( clientPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "clientPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( clientSk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "clientSk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( serverPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "serverPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_kx_client_session_keys(rx, tx, clientPk, clientSk, serverPk) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_kx_server_session_keys = function (rx, tx, serverPk, serverSk, clientPk) { if (!rx) rx = undefined if (!tx) tx = undefined assert(rx || tx, 'at least one session key must be specified') if (rx) { assert(ArrayBuffer.isView(rx), 'rx must be a typed array') assert( rx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "rx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } if (tx) { assert(ArrayBuffer.isView(tx), 'tx must be a typed array') assert( tx.byteLength === binding.crypto_kx_SESSIONKEYBYTES, "tx must be 'crypto_kx_SESSIONKEYBYTES' bytes" ) } assert(ArrayBuffer.isView(serverPk), 'serverPk must be a typed array') assert(ArrayBuffer.isView(serverSk), 'serverSk must be a typed array') assert(ArrayBuffer.isView(clientPk), 'clientPk must be a typed array') assert( serverPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "serverPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) assert( serverSk.byteLength === binding.crypto_kx_SECRETKEYBYTES, "serverSk must be 'crypto_kx_SECRETKEYBYTES' bytes" ) assert( clientPk.byteLength === binding.crypto_kx_PUBLICKEYBYTES, "clientPk must be 'crypto_kx_PUBLICKEYBYTES' bytes" ) const res = binding.crypto_kx_server_session_keys(rx, tx, serverPk, serverSk, clientPk) if (res !== 0) throw new Error('status: ' + res) } // crypto_scalarmult exports.crypto_scalarmult_base = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_BYTES, "q must be 'crypto_scalarmult_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_SCALARBYTES, "n must be 'crypto_scalarmult_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_base(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_BYTES, "q must be 'crypto_scalarmult_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_SCALARBYTES, "n must be 'crypto_scalarmult_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_BYTES, "p must be 'crypto_scalarmult_BYTES' bytes" ) const res = binding.crypto_scalarmult(q, n, p) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_base = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_base(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519 = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "p must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519(q, n, p) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_is_valid_point = function (p) { assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) return binding.crypto_core_ed25519_is_valid_point(p) } exports.crypto_core_ed25519_from_uniform = function (p, r) { assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_UNIFORMBYTES, "r must be 'crypto_core_ed25519_UNIFORMBYTES' bytes" ) const res = binding.crypto_core_ed25519_from_uniform(p, r) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_base_noclamp = function (q, n) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_base_noclamp(q, n) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_scalarmult_ed25519_noclamp = function (q, n, p) { assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "q must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_scalarmult_ed25519_SCALARBYTES, "n must be 'crypto_scalarmult_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_scalarmult_ed25519_BYTES, "p must be 'crypto_scalarmult_ed25519_BYTES' bytes" ) const res = binding.crypto_scalarmult_ed25519_noclamp(q, n, p) if (res !== 0) throw new Error('status: ' + res) } // crypto_core exports.crypto_core_ed25519_add = function (r, p, q) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_BYTES, "r must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_core_ed25519_BYTES, "q must be 'crypto_core_ed25519_BYTES' bytes" ) const res = binding.crypto_core_ed25519_add(r, p, q) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_sub = function (r, p, q) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_BYTES, "r must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_core_ed25519_BYTES, "p must be 'crypto_core_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(q), 'q must be a typed array') assert( q.byteLength === binding.crypto_core_ed25519_BYTES, "q must be 'crypto_core_ed25519_BYTES' bytes" ) const res = binding.crypto_core_ed25519_sub(r, p, q) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_core_ed25519_scalar_random = function (r) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "r must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_random(r) } exports.crypto_core_ed25519_scalar_reduce = function (r, s) { assert(ArrayBuffer.isView(r), 'r must be a typed array') assert( r.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "r must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_NONREDUCEDSCALARBYTES, "s must be 'crypto_core_ed25519_NONREDUCEDSCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_reduce(r, s) } exports.crypto_core_ed25519_scalar_invert = function (recip, s) { assert(ArrayBuffer.isView(recip), 'recip must be a typed array') assert( recip.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "recip must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_invert(recip, s) } exports.crypto_core_ed25519_scalar_negate = function (neg, s) { assert(ArrayBuffer.isView(neg), 'neg must be a typed array') assert( neg.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "neg must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_negate(neg, s) } exports.crypto_core_ed25519_scalar_complement = function (comp, s) { assert(ArrayBuffer.isView(comp), 'comp must be a typed array') assert( comp.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "comp must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(s), 's must be a typed array') assert( s.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "s must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_complement(comp, s) } exports.crypto_core_ed25519_scalar_add = function (z, x, y) { assert(ArrayBuffer.isView(z), 'z must be a typed array') assert( z.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "z must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(x), 'x must be a typed array') assert( x.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "x must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(y), 'y must be a typed array') assert( y.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "y must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_add(z, x, y) } exports.crypto_core_ed25519_scalar_sub = function (z, x, y) { assert(ArrayBuffer.isView(z), 'z must be a typed array') assert( z.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "z must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(x), 'x must be a typed array') assert( x.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "x must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(y), 'y must be a typed array') assert( y.byteLength === binding.crypto_core_ed25519_SCALARBYTES, "y must be 'crypto_core_ed25519_SCALARBYTES' bytes" ) binding.crypto_core_ed25519_scalar_sub(z, x, y) } // crypto_shorthash exports.crypto_shorthash = function (out, input, k) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_shorthash_BYTES, "out must be 'crypto_shorthash_BYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_shorthash_KEYBYTES, "k must be 'crypto_shorthash_KEYBYTES' bytes" ) const res = binding.crypto_shorthash(out, input, k) if (res !== 0) throw new Error('status: ' + res) } // crypto_kdf exports.crypto_kdf_keygen = function (key) { assert(ArrayBuffer.isView(key), 'key must be a typed array') assert(key.byteLength === binding.crypto_kdf_KEYBYTES, "key must be 'crypto_kdf_KEYBYTES' bytes") binding.crypto_kdf_keygen(key) } exports.crypto_kdf_derive_from_key = function (subkey, subkeyId, ctx, key) { assert(ArrayBuffer.isView(subkey), 'subkey must be a typed array') assert( subkey.byteLength >= binding.crypto_kdf_BYTES_MIN, "subkey must be at least 'crypto_kdf_BYTES_MIN' bytes" ) assert( subkey.byteLength <= binding.crypto_kdf_BYTES_MAX, "subkey must be at most 'crypto_kdf_BYTES_MAX' bytes" ) assert(ArrayBuffer.isView(ctx), 'ctx must be a typed array') assert( ctx.byteLength === binding.crypto_kdf_CONTEXTBYTES, "ctx must be 'crypto_kdf_CONTEXTBYTES' bytes" ) assert(ArrayBuffer.isView(key), 'key must be a typed array') assert(key.byteLength === binding.crypto_kdf_KEYBYTES, "key must be 'crypto_kdf_KEYBYTES' bytes") const res = binding.crypto_kdf_derive_from_key(subkey, subkeyId, ctx, key) if (res !== 0) throw new Error('status: ' + res) } // crypto_hash exports.crypto_hash = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert(out.byteLength === binding.crypto_hash_BYTES, "out must be 'crypto_hash_BYTES' bytes") const res = binding.crypto_hash(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256 = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_hash_sha256_BYTES, "out must be 'crypto_hash_sha256_BYTES' bytes" ) const res = binding.crypto_hash_sha256(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_init = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha256_init(state) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha256_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha256_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha256_STATEBYTES, "state must be 'crypto_hash_sha256_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( out.byteLength === binding.crypto_hash_sha256_BYTES, "out must be 'crypto_hash_sha256_BYTES' bytes" ) const res = binding.crypto_hash_sha256_final(state, out) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512 = function (out, input) { assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( out.byteLength === binding.crypto_hash_sha512_BYTES, "out must be 'crypto_hash_sha512_BYTES' bytes" ) const res = binding.crypto_hash_sha512(out, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_init = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha512_init(state) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_update = function (state, input) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert(ArrayBuffer.isView(input), 'input must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) const res = binding.crypto_hash_sha512_update(state, input) if (res !== 0) throw new Error('status: ' + res) } exports.crypto_hash_sha512_final = function (state, out) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_hash_sha512_STATEBYTES, "state must be 'crypto_hash_sha512_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert( out.byteLength === binding.crypto_hash_sha512_BYTES, "out must be 'crypto_hash_sha512_BYTES' bytes" ) const res = binding.crypto_hash_sha512_final(state, out) if (res !== 0) throw new Error('status: ' + res) } // crypto_aead exports.crypto_aead_xchacha20poly1305_ietf_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) binding.crypto_aead_xchacha20poly1305_ietf_keygen(k) } exports.crypto_aead_xchacha20poly1305_ietf_encrypt = function (c, m, ad, nsec, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "c must be 'm.byteLength + crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(c.byteLength <= 0xffffffff, 'c.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_encrypt(c, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_xchacha20poly1305_ietf_decrypt = function (m, nsec, c, ad, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "m must be 'c.byteLength - crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(m.byteLength <= 0xffffffff, 'm.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_decrypt(m, c, ad, npub, k) if (res < 0) throw new Error('could not verify data') return res } exports.crypto_aead_xchacha20poly1305_ietf_encrypt_detached = function ( c, mac, m, ad, nsec, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_encrypt_detached(c, mac, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_xchacha20poly1305_ietf_decrypt_detached = function ( m, nsec, c, mac, ad, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_xchacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_xchacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_xchacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_xchacha20poly1305_ietf_decrypt_detached(m, c, mac, ad, npub, k) if (res !== 0) throw new Error('could not verify data') } exports.crypto_aead_chacha20poly1305_ietf_keygen = function (k) { assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) binding.crypto_aead_chacha20poly1305_ietf_keygen(k) } exports.crypto_aead_chacha20poly1305_ietf_encrypt = function (c, m, ad, nsec, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert( c.byteLength === m.byteLength + binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "c must be 'm.byteLength + crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(c.byteLength <= 0xffffffff, 'c.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_encrypt(c, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_chacha20poly1305_ietf_decrypt = function (m, nsec, c, ad, npub, k) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert( m.byteLength === c.byteLength - binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "m must be 'c.byteLength - crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(m.byteLength <= 0xffffffff, 'm.byteLength must be a 32bit integer') assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_decrypt(m, c, ad, npub, k) if (res < 0) throw new Error('could not verify data') return res } exports.crypto_aead_chacha20poly1305_ietf_encrypt_detached = function ( c, mac, m, ad, nsec, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_encrypt_detached(c, mac, m, ad, npub, k) if (res < 0) throw new Error('could not encrypt data') return res } exports.crypto_aead_chacha20poly1305_ietf_decrypt_detached = function ( m, nsec, c, mac, ad, npub, k ) { if (!ad) ad = undefined assert(nsec === null, 'nsec must always be set to null') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(m.byteLength === c.byteLength, "m must be 'c.byteLength' bytes") assert(ArrayBuffer.isView(mac), 'mac must be a typed array') assert( mac.byteLength === binding.crypto_aead_chacha20poly1305_ietf_ABYTES, "mac must be 'crypto_aead_chacha20poly1305_ietf_ABYTES' bytes" ) assert(ArrayBuffer.isView(npub), 'npub must be a typed array') assert( npub.byteLength === binding.crypto_aead_chacha20poly1305_ietf_NPUBBYTES, "npub must be 'crypto_aead_chacha20poly1305_ietf_NPUBBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_aead_chacha20poly1305_ietf_KEYBYTES, "k must be 'crypto_aead_chacha20poly1305_ietf_KEYBYTES' bytes" ) const res = binding.crypto_aead_chacha20poly1305_ietf_decrypt_detached(m, c, mac, ad, npub, k) if (res !== 0) throw new Error('could not verify data') } // crypto_stream exports.crypto_stream_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_NONCEBYTES, "n must be 'crypto_stream_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_KEYBYTES, "k must be 'crypto_stream_KEYBYTES' bytes" ) binding.crypto_stream_xor_wrap_init(state, n, k) } exports.crypto_stream_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_xor_wrap_update(state, c, m) } exports.crypto_stream_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.sn_crypto_stream_xor_STATEBYTES, "state must be 'sn_crypto_stream_xor_STATEBYTES' bytes" ) binding.crypto_stream_xor_wrap_final(state) } exports.crypto_stream_chacha20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_NONCEBYTES, "n must be 'crypto_stream_chacha20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_chacha20_KEYBYTES, "k must be 'crypto_stream_chacha20_KEYBYTES' bytes" ) binding.crypto_stream_chacha20_xor_wrap_init(state, n, k) } exports.crypto_stream_chacha20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_chacha20_xor_wrap_update(state, c, m) } exports.crypto_stream_chacha20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_xor_STATEBYTES' bytes" ) binding.crypto_stream_chacha20_xor_wrap_final(state) } exports.crypto_stream_chacha20_ietf_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_chacha20_ietf_NONCEBYTES, "n must be 'crypto_stream_chacha20_ietf_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_chacha20_ietf_KEYBYTES, "k must be 'crypto_stream_chacha20_ietf_KEYBYTES' bytes" ) binding.crypto_stream_chacha20_ietf_xor_wrap_init(state, n, k) } exports.crypto_stream_chacha20_ietf_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_chacha20_ietf_xor_wrap_update(state, c, m) } exports.crypto_stream_chacha20_ietf_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_chacha20_ietf_xor_STATEBYTES, "state must be 'crypto_stream_chacha20_ietf_xor_STATEBYTES' bytes" ) binding.crypto_stream_chacha20_ietf_xor_wrap_final(state) } exports.crypto_stream_xchacha20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_xchacha20_NONCEBYTES, "n must be 'crypto_stream_xchacha20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_xchacha20_KEYBYTES, "k must be 'crypto_stream_xchacha20_KEYBYTES' bytes" ) binding.crypto_stream_xchacha20_xor_wrap_init(state, n, k) } exports.crypto_stream_xchacha20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_xchacha20_xor_wrap_update(state, c, m) } exports.crypto_stream_xchacha20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_xchacha20_xor_STATEBYTES, "state must be 'crypto_stream_xchacha20_xor_STATEBYTES' bytes" ) binding.crypto_stream_xchacha20_xor_wrap_final(state) } exports.crypto_stream_salsa20_xor_wrap_init = function (state, n, k) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.crypto_stream_salsa20_NONCEBYTES, "n must be 'crypto_stream_salsa20_NONCEBYTES' bytes" ) assert(ArrayBuffer.isView(k), 'k must be a typed array') assert( k.byteLength === binding.crypto_stream_salsa20_KEYBYTES, "k must be 'crypto_stream_salsa20_KEYBYTES' bytes" ) binding.crypto_stream_salsa20_xor_wrap_init(state, n, k) } exports.crypto_stream_salsa20_xor_wrap_update = function (state, c, m) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) assert(ArrayBuffer.isView(c), 'c must be a typed array') assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(c.byteLength === m.byteLength, "c must be 'm.byteLength' bytes") binding.crypto_stream_salsa20_xor_wrap_update(state, c, m) } exports.crypto_stream_salsa20_xor_wrap_final = function (state) { assert(ArrayBuffer.isView(state), 'state must be a typed array') assert( state.byteLength === binding.crypto_stream_salsa20_xor_STATEBYTES, "state must be 'crypto_stream_salsa20_xor_STATEBYTES' bytes" ) binding.crypto_stream_salsa20_xor_wrap_final(state) } // experimental exports.extension_tweak_ed25519_base = function (n, p, ns) { assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.extension_tweak_ed25519_BYTES, "p must be 'extension_tweak_ed25519_BYTES' bytes" ) binding.extension_tweak_ed25519_base(n, p, ns) } exports.extension_tweak_ed25519_sign_detached = function (sig, m, scalar, pk) { assert(ArrayBuffer.isView(sig), 'sig must be a typed array') assert(sig.byteLength === binding.crypto_sign_BYTES, "sig must be 'crypto_sign_BYTES' bytes") assert(ArrayBuffer.isView(m), 'm must be a typed array') assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) if (pk) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) } const res = binding.extension_tweak_ed25519_sign_detached(sig, m, scalar, pk) if (res !== 0) throw new Error('failed to compute signature') } exports.extension_tweak_ed25519_sk_to_scalar = function (n, sk) { assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(sk), 'sk must be a typed array') assert( sk.byteLength === binding.crypto_sign_SECRETKEYBYTES, "sk must be 'crypto_sign_SECRETKEYBYTES' bytes" ) binding.extension_tweak_ed25519_sk_to_scalar(n, sk) } exports.extension_tweak_ed25519_scalar = function (scalarOut, scalar, ns) { assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_scalar(scalarOut, scalar, ns) } exports.extension_tweak_ed25519_pk = function (tpk, pk, ns) { assert(ArrayBuffer.isView(tpk), 'tpk must be a typed array') assert( tpk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "tpk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.extension_tweak_ed25519_pk(tpk, pk, ns) if (res !== 0) throw new Error('failed to tweak public key') } exports.extension_tweak_ed25519_keypair = function (pk, scalarOut, scalarIn, ns) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.extension_tweak_ed25519_BYTES, "pk must be 'extension_tweak_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalarIn), 'scalarIn must be a typed array') assert( scalarIn.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarIn must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_keypair(pk, scalarOut, scalarIn, ns) } exports.extension_tweak_ed25519_scalar_add = function (scalarOut, scalar, n) { assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalar), 'scalar must be a typed array') assert( scalar.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalar must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(n), 'n must be a typed array') assert( n.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "n must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) binding.extension_tweak_ed25519_scalar_add(scalarOut, scalar, n) } exports.extension_tweak_ed25519_pk_add = function (tpk, pk, p) { assert(ArrayBuffer.isView(tpk), 'tpk must be a typed array') assert( tpk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "tpk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "pk must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) assert(ArrayBuffer.isView(p), 'p must be a typed array') assert( p.byteLength === binding.crypto_sign_PUBLICKEYBYTES, "p must be 'crypto_sign_PUBLICKEYBYTES' bytes" ) const res = binding.extension_tweak_ed25519_pk_add(tpk, pk, p) if (res !== 0) throw new Error('failed to add tweak to public key') } exports.extension_tweak_ed25519_keypair_add = function (pk, scalarOut, scalarIn, tweak) { assert(ArrayBuffer.isView(pk), 'pk must be a typed array') assert( pk.byteLength === binding.extension_tweak_ed25519_BYTES, "pk must be 'extension_tweak_ed25519_BYTES' bytes" ) assert(ArrayBuffer.isView(scalarOut), 'scalarOut must be a typed array') assert( scalarOut.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarOut must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(scalarIn), 'scalarIn must be a typed array') assert( scalarIn.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "scalarIn must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) assert(ArrayBuffer.isView(tweak), 'tweak must be a typed array') assert( tweak.byteLength === binding.extension_tweak_ed25519_SCALARBYTES, "tweak must be 'extension_tweak_ed25519_SCALARBYTES' bytes" ) const res = binding.extension_tweak_ed25519_keypair_add(pk, scalarOut, scalarIn, tweak) if (res !== 0) throw new Error('failed to add tweak to keypair') } exports.extension_pbkdf2_sha512_async = function (out, passwd, salt, iter, outlen, callback) { assert( iter >= binding.extension_pbkdf2_sha512_ITERATIONS_MIN, "iter must be at least 'extension_pbkdf2_sha512_ITERATIONS_MIN'" ) assert( outlen <= binding.extension_pbkdf2_sha512_BYTES_MAX, "outlen must be at most 'extension_pbkdf2_sha512_BYTES_MAX'" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(out.byteLength >= outlen, "out must be at least 'outlen' bytes") assert(out.byteLength > 0, 'out must not be empty') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(passwd.byteLength > 0, 'passwd must not be empty') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert(salt.byteLength > 0, 'salt must not be empty') const [done, promise] = checkStatus(callback) binding.extension_pbkdf2_sha512_async( out.buffer, out.byteOffset, out.byteLength, passwd.buffer, passwd.byteOffset, passwd.byteLength, salt.buffer, salt.byteOffset, salt.byteLength, iter, outlen, done ) return promise } exports.extension_pbkdf2_sha512 = function (out, passwd, salt, iter, outlen) { assert( iter >= binding.extension_pbkdf2_sha512_ITERATIONS_MIN, "iter must be at least 'extension_pbkdf2_sha512_ITERATIONS_MIN'" ) assert( outlen <= binding.extension_pbkdf2_sha512_BYTES_MAX, "outlen must be at most 'extension_pbkdf2_sha512_BYTES_MAX'" ) assert(ArrayBuffer.isView(out), 'out must be a typed array') assert(out.byteLength >= outlen, "out must be at least 'outlen' bytes") assert(out.byteLength > 0, 'out must not be empty') assert(ArrayBuffer.isView(passwd), 'passwd must be a typed array') assert(passwd.byteLength > 0, 'passwd must not be empty') assert(ArrayBuffer.isView(salt), 'salt must be a typed array') assert(salt.byteLength > 0, 'salt must not be empty') const res = binding.extension_pbkdf2_sha512(out, passwd, salt, iter, outlen) if (res !== 0) throw new Error('failed to add tweak to public key') } function checkStatus(callback, booleanResult = false) { let done, promise if (typeof callback === 'function') { done = function (status) { if (booleanResult) callback(null, status === 0) else if (status === 0) callback(null) else callback(new Error('status: ' + status)) } } else { promise = new Promise(function (resolve, reject) { done = function (status) { if (booleanResult) resolve(status === 0) else if (status === 0) resolve() else reject(new Error('status: ' + status)) } }) } return [done, promise] } { "name": "sodium-native", "version": "5.1.0", "description": "Low level bindings for libsodium", "main": "index.js", "files": [ "index.js", "binding.cc", "binding.js", "extensions", "prebuilds", "CMakeLists.txt" ], "imports": { "assert": { "bare": "bare-assert", "node": "assert" } }, "addon": true, "dependencies": { "bare-assert": "^1.2.0", "require-addon": "^1.1.0", "which-runtime": "^1.2.1" }, "devDependencies": { "bare-compat-napi": "^1.3.5", "brittle": "^3.16.2", "cmake-bare": "^1.6.1", "cmake-fetch": "^1.4.3", "cmake-napi": "^1.2.1", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "scripts": { "test": "prettier . --check && npm run test:node && npm run test:bare", "test:node": "node test/all.js", "test:bare": "bare test/all.js" }, "standard": { "ignore": [ "/test/fixtures/*.js" ] }, "engines": { "bare": ">=1.16.0" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/sodium-native.git" }, "contributors": [ "Emil Bay (http://bayes.dk)", "Mathias Buus (https://mafinto.sh)", "Christophe Diederichs " ], "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/sodium-native/issues" }, "homepage": "https://github.com/holepunchto/sodium-native" } module.exports = require('sodium-native') { "name": "sodium-universal", "version": "5.0.1", "description": "Universal wrapper for sodium-javascript and sodium-native working in Node.js and the Browser", "main": "index.js", "dependencies": { "sodium-native": "^5.0.1" }, "peerDependencies": { "sodium-javascript": "~0.8.0" }, "peerDependenciesMeta": { "sodium-javascript": { "optional": true } }, "scripts": { "prepublish": "./build-scripts/generate.js" }, "browser": { "sodium-native": "sodium-javascript" }, "browserify": { "transform": [ "./build-scripts/transform.js" ] }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/sodium-universal.git" }, "keywords": [ "libsodium", "sodium", "sodium-native", "sodium-javascript", "browserify" ], "contributors": [ "Emil Bay (http://bayes.dk)", "Mathias Buus (https://mafinto.sh)", "Christophe Diederichs " ], "license": "MIT", "bugs": { "url": "https://github.com/holepunchto/sodium-universal/issues" }, "homepage": "https://github.com/holepunchto/sodium-universal#readme" } const { EventEmitter } = require('events-universal') const FIFO = require('fast-fifo') const TextDecoder = require('text-decoder') const StreamError = require('./lib/errors.js') // if we do a future major, expect queue microtask to be there always, for now a bit defensive const qmt = typeof queueMicrotask === 'undefined' ? (fn) => global.process.nextTick(fn) : queueMicrotask // 29 bits used total (4 from shared, 14 from read, and 11 from write) const MAX = (1 << 29) - 1 // Shared state const OPENING = 0b0001 const PREDESTROYING = 0b0010 const DESTROYING = 0b0100 const DESTROYED = 0b1000 const NOT_OPENING = MAX ^ OPENING const NOT_PREDESTROYING = MAX ^ PREDESTROYING // Read state (4 bit offset from shared state) const READ_ACTIVE = 0b00000000000001 << 4 const READ_UPDATING = 0b00000000000010 << 4 const READ_PRIMARY = 0b00000000000100 << 4 const READ_QUEUED = 0b00000000001000 << 4 const READ_RESUMED = 0b00000000010000 << 4 const READ_PIPE_DRAINED = 0b00000000100000 << 4 const READ_ENDING = 0b00000001000000 << 4 const READ_EMIT_DATA = 0b00000010000000 << 4 const READ_EMIT_READABLE = 0b00000100000000 << 4 const READ_EMITTED_READABLE = 0b00001000000000 << 4 const READ_DONE = 0b00010000000000 << 4 const READ_NEXT_TICK = 0b00100000000000 << 4 const READ_NEEDS_PUSH = 0b01000000000000 << 4 const READ_READ_AHEAD = 0b10000000000000 << 4 // Combined read state const READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED const READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH const READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE const READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED const READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD const READ_NOT_ACTIVE = MAX ^ READ_ACTIVE const READ_NON_PRIMARY = MAX ^ READ_PRIMARY const READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH) const READ_PUSHED = MAX ^ READ_NEEDS_PUSH const READ_PAUSED = MAX ^ READ_RESUMED const READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE) const READ_NOT_ENDING = MAX ^ READ_ENDING const READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING const READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK const READ_NOT_UPDATING = MAX ^ READ_UPDATING const READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD const READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD // Write state (18 bit offset, 4 bit offset from shared state and 14 from read state) const WRITE_ACTIVE = 0b00000000001 << 18 const WRITE_UPDATING = 0b00000000010 << 18 const WRITE_PRIMARY = 0b00000000100 << 18 const WRITE_QUEUED = 0b00000001000 << 18 const WRITE_UNDRAINED = 0b00000010000 << 18 const WRITE_DONE = 0b00000100000 << 18 const WRITE_EMIT_DRAIN = 0b00001000000 << 18 const WRITE_NEXT_TICK = 0b00010000000 << 18 const WRITE_WRITING = 0b00100000000 << 18 const WRITE_FINISHING = 0b01000000000 << 18 const WRITE_CORKED = 0b10000000000 << 18 const WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING) const WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY const WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING) const WRITE_DRAINED = MAX ^ WRITE_UNDRAINED const WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED const WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK const WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING const WRITE_NOT_CORKED = MAX ^ WRITE_CORKED // Combined shared state const ACTIVE = READ_ACTIVE | WRITE_ACTIVE const NOT_ACTIVE = MAX ^ ACTIVE const DONE = READ_DONE | WRITE_DONE const DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING const OPEN_STATUS = DESTROY_STATUS | OPENING const AUTO_DESTROY = DESTROY_STATUS | DONE const NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY const ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK const TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE const IS_OPENING = OPEN_STATUS | TICKING // Combined shared state and read state const READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE const READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED const READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED const READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE const SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD const READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE const READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY const READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING // Combined write state const WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE const WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED const WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE const WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE const WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED const WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE const WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING const WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE const WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE const WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY const WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS const asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator') class WritableState { constructor( stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {} ) { this.stream = stream this.queue = new FIFO() this.highWaterMark = highWaterMark this.buffered = 0 this.error = null this.pipeline = null this.drains = null // if we add more seldomly used helpers we might them into a subobject so its a single ptr this.byteLength = byteLengthWritable || byteLength || defaultByteLength this.map = mapWritable || map this.afterWrite = afterWrite.bind(this) this.afterUpdateNextTick = updateWriteNT.bind(this) } get ending() { return (this.stream._duplexState & WRITE_FINISHING) !== 0 } get ended() { return (this.stream._duplexState & WRITE_DONE) !== 0 } push(data) { if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false if (this.map !== null) data = this.map(data) this.buffered += this.byteLength(data) this.queue.push(data) if (this.buffered < this.highWaterMark) { this.stream._duplexState |= WRITE_QUEUED return true } this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED return false } shift() { const data = this.queue.shift() this.buffered -= this.byteLength(data) if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED return data } end(data) { if (typeof data === 'function') { this.stream.once('finish', data) } else if (data !== undefined && data !== null) { this.push(data) } this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY } autoBatch(data, cb) { const buffer = [] const stream = this.stream buffer.push(data) while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) { buffer.push(stream._writableState.shift()) } if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null) stream._writev(buffer, cb) } update() { const stream = this.stream stream._duplexState |= WRITE_UPDATING do { while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) { const data = this.shift() stream._duplexState |= WRITE_ACTIVE_AND_WRITING stream._write(data, this.afterWrite) } if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary() } while (this.continueUpdate() === true) stream._duplexState &= WRITE_NOT_UPDATING } updateNonPrimary() { const stream = this.stream if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) { stream._duplexState = stream._duplexState | WRITE_ACTIVE stream._final(afterFinal.bind(this)) return } if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { stream._duplexState |= ACTIVE stream._destroy(afterDestroy.bind(this)) } return } if ((stream._duplexState & IS_OPENING) === OPENING) { stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING stream._open(afterOpen.bind(this)) } } continueUpdate() { if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false this.stream._duplexState &= WRITE_NOT_NEXT_TICK return true } updateCallback() { if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) { this.update() } else { this.updateNextTick() } } updateNextTick() { if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return this.stream._duplexState |= WRITE_NEXT_TICK if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick) } } class ReadableState { constructor( stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {} ) { this.stream = stream this.queue = new FIFO() this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark this.buffered = 0 this.readAhead = highWaterMark > 0 this.error = null this.pipeline = null this.byteLength = byteLengthReadable || byteLength || defaultByteLength this.map = mapReadable || map this.pipeTo = null this.afterRead = afterRead.bind(this) this.afterUpdateNextTick = updateReadNT.bind(this) } get ending() { return (this.stream._duplexState & READ_ENDING) !== 0 } get ended() { return (this.stream._duplexState & READ_DONE) !== 0 } pipe(pipeTo, cb) { if (this.pipeTo !== null) throw StreamError.BAD_ARGUMENT('Can only pipe to one destination') if (typeof cb !== 'function') cb = null this.stream._duplexState |= READ_PIPE_DRAINED this.pipeTo = pipeTo this.pipeline = new Pipeline(this.stream, pipeTo, cb) if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes if (isStreamx(pipeTo)) { pipeTo._writableState.pipeline = this.pipeline if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself } else { const onerror = this.pipeline.done.bind(this.pipeline, pipeTo) const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool arg pipeTo.on('error', onerror) pipeTo.on('close', onclose) pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) } pipeTo.on('drain', afterDrain.bind(this)) this.stream.emit('piping', pipeTo) pipeTo.emit('pipe', this.stream) } push(data) { const stream = this.stream if (data === null) { this.highWaterMark = 0 stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED return false } if (this.map !== null) { data = this.map(data) if (data === null) { stream._duplexState &= READ_PUSHED return this.buffered < this.highWaterMark } } this.buffered += this.byteLength(data) this.queue.push(data) stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED return this.buffered < this.highWaterMark } shift() { const data = this.queue.shift() this.buffered -= this.byteLength(data) if (this.buffered === 0) { this.stream._duplexState &= READ_NOT_QUEUED } return data } unshift(data) { const pending = [this.map !== null ? this.map(data) : data] while (this.buffered > 0) pending.push(this.shift()) for (let i = 0; i < pending.length - 1; i++) { const data = pending[i] this.buffered += this.byteLength(data) this.queue.push(data) } this.push(pending[pending.length - 1]) } read() { const stream = this.stream if ((stream._duplexState & READ_STATUS) === READ_QUEUED) { const data = this.shift() if (this.pipeTo !== null && this.pipeTo.write(data) === false) { stream._duplexState &= READ_PIPE_NOT_DRAINED } if ((stream._duplexState & READ_EMIT_DATA) !== 0) { stream.emit('data', data) } return data } if (this.readAhead === false) { stream._duplexState |= READ_READ_AHEAD this.updateNextTick() } return null } drain() { const stream = this.stream while ( (stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0 ) { const data = this.shift() if (this.pipeTo !== null && this.pipeTo.write(data) === false) { stream._duplexState &= READ_PIPE_NOT_DRAINED } if ((stream._duplexState & READ_EMIT_DATA) !== 0) { stream.emit('data', data) } } } update() { const stream = this.stream stream._duplexState |= READ_UPDATING do { this.drain() while ( this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD ) { stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH stream._read(this.afterRead) this.drain() } if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) { stream._duplexState |= READ_EMITTED_READABLE stream.emit('readable') } if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) { this.updateNonPrimary() } } while (this.continueUpdate() === true) stream._duplexState &= READ_NOT_UPDATING } updateNonPrimary() { const stream = this.stream if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) { stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING stream.emit('end') if ((stream._duplexState & AUTO_DESTROY) === DONE) { stream._duplexState |= DESTROYING } if (this.pipeTo !== null) { this.pipeTo.end() } } if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) { if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) { stream._duplexState |= ACTIVE stream._destroy(afterDestroy.bind(this)) } return } if ((stream._duplexState & IS_OPENING) === OPENING) { stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING stream._open(afterOpen.bind(this)) } } continueUpdate() { if ((this.stream._duplexState & READ_NEXT_TICK) === 0) return false this.stream._duplexState &= READ_NOT_NEXT_TICK return true } updateCallback() { if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) { this.update() } else { this.updateNextTick() } } updateNextTickIfOpen() { if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return this.stream._duplexState |= READ_NEXT_TICK if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick) } updateNextTick() { if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return this.stream._duplexState |= READ_NEXT_TICK if ((this.stream._duplexState & READ_UPDATING) === 0) qmt(this.afterUpdateNextTick) } } class TransformState { constructor(stream) { this.data = null this.afterTransform = afterTransform.bind(stream) this.afterFinal = null } } class Pipeline { constructor(src, dst, cb) { this.from = src this.to = dst this.afterPipe = cb this.error = null this.pipeToFinished = false } finished() { this.pipeToFinished = true } done(stream, err) { if (err) this.error = err if (stream === this.to) { this.to = null if (this.from !== null) { if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) { this.from.destroy(this.error || StreamError.PREMATURE_CLOSE('Writable stream closed')) } return } } if (stream === this.from) { this.from = null if (this.to !== null) { if ((stream._duplexState & READ_DONE) === 0) { this.to.destroy(this.error || StreamError.PREMATURE_CLOSE('Readable stream closed')) } return } } if (this.afterPipe !== null) this.afterPipe(this.error) this.to = this.from = this.afterPipe = null } } function afterDrain() { this.stream._duplexState |= READ_PIPE_DRAINED this.updateCallback() } function afterFinal(err) { const stream = this.stream if (err) stream.destroy(err) if ((stream._duplexState & DESTROY_STATUS) === 0) { stream._duplexState |= WRITE_DONE stream.emit('finish') } if ((stream._duplexState & AUTO_DESTROY) === DONE) { stream._duplexState |= DESTROYING } stream._duplexState &= WRITE_NOT_FINISHING // no need to wait the extra tick here, so we short circuit that if ((stream._duplexState & WRITE_UPDATING) === 0) { this.update() } else { this.updateNextTick() } } function afterDestroy(err) { const stream = this.stream if (!err && !StreamError.isStreamDestroyed(this.error)) err = this.error if (err) stream.emit('error', err) stream._duplexState |= DESTROYED stream.emit('close') const rs = stream._readableState const ws = stream._writableState if (rs !== null && rs.pipeline !== null) { rs.pipeline.done(stream, err) } if (ws !== null) { while (ws.drains !== null && ws.drains.length > 0) { ws.drains.shift().resolve(false) } if (ws.pipeline !== null) { ws.pipeline.done(stream, err) } } } function afterWrite(err) { const stream = this.stream if (err) stream.destroy(err) stream._duplexState &= WRITE_NOT_ACTIVE if (this.drains !== null) tickDrains(this.drains) if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) { stream._duplexState &= WRITE_DRAINED if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) { stream.emit('drain') } } this.updateCallback() } function afterRead(err) { if (err) this.stream.destroy(err) this.stream._duplexState &= READ_NOT_ACTIVE if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) { this.stream._duplexState &= READ_NO_READ_AHEAD } this.updateCallback() } function updateReadNT() { if ((this.stream._duplexState & READ_UPDATING) === 0) { this.stream._duplexState &= READ_NOT_NEXT_TICK this.update() } } function updateWriteNT() { if ((this.stream._duplexState & WRITE_UPDATING) === 0) { this.stream._duplexState &= WRITE_NOT_NEXT_TICK this.update() } } function tickDrains(drains) { for (let i = 0; i < drains.length; i++) { // drains.writes are monotonic, so if one is 0 its always the first one if (--drains[i].writes === 0) { drains.shift().resolve(true) i-- } } } function afterOpen(err) { const stream = this.stream if (err) stream.destroy(err) if ((stream._duplexState & DESTROYING) === 0) { if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) { stream._duplexState |= READ_PRIMARY } if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) { stream._duplexState |= WRITE_PRIMARY } stream.emit('open') } stream._duplexState &= NOT_ACTIVE if (stream._writableState !== null) { stream._writableState.updateCallback() } if (stream._readableState !== null) { stream._readableState.updateCallback() } } function afterTransform(err, data) { if (data !== undefined && data !== null) this.push(data) this._writableState.afterWrite(err) } function newListener(name) { if (this._readableState !== null) { if (name === 'data') { this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD this._readableState.updateNextTick() } if (name === 'readable') { this._duplexState |= READ_EMIT_READABLE this._readableState.updateNextTick() } } if (this._writableState !== null) { if (name === 'drain') { this._duplexState |= WRITE_EMIT_DRAIN this._writableState.updateNextTick() } } } class Stream extends EventEmitter { constructor(opts) { super() this._duplexState = 0 this._readableState = null this._writableState = null if (opts) { if (opts.open) this._open = opts.open if (opts.destroy) this._destroy = opts.destroy if (opts.predestroy) this._predestroy = opts.predestroy if (opts.signal) opts.signal.addEventListener('abort', abort.bind(this)) } this.on('newListener', newListener) } _open(cb) { cb(null) } _destroy(cb) { cb(null) } _predestroy() { // does nothing } get readable() { return this._readableState !== null ? true : undefined } get writable() { return this._writableState !== null ? true : undefined } get destroyed() { return (this._duplexState & DESTROYED) !== 0 } get destroying() { return (this._duplexState & DESTROY_STATUS) !== 0 } destroy(err) { if ((this._duplexState & DESTROY_STATUS) === 0) { if (!err) err = StreamError.STREAM_DESTROYED() this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY if (this._readableState !== null) { this._readableState.highWaterMark = 0 this._readableState.error = err } if (this._writableState !== null) { this._writableState.highWaterMark = 0 this._writableState.error = err } this._duplexState |= PREDESTROYING this._predestroy() this._duplexState &= NOT_PREDESTROYING if (this._readableState !== null) { this._readableState.updateNextTick() } if (this._writableState !== null) { this._writableState.updateNextTick() } } } } class Readable extends Stream { constructor(opts) { super(opts) this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD this._readableState = new ReadableState(this, opts) if (opts) { if (this._readableState.readAhead === false) this._duplexState &= READ_NO_READ_AHEAD if (opts.read) this._read = opts.read if (opts.eagerOpen) this._readableState.updateNextTick() if (opts.encoding) this.setEncoding(opts.encoding) } } static deferred(fn, opts) { const out = new PassThrough(opts) fn() .then((src) => { if (src === null) return out.end() if (out.destroying) return pipeline(src, out, noop) }) .catch((err) => out.destroy(err)) return out } setEncoding(encoding) { const dec = new TextDecoder(encoding) const map = this._readableState.map || echo this._readableState.map = mapOrSkip return this function mapOrSkip(data) { const next = dec.push(data) return next === '' && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next) } } _read(cb) { cb(null) } pipe(dest, cb) { this._readableState.updateNextTick() this._readableState.pipe(dest, cb) return dest } read() { this._readableState.updateNextTick() return this._readableState.read() } push(data) { this._readableState.updateNextTickIfOpen() return this._readableState.push(data) } unshift(data) { this._readableState.updateNextTickIfOpen() return this._readableState.unshift(data) } resume() { this._duplexState |= READ_RESUMED_READ_AHEAD this._readableState.updateNextTick() return this } pause() { this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED return this } static _fromAsyncIterator(ite, opts) { let destroy const rs = new Readable({ ...opts, read(cb) { ite.next().then(push).then(cb.bind(null, null)).catch(cb) }, predestroy() { destroy = ite.return() }, destroy(cb) { if (!destroy) return cb(null) destroy.then(cb.bind(null, null)).catch(cb) } }) return rs function push(data) { if (data.done) rs.push(null) else rs.push(data.value) } } static from(data, opts) { if (isReadStreamx(data)) return data if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts) if (!Array.isArray(data)) data = data === undefined ? [] : [data] let i = 0 return new Readable({ ...opts, read(cb) { this.push(i === data.length ? null : data[i++]) cb(null) } }) } static isBackpressured(rs) { return ( (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark ) } static isPaused(rs) { return (rs._duplexState & READ_RESUMED) === 0 } [asyncIterator]() { const stream = this let error = null let promiseResolve = null let promiseReject = null this.on('error', (err) => { error = err }) this.on('readable', onreadable) this.on('close', onclose) return { [asyncIterator]() { return this }, next() { return new Promise(function (resolve, reject) { promiseResolve = resolve promiseReject = reject const data = stream.read() if (data !== null) ondata(data) else if ((stream._duplexState & DESTROYED) !== 0) ondata(null) }) }, return() { return destroy(null) }, throw(err) { return destroy(err) } } function onreadable() { if (promiseResolve !== null) ondata(stream.read()) } function onclose() { if (promiseResolve !== null) ondata(null) } function ondata(data) { if (promiseReject === null) return if (error) { promiseReject(error) } else if (data === null && (stream._duplexState & READ_DONE) === 0) { promiseReject(StreamError.STREAM_DESTROYED()) } else { promiseResolve({ value: data, done: data === null }) } promiseReject = promiseResolve = null } function destroy(err) { stream.destroy(err) return new Promise((resolve, reject) => { if (stream._duplexState & DESTROYED) return resolve({ value: undefined, done: true }) stream.once('close', function () { if (err) reject(err) else resolve({ value: undefined, done: true }) }) }) } } } class Writable extends Stream { constructor(opts) { super(opts) this._duplexState |= OPENING | READ_DONE this._writableState = new WritableState(this, opts) if (opts) { if (opts.writev) this._writev = opts.writev if (opts.write) this._write = opts.write if (opts.final) this._final = opts.final if (opts.eagerOpen) this._writableState.updateNextTick() } } cork() { this._duplexState |= WRITE_CORKED } uncork() { this._duplexState &= WRITE_NOT_CORKED this._writableState.updateNextTick() } _writev(batch, cb) { cb(null) } _write(data, cb) { this._writableState.autoBatch(data, cb) } _final(cb) { cb(null) } static isBackpressured(ws) { return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0 } static drained(ws) { if (ws.destroyed) return Promise.resolve(false) const state = ws._writableState const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0) if (writes === 0) return Promise.resolve(true) if (state.drains === null) state.drains = [] return new Promise((resolve) => { state.drains.push({ writes, resolve }) }) } write(data) { this._writableState.updateNextTick() return this._writableState.push(data) } end(data) { this._writableState.updateNextTick() this._writableState.end(data) return this } } class Duplex extends Readable { // and Writable constructor(opts) { super(opts) this._duplexState = OPENING | (this._duplexState & READ_READ_AHEAD) this._writableState = new WritableState(this, opts) if (opts) { if (opts.writev) this._writev = opts.writev if (opts.write) this._write = opts.write if (opts.final) this._final = opts.final } } cork() { this._duplexState |= WRITE_CORKED } uncork() { this._duplexState &= WRITE_NOT_CORKED this._writableState.updateNextTick() } _writev(batch, cb) { cb(null) } _write(data, cb) { this._writableState.autoBatch(data, cb) } _final(cb) { cb(null) } write(data) { this._writableState.updateNextTick() return this._writableState.push(data) } end(data) { this._writableState.updateNextTick() this._writableState.end(data) return this } } class Transform extends Duplex { constructor(opts) { super(opts) this._transformState = new TransformState(this) if (opts) { if (opts.transform) this._transform = opts.transform if (opts.flush) this._flush = opts.flush } } _write(data, cb) { if (this._readableState.buffered >= this._readableState.highWaterMark) { this._transformState.data = data } else { this._transform(data, this._transformState.afterTransform) } } _read(cb) { if (this._transformState.data !== null) { const data = this._transformState.data this._transformState.data = null cb(null) this._transform(data, this._transformState.afterTransform) } else { cb(null) } } destroy(err) { super.destroy(err) if (this._transformState.data !== null) { this._transformState.data = null this._transformState.afterTransform() } } _transform(data, cb) { cb(null, data) } _flush(cb) { cb(null) } _final(cb) { this._transformState.afterFinal = cb this._flush(transformAfterFlush.bind(this)) } } class PassThrough extends Transform {} function transformAfterFlush(err, data) { const cb = this._transformState.afterFinal if (err) return cb(err) if (data !== null && data !== undefined) this.push(data) this.push(null) cb(null) } function pipelinePromise(...streams) { return new Promise((resolve, reject) => { return pipeline(...streams, (err) => { if (err) return reject(err) resolve() }) }) } function pipeline(stream, ...streams) { const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams] const done = all.length && typeof all[all.length - 1] === 'function' ? all.pop() : null if (all.length < 2) throw StreamError.BAD_ARGUMENT('Pipeline requires at least 2 streams') let src = all[0] let dest = null let error = null for (let i = 1; i < all.length; i++) { dest = all[i] if (isStreamx(src)) { src.pipe(dest, onerror) } else { errorHandle(src, true, i > 1, onerror) src.pipe(dest) } src = dest } if (done) { let fin = false const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy) dest.on('error', (err) => { if (error === null) error = err }) dest.on('finish', () => { fin = true if (!autoDestroy) done(error) }) if (autoDestroy) { dest.on('close', () => done(error || (fin ? null : StreamError.PREMATURE_CLOSE()))) } } return dest function errorHandle(s, rd, wr, onerror) { s.on('error', onerror) s.on('close', onclose) function onclose() { if (rd && s._readableState && !s._readableState.ended) { return onerror(StreamError.PREMATURE_CLOSE()) } if (wr && s._writableState && !s._writableState.ended) { return onerror(StreamError.PREMATURE_CLOSE()) } } } function onerror(err) { if (!err || error) return error = err for (const s of all) { s.destroy(err) } } } function echo(s) { return s } function isStream(stream) { return !!stream._readableState || !!stream._writableState } function isStreamx(stream) { return typeof stream._duplexState === 'number' && isStream(stream) } function isEnding(stream) { return !!stream._readableState && stream._readableState.ending } function isEnded(stream) { return !!stream._readableState && stream._readableState.ended } function isFinishing(stream) { return !!stream._writableState && stream._writableState.ending } function isFinished(stream) { return !!stream._writableState && stream._writableState.ended } function getStreamError(stream, opts = {}) { const err = (stream._readableState && stream._readableState.error) || (stream._writableState && stream._writableState.error) // avoid implicit errors by default return !opts.all && StreamError.isStreamDestroyed(err) ? null : err } function isReadStreamx(stream) { return isStreamx(stream) && stream.readable } function isDisturbed(stream) { return ( (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0 ) } function isTypedArray(data) { return typeof data === 'object' && data !== null && typeof data.byteLength === 'number' } function defaultByteLength(data) { return isTypedArray(data) ? data.byteLength : 1024 } function noop() {} function abort() { this.destroy(StreamError.ABORTED()) } function isWritev(s) { return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev } module.exports = { pipeline, pipelinePromise, isStream, isStreamx, isEnding, isEnded, isFinishing, isFinished, isDisturbed, getStreamError, Stream, Writable, Readable, Duplex, Transform, // Export PassThrough for compatibility with Node.js core's stream module PassThrough } module.exports = class StreamError extends Error { constructor(msg, code, fn = StreamError) { super(msg) this.code = code if (Error.captureStackTrace) { Error.captureStackTrace(this, fn) } } static isStreamDestroyed(err) { return err && err.code === 'STREAM_DESTROYED' } static isPrematureClose(err) { return err && err.code === 'PREMATURE_CLOSE' } static isAborted(err) { return err && err.code === 'ABORTED' } static isBadArgument(err) { return err && err.code === 'BAD_ARGUMENT' } get name() { return 'StreamError' } static STREAM_DESTROYED() { return new StreamError('Stream was destroyed', 'STREAM_DESTROYED', StreamError.STREAM_DESTROYED) } static PREMATURE_CLOSE(msg = 'Premature close') { return new StreamError(msg, 'PREMATURE_CLOSE', StreamError.PREMATURE_CLOSE) } static ABORTED() { return new StreamError('Stream aborted', 'ABORTED', StreamError.ABORTED) } static BAD_ARGUMENT(msg = 'Bad argument') { return new StreamError(msg, 'BAD_ARGUMENT', StreamError.BAD_ARGUMENT) } } { "name": "streamx", "version": "2.28.0", "description": "An iteration of the Node.js core streams with a series of improvements", "main": "index.js", "exports": { ".": { "types": "./index.d.ts", "default": "./index.js" }, "./package": "./package.json", "./errors": { "types": "./lib/errors.d.ts", "default": "./lib/errors" } }, "dependencies": { "events-universal": "^1.0.0", "fast-fifo": "^1.3.2", "text-decoder": "^1.1.0" }, "devDependencies": { "b4a": "^1.6.6", "brittle": "^3.1.1", "end-of-stream": "^1.4.4", "lunte": "^1.8.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" }, "files": [ "index.js", "index.d.ts", "runtime.d.ts", "lib" ], "scripts": { "format": "prettier . --write", "test": "brittle test/all.js && brittle-bare test/all.js", "lint": "prettier . --check && lunte" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/streamx.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/streamx/issues" }, "homepage": "https://github.com/mafintosh/streamx" } const { Readable } = require('streamx') module.exports = function (s, forks = 2) { const streams = new Array(forks) const status = new Array(forks).fill(true) let ended = false for (let i = 0; i < forks; i++) { streams[i] = new Readable({ read (cb) { const check = !status[i] status[i] = true if (check && allReadable()) s.resume() cb(null) } }) } s.on('end', function () { ended = true for (const stream of streams) stream.push(null) }) s.on('error', function (err) { for (const stream of streams) stream.destroy(err) }) s.on('close', function () { if (ended) return for (const stream of streams) stream.destroy() }) s.on('data', function (data) { let needsPause = false for (let i = 0; i < streams.length; i++) { if (!(status[i] = streams[i].push(data))) { needsPause = true } } if (needsPause) s.pause() }) return streams function allReadable () { for (let j = 0; j < status.length; j++) { if (!status[j]) return false } return true } } { "name": "teex", "version": "1.0.1", "description": "Turn a readable stream into multiple readable streamx streams", "main": "index.js", "dependencies": { "streamx": "^2.12.5" }, "devDependencies": { "standard": "^14.3.4", "tape": "^5.0.1" }, "scripts": { "test": "standard && tape test.js" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/teex.git" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/teex/issues" }, "homepage": "https://github.com/mafintosh/teex" } const PassThroughDecoder = require('./lib/pass-through-decoder') const UTF8Decoder = require('./lib/utf8-decoder') module.exports = class TextDecoder { constructor(encoding = 'utf8') { this.encoding = normalizeEncoding(encoding) switch (this.encoding) { case 'utf8': this.decoder = new UTF8Decoder() break case 'utf16le': case 'base64': throw new Error('Unsupported encoding: ' + this.encoding) default: this.decoder = new PassThroughDecoder(this.encoding) } } get remaining() { return this.decoder.remaining } push(data) { if (typeof data === 'string') return data return this.decoder.decode(data) } // For Node.js compatibility write(data) { return this.push(data) } end(data) { let result = '' if (data) result = this.push(data) result += this.decoder.flush() return result } } function normalizeEncoding(encoding) { encoding = encoding.toLowerCase() switch (encoding) { case 'utf8': case 'utf-8': return 'utf8' case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return 'utf16le' case 'latin1': case 'binary': return 'latin1' case 'base64': case 'ascii': case 'hex': return encoding default: throw new Error('Unknown encoding: ' + encoding) } } const b4a = require('b4a') module.exports = class PassThroughDecoder { constructor(encoding) { this.encoding = encoding } get remaining() { return 0 } decode(data) { return b4a.toString(data, this.encoding) } flush() { return '' } } const b4a = require('b4a') /** * https://encoding.spec.whatwg.org/#utf-8-decoder */ module.exports = class UTF8Decoder { constructor() { this._reset() } get remaining() { return this.bytesSeen } decode(data) { if (data.byteLength === 0) return '' if (this.bytesNeeded === 0 && trailingIncomplete(data, 0) === 0) { this.bytesSeen = trailingBytesSeen(data) return b4a.toString(data, 'utf8') } let result = '' let start = 0 if (this.bytesNeeded > 0) { while (start < data.byteLength) { const byte = data[start] if (byte < this.lowerBoundary || byte > this.upperBoundary) { result += '\ufffd' this._reset() break } this.lowerBoundary = 0x80 this.upperBoundary = 0xbf this.codePoint = (this.codePoint << 6) | (byte & 0x3f) this.bytesSeen++ start++ if (this.bytesSeen === this.bytesNeeded) { result += String.fromCodePoint(this.codePoint) this._reset() break } } if (this.bytesNeeded > 0) return result } const trailing = trailingIncomplete(data, start) const end = data.byteLength - trailing if (end > start) result += b4a.toString(data, 'utf8', start, end) for (let i = end; i < data.byteLength; i++) { const byte = data[i] if (this.bytesNeeded === 0) { if (byte <= 0x7f) { this.bytesSeen = 0 result += String.fromCharCode(byte) } else if (byte >= 0xc2 && byte <= 0xdf) { this.bytesNeeded = 2 this.bytesSeen = 1 this.codePoint = byte & 0x1f } else if (byte >= 0xe0 && byte <= 0xef) { if (byte === 0xe0) this.lowerBoundary = 0xa0 else if (byte === 0xed) this.upperBoundary = 0x9f this.bytesNeeded = 3 this.bytesSeen = 1 this.codePoint = byte & 0xf } else if (byte >= 0xf0 && byte <= 0xf4) { if (byte === 0xf0) this.lowerBoundary = 0x90 else if (byte === 0xf4) this.upperBoundary = 0x8f this.bytesNeeded = 4 this.bytesSeen = 1 this.codePoint = byte & 0x7 } else { this.bytesSeen = 1 result += '\ufffd' } continue } if (byte < this.lowerBoundary || byte > this.upperBoundary) { result += '\ufffd' i-- this._reset() continue } this.lowerBoundary = 0x80 this.upperBoundary = 0xbf this.codePoint = (this.codePoint << 6) | (byte & 0x3f) this.bytesSeen++ if (this.bytesSeen === this.bytesNeeded) { result += String.fromCodePoint(this.codePoint) this._reset() } } return result } flush() { const result = this.bytesNeeded > 0 ? '\ufffd' : '' this._reset() return result } _reset() { this.codePoint = 0 this.bytesNeeded = 0 this.bytesSeen = 0 this.lowerBoundary = 0x80 this.upperBoundary = 0xbf } } function trailingIncomplete(data, start) { const len = data.byteLength if (len <= start) return 0 const limit = Math.max(start, len - 4) let i = len - 1 while (i > limit && (data[i] & 0xc0) === 0x80) i-- if (i < start) return 0 const byte = data[i] let needed if (byte <= 0x7f) return 0 if (byte >= 0xc2 && byte <= 0xdf) needed = 2 else if (byte >= 0xe0 && byte <= 0xef) needed = 3 else if (byte >= 0xf0 && byte <= 0xf4) needed = 4 else return 0 const available = len - i return available < needed ? available : 0 } function trailingBytesSeen(data) { const len = data.byteLength if (len === 0) return 0 const last = data[len - 1] if (last <= 0x7f) return 0 if ((last & 0xc0) !== 0x80) return 1 const limit = Math.max(0, len - 4) let i = len - 2 while (i >= limit && (data[i] & 0xc0) === 0x80) i-- if (i < 0) return 1 const first = data[i] let needed if (first >= 0xc2 && first <= 0xdf) needed = 2 else if (first >= 0xe0 && first <= 0xef) needed = 3 else if (first >= 0xf0 && first <= 0xf4) needed = 4 else return 1 if (len - i !== needed) return 1 if (needed >= 3) { const second = data[i + 1] if (first === 0xe0 && second < 0xa0) return 1 if (first === 0xed && second > 0x9f) return 1 if (first === 0xf0 && second < 0x90) return 1 if (first === 0xf4 && second > 0x8f) return 1 } return 0 } { "name": "text-decoder", "version": "1.2.7", "description": "Streaming text decoder that preserves multibyte Unicode characters", "exports": { "./package": "./package.json", ".": "./index.js" }, "files": [ "index.js", "lib" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "git+https://github.com/holepunchto/text-decoder.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/text-decoder/issues" }, "homepage": "https://github.com/holepunchto/text-decoder#readme", "dependencies": { "b4a": "^1.6.4" }, "devDependencies": { "brittle": "^3.3.2", "lunte": "^1.3.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^1.0.0" } } const b4a = require('b4a') unslab.all = all unslab.is = is module.exports = unslab function unslab (buf) { if (buf === null || buf.buffer.byteLength === buf.byteLength) return buf const copy = b4a.allocUnsafeSlow(buf.byteLength) copy.set(buf, 0) return copy } function is (buf) { return buf.buffer.byteLength !== buf.byteLength } function all (list) { let size = 0 for (let i = 0; i < list.length; i++) { const buf = list[i] size += buf === null || buf.buffer.byteLength === buf.byteLength ? 0 : buf.byteLength } const copy = b4a.allocUnsafeSlow(size) const result = new Array(list.length) let offset = 0 for (let i = 0; i < list.length; i++) { let buf = list[i] if (buf !== null && buf.buffer.byteLength !== buf.byteLength) { copy.set(buf, offset) buf = copy.subarray(offset, offset += buf.byteLength) } result[i] = buf } return result } { "name": "unslab", "version": "1.3.0", "description": "Unslab some slab'ed buffers", "main": "index.js", "files": [ "index.js" ], "dependencies": { "b4a": "^1.6.6" }, "devDependencies": { "brittle": "^3.5.2", "standard": "^17.1.0" }, "scripts": { "test": "standard && brittle test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/unslab.git" }, "author": "Holepunch", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/unslab/issues" }, "homepage": "https://github.com/holepunchto/unslab" } module.exports = read var MSB = 0x80 , REST = 0x7F function read(buf, offset) { var res = 0 , offset = offset || 0 , shift = 0 , counter = offset , b , l = buf.length do { if (counter >= l) { read.bytes = 0 throw new RangeError('Could not decode varint') } b = buf[counter++] res += shift < 28 ? (b & REST) << shift : (b & REST) * Math.pow(2, shift) shift += 7 } while (b >= MSB) read.bytes = counter - offset return res } module.exports = encode var MSB = 0x80 , REST = 0x7F , MSBALL = ~REST , INT = Math.pow(2, 31) function encode(num, out, offset) { out = out || [] offset = offset || 0 var oldOffset = offset while(num >= INT) { out[offset++] = (num & 0xFF) | MSB num /= 128 } while(num & MSBALL) { out[offset++] = (num & 0xFF) | MSB num >>>= 7 } out[offset] = num | 0 encode.bytes = offset - oldOffset + 1 return out } module.exports = { encode: require('./encode.js') , decode: require('./decode.js') , encodingLength: require('./length.js') } var N1 = Math.pow(2, 7) var N2 = Math.pow(2, 14) var N3 = Math.pow(2, 21) var N4 = Math.pow(2, 28) var N5 = Math.pow(2, 35) var N6 = Math.pow(2, 42) var N7 = Math.pow(2, 49) var N8 = Math.pow(2, 56) var N9 = Math.pow(2, 63) module.exports = function (value) { return ( value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10 ) } { "name": "varint", "version": "5.0.0", "description": "protobuf-style varint bytes - use msb to create integer values of varying sizes", "main": "index.js", "scripts": { "test": "node test.js" }, "repository": { "type": "git", "url": "git://github.com/chrisdickinson/varint.git" }, "keywords": [ "varint", "protobuf", "encode", "decode" ], "author": "Chris Dickinson ", "license": "MIT", "devDependencies": { "tape": "~2.12.3" } } const { runtime, platform, arch, version } = typeof Bare !== 'undefined' ? { runtime: 'bare', platform: global.Bare.platform, arch: global.Bare.arch, version: global.Bare.version } : typeof process !== 'undefined' ? { runtime: 'node', platform: global.process.platform, arch: global.process.arch, version: global.process.version } : typeof Window !== 'undefined' ? { runtime: 'browser', platform: 'unknown', arch: 'unknown', version: 'unknown' } : { runtime: 'unknown', platform: 'unknown', arch: 'unknown', version: 'unknown' } exports.runtime = runtime exports.version = version exports.platform = platform exports.arch = arch exports.isBare = runtime === 'bare' exports.isBareKit = exports.isBare && typeof BareKit !== 'undefined' exports.isPear = typeof Pear !== 'undefined' exports.isNode = runtime === 'node' exports.isBrowser = runtime === 'browser' exports.isWindows = platform === 'win32' exports.isLinux = platform === 'linux' exports.isMac = platform === 'darwin' exports.isIOS = platform === 'ios' || platform === 'ios-simulator' exports.isAndroid = platform === 'android' exports.isElectron = typeof process !== 'undefined' && !!global.process.versions?.electron exports.isElectronRenderer = exports.isElectron && global.process.type === 'renderer' exports.isElectronWorker = exports.isElectron && global.process.type === 'worker' { "name": "which-runtime", "version": "1.4.0", "description": "Detect if you are in Bare or Node and which os etc", "main": "index.js", "files": [ "index.js" ], "scripts": { "format": "prettier --write .", "lint": "prettier --check . && lunte .", "test": "npm run test:node && npm run test:bare", "test:node": "brittle-node test.js", "test:bare": "brittle-bare test.js" }, "repository": { "type": "git", "url": "https://github.com/holepunchto/which-runtime.git" }, "author": "Holepunch Inc.", "license": "Apache-2.0", "bugs": { "url": "https://github.com/holepunchto/which-runtime/issues" }, "homepage": "https://github.com/holepunchto/which-runtime", "devDependencies": { "brittle": "^3.0.0", "lunte": "^1.4.0", "prettier": "^3.6.2", "prettier-config-holepunch": "^2.0.0" } } const b4a = require('b4a') const ALPHABET = 'ybndrfg8ejkmcpqxot1uwisza345h769' const MIN = 0x31 // 1 const MAX = 0x7a // z const REVERSE = new Int8Array(1 + MAX - MIN) REVERSE.fill(-1) for (let i = 0; i < ALPHABET.length; i++) { const v = ALPHABET.charCodeAt(i) - MIN REVERSE[v] = i } exports.encode = encode exports.decode = decode exports.ALPHABET = ALPHABET function decode (s, out) { let pb = 0 let ps = 0 const r = s.length & 7 const q = (s.length - r) / 8 if (!out) out = b4a.allocUnsafe(Math.ceil(s.length * 5 / 8)) // 0 5 2 7 4 1 6 3 (+5 mod 8) for (let i = 0; i < q; i++) { const a = quintet(s, ps++) const b = quintet(s, ps++) const c = quintet(s, ps++) const d = quintet(s, ps++) const e = quintet(s, ps++) const f = quintet(s, ps++) const g = quintet(s, ps++) const h = quintet(s, ps++) out[pb++] = (a << 3) | (b >>> 2) out[pb++] = ((b & 0b11) << 6) | (c << 1) | (d >>> 4) out[pb++] = ((d & 0b1111) << 4) | (e >>> 1) out[pb++] = ((e & 0b1) << 7) | (f << 2) | (g >>> 3) out[pb++] = ((g & 0b111) << 5) | h } if (r === 0) return out.subarray(0, pb) const a = quintet(s, ps++) const b = quintet(s, ps++) out[pb++] = (a << 3) | (b >>> 2) if (r <= 2) return out.subarray(0, pb) const c = quintet(s, ps++) const d = quintet(s, ps++) out[pb++] = ((b & 0b11) << 6) | (c << 1) | (d >>> 4) if (r <= 4) return out.subarray(0, pb) const e = quintet(s, ps++) out[pb++] = ((d & 0b1111) << 4) | (e >>> 1) if (r <= 5) return out.subarray(0, pb) const f = quintet(s, ps++) const g = quintet(s, ps++) out[pb++] = ((e & 0b1) << 7) | (f << 2) | (g >>> 3) if (r <= 7) return out.subarray(0, pb) const h = quintet(s, ps++) out[pb++] = ((g & 0b111) << 5) | h return out.subarray(0, pb) } function encode (buf) { if (typeof buf === 'string') buf = b4a.from(buf) const max = buf.byteLength * 8 let s = '' for (let p = 0; p < max; p += 5) { const i = p >>> 3 const j = p & 7 if (j <= 3) { s += ALPHABET[(buf[i] >>> (3 - j)) & 0b11111] continue } const of = j - 3 const h = (buf[i] << of) & 0b11111 const l = (i >= buf.byteLength ? 0 : buf[i + 1]) >>> (8 - of) s += ALPHABET[h | l] } return s } function quintet (s, i) { if (i > s.length) { return 0 } const v = s.charCodeAt(i) if (v < MIN || v > MAX) { throw Error('Invalid character in base32 input: "' + s[i] + '" at position ' + i) } const bits = REVERSE[v - MIN] if (bits === -1) { throw Error('Invalid character in base32 input: "' + s[i] + '" at position ' + i) } return bits } { "name": "z32", "version": "1.1.0", "description": "Encode & decode z-base32", "main": "index.js", "dependencies": { "b4a": "^1.5.3" }, "devDependencies": { "base-x": "^4.0.0", "base32": "0.0.7", "brittle": "^3.1.3", "nanobench": "^3.0.0", "rfc4648": "^1.5.2", "standard": "^17.0.0" }, "repository": { "type": "git", "url": "https://github.com/mafintosh/z32.git" }, "scripts": { "test": "standard && brittle test.js", "bench": "node benchmark.js" }, "author": "Mathias Buus (@mafintosh)", "license": "MIT", "bugs": { "url": "https://github.com/mafintosh/z32/issues" }, "homepage": "https://github.com/mafintosh/z32" } { "name": "hyper-overlay", "version": "0.3.13", "description": "Content-addressed P2P file distribution over Protomux — FastCDC chunking, multi-source fetch, resumable transfers, zero blob duplication. Files live on disk; the overlay is a thin index and transfer protocol.", "type": "module", "main": "index.js", "imports": { "#fs": { "bare": "bare-fs", "default": "fs" }, "#path": { "bare": "bare-path", "default": "path" }, "#os": { "bare": "bare-os", "default": "os" }, "#zlib": { "bare": "bare-zlib", "default": "zlib" } }, "exports": { ".": "./index.js", "./overlay": "./lib/overlay.js", "./protocol": "./lib/protocol.js", "./messages": "./lib/messages.js", "./chunker": "./lib/chunker.js", "./chunk-scheduler": "./lib/chunk-scheduler.js", "./transfer": "./lib/transfer.js", "./file-index": "./lib/file-index.js", "./sync-engine": "./lib/sync-engine.js", "./tree": "./lib/tree.js", "./pointer": "./lib/pointer.js", "./ignore": "./lib/ignore.js", "./manifest": "./lib/manifest.js", "./package.json": "./package.json" }, "scripts": { "test": "brittle-bare test/*.test.js test/integration/*.test.js", "test:node": "brittle-node test/*.test.js" }, "engines": { "bare": ">=1.16.0" }, "license": "AGPL-3.0", "keywords": [ "p2p", "hypercore", "hyperbee", "protomux", "overlay", "content-addressed", "deduplication", "file-transfer", "fastcdc", "chunking", "multi-source", "resumable", "bare" ], "dependencies": { "b4a": "^1.0.0", "bare-fs": "^4.7.2", "bare-os": "^3.8.7", "bare-path": "^3.0.0", "bare-zlib": "^1.3.3", "compact-encoding": "^3.2.0", "corestore": "^7.0.0", "hyperbee": "^2.0.0", "hypercore-crypto": "^3.0.0", "protomux": "^3.0.0", "ready-resource": "^1.0.0", "sodium-universal": "^5.0.1", "streamx": "^2.0.0" }, "devDependencies": { "brittle": "^3.0.0", "hyperswarm": "^4.0.0", "@hyperswarm/testnet": "^3.1.4" } } /** * hyper-svc — reusable per-app daemon library * * RPC transports: UDS, HTTP, and Hyperswarm (Protomux channel). * Replication: Hyperswarm topic join + corestore/autobase/mux replicate. */ export { Service } from './lib/service.js' export { Client } from './lib/client.js' export { encodeFrame, FrameDecoder } from './lib/frame.js' export { attachRpcServer, attachRpcClient } from './lib/transports/swarm-rpc.js' /** * Client — RPC client for hyper-svc daemons. * * Local-only. Connects via UDS (preferred) or HTTP. Both transports speak the * same JSON-RPC-ish protocol; the wire format differs (length-prefixed frames * for UDS, POST /rpc/ for HTTP) but the call signature is identical. * * Discovery: try UDS first (if a path is provided and the socket is reachable), * fall back to HTTP. Explicit transport selection is also supported. * * Usage: * * const client = await Client.discover({ * uds: '/tmp/pear-git.sock', * http: 'http://127.0.0.1:4040' * }) * * const orgs = await client.call('list-orgs', { limit: 10 }) * * await client.close() */ import http from '#node:http' import { URL } from '#node:url' import b4a from 'b4a' import { stat } from '#node:fs/promises' import { udsBackend } from './uds-backend.js' import Hyperswarm from 'hyperswarm' import Protomux from 'protomux' import crypto from 'hypercore-crypto' import { encodeFrame, FrameDecoder } from './frame.js' import { attachRpcClient } from './transports/swarm-rpc.js' export class Client { /** * Discover and connect to a running hyper-svc daemon. * * @param {object} opts * @param {string} [opts.uds] - UDS socket path. Tried first. * @param {string} [opts.http] - HTTP base URL (e.g. 'http://127.0.0.1:4040'). Fallback. * @param {'uds'|'http'} [opts.prefer] - explicit override * @returns {Promise} */ static async discover (opts = {}) { const prefer = opts.prefer if (prefer === 'uds') { if (!opts.uds) throw new Error('discover({ prefer: "uds" }) requires opts.uds') return Client.connectUds(opts.uds) } if (prefer === 'http') { if (!opts.http) throw new Error('discover({ prefer: "http" }) requires opts.http') return Client.connectHttp(opts.http) } // Auto: UDS first if reachable, then HTTP if (opts.uds) { const reachable = await udsReachable(opts.uds) if (reachable) return Client.connectUds(opts.uds) } if (opts.http) { return Client.connectHttp(opts.http) } const tried = [] if (opts.uds) tried.push(`uds:${opts.uds}`) if (opts.http) tried.push(`http:${opts.http}`) throw new Error(`no daemon reachable (tried: ${tried.join(', ') || 'nothing — pass uds and/or http'})`) } static async connectUds (path) { const { backend, name } = await udsBackend(path) const sock = backend.createConnection(name) await new Promise((resolve, reject) => { sock.once('connect', () => { sock.removeListener('error', reject) resolve() }) sock.once('error', reject) }) return new Client({ kind: 'uds', sock }) } static connectHttp (base) { return new Client({ kind: 'http', base: base.replace(/\/+$/, '') }) } /** * Connect to a remote daemon via Hyperswarm. Joins the topic derived from * `serverKey`, waits for a connection, attaches a Protomux RPC channel, and * (when `opts.verify` is given) confirms the peer that answered is the one * that was asked for. * * ⚠ `serverKey` IS NOT AN IDENTITY — IT IS ONLY A RENDEZVOUS ADDRESS. * * The topic is `hash(serverKey + salt)`, and SwarmTransport.listen() creates * its Hyperswarm with NO keyPair, so a server's Noise key is random per * process and never equals the `serverKey` clients use to find it. Anything * joined to that topic as a server can therefore answer, and there is no * cryptographic binding to check `conn.remotePublicKey` against. * * That is not hypothetical. In a pear-git-v3 fleet, a mirror joins its * ORIGIN's topic (the topic travels in the deployment bundle), so it is a * server on the exact topic clients use to reach the origin. Measured * 2026-08-08: `connectSwarm({serverKey: })` issued ON stortron was * answered by STORTRON ITSELF 6 times out of 6. It asked itself for the * origin's release index, got its own, and every artifact fetch then failed * with "no holder" — a wrong ANSWER, not a transport error, so nothing looked * broken. resync-from-origin on the same path hung twice for 300 s. * * `opts.verify` closes that hole at the application layer, where identity * actually lives. It receives a connected Client and returns truthy to accept. * Rejected peers are destroyed and the wait continues until `timeout`, so a * caller reaches the intended daemon or fails loudly, never silently talks to * the wrong one. It is layered as a callback rather than a built-in `status` * check because hyper-svc is generic — which handler proves identity is the * consumer's business, and this stays compatible with servers of any version. * * @param {object} opts * @param {string|Buffer} opts.serverKey - rendezvous key; derives the topic * @param {string} [opts.topicSalt='pear-git-v3'] - salt for topic derivation * @param {object} [opts.swarm] - Hyperswarm constructor options (e.g. testnet bootstrap) * @param {number} [opts.timeout=30000] - total ms to find an ACCEPTED peer * @param {(client: Client) => Promise} [opts.verify] - identity gate * @returns {Promise} */ static async connectSwarm (opts = {}) { if (!opts.serverKey) throw new Error('connectSwarm requires opts.serverKey') const serverKey = typeof opts.serverKey === 'string' ? b4a.from(opts.serverKey, 'hex') : opts.serverKey const salt = opts.topicSalt || 'pear-git-v3' const topic = crypto.hash(b4a.concat([serverKey, b4a.from(salt)])) const timeout = opts.timeout || 30_000 const verify = typeof opts.verify === 'function' ? opts.verify : null const swarm = new Hyperswarm(opts.swarm || {}) const discovery = swarm.join(topic, { server: false, client: true }) let rejected = 0 let client = null try { client = await new Promise((resolve, reject) => { let settled = false // NOTE: onConnection stays attached for the swarm's whole life — it is // deliberately NOT removed here. Connections can still arrive after a // peer is accepted, and a NoiseSecretStream with no 'error' listener // throws on reset, so detaching left later arrivals unguarded and // crashed the process at teardown with ECONNRESET. The listener dies // with the swarm when the returned Client is closed. const finish = (fn, arg) => { if (settled) return settled = true clearTimeout(timer) fn(arg) } const timer = setTimeout(() => { finish(reject, new Error('swarm-rpc: connection timeout' + (rejected ? ' (' + rejected + ' peer(s) answered but failed verification — ' + 'the requested serverKey is a topic, not an identity, so other peers on ' + 'that topic can answer)' : ''))) }, timeout) const onConnection = (c) => { // Routine, and load-bearing: a NoiseSecretStream with no 'error' // listener throws on ECONNRESET, and this path DESTROYS connections // by design (every peer that fails verification, plus any that arrive // after one is accepted). Without this the first rejected peer takes // the whole process down. SwarmTransport._onConnection takes the same // posture server-side. c.on('error', () => {}) if (settled) { try { c.destroy() } catch {} ; return } const candidate = new Client({ kind: 'swarm', swarm, conn: c, rpc: attachRpcClient(Protomux.from(c)) }) if (!verify) return finish(resolve, candidate) // Verified off the critical path: keep listening while this runs, so a // slow or lying peer cannot stall a good one behind it. Promise.resolve() .then(() => verify(candidate)) .then((ok) => { if (ok) return finish(resolve, candidate) rejected++ try { c.destroy() } catch {} }) .catch(() => { rejected++ try { c.destroy() } catch {} }) } swarm.on('connection', onConnection) discovery.flushed().catch((err) => finish(reject, err)) }) } catch (err) { // Destroy the swarm on EVERY failure path. It used to be left running: a // Hyperswarm holds the event loop open, so each failed connect leaked one // and the process never exited. That is what hung pear-git-v3's // basic.test.js when a mirror's origin was unreachable — 123/123 tests // passed, then the run never terminated. try { await swarm.destroy() } catch {} throw err } return client } constructor (opts) { this._kind = opts.kind this._sock = opts.sock || null this._base = opts.base || null this._swarm = opts.swarm || null this._conn = opts.conn || null this._rpc = opts.rpc || null this._closed = false // UDS pending request map (id → {resolve, reject}) this._pending = new Map() this._nextId = 1 if (this._kind === 'uds') { this._decoder = new FrameDecoder((frame) => this._onFrame(frame)) this._sock.on('data', (chunk) => { try { this._decoder.push(chunk) } catch (err) { this._failAll(err) this._down() } }) // EVENT-DRIVEN disconnect detection (fleet reconciliation contract). When the peer daemon // restarts (the common case: an OTA/`pgh app restart` of hpp/pgv3/etc.), the cached client's // socket dies. Previously 'close' only `_failAll`'d the pending map but NEVER set `_closed`, // and there was no 'end' handler at all — so `client.closed` stayed FALSE and long-lived // consumers (favela-web Writer, pgh sidecar lookups) kept handing back a DEAD client, whose // calls hang or reject "connection closed" forever with nothing to trigger a reconnect. Mark // the client CLOSED on close/end/error so `.closed` is truthy → consumers reconcile (reconnect // a fresh Client) on their next call. 'end' is load-bearing under bare-net (allowHalfOpen: on // peer-end it fires 'end' but not 'close'), so we destroy to force teardown — same posture as // the server-side half-open fix (hyper-svc 0.1.3). this._sock.on('close', () => this._down()) this._sock.on('end', () => this._down()) this._sock.on('error', () => this._down()) } } get kind () { return this._kind } get closed () { return this._closed } /** * Make an RPC call. Throws on transport errors or remote handler errors. * @param {string} method * @param {any} [params] */ async call (method, params = {}) { if (this._closed) throw new Error('client closed') if (this._kind === 'uds') return this._callUds(method, params) if (this._kind === 'http') return this._callHttp(method, params) if (this._kind === 'swarm') return this._rpc.call(method, params) throw new Error('unknown client kind: ' + this._kind) } _callUds (method, params) { const id = this._nextId++ return new Promise((resolve, reject) => { this._pending.set(id, { resolve, reject }) try { this._sock.write(encodeFrame({ id, method, params })) } catch (err) { this._pending.delete(id) reject(err) } }) } _onFrame (frame) { if (frame == null || (typeof frame.id !== 'number' && typeof frame.id !== 'string')) { // Malformed response, can't match it to a caller return } const pending = this._pending.get(frame.id) if (!pending) return this._pending.delete(frame.id) if (frame.error) { pending.reject(new Error(frame.error)) } else { pending.resolve(frame.result) } } _failAll (err) { for (const [, pending] of this._pending) pending.reject(err) this._pending.clear() } // The socket died (peer restarted / errored / half-open end). Mark the client CLOSED so any // consumer's `.closed` check reconnects, fail every in-flight call, and force teardown. Idempotent. _down () { if (this._closed) return this._closed = true this._failAll(new Error('connection closed')) if (this._sock) { try { this._sock.destroy() } catch {} } } async _callHttp (method, params) { const url = new URL(`${this._base}/rpc/${encodeURIComponent(method)}`) return new Promise((resolve, reject) => { const body = JSON.stringify(params) const req = http.request({ method: 'POST', hostname: url.hostname, port: url.port || 80, path: url.pathname + url.search, headers: { 'Content-Type': 'application/json', 'Content-Length': b4a.byteLength(body) } }, (res) => { const parts = [] res.on('data', (c) => parts.push(c)) res.on('end', () => { const text = b4a.concat(parts).toString('utf8') let parsed try { parsed = JSON.parse(text) } catch { return reject(new Error(`bad JSON response (status ${res.statusCode}): ${text.slice(0, 200)}`)) } if (res.statusCode >= 200 && res.statusCode < 300) { return resolve(parsed.result) } return reject(new Error(parsed.error || `HTTP ${res.statusCode}`)) }) res.on('error', reject) }) req.on('error', reject) req.write(body) req.end() }) } async close () { if (this._closed) return this._closed = true if (this._sock) { this._failAll(new Error('client closed')) try { this._sock.destroy() } catch {} this._sock = null } if (this._rpc) { try { this._rpc.close() } catch {} this._rpc = null } if (this._conn) { try { this._conn.destroy() } catch {} this._conn = null } if (this._swarm) { try { await this._swarm.destroy() } catch {} this._swarm = null } } } async function udsReachable (path) { const { backend, name, abstract } = await udsBackend(path) // Pathname sockets: verify the file exists and is actually a socket first. // Abstract sockets have no filesystem entry — skip straight to the connect probe. if (!abstract) { try { const s = await stat(path) if (!s.isSocket()) return false } catch { return false } } // Try a real connect — covers stale sockets where the daemon crashed return new Promise((resolve) => { const sock = backend.createConnection(name) sock.once('connect', () => { sock.destroy() resolve(true) }) sock.once('error', () => { sock.destroy() resolve(false) }) }) } /** * Length-prefixed JSON framing. * * Wire format: [4 bytes BE length][JSON payload]. * * One frame = one JSON object. Multiple frames can be pipelined on a single * stream — FrameDecoder handles incremental reads where a frame may arrive * across multiple data chunks. */ import b4a from 'b4a' const MAX_FRAME = 16 * 1024 * 1024 // 16 MiB hard cap to avoid runaway buffers export function encodeFrame (obj) { const json = JSON.stringify(obj) const payload = b4a.from(json, 'utf8') if (payload.length > MAX_FRAME) { throw new Error(`Frame too large: ${payload.length} > ${MAX_FRAME}`) } const frame = b4a.alloc(4 + payload.length) frame.writeUInt32BE(payload.length, 0) payload.copy(frame, 4) return frame } export class FrameDecoder { /** * @param {(obj: any) => void} onFrame - called once per complete frame */ constructor (onFrame) { if (typeof onFrame !== 'function') throw new Error('onFrame is required') this._onFrame = onFrame this._buf = b4a.alloc(0) } /** * Feed a chunk into the decoder. Calls onFrame for each complete frame. * Throws if a frame exceeds MAX_FRAME or contains invalid JSON. */ push (chunk) { this._buf = b4a.concat([this._buf, chunk]) while (this._buf.length >= 4) { const len = this._buf.readUInt32BE(0) if (len > MAX_FRAME) { throw new Error(`Frame too large: ${len} > ${MAX_FRAME}`) } if (this._buf.length < 4 + len) break // wait for more bytes const payload = this._buf.subarray(4, 4 + len) this._buf = this._buf.subarray(4 + len) const json = b4a.toString(payload, 'utf8') const obj = JSON.parse(json) // throws on bad JSON this._onFrame(obj) } } /** Number of bytes currently buffered (waiting for the rest of a frame). */ get pending () { return this._buf.length } } /** * Service — reusable per-app daemon library. * * One instance per app process. Owns: * - Generic RPC handler registry (svc.handle) * - Module mounts (svc.mount) with optional swarm replication * - UDS, HTTP, and Hyperswarm transport instances (whichever the consumer enables) * * The consumer's corestore is passed in (or one is implied via swarm.corestore). * The Service does NOT create or own storage — that's the app's job. * * Local-only RPC. Peers exchange data via swarm replication, never commands. * * Usage: * * const svc = new Service({ * name: 'pear-git', * corestore: store, * uds: '/tmp/pear-git.sock', * http: { port: 4040 }, * swarm: { topic: '...32 bytes hex...' } * }) * * svc.mount('orgs', new HyperOrgs(store, { namespace: 'orgs' })) * * svc.handle('list-orgs', async (ctx, params) => { * return svc.modules.orgs.list() * }) * * await svc.listen() */ import process from '#node:process' import ReadyResource from 'ready-resource' import { UdsServer } from './transports/uds.js' import { HttpServer } from './transports/http.js' import { SwarmTransport } from './transports/swarm.js' class NoSuchMethodError extends Error { constructor (method) { super(`unknown method: ${method}`) this.code = 'ENOMETHOD' } } class AnonymousDeniedError extends Error { constructor (method) { super(`anonymous access denied: ${method}`) this.code = 'EDENIED' this.status = 403 } } /** * Default "is this caller anonymous?" predicate. * * Deliberately conservative — anything that is not clearly an authenticated * caller counts as anonymous. Consumers whose ctx carries richer identity * (pear-git-v3 has four distinct shapes) should pass their own via * opts.isAnonymous rather than widen this one. */ function defaultIsAnonymous (ctx) { if (!ctx) return true if (ctx.transport === 'uds') return false // local operator holds the socket return !ctx.identity } export class Service extends ReadyResource { /** * @param {object} opts * @param {string} opts.name - service name (used for default UDS path, logging) * @param {object} [opts.corestore] - required if swarm transport is enabled * @param {string} [opts.uds] - UDS socket path. Pass null/undefined to disable. * @param {object} [opts.http] - HTTP transport options { port, host }. Disable by omitting. * @param {object} [opts.swarm] - Swarm options { topic, swarm? }. Disable by omitting. */ constructor (opts = {}) { super() if (!opts.name) throw new Error('Service requires opts.name') this._name = opts.name this._corestore = opts.corestore || null this._handlers = new Map() this._mounts = new Map() // Anonymous-dispatch policy (pear-git org #12). // // Every registered handler used to be callable by anyone, over HTTP and // over swarm-rpc, with no allowlist and no auth gate — so each new // svc.handle() was silently world-callable, and a daemon behind a public // reverse proxy exposed its entire RPC surface to the internet. // // Default stays 'allow' so the existing consumers (pear-git-v3, hypernote, // hyper-social-web, pgh-sidecar) are untouched until they opt in. Under // 'deny', a handler must declare `{ anonymous: true }` at registration to // be reachable by an unauthenticated caller. // // Opt-in at REGISTRATION rather than via a separate allowlist table: with // ~100 handlers a table drifts out of step with the handler set, whereas a // flag cannot. And the drift direction is safe — a handler nobody marked // is DENIED, which surfaces as a visible 403 rather than a silent hole. this._anonymousPolicy = opts.anonymousPolicy === 'deny' ? 'deny' : 'allow' this._isAnonymous = typeof opts.isAnonymous === 'function' ? opts.isAnonymous : defaultIsAnonymous // Called with ({ method, ctx }) whenever a dispatch is refused, so the // consumer can record denials alongside its own audit trail. this._onDeny = typeof opts.onDeny === 'function' ? opts.onDeny : null this._anonymousAllowed = new Set() this._udsOpt = opts.uds || null this._httpOpt = opts.http || null this._swarmOpt = opts.swarm || null this._uds = null this._http = null this._swarm = null if (this._swarmOpt && !this._corestore) { throw new Error('Service: swarm transport requires opts.corestore') } // Instantiate transports eagerly so apps can register HTTP routes, // grab the UDS path, etc., BEFORE calling listen(). const dispatch = (method, params, ctx) => this.dispatch(method, params, ctx) if (this._udsOpt) { this._uds = new UdsServer({ path: this._udsOpt, dispatch }) } if (this._httpOpt) { this._http = new HttpServer({ port: this._httpOpt.port, host: this._httpOpt.host, prefix: this._httpOpt.prefix, ctxFactory: this._httpOpt.ctxFactory, dispatch }) } if (this._swarmOpt) { this._swarm = new SwarmTransport({ topic: this._swarmOpt.topic, corestore: this._corestore, mounts: () => this._listMounts(), dispatch: this._swarmOpt.rpc !== false ? dispatch : null, swarm: this._swarmOpt.swarm, server: this._swarmOpt.server, client: this._swarmOpt.client }) } } // ── Properties ────────────────────────────────────────────── get name () { return this._name } get corestore () { return this._corestore } /** Read-only handle to the UDS transport (or null if disabled). */ get uds () { return this._uds } /** Read-only handle to the HTTP transport (or null if disabled). */ get http () { return this._http } /** Read-only handle to the swarm transport (or null if disabled). */ get swarm () { return this._swarm } /** * Mounted modules, accessible by name. Use `svc.modules.orgs` after * `svc.mount('orgs', orgsInstance)`. */ get modules () { // Lazily build a property-style accessor object on top of the map if (!this._modulesProxy) { const map = this._mounts this._modulesProxy = new Proxy({}, { get (_target, prop) { const m = map.get(prop) return m ? m.instance : undefined }, has (_target, prop) { return map.has(prop) }, ownKeys () { return Array.from(map.keys()) }, getOwnPropertyDescriptor (_target, prop) { if (map.has(prop)) { return { enumerable: true, configurable: true, value: map.get(prop).instance } } } }) } return this._modulesProxy } /** Map iteration: list mount entries as { name, instance }. */ _listMounts () { const out = [] for (const [name, m] of this._mounts) out.push({ name, instance: m.instance }) return out } // ── Registration ──────────────────────────────────────────── /** * Register an RPC handler. The handler is invoked from any RPC transport * with `(ctx, params)` and should return a JSON-serializable result. * * @param {string} name - method name (e.g. "list-orgs") * @param {(ctx: object, params: any) => Promise|any} fn */ handle (name, fn, opts = {}) { if (typeof name !== 'string' || !name) throw new Error('handle requires a name') if (typeof fn !== 'function') throw new Error('handle requires a function') if (this._handlers.has(name)) throw new Error(`handler "${name}" already registered`) this._handlers.set(name, fn) // `anonymous: true` opts this method IN to unauthenticated dispatch when // the service runs anonymousPolicy: 'deny'. Absent = denied, which is the // safe default for a handler nobody has classified yet. if (opts && opts.anonymous === true) this._anonymousAllowed.add(name) } /** Is this method callable by an unauthenticated caller? */ allowsAnonymous (name) { return this._anonymousAllowed.has(name) } /** Methods explicitly opted in to anonymous dispatch, sorted. */ listAnonymous () { return Array.from(this._anonymousAllowed).sort() } /** Whether a handler is registered. */ hasHandler (name) { return this._handlers.has(name) } /** List registered handler names. */ listHandlers () { return Array.from(this._handlers.keys()).sort() } /** * Mount a module instance. Modules are accessible via `svc.modules.`. * If the module exposes a `.base` (Autobase consumer) and the swarm * transport is enabled, the base is replicated on every swarm connection. * * @param {string} name * @param {object} instance */ mount (name, instance) { if (typeof name !== 'string' || !name) throw new Error('mount requires a name') if (!instance) throw new Error('mount requires an instance') if (this._mounts.has(name)) throw new Error(`mount "${name}" already registered`) this._mounts.set(name, { instance }) } /** Whether a module is mounted. */ hasMount (name) { return this._mounts.has(name) } /** List mounted module names. */ listMounts () { return Array.from(this._mounts.keys()).sort() } // ── Dispatch ──────────────────────────────────────────────── /** * Dispatch a method call to its handler. Used by all RPC transports. * Throws NoSuchMethodError (code: 'ENOMETHOD') if the method isn't registered. */ async dispatch (method, params, ctx) { const handler = this._handlers.get(method) if (!handler) throw new NoSuchMethodError(method) // Anonymous gate (#12). Runs for EVERY transport, because the surface was // open on all of them — HTTP via a public reverse proxy, and swarm-rpc to // any peer that knows the topic. // // Ordered after the ENOMETHOD check on purpose: an unknown method should // still say so, otherwise the gate turns every typo into a 403 and makes // the API undebuggable. It leaks only which method names exist, which the // handler list already exposes. if (this._anonymousPolicy === 'deny' && !this._anonymousAllowed.has(method)) { let anon = true try { anon = this._isAnonymous(ctx) } catch { anon = true // a predicate that throws must fail CLOSED } if (anon) { if (this._onDeny) { try { this._onDeny({ method, ctx, reason: 'anonymous' }) } catch {} } throw new AnonymousDeniedError(method) } } return handler(ctx || {}, params) } // ── Lifecycle ─────────────────────────────────────────────── async _open () { if (this._uds) await this._uds.listen() if (this._http) await this._http.listen() if (this._swarm) await this._swarm.listen() } /** * Alias for `ready()` — feels more natural for a daemon ("start listening"). */ async listen () { await this.ready() } async _close () { const errors = [] if (this._swarm) try { await this._swarm.close() } catch (e) { errors.push(e) } if (this._http) try { await this._http.close() } catch (e) { errors.push(e) } if (this._uds) try { await this._uds.close() } catch (e) { errors.push(e) } this._swarm = null this._http = null this._uds = null if (errors.length) { const msg = errors.map(e => e.message).join('; ') throw new Error('Service close errors: ' + msg) } } } /** * HTTP transport for hyper-svc. * * Local-only RPC. Browsers (or curl, or any HTTP client) on the same machine * POST a JSON body to /rpc/ and receive a JSON response. * * Wire protocol: * POST /rpc/ * Content-Type: application/json * { ...params... } * * → 200 application/json { result: ... } * 400 application/json { error: ... } (bad request / handler threw) * 404 application/json { error: 'unknown method' } * * Other routes are NOT handled by hyper-svc — apps wire their own SSR pages * via the underlying http.Server (exposed as `.server` on this class). Any * request not matching POST /rpc/ falls through to user-registered * 'request' listeners or, if none, returns 404. */ import http from '#node:http' import b4a from 'b4a' export class HttpServer { /** * @param {object} opts * @param {number} [opts.port=0] - 0 = random port * @param {string} [opts.host='127.0.0.1'] - bind address (local-only by default) * @param {string} [opts.prefix=''] - URL prefix to strip before matching /rpc/* (e.g. '/git') * @param {(method: string, params: any, ctx: object) => Promise} opts.dispatch - request handler */ constructor (opts = {}) { if (typeof opts.dispatch !== 'function') throw new Error('HttpServer requires opts.dispatch') this._port = opts.port || 0 this._host = opts.host || '127.0.0.1' this._dispatch = opts.dispatch // Optional URL prefix (e.g. '/git') stripped before matching /rpc/*. Set // when the daemon is reverse-proxied OR accessed directly under a path // prefix that the browser bakes into outgoing fetch URLs. Without this, // direct (non-proxied) hits to `//rpc/*` fall through both // hyper-svc's listener (which only matches '/rpc/') and the consumer's // listener (which strips the prefix and skips '/rpc/' assuming hyper-svc // already handled it) — neither responds and the request hangs. this._prefix = normalizePrefix(opts.prefix) // Optional consumer-provided ctx builder. Called per /rpc/* request to // populate fields like identity from request headers/cookies. Receives // (req) and may return either an object or a Promise

Claim this favela

Sign in

People

Handles

Posts

Replies

Graph

Explore

Asking to join

Members

' + esc(title) + '

@' + esc(p.handle) + '

' + esc(p.name) + '

no published name

Handle

Handle

Namespaces this node holds

Nodes asking to carry this log

Unspent invites

Namespace

Appearance

Publishing

App updates

Settings

Welcome to favela

Create a new identity

I already have a recovery phrase

Link this device to another

Identity restored

Write these words down

Nobody here yet

People here

Status

This node

Namespace

Feeds

Updates