wherdr 0.0.0-stage → 1.2.0

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/ip_converter.js

@@ -0,0 +1,173 @@
+import { hex } from "@peculiar/utils/encoding";
+export class IpConverter {
+    static isIPv4(ip) {
+        return /^(\d{1,3}\.){3}\d{1,3}$/.test(ip);
+    }
+    static parseIPv4(ip) {
+        const parts = ip.split(".");
+        if (parts.length !== 4) {
+            throw new Error("Invalid IPv4 address");
+        }
+        return parts.map((part) => {
+            const num = parseInt(part, 10);
+            if (isNaN(num) || num < 0 || num > 255) {
+                throw new Error("Invalid IPv4 address part");
+            }
+            return num;
+        });
+    }
+    static parseIPv6(ip) {
+        const expandedIP = this.expandIPv6(ip);
+        const parts = expandedIP.split(":");
+        if (parts.length !== 8) {
+            throw new Error("Invalid IPv6 address");
+        }
+        return parts.reduce((bytes, part) => {
+            const num = parseInt(part, 16);
+            if (isNaN(num) || num < 0 || num > 0xffff) {
+                throw new Error("Invalid IPv6 address part");
+            }
+            bytes.push((num >> 8) & 0xff);
+            bytes.push(num & 0xff);
+            return bytes;
+        }, []);
+    }
+    static expandIPv6(ip) {
+        if (!ip.includes("::")) {
+            return ip;
+        }
+        const parts = ip.split("::");
+        if (parts.length > 2) {
+            throw new Error("Invalid IPv6 address");
+        }
+        const left = parts[0] ? parts[0].split(":") : [];
+        const right = parts[1] ? parts[1].split(":") : [];
+        const missing = 8 - (left.length + right.length);
+        if (missing < 0) {
+            throw new Error("Invalid IPv6 address");
+        }
+        return [...left, ...Array(missing).fill("0"), ...right].join(":");
+    }
+    static formatIPv6(bytes) {
+        const parts = [];
+        for (let i = 0; i < 16; i += 2) {
+            parts.push(((bytes[i] << 8) | bytes[i + 1]).toString(16));
+        }
+        return this.compressIPv6(parts.join(":"));
+    }
+    static compressIPv6(ip) {
+        const parts = ip.split(":");
+        let longestZeroStart = -1;
+        let longestZeroLength = 0;
+        let currentZeroStart = -1;
+        let currentZeroLength = 0;
+        for (let i = 0; i < parts.length; i++) {
+            if (parts[i] === "0") {
+                if (currentZeroStart === -1) {
+                    currentZeroStart = i;
+                }
+                currentZeroLength++;
+            }
+            else {
+                if (currentZeroLength > longestZeroLength) {
+                    longestZeroStart = currentZeroStart;
+                    longestZeroLength = currentZeroLength;
+                }
+                currentZeroStart = -1;
+                currentZeroLength = 0;
+            }
+        }
+        if (currentZeroLength > longestZeroLength) {
+            longestZeroStart = currentZeroStart;
+            longestZeroLength = currentZeroLength;
+        }
+        if (longestZeroLength > 1) {
+            const before = parts.slice(0, longestZeroStart).join(":");
+            const after = parts.slice(longestZeroStart + longestZeroLength).join(":");
+            return `${before}::${after}`;
+        }
+        return ip;
+    }
+    static parseCIDR(text) {
+        const [addr, prefixStr] = text.split("/");
+        const prefix = parseInt(prefixStr, 10);
+        if (this.isIPv4(addr)) {
+            if (prefix < 0 || prefix > 32) {
+                throw new Error("Invalid IPv4 prefix length");
+            }
+            return [this.parseIPv4(addr), prefix];
+        }
+        else {
+            if (prefix < 0 || prefix > 128) {
+                throw new Error("Invalid IPv6 prefix length");
+            }
+            return [this.parseIPv6(addr), prefix];
+        }
+    }
+    static decodeIP(value) {
+        if (value.length === 64 && parseInt(value, 16) === 0) {
+            return "::/0";
+        }
+        if (value.length !== 16) {
+            return value;
+        }
+        const mask = parseInt(value.slice(8), 16)
+            .toString(2)
+            .split("")
+            .reduce((a, k) => a + +k, 0);
+        let ip = value.slice(0, 8).replace(/(.{2})/g, (match) => `${parseInt(match, 16)}.`);
+        ip = ip.slice(0, -1);
+        return `${ip}/${mask}`;
+    }
+    static toString(buf) {
+        const uint8 = new Uint8Array(buf);
+        if (uint8.length === 4) {
+            return Array.from(uint8).join(".");
+        }
+        if (uint8.length === 16) {
+            return this.formatIPv6(uint8);
+        }
+        if (uint8.length === 8 || uint8.length === 32) {
+            const half = uint8.length / 2;
+            const addrBytes = uint8.slice(0, half);
+            const maskBytes = uint8.slice(half);
+            const isAllZeros = uint8.every((byte) => byte === 0);
+            if (isAllZeros) {
+                return uint8.length === 8 ? "0.0.0.0/0" : "::/0";
+            }
+            const prefixLen = maskBytes.reduce((a, b) => a + (b.toString(2).match(/1/g) || []).length, 0);
+            if (uint8.length === 8) {
+                const addrStr = Array.from(addrBytes).join(".");
+                return `${addrStr}/${prefixLen}`;
+            }
+            else {
+                const addrStr = this.formatIPv6(addrBytes);
+                return `${addrStr}/${prefixLen}`;
+            }
+        }
+        return this.decodeIP(hex.encode(buf));
+    }
+    static fromString(text) {
+        if (text.includes("/")) {
+            const [addr, prefix] = this.parseCIDR(text);
+            const maskBytes = new Uint8Array(addr.length);
+            let bitsLeft = prefix;
+            for (let i = 0; i < maskBytes.length; i++) {
+                if (bitsLeft >= 8) {
+                    maskBytes[i] = 0xff;
+                    bitsLeft -= 8;
+                }
+                else if (bitsLeft > 0) {
+                    maskBytes[i] = 0xff << (8 - bitsLeft);
+                    bitsLeft = 0;
+                }
+            }
+            const out = new Uint8Array(addr.length * 2);
+            out.set(addr, 0);
+            out.set(maskBytes, addr.length);
+            return out.buffer;
+        }
+        const bytes = this.isIPv4(text) ? this.parseIPv4(text) : this.parseIPv6(text);
+        return new Uint8Array(bytes).buffer;
+    }
+}

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/name.js

@@ -0,0 +1,106 @@
+var RelativeDistinguishedName_1, RDNSequence_1, Name_1;
+import { __decorate } from "tslib";
+import { AsnProp, AsnPropTypes, AsnType, AsnTypeTypes, AsnArray } from "@peculiar/asn1-schema";
+import { hex } from "@peculiar/utils/encoding";
+let DirectoryString = class DirectoryString {
+    teletexString;
+    printableString;
+    universalString;
+    utf8String;
+    bmpString;
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+    toString() {
+        return this.bmpString || this.printableString || this.teletexString || this.universalString || this.utf8String || "";
+    }
+};
+__decorate([
+    AsnProp({ type: AsnPropTypes.TeletexString })
+], DirectoryString.prototype, "teletexString", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.PrintableString })
+], DirectoryString.prototype, "printableString", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.UniversalString })
+], DirectoryString.prototype, "universalString", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Utf8String })
+], DirectoryString.prototype, "utf8String", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.BmpString })
+], DirectoryString.prototype, "bmpString", void 0);
+DirectoryString = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], DirectoryString);
+export { DirectoryString };
+let AttributeValue = class AttributeValue extends DirectoryString {
+    ia5String;
+    anyValue;
+    constructor(params = {}) {
+        super(params);
+        Object.assign(this, params);
+    }
+    toString() {
+        return this.ia5String || (this.anyValue ? hex.encode(this.anyValue) : super.toString());
+    }
+};
+__decorate([
+    AsnProp({ type: AsnPropTypes.IA5String })
+], AttributeValue.prototype, "ia5String", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.Any })
+], AttributeValue.prototype, "anyValue", void 0);
+AttributeValue = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], AttributeValue);
+export { AttributeValue };
+export class AttributeTypeAndValue {
+    type = "";
+    value = new AttributeValue();
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AsnPropTypes.ObjectIdentifier })
+], AttributeTypeAndValue.prototype, "type", void 0);
+__decorate([
+    AsnProp({ type: AttributeValue })
+], AttributeTypeAndValue.prototype, "value", void 0);
+let RelativeDistinguishedName = RelativeDistinguishedName_1 = class RelativeDistinguishedName extends AsnArray {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, RelativeDistinguishedName_1.prototype);
+    }
+};
+RelativeDistinguishedName = RelativeDistinguishedName_1 = __decorate([
+    AsnType({
+        type: AsnTypeTypes.Set,
+        itemType: AttributeTypeAndValue,
+    })
+], RelativeDistinguishedName);
+export { RelativeDistinguishedName };
+let RDNSequence = RDNSequence_1 = class RDNSequence extends AsnArray {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, RDNSequence_1.prototype);
+    }
+};
+RDNSequence = RDNSequence_1 = __decorate([
+    AsnType({
+        type: AsnTypeTypes.Sequence,
+        itemType: RelativeDistinguishedName,
+    })
+], RDNSequence);
+export { RDNSequence };
+let Name = Name_1 = class Name extends RDNSequence {
+    constructor(items) {
+        super(items);
+        Object.setPrototypeOf(this, Name_1.prototype);
+    }
+};
+Name = Name_1 = __decorate([
+    AsnType({ type: AsnTypeTypes.Sequence })
+], Name);
+export { Name };

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/object_identifiers.js

@@ -0,0 +1,13 @@
+export const id_pkix = "1.3.6.1.5.5.7";
+export const id_pe = `${id_pkix}.1`;
+export const id_qt = `${id_pkix}.2`;
+export const id_kp = `${id_pkix}.3`;
+export const id_ad = `${id_pkix}.48`;
+export const id_qt_csp = `${id_qt}.1`;
+export const id_qt_unotice = `${id_qt}.2`;
+export const id_ad_ocsp = `${id_ad}.1`;
+export const id_ad_caIssuers = `${id_ad}.2`;
+export const id_ad_timeStamping = `${id_ad}.3`;
+export const id_ad_caRepository = `${id_ad}.5`;
+export const id_ce = "2.5.29";
+export const id_alg_unsigned = "1.3.6.1.5.5.7.6.36";

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/subject_public_key_info.js

@@ -0,0 +1,16 @@
+import { __decorate } from "tslib";
+import { AsnProp, AsnPropTypes } from "@peculiar/asn1-schema";
+import { AlgorithmIdentifier } from "./algorithm_identifier.js";
+export class SubjectPublicKeyInfo {
+    algorithm = new AlgorithmIdentifier();
+    subjectPublicKey = new ArrayBuffer(0);
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({ type: AlgorithmIdentifier })
+], SubjectPublicKeyInfo.prototype, "algorithm", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.BitString })
+], SubjectPublicKeyInfo.prototype, "subjectPublicKey", void 0);

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/tbs_cert_list.js

@@ -0,0 +1,78 @@
+import { __decorate } from "tslib";
+import { AsnProp, AsnPropTypes, AsnIntegerArrayBufferConverter } from "@peculiar/asn1-schema";
+import { AlgorithmIdentifier } from "./algorithm_identifier.js";
+import { Name } from "./name.js";
+import { Time } from "./time.js";
+import { Extension } from "./extension.js";
+export class RevokedCertificate {
+    userCertificate = new ArrayBuffer(0);
+    revocationDate = new Time();
+    crlEntryExtensions;
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({
+        type: AsnPropTypes.Integer,
+        converter: AsnIntegerArrayBufferConverter,
+    })
+], RevokedCertificate.prototype, "userCertificate", void 0);
+__decorate([
+    AsnProp({ type: Time })
+], RevokedCertificate.prototype, "revocationDate", void 0);
+__decorate([
+    AsnProp({
+        type: Extension,
+        optional: true,
+        repeated: "sequence",
+    })
+], RevokedCertificate.prototype, "crlEntryExtensions", void 0);
+export class TBSCertList {
+    version;
+    signature = new AlgorithmIdentifier();
+    issuer = new Name();
+    thisUpdate = new Time();
+    nextUpdate;
+    revokedCertificates;
+    crlExtensions;
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({
+        type: AsnPropTypes.Integer,
+        optional: true,
+    })
+], TBSCertList.prototype, "version", void 0);
+__decorate([
+    AsnProp({ type: AlgorithmIdentifier })
+], TBSCertList.prototype, "signature", void 0);
+__decorate([
+    AsnProp({ type: Name })
+], TBSCertList.prototype, "issuer", void 0);
+__decorate([
+    AsnProp({ type: Time })
+], TBSCertList.prototype, "thisUpdate", void 0);
+__decorate([
+    AsnProp({
+        type: Time,
+        optional: true,
+    })
+], TBSCertList.prototype, "nextUpdate", void 0);
+__decorate([
+    AsnProp({
+        type: RevokedCertificate,
+        repeated: "sequence",
+        optional: true,
+    })
+], TBSCertList.prototype, "revokedCertificates", void 0);
+__decorate([
+    AsnProp({
+        type: Extension,
+        optional: true,
+        context: 0,
+        repeated: "sequence",
+    })
+], TBSCertList.prototype, "crlExtensions", void 0);

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/tbs_certificate.js

@@ -0,0 +1,74 @@
+import { __decorate } from "tslib";
+import { AsnProp, AsnPropTypes, AsnIntegerArrayBufferConverter } from "@peculiar/asn1-schema";
+import { AlgorithmIdentifier } from "./algorithm_identifier.js";
+import { Name } from "./name.js";
+import { SubjectPublicKeyInfo } from "./subject_public_key_info.js";
+import { Validity } from "./validity.js";
+import { Extensions } from "./extension.js";
+import { Version } from "./types.js";
+export class TBSCertificate {
+    version = Version.v1;
+    serialNumber = new ArrayBuffer(0);
+    signature = new AlgorithmIdentifier();
+    issuer = new Name();
+    validity = new Validity();
+    subject = new Name();
+    subjectPublicKeyInfo = new SubjectPublicKeyInfo();
+    issuerUniqueID;
+    subjectUniqueID;
+    extensions;
+    constructor(params = {}) {
+        Object.assign(this, params);
+    }
+}
+__decorate([
+    AsnProp({
+        type: AsnPropTypes.Integer,
+        context: 0,
+        defaultValue: Version.v1,
+    })
+], TBSCertificate.prototype, "version", void 0);
+__decorate([
+    AsnProp({
+        type: AsnPropTypes.Integer,
+        converter: AsnIntegerArrayBufferConverter,
+    })
+], TBSCertificate.prototype, "serialNumber", void 0);
+__decorate([
+    AsnProp({ type: AlgorithmIdentifier })
+], TBSCertificate.prototype, "signature", void 0);
+__decorate([
+    AsnProp({ type: Name })
+], TBSCertificate.prototype, "issuer", void 0);
+__decorate([
+    AsnProp({ type: Validity })
+], TBSCertificate.prototype, "validity", void 0);
+__decorate([
+    AsnProp({ type: Name })
+], TBSCertificate.prototype, "subject", void 0);
+__decorate([
+    AsnProp({ type: SubjectPublicKeyInfo })
+], TBSCertificate.prototype, "subjectPublicKeyInfo", void 0);
+__decorate([
+    AsnProp({
+        type: AsnPropTypes.BitString,
+        context: 1,
+        implicit: true,
+        optional: true,
+    })
+], TBSCertificate.prototype, "issuerUniqueID", void 0);
+__decorate([
+    AsnProp({
+        type: AsnPropTypes.BitString,
+        context: 2,
+        implicit: true,
+        optional: true,
+    })
+], TBSCertificate.prototype, "subjectUniqueID", void 0);
+__decorate([
+    AsnProp({
+        type: Extensions,
+        context: 3,
+        optional: true,
+    })
+], TBSCertificate.prototype, "extensions", void 0);

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/time.js

@@ -0,0 +1,40 @@
+import { __decorate } from "tslib";
+import { AsnProp, AsnPropTypes, AsnType, AsnTypeTypes } from "@peculiar/asn1-schema";
+let Time = class Time {
+    utcTime;
+    generalTime;
+    constructor(time) {
+        if (time) {
+            if (typeof time === "string" || typeof time === "number" || time instanceof Date) {
+                const date = new Date(time);
+                date.setMilliseconds(0);
+                if (date.getUTCFullYear() > 2049) {
+                    this.generalTime = date;
+                }
+                else {
+                    this.utcTime = date;
+                }
+            }
+            else {
+                Object.assign(this, time);
+            }
+        }
+    }
+    getTime() {
+        const time = this.utcTime || this.generalTime;
+        if (!time) {
+            throw new Error("Cannot get time from CHOICE object");
+        }
+        return time;
+    }
+};
+__decorate([
+    AsnProp({ type: AsnPropTypes.UTCTime })
+], Time.prototype, "utcTime", void 0);
+__decorate([
+    AsnProp({ type: AsnPropTypes.GeneralizedTime })
+], Time.prototype, "generalTime", void 0);
+Time = __decorate([
+    AsnType({ type: AsnTypeTypes.Choice })
+], Time);
+export { Time };

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/types.js

@@ -0,0 +1,6 @@
+export var Version;
+(function (Version) {
+    Version[Version["v1"] = 0] = "v1";
+    Version[Version["v2"] = 1] = "v2";
+    Version[Version["v3"] = 2] = "v3";
+})(Version || (Version = {}));

package/.output/server/node_modules/@peculiar/asn1-x509/build/es2015/validity.js

@@ -0,0 +1,19 @@
+import { __decorate } from "tslib";
+import { AsnProp } from "@peculiar/asn1-schema";
+import { Time } from "./time.js";
+export class Validity {
+    notBefore = new Time(new Date());
+    notAfter = new Time(new Date());
+    constructor(params) {
+        if (params) {
+            this.notBefore = new Time(params.notBefore);
+            this.notAfter = new Time(params.notAfter);
+        }
+    }
+}
+__decorate([
+    AsnProp({ type: Time })
+], Validity.prototype, "notBefore", void 0);
+__decorate([
+    AsnProp({ type: Time })
+], Validity.prototype, "notAfter", void 0);

package/.output/server/node_modules/@peculiar/asn1-x509/node_modules/tslib/modules/index.js

@@ -0,0 +1,70 @@
+import tslib from '../tslib.js';
+const {
+    __extends,
+    __assign,
+    __rest,
+    __decorate,
+    __param,
+    __esDecorate,
+    __runInitializers,
+    __propKey,
+    __setFunctionName,
+    __metadata,
+    __awaiter,
+    __generator,
+    __exportStar,
+    __createBinding,
+    __values,
+    __read,
+    __spread,
+    __spreadArrays,
+    __spreadArray,
+    __await,
+    __asyncGenerator,
+    __asyncDelegator,
+    __asyncValues,
+    __makeTemplateObject,
+    __importStar,
+    __importDefault,
+    __classPrivateFieldGet,
+    __classPrivateFieldSet,
+    __classPrivateFieldIn,
+    __addDisposableResource,
+    __disposeResources,
+    __rewriteRelativeImportExtension,
+} = tslib;
+export {
+    __extends,
+    __assign,
+    __rest,
+    __decorate,
+    __param,
+    __esDecorate,
+    __runInitializers,
+    __propKey,
+    __setFunctionName,
+    __metadata,
+    __awaiter,
+    __generator,
+    __exportStar,
+    __createBinding,
+    __values,
+    __read,
+    __spread,
+    __spreadArrays,
+    __spreadArray,
+    __await,
+    __asyncGenerator,
+    __asyncDelegator,
+    __asyncValues,
+    __makeTemplateObject,
+    __importStar,
+    __importDefault,
+    __classPrivateFieldGet,
+    __classPrivateFieldSet,
+    __classPrivateFieldIn,
+    __addDisposableResource,
+    __disposeResources,
+    __rewriteRelativeImportExtension,
+};
+export default tslib;

package/.output/server/node_modules/@peculiar/asn1-x509/node_modules/tslib/modules/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/.output/server/node_modules/@peculiar/asn1-x509/node_modules/tslib/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "tslib",
+  "author": "Microsoft Corp.",
+  "homepage": "https://www.typescriptlang.org/",
+  "version": "2.8.1",
+  "license": "0BSD",
+  "description": "Runtime library for TypeScript helper functions",
+  "keywords": [
+    "TypeScript",
+    "Microsoft",
+    "compiler",
+    "language",
+    "javascript",
+    "tslib",
+    "runtime"
+  ],
+  "bugs": {
+    "url": "https://github.com/Microsoft/TypeScript/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Microsoft/tslib.git"
+  },
+  "main": "tslib.js",
+  "module": "tslib.es6.js",
+  "jsnext:main": "tslib.es6.js",
+  "typings": "tslib.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "module": {
+        "types": "./modules/index.d.ts",
+        "default": "./tslib.es6.mjs"
+      },
+      "import": {
+        "node": "./modules/index.js",
+        "default": {
+          "types": "./modules/index.d.ts",
+          "default": "./tslib.es6.mjs"
+        }
+      },
+      "default": "./tslib.js"
+    },
+    "./*": "./*",
+    "./": "./"
+  }
+}