wherdr 0.0.0-stage → 1.2.0

package/.output/server/node_modules/@peculiar/asn1-schema/build/cjs/types/bit_string.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitString = void 0;
+const tslib_1 = require("tslib");
+const asn1js = tslib_1.__importStar(require("asn1js"));
+const utils_1 = require("@peculiar/utils");
+class BitString {
+    unusedBits = 0;
+    value = new ArrayBuffer(0);
+    constructor(params, unusedBits = 0) {
+        if (params) {
+            if (typeof params === "number") {
+                this.fromNumber(params);
+            }
+            else if ((0, utils_1.isBufferSource)(params)) {
+                this.unusedBits = unusedBits;
+                this.value = (0, utils_1.toArrayBuffer)(params);
+            }
+            else {
+                throw TypeError("Unsupported type of 'params' argument for BitString");
+            }
+        }
+    }
+    fromASN(asn) {
+        if (!(asn instanceof asn1js.BitString)) {
+            throw new TypeError("Argument 'asn' is not instance of ASN.1 BitString");
+        }
+        this.unusedBits = asn.valueBlock.unusedBits;
+        this.value = (0, utils_1.toArrayBuffer)(asn.valueBlock.valueHex);
+        return this;
+    }
+    toASN() {
+        return new asn1js.BitString({
+            unusedBits: this.unusedBits,
+            valueHex: this.value,
+        });
+    }
+    toSchema(name) {
+        return new asn1js.BitString({ name });
+    }
+    toNumber() {
+        let res = "";
+        const uintArray = new Uint8Array(this.value);
+        for (const octet of uintArray) {
+            res += octet.toString(2).padStart(8, "0");
+        }
+        res = res.split("").reverse().join("");
+        if (this.unusedBits) {
+            res = res.slice(this.unusedBits).padStart(this.unusedBits, "0");
+        }
+        return parseInt(res, 2);
+    }
+    fromNumber(value) {
+        let bits = value.toString(2);
+        const octetSize = (bits.length + 7) >> 3;
+        this.unusedBits = (octetSize << 3) - bits.length;
+        const octets = new Uint8Array(octetSize);
+        bits = bits
+            .padStart(octetSize << 3, "0")
+            .split("")
+            .reverse()
+            .join("");
+        let index = 0;
+        while (index < octetSize) {
+            octets[index] = parseInt(bits.slice(index << 3, (index << 3) + 8), 2);
+            index++;
+        }
+        this.value = octets.buffer;
+    }
+}
+exports.BitString = BitString;

package/.output/server/node_modules/@peculiar/asn1-schema/build/cjs/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./bit_string"), exports);
+tslib_1.__exportStar(require("./octet_string"), exports);

package/.output/server/node_modules/@peculiar/asn1-schema/build/cjs/types/octet_string.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OctetString = void 0;
+const tslib_1 = require("tslib");
+const asn1js = tslib_1.__importStar(require("asn1js"));
+const utils_1 = require("@peculiar/utils");
+class OctetString {
+    buffer;
+    get byteLength() {
+        return this.buffer.byteLength;
+    }
+    get byteOffset() {
+        return 0;
+    }
+    constructor(param) {
+        if (typeof param === "number") {
+            this.buffer = new ArrayBuffer(param);
+        }
+        else {
+            if ((0, utils_1.isBufferSource)(param)) {
+                this.buffer = (0, utils_1.toArrayBuffer)(param);
+            }
+            else if (Array.isArray(param)) {
+                this.buffer = new Uint8Array(param).buffer;
+            }
+            else {
+                this.buffer = new ArrayBuffer(0);
+            }
+        }
+    }
+    fromASN(asn) {
+        if (!(asn instanceof asn1js.OctetString)) {
+            throw new TypeError("Argument 'asn' is not instance of ASN.1 OctetString");
+        }
+        this.buffer = (0, utils_1.toArrayBuffer)(asn.valueBlock.valueHex);
+        return this;
+    }
+    toASN() {
+        return new asn1js.OctetString({ valueHex: this.buffer });
+    }
+    toSchema(name) {
+        return new asn1js.OctetString({ name });
+    }
+}
+exports.OctetString = OctetString;

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/convert.js

@@ -0,0 +1,20 @@
+import * as asn1js from "asn1js";
+import { isBufferSource, toArrayBuffer } from "@peculiar/utils";
+import { AsnParser } from "./parser.js";
+import { AsnSerializer } from "./serializer.js";
+export class AsnConvert {
+    static serialize(obj) {
+        return AsnSerializer.serialize(obj);
+    }
+    static parse(data, target, options) {
+        return AsnParser.parse(data, target, options);
+    }
+    static toString(data, options) {
+        const buf = isBufferSource(data) ? toArrayBuffer(data) : AsnConvert.serialize(data);
+        const asn = asn1js.fromBER(buf, options?.berOptions);
+        if (asn.offset === -1) {
+            throw new Error(`Cannot decode ASN.1 data. ${asn.result.error}`);
+        }
+        return asn.result.toString();
+    }
+}

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/converters.js

@@ -0,0 +1,143 @@
+import * as asn1js from "asn1js";
+import { toArrayBuffer } from "@peculiar/utils";
+import { AsnPropTypes } from "./enums.js";
+import { OctetString } from "./types/index.js";
+export const AsnAnyConverter = {
+    fromASN: (value) => (value instanceof asn1js.Null ? null : toArrayBuffer(value.valueBeforeDecodeView)),
+    toASN: (value) => {
+        if (value === null) {
+            return new asn1js.Null();
+        }
+        const schema = asn1js.fromBER(value);
+        if (schema.result.error) {
+            throw new Error(schema.result.error);
+        }
+        return schema.result;
+    },
+};
+export const AsnIntegerConverter = {
+    fromASN: (value) => value.valueBlock.valueHexView.byteLength >= 4
+        ? value.valueBlock.toString()
+        : value.valueBlock.valueDec,
+    toASN: (value) => new asn1js.Integer({ value: +value }),
+};
+export const AsnEnumeratedConverter = {
+    fromASN: (value) => value.valueBlock.valueDec,
+    toASN: (value) => new asn1js.Enumerated({ value }),
+};
+export const AsnIntegerArrayBufferConverter = {
+    fromASN: (value) => toArrayBuffer(value.valueBlock.valueHexView),
+    toASN: (value) => new asn1js.Integer({ valueHex: value }),
+};
+export const AsnIntegerBigIntConverter = {
+    fromASN: (value) => value.toBigInt(),
+    toASN: (value) => asn1js.Integer.fromBigInt(value),
+};
+export const AsnBitStringConverter = {
+    fromASN: (value) => toArrayBuffer(value.valueBlock.valueHexView),
+    toASN: (value) => new asn1js.BitString({ valueHex: value }),
+};
+export const AsnObjectIdentifierConverter = {
+    fromASN: (value) => value.valueBlock.toString(),
+    toASN: (value) => new asn1js.ObjectIdentifier({ value }),
+};
+export const AsnRelativeObjectIdentifierConverter = {
+    fromASN: (value) => value.valueBlock.toString(),
+    toASN: (value) => new asn1js.RelativeObjectIdentifier({ value }),
+};
+export const AsnBooleanConverter = {
+    fromASN: (value) => value.valueBlock.value,
+    toASN: (value) => new asn1js.Boolean({ value }),
+};
+export const AsnOctetStringConverter = {
+    fromASN: (value) => toArrayBuffer(value.valueBlock.valueHexView),
+    toASN: (value) => new asn1js.OctetString({ valueHex: value }),
+};
+export const AsnConstructedOctetStringConverter = {
+    fromASN: (value) => new OctetString(value.getValue()),
+    toASN: (value) => value.toASN(),
+};
+function createStringConverter(Asn1Type) {
+    return {
+        fromASN: (value) => value.valueBlock.value,
+        toASN: (value) => new Asn1Type({ value }),
+    };
+}
+export const AsnUtf8StringConverter = createStringConverter(asn1js.Utf8String);
+export const AsnBmpStringConverter = createStringConverter(asn1js.BmpString);
+export const AsnUniversalStringConverter = createStringConverter(asn1js.UniversalString);
+export const AsnNumericStringConverter = createStringConverter(asn1js.NumericString);
+export const AsnPrintableStringConverter = createStringConverter(asn1js.PrintableString);
+export const AsnTeletexStringConverter = createStringConverter(asn1js.TeletexString);
+export const AsnVideotexStringConverter = createStringConverter(asn1js.VideotexString);
+export const AsnIA5StringConverter = createStringConverter(asn1js.IA5String);
+export const AsnGraphicStringConverter = createStringConverter(asn1js.GraphicString);
+export const AsnVisibleStringConverter = createStringConverter(asn1js.VisibleString);
+export const AsnGeneralStringConverter = createStringConverter(asn1js.GeneralString);
+export const AsnCharacterStringConverter = createStringConverter(asn1js.CharacterString);
+export const AsnUTCTimeConverter = {
+    fromASN: (value) => value.toDate(),
+    toASN: (value) => new asn1js.UTCTime({ valueDate: value }),
+};
+export const AsnGeneralizedTimeConverter = {
+    fromASN: (value) => value.toDate(),
+    toASN: (value) => new asn1js.GeneralizedTime({ valueDate: value }),
+};
+export const AsnNullConverter = {
+    fromASN: () => null,
+    toASN: () => {
+        return new asn1js.Null();
+    },
+};
+export function defaultConverter(type) {
+    switch (type) {
+        case AsnPropTypes.Any:
+            return AsnAnyConverter;
+        case AsnPropTypes.BitString:
+            return AsnBitStringConverter;
+        case AsnPropTypes.BmpString:
+            return AsnBmpStringConverter;
+        case AsnPropTypes.Boolean:
+            return AsnBooleanConverter;
+        case AsnPropTypes.CharacterString:
+            return AsnCharacterStringConverter;
+        case AsnPropTypes.Enumerated:
+            return AsnEnumeratedConverter;
+        case AsnPropTypes.GeneralString:
+            return AsnGeneralStringConverter;
+        case AsnPropTypes.GeneralizedTime:
+            return AsnGeneralizedTimeConverter;
+        case AsnPropTypes.GraphicString:
+            return AsnGraphicStringConverter;
+        case AsnPropTypes.IA5String:
+            return AsnIA5StringConverter;
+        case AsnPropTypes.Integer:
+            return AsnIntegerConverter;
+        case AsnPropTypes.Null:
+            return AsnNullConverter;
+        case AsnPropTypes.NumericString:
+            return AsnNumericStringConverter;
+        case AsnPropTypes.ObjectIdentifier:
+            return AsnObjectIdentifierConverter;
+        case AsnPropTypes.RelativeObjectIdentifier:
+            return AsnRelativeObjectIdentifierConverter;
+        case AsnPropTypes.OctetString:
+            return AsnOctetStringConverter;
+        case AsnPropTypes.PrintableString:
+            return AsnPrintableStringConverter;
+        case AsnPropTypes.TeletexString:
+            return AsnTeletexStringConverter;
+        case AsnPropTypes.UTCTime:
+            return AsnUTCTimeConverter;
+        case AsnPropTypes.UniversalString:
+            return AsnUniversalStringConverter;
+        case AsnPropTypes.Utf8String:
+            return AsnUtf8StringConverter;
+        case AsnPropTypes.VideotexString:
+            return AsnVideotexStringConverter;
+        case AsnPropTypes.VisibleString:
+            return AsnVisibleStringConverter;
+        default:
+            return null;
+    }
+}

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/decorators.js

@@ -0,0 +1,43 @@
+import * as converters from "./converters.js";
+import { AsnTypeTypes } from "./enums.js";
+import { schemaStorage } from "./storage.js";
+export const AsnType = (options) => (target) => {
+    let schema;
+    if (!schemaStorage.has(target)) {
+        schema = schemaStorage.createDefault(target);
+        schemaStorage.set(target, schema);
+    }
+    else {
+        schema = schemaStorage.get(target);
+    }
+    Object.assign(schema, options);
+};
+export const AsnChoiceType = () => AsnType({ type: AsnTypeTypes.Choice });
+export const AsnSetType = (options) => AsnType({
+    type: AsnTypeTypes.Set,
+    ...options,
+});
+export const AsnSequenceType = (options) => AsnType({
+    type: AsnTypeTypes.Sequence,
+    ...options,
+});
+export const AsnProp = (options) => (target, propertyKey) => {
+    let schema;
+    if (!schemaStorage.has(target.constructor)) {
+        schema = schemaStorage.createDefault(target.constructor);
+        schemaStorage.set(target.constructor, schema);
+    }
+    else {
+        schema = schemaStorage.get(target.constructor);
+    }
+    const copyOptions = Object.assign({}, options);
+    if (typeof copyOptions.type === "number" && !copyOptions.converter) {
+        const defaultConverter = converters.defaultConverter(options.type);
+        if (!defaultConverter) {
+            throw new Error(`Cannot get default converter for property '${propertyKey}' of ${target.constructor.name}`);
+        }
+        copyOptions.converter = defaultConverter;
+    }
+    copyOptions.raw = options.raw;
+    schema.items[propertyKey] = copyOptions;
+};

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/enums.js

@@ -0,0 +1,37 @@
+export var AsnTypeTypes;
+(function (AsnTypeTypes) {
+    AsnTypeTypes[AsnTypeTypes["Sequence"] = 0] = "Sequence";
+    AsnTypeTypes[AsnTypeTypes["Set"] = 1] = "Set";
+    AsnTypeTypes[AsnTypeTypes["Choice"] = 2] = "Choice";
+})(AsnTypeTypes || (AsnTypeTypes = {}));
+export var AsnPropTypes;
+(function (AsnPropTypes) {
+    AsnPropTypes[AsnPropTypes["Any"] = 1] = "Any";
+    AsnPropTypes[AsnPropTypes["Boolean"] = 2] = "Boolean";
+    AsnPropTypes[AsnPropTypes["OctetString"] = 3] = "OctetString";
+    AsnPropTypes[AsnPropTypes["BitString"] = 4] = "BitString";
+    AsnPropTypes[AsnPropTypes["Integer"] = 5] = "Integer";
+    AsnPropTypes[AsnPropTypes["Enumerated"] = 6] = "Enumerated";
+    AsnPropTypes[AsnPropTypes["ObjectIdentifier"] = 7] = "ObjectIdentifier";
+    AsnPropTypes[AsnPropTypes["Utf8String"] = 8] = "Utf8String";
+    AsnPropTypes[AsnPropTypes["BmpString"] = 9] = "BmpString";
+    AsnPropTypes[AsnPropTypes["UniversalString"] = 10] = "UniversalString";
+    AsnPropTypes[AsnPropTypes["NumericString"] = 11] = "NumericString";
+    AsnPropTypes[AsnPropTypes["PrintableString"] = 12] = "PrintableString";
+    AsnPropTypes[AsnPropTypes["TeletexString"] = 13] = "TeletexString";
+    AsnPropTypes[AsnPropTypes["VideotexString"] = 14] = "VideotexString";
+    AsnPropTypes[AsnPropTypes["IA5String"] = 15] = "IA5String";
+    AsnPropTypes[AsnPropTypes["GraphicString"] = 16] = "GraphicString";
+    AsnPropTypes[AsnPropTypes["VisibleString"] = 17] = "VisibleString";
+    AsnPropTypes[AsnPropTypes["GeneralString"] = 18] = "GeneralString";
+    AsnPropTypes[AsnPropTypes["CharacterString"] = 19] = "CharacterString";
+    AsnPropTypes[AsnPropTypes["UTCTime"] = 20] = "UTCTime";
+    AsnPropTypes[AsnPropTypes["GeneralizedTime"] = 21] = "GeneralizedTime";
+    AsnPropTypes[AsnPropTypes["DATE"] = 22] = "DATE";
+    AsnPropTypes[AsnPropTypes["TimeOfDay"] = 23] = "TimeOfDay";
+    AsnPropTypes[AsnPropTypes["DateTime"] = 24] = "DateTime";
+    AsnPropTypes[AsnPropTypes["Duration"] = 25] = "Duration";
+    AsnPropTypes[AsnPropTypes["TIME"] = 26] = "TIME";
+    AsnPropTypes[AsnPropTypes["Null"] = 27] = "Null";
+    AsnPropTypes[AsnPropTypes["RelativeObjectIdentifier"] = 28] = "RelativeObjectIdentifier";
+})(AsnPropTypes || (AsnPropTypes = {}));

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/errors/index.js

@@ -0,0 +1 @@
+export * from "./schema_validation.js";

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/errors/schema_validation.js

@@ -0,0 +1,3 @@
+export class AsnSchemaValidationError extends Error {
+    schemas = [];
+}

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/helper.js

@@ -0,0 +1,39 @@
+export function isConvertible(target) {
+    if (typeof target === "function" && target.prototype) {
+        if (target.prototype.toASN && target.prototype.fromASN) {
+            return true;
+        }
+        else {
+            return isConvertible(target.prototype);
+        }
+    }
+    else {
+        return !!(target && typeof target === "object" && "toASN" in target && "fromASN" in target);
+    }
+}
+export function isTypeOfArray(target) {
+    if (target) {
+        const proto = Object.getPrototypeOf(target);
+        if (proto?.prototype?.constructor === Array) {
+            return true;
+        }
+        return isTypeOfArray(proto);
+    }
+    return false;
+}
+export function isArrayEqual(bytes1, bytes2) {
+    if (!(bytes1 && bytes2)) {
+        return false;
+    }
+    if (bytes1.byteLength !== bytes2.byteLength) {
+        return false;
+    }
+    const b1 = new Uint8Array(bytes1);
+    const b2 = new Uint8Array(bytes2);
+    for (let i = 0; i < bytes1.byteLength; i++) {
+        if (b1[i] !== b2[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/index.js

@@ -0,0 +1,9 @@
+export * from "./converters.js";
+export * from "./types/index.js";
+export { AsnProp, AsnType, AsnChoiceType, AsnSequenceType, AsnSetType } from "./decorators.js";
+export { AsnTypeTypes, AsnPropTypes } from "./enums.js";
+export { AsnParser } from "./parser.js";
+export { AsnSerializer } from "./serializer.js";
+export * from "./errors/index.js";
+export * from "./objects.js";
+export * from "./convert.js";

package/.output/server/node_modules/@peculiar/asn1-schema/build/es2015/objects.js

@@ -0,0 +1,13 @@
+export class AsnArray extends Array {
+    constructor(items = []) {
+        if (typeof items === "number") {
+            super(items);
+        }
+        else {
+            super();
+            for (const item of items) {
+                this.push(item);
+            }
+        }
+    }
+}

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

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