@dbos-inc/dbos-sdk 0.8.39-preview → 0.8.41-preview

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/OSDetectorSync.d.ts

@@ -0,0 +1,13 @@
+import { Resource } from '../../Resource';
+import { DetectorSync } from '../../types';
+import { ResourceDetectionConfig } from '../../config';
+/**
+ * OSDetectorSync detects the resources related to the operating system (OS) on
+ * which the process represented by this resource is running.
+ */
+declare class OSDetectorSync implements DetectorSync {
+    detect(_config?: ResourceDetectionConfig): Resource;
+}
+export declare const osDetectorSync: OSDetectorSync;
+export {};
+//# sourceMappingURL=OSDetectorSync.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/OSDetectorSync.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import { Resource } from '../../Resource';
+import { platform, release } from 'os';
+import { normalizeType } from './utils';
+/**
+ * OSDetectorSync detects the resources related to the operating system (OS) on
+ * which the process represented by this resource is running.
+ */
+var OSDetectorSync = /** @class */ (function () {
+    function OSDetectorSync() {
+    }
+    OSDetectorSync.prototype.detect = function (_config) {
+        var _a;
+        var attributes = (_a = {},
+            _a[SemanticResourceAttributes.OS_TYPE] = normalizeType(platform()),
+            _a[SemanticResourceAttributes.OS_VERSION] = release(),
+            _a);
+        return new Resource(attributes);
+    };
+    return OSDetectorSync;
+}());
+export var osDetectorSync = new OSDetectorSync();
+//# sourceMappingURL=OSDetectorSync.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/OSDetectorSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OSDetectorSync.js","sourceRoot":"","sources":["../../../../src/platform/node/OSDetectorSync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG1C,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC;;;GAGG;AACH;IAAA;IAQA,CAAC;IAPC,+BAAM,GAAN,UAAO,OAAiC;;QACtC,IAAM,UAAU;YACd,GAAC,0BAA0B,CAAC,OAAO,IAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC/D,GAAC,0BAA0B,CAAC,UAAU,IAAG,OAAO,EAAE;eACnD,CAAC;QACF,OAAO,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IACH,qBAAC;AAAD,CAAC,AARD,IAQC;AAED,MAAM,CAAC,IAAM,cAAc,GAAG,IAAI,cAAc,EAAE,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';\nimport { Resource } from '../../Resource';\nimport { DetectorSync, ResourceAttributes } from '../../types';\nimport { ResourceDetectionConfig } from '../../config';\nimport { platform, release } from 'os';\nimport { normalizeType } from './utils';\n\n/**\n * OSDetectorSync detects the resources related to the operating system (OS) on\n * which the process represented by this resource is running.\n */\nclass OSDetectorSync implements DetectorSync {\n  detect(_config?: ResourceDetectionConfig): Resource {\n    const attributes: ResourceAttributes = {\n      [SemanticResourceAttributes.OS_TYPE]: normalizeType(platform()),\n      [SemanticResourceAttributes.OS_VERSION]: release(),\n    };\n    return new Resource(attributes);\n  }\n}\n\nexport const osDetectorSync = new OSDetectorSync();\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/ProcessDetector.d.ts

@@ -0,0 +1,13 @@
+import { Detector } from '../../types';
+import { ResourceDetectionConfig } from '../../config';
+import { IResource } from '../../IResource';
+/**
+ * ProcessDetector will be used to detect the resources related current process running
+ * and being instrumented from the NodeJS Process module.
+ */
+declare class ProcessDetector implements Detector {
+    detect(config?: ResourceDetectionConfig): Promise<IResource>;
+}
+export declare const processDetector: ProcessDetector;
+export {};
+//# sourceMappingURL=ProcessDetector.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/ProcessDetector.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { processDetectorSync } from './ProcessDetectorSync';
+/**
+ * ProcessDetector will be used to detect the resources related current process running
+ * and being instrumented from the NodeJS Process module.
+ */
+var ProcessDetector = /** @class */ (function () {
+    function ProcessDetector() {
+    }
+    ProcessDetector.prototype.detect = function (config) {
+        return Promise.resolve(processDetectorSync.detect(config));
+    };
+    return ProcessDetector;
+}());
+export var processDetector = new ProcessDetector();
+//# sourceMappingURL=ProcessDetector.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/ProcessDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessDetector.js","sourceRoot":"","sources":["../../../../src/platform/node/ProcessDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;GAGG;AACH;IAAA;IAIA,CAAC;IAHC,gCAAM,GAAN,UAAO,MAAgC;QACrC,OAAO,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7D,CAAC;IACH,sBAAC;AAAD,CAAC,AAJD,IAIC;AAED,MAAM,CAAC,IAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Detector } from '../../types';\nimport { ResourceDetectionConfig } from '../../config';\nimport { IResource } from '../../IResource';\nimport { processDetectorSync } from './ProcessDetectorSync';\n\n/**\n * ProcessDetector will be used to detect the resources related current process running\n * and being instrumented from the NodeJS Process module.\n */\nclass ProcessDetector implements Detector {\n  detect(config?: ResourceDetectionConfig): Promise<IResource> {\n    return Promise.resolve(processDetectorSync.detect(config));\n  }\n}\n\nexport const processDetector = new ProcessDetector();\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/ProcessDetectorSync.d.ts

@@ -0,0 +1,13 @@
+import { DetectorSync } from '../../types';
+import { ResourceDetectionConfig } from '../../config';
+import { IResource } from '../../IResource';
+/**
+ * ProcessDetectorSync will be used to detect the resources related current process running
+ * and being instrumented from the NodeJS Process module.
+ */
+declare class ProcessDetectorSync implements DetectorSync {
+    detect(_config?: ResourceDetectionConfig): IResource;
+}
+export declare const processDetectorSync: ProcessDetectorSync;
+export {};
+//# sourceMappingURL=ProcessDetectorSync.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/ProcessDetectorSync.js

@@ -0,0 +1,80 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { diag } from '@opentelemetry/api';
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import { Resource } from '../../Resource';
+import * as os from 'os';
+/**
+ * ProcessDetectorSync will be used to detect the resources related current process running
+ * and being instrumented from the NodeJS Process module.
+ */
+var ProcessDetectorSync = /** @class */ (function () {
+    function ProcessDetectorSync() {
+    }
+    ProcessDetectorSync.prototype.detect = function (_config) {
+        var _a;
+        var attributes = (_a = {},
+            _a[SemanticResourceAttributes.PROCESS_PID] = process.pid,
+            _a[SemanticResourceAttributes.PROCESS_EXECUTABLE_NAME] = process.title,
+            _a[SemanticResourceAttributes.PROCESS_EXECUTABLE_PATH] = process.execPath,
+            _a[SemanticResourceAttributes.PROCESS_COMMAND_ARGS] = __spreadArray(__spreadArray([
+                process.argv[0]
+            ], __read(process.execArgv), false), __read(process.argv.slice(1)), false),
+            _a[SemanticResourceAttributes.PROCESS_RUNTIME_VERSION] = process.versions.node,
+            _a[SemanticResourceAttributes.PROCESS_RUNTIME_NAME] = 'nodejs',
+            _a[SemanticResourceAttributes.PROCESS_RUNTIME_DESCRIPTION] = 'Node.js',
+            _a);
+        if (process.argv.length > 1) {
+            attributes[SemanticResourceAttributes.PROCESS_COMMAND] = process.argv[1];
+        }
+        try {
+            var userInfo = os.userInfo();
+            attributes[SemanticResourceAttributes.PROCESS_OWNER] = userInfo.username;
+        }
+        catch (e) {
+            diag.debug("error obtaining process owner: " + e);
+        }
+        return new Resource(attributes);
+    };
+    return ProcessDetectorSync;
+}());
+export var processDetectorSync = new ProcessDetectorSync();
+//# sourceMappingURL=ProcessDetectorSync.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/ProcessDetectorSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessDetectorSync.js","sourceRoot":"","sources":["../../../../src/platform/node/ProcessDetectorSync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI1C,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AAEzB;;;GAGG;AACH;IAAA;IA8BA,CAAC;IA7BC,oCAAM,GAAN,UAAO,OAAiC;;QACtC,IAAM,UAAU;YACd,GAAC,0BAA0B,CAAC,WAAW,IAAG,OAAO,CAAC,GAAG;YACrD,GAAC,0BAA0B,CAAC,uBAAuB,IAAG,OAAO,CAAC,KAAK;YACnE,GAAC,0BAA0B,CAAC,uBAAuB,IAAG,OAAO,CAAC,QAAQ;YACtE,GAAC,0BAA0B,CAAC,oBAAoB;gBAC9C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;sBACZ,OAAO,CAAC,QAAQ,kBAChB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SACzB;YACD,GAAC,0BAA0B,CAAC,uBAAuB,IACjD,OAAO,CAAC,QAAQ,CAAC,IAAI;YACvB,GAAC,0BAA0B,CAAC,oBAAoB,IAAG,QAAQ;YAC3D,GAAC,0BAA0B,CAAC,2BAA2B,IAAG,SAAS;eACpE,CAAC;QAEF,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YAC3B,UAAU,CAAC,0BAA0B,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SAC1E;QAED,IAAI;YACF,IAAM,QAAQ,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;YAC/B,UAAU,CAAC,0BAA0B,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC;SAC1E;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,KAAK,CAAC,oCAAkC,CAAG,CAAC,CAAC;SACnD;QAED,OAAO,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IACH,0BAAC;AAAD,CAAC,AA9BD,IA8BC;AAED,MAAM,CAAC,IAAM,mBAAmB,GAAG,IAAI,mBAAmB,EAAE,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { diag } from '@opentelemetry/api';\nimport { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';\nimport { Resource } from '../../Resource';\nimport { DetectorSync, ResourceAttributes } from '../../types';\nimport { ResourceDetectionConfig } from '../../config';\nimport { IResource } from '../../IResource';\nimport * as os from 'os';\n\n/**\n * ProcessDetectorSync will be used to detect the resources related current process running\n * and being instrumented from the NodeJS Process module.\n */\nclass ProcessDetectorSync implements DetectorSync {\n  detect(_config?: ResourceDetectionConfig): IResource {\n    const attributes: ResourceAttributes = {\n      [SemanticResourceAttributes.PROCESS_PID]: process.pid,\n      [SemanticResourceAttributes.PROCESS_EXECUTABLE_NAME]: process.title,\n      [SemanticResourceAttributes.PROCESS_EXECUTABLE_PATH]: process.execPath,\n      [SemanticResourceAttributes.PROCESS_COMMAND_ARGS]: [\n        process.argv[0],\n        ...process.execArgv,\n        ...process.argv.slice(1),\n      ],\n      [SemanticResourceAttributes.PROCESS_RUNTIME_VERSION]:\n        process.versions.node,\n      [SemanticResourceAttributes.PROCESS_RUNTIME_NAME]: 'nodejs',\n      [SemanticResourceAttributes.PROCESS_RUNTIME_DESCRIPTION]: 'Node.js',\n    };\n\n    if (process.argv.length > 1) {\n      attributes[SemanticResourceAttributes.PROCESS_COMMAND] = process.argv[1];\n    }\n\n    try {\n      const userInfo = os.userInfo();\n      attributes[SemanticResourceAttributes.PROCESS_OWNER] = userInfo.username;\n    } catch (e) {\n      diag.debug(`error obtaining process owner: ${e}`);\n    }\n\n    return new Resource(attributes);\n  }\n}\n\nexport const processDetectorSync = new ProcessDetectorSync();\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/default-service-name.d.ts

@@ -0,0 +1,2 @@
+export declare function defaultServiceName(): string;
+//# sourceMappingURL=default-service-name.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/default-service-name.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function defaultServiceName() {
+    return "unknown_service:" + process.argv0;
+}
+//# sourceMappingURL=default-service-name.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/default-service-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-service-name.js","sourceRoot":"","sources":["../../../../src/platform/node/default-service-name.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,UAAU,kBAAkB;IAChC,OAAO,qBAAmB,OAAO,CAAC,KAAO,CAAC;AAC5C,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function defaultServiceName(): string {\n  return `unknown_service:${process.argv0}`;\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/index.d.ts

@@ -0,0 +1,8 @@
+export * from './default-service-name';
+export * from './HostDetector';
+export * from './OSDetector';
+export * from './HostDetectorSync';
+export * from './OSDetectorSync';
+export * from './ProcessDetector';
+export * from './ProcessDetectorSync';
+//# sourceMappingURL=index.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/index.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './default-service-name';
+export * from './HostDetector';
+export * from './OSDetector';
+export * from './HostDetectorSync';
+export * from './OSDetectorSync';
+export * from './ProcessDetector';
+export * from './ProcessDetectorSync';
+//# sourceMappingURL=index.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/platform/node/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport * from './default-service-name';\nexport * from './HostDetector';\nexport * from './OSDetector';\nexport * from './HostDetectorSync';\nexport * from './OSDetectorSync';\nexport * from './ProcessDetector';\nexport * from './ProcessDetectorSync';\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/execAsync.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import * as child_process from 'child_process';
+export declare const execAsync: typeof child_process.exec.__promisify__;
+//# sourceMappingURL=execAsync.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/execAsync.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as child_process from 'child_process';
+import * as util from 'util';
+export var execAsync = util.promisify(child_process.exec);
+//# sourceMappingURL=execAsync.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/execAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execAsync.js","sourceRoot":"","sources":["../../../../../src/platform/node/machine-id/execAsync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,aAAa,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,MAAM,CAAC,IAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as child_process from 'child_process';\nimport * as util from 'util';\n\nexport const execAsync = util.promisify(child_process.exec);\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/getMachineId-bsd.d.ts

@@ -0,0 +1,2 @@
+export declare function getMachineId(): Promise<string>;
+//# sourceMappingURL=getMachineId-bsd.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/getMachineId-bsd.js

@@ -0,0 +1,85 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { promises as fs } from 'fs';
+import { execAsync } from './execAsync';
+import { diag } from '@opentelemetry/api';
+export function getMachineId() {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, e_1, result, e_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, fs.readFile('/etc/hostid', { encoding: 'utf8' })];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result.trim()];
+                case 2:
+                    e_1 = _a.sent();
+                    diag.debug("error reading machine id: " + e_1);
+                    return [3 /*break*/, 3];
+                case 3:
+                    _a.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, execAsync('kenv -q smbios.system.uuid')];
+                case 4:
+                    result = _a.sent();
+                    return [2 /*return*/, result.stdout.trim()];
+                case 5:
+                    e_2 = _a.sent();
+                    diag.debug("error reading machine id: " + e_2);
+                    return [3 /*break*/, 6];
+                case 6: return [2 /*return*/, ''];
+            }
+        });
+    });
+}
+//# sourceMappingURL=getMachineId-bsd.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/getMachineId-bsd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMachineId-bsd.js","sourceRoot":"","sources":["../../../../../src/platform/node/machine-id/getMachineId-bsd.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,MAAM,UAAgB,YAAY;;;;;;;oBAEf,qBAAM,EAAE,CAAC,QAAQ,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAA;;oBAA/D,MAAM,GAAG,SAAsD;oBACrE,sBAAO,MAAM,CAAC,IAAI,EAAE,EAAC;;;oBAErB,IAAI,CAAC,KAAK,CAAC,+BAA6B,GAAG,CAAC,CAAC;;;;oBAI9B,qBAAM,SAAS,CAAC,4BAA4B,CAAC,EAAA;;oBAAtD,MAAM,GAAG,SAA6C;oBAC5D,sBAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAC;;;oBAE5B,IAAI,CAAC,KAAK,CAAC,+BAA6B,GAAG,CAAC,CAAC;;wBAG/C,sBAAO,EAAE,EAAC;;;;CACX","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { promises as fs } from 'fs';\nimport { execAsync } from './execAsync';\nimport { diag } from '@opentelemetry/api';\n\nexport async function getMachineId(): Promise<string> {\n  try {\n    const result = await fs.readFile('/etc/hostid', { encoding: 'utf8' });\n    return result.trim();\n  } catch (e) {\n    diag.debug(`error reading machine id: ${e}`);\n  }\n\n  try {\n    const result = await execAsync('kenv -q smbios.system.uuid');\n    return result.stdout.trim();\n  } catch (e) {\n    diag.debug(`error reading machine id: ${e}`);\n  }\n\n  return '';\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/getMachineId-darwin.d.ts

@@ -0,0 +1,2 @@
+export declare function getMachineId(): Promise<string>;
+//# sourceMappingURL=getMachineId-darwin.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/getMachineId-darwin.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { execAsync } from './execAsync';
+import { diag } from '@opentelemetry/api';
+export function getMachineId() {
+    return __awaiter(this, void 0, void 0, function () {
+        var result, idLine, parts, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, execAsync('ioreg -rd1 -c "IOPlatformExpertDevice"')];
+                case 1:
+                    result = _a.sent();
+                    idLine = result.stdout
+                        .split('\n')
+                        .find(function (line) { return line.includes('IOPlatformUUID'); });
+                    if (!idLine) {
+                        return [2 /*return*/, ''];
+                    }
+                    parts = idLine.split('" = "');
+                    if (parts.length === 2) {
+                        return [2 /*return*/, parts[1].slice(0, -1)];
+                    }
+                    return [3 /*break*/, 3];
+                case 2:
+                    e_1 = _a.sent();
+                    diag.debug("error reading machine id: " + e_1);
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/, ''];
+            }
+        });
+    });
+}
+//# sourceMappingURL=getMachineId-darwin.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/getMachineId-darwin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMachineId-darwin.js","sourceRoot":"","sources":["../../../../../src/platform/node/machine-id/getMachineId-darwin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,MAAM,UAAgB,YAAY;;;;;;;oBAEf,qBAAM,SAAS,CAAC,wCAAwC,CAAC,EAAA;;oBAAlE,MAAM,GAAG,SAAyD;oBAElE,MAAM,GAAG,MAAM,CAAC,MAAM;yBACzB,KAAK,CAAC,IAAI,CAAC;yBACX,IAAI,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAA/B,CAA+B,CAAC,CAAC;oBAEjD,IAAI,CAAC,MAAM,EAAE;wBACX,sBAAO,EAAE,EAAC;qBACX;oBAEK,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;oBACpC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;wBACtB,sBAAO,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC;qBAC9B;;;;oBAED,IAAI,CAAC,KAAK,CAAC,+BAA6B,GAAG,CAAC,CAAC;;wBAG/C,sBAAO,EAAE,EAAC;;;;CACX","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { execAsync } from './execAsync';\nimport { diag } from '@opentelemetry/api';\n\nexport async function getMachineId(): Promise<string> {\n  try {\n    const result = await execAsync('ioreg -rd1 -c \"IOPlatformExpertDevice\"');\n\n    const idLine = result.stdout\n      .split('\\n')\n      .find(line => line.includes('IOPlatformUUID'));\n\n    if (!idLine) {\n      return '';\n    }\n\n    const parts = idLine.split('\" = \"');\n    if (parts.length === 2) {\n      return parts[1].slice(0, -1);\n    }\n  } catch (e) {\n    diag.debug(`error reading machine id: ${e}`);\n  }\n\n  return '';\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/getMachineId-linux.d.ts

@@ -0,0 +1,2 @@
+export declare function getMachineId(): Promise<string>;
+//# sourceMappingURL=getMachineId-linux.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/resources/build/esm/platform/node/machine-id/getMachineId-linux.js

@@ -0,0 +1,111 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { promises as fs } from 'fs';
+import { diag } from '@opentelemetry/api';
+export function getMachineId() {
+    return __awaiter(this, void 0, void 0, function () {
+        var paths, paths_1, paths_1_1, path, result, e_1, e_2_1;
+        var e_2, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    paths = ['/etc/machine-id', '/var/lib/dbus/machine-id'];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 8, 9, 10]);
+                    paths_1 = __values(paths), paths_1_1 = paths_1.next();
+                    _b.label = 2;
+                case 2:
+                    if (!!paths_1_1.done) return [3 /*break*/, 7];
+                    path = paths_1_1.value;
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, fs.readFile(path, { encoding: 'utf8' })];
+                case 4:
+                    result = _b.sent();
+                    return [2 /*return*/, result.trim()];
+                case 5:
+                    e_1 = _b.sent();
+                    diag.debug("error reading machine id: " + e_1);
+                    return [3 /*break*/, 6];
+                case 6:
+                    paths_1_1 = paths_1.next();
+                    return [3 /*break*/, 2];
+                case 7: return [3 /*break*/, 10];
+                case 8:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 10];
+                case 9:
+                    try {
+                        if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 10: return [2 /*return*/, ''];
+            }
+        });
+    });
+}
+//# sourceMappingURL=getMachineId-linux.js.map