@hashgraphonline/standards-sdk 0.1.144 → 0.1.146-chore-jsr-improvements.canary.74bacb9.89

package/dist/es/standards-sdk.es46.js

@@ -1,355 +1,465 @@
-class TemplateEngine {
-  constructor(logger) {
-    this.templateCache = /* @__PURE__ */ new Map();
-    this.helpers = /* @__PURE__ */ new Map();
-    this.compiledTemplates = /* @__PURE__ */ new Map();
+import { HCS } from "./standards-sdk.es2.js";
+import { isSSREnvironment } from "./standards-sdk.es117.js";
+class ResourceManager {
+  constructor(networkType, logger, hcs, options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.currentCacheSize = 0;
+    this.supportedImageTypes = /* @__PURE__ */ new Set([
+      "image/png",
+      "image/jpeg",
+      "image/jpg",
+      "image/gif",
+      "image/svg+xml",
+      "image/webp"
+    ]);
+    this.dangerousJSPatterns = [
+      /eval\s*\(/g,
+      /Function\s*\(/g,
+      /setTimeout\s*\(\s*["'].*["']/g,
+      /setInterval\s*\(\s*["'].*["']/g,
+      /document\.write/g,
+      /innerHTML\s*=/g,
+      /outerHTML\s*=/g
+    ];
+    this.dangerousCSSPatterns = [
+      /javascript\s*:/gi,
+      /@import.*url\s*\(\s*["']?javascript:/gi,
+      /expression\s*\(/gi,
+      /behavior\s*:/gi
+    ];
     this.logger = logger;
-    this.setupBuiltinHelpers();
+    this.hcs = hcs || new HCS();
+    this.options = {
+      cacheTTL: options.cacheTTL || 3e5,
+      maxCacheSize: options.maxCacheSize || 50 * 1024 * 1024,
+      maxResourceSize: options.maxResourceSize || 5 * 1024 * 1024
+    };
   }
   /**
-   * Render a template with the given context
+   * Load CSS resource from HCS-3
    */
-  async render(template, context = {}) {
-    this.logger.debug("Rendering template", {
-      templateLength: template.length,
-      context: JSON.stringify(context, null, 2),
-      attributesType: context.attributes ? typeof context.attributes : "undefined",
-      contextKeys: Object.keys(context)
-    });
+  async loadCSS(topicId) {
+    this.logger.debug("Loading CSS resource", { topicId });
     try {
-      const cacheKey = this.getCacheKey(template);
-      let compiled = this.templateCache.get(cacheKey);
-      if (!compiled) {
-        compiled = await this.compileTemplate(template);
-        this.templateCache.set(cacheKey, compiled);
+      const resource = await this.loadResource(topicId);
+      if (resource.contentType !== "text/css") {
+        throw new Error(`Expected CSS resource, got ${resource.contentType}`);
       }
-      const result = compiled.render(this.sanitizeContext(context));
-      this.logger.debug("Template rendered successfully", {
-        resultLength: result.length
+      const content = resource.content;
+      const sanitized = this.sanitizeCSS(content);
+      this.logger.debug("CSS resource loaded successfully", {
+        topicId,
+        size: content.length,
+        sanitized: sanitized.length !== content.length
       });
-      return result;
+      return sanitized;
     } catch (error) {
-      this.logger.error("Template rendering failed", { error, template });
+      this.logger.error("Failed to load CSS resource", { topicId, error });
       throw new Error(
-        `Template rendering failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to load CSS resource: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   /**
-   * Precompile a template and store it with a name
+   * Load JavaScript resource from HCS-3
    */
-  async precompile(name, template) {
-    this.logger.debug("Precompiling template", {
-      name,
-      templateLength: template.length
-    });
+  async loadJS(topicId) {
+    this.logger.debug("Loading JavaScript resource", { topicId });
     try {
-      const compiled = await this.compileTemplate(template);
-      this.compiledTemplates.set(name, compiled);
-      this.logger.debug("Template precompiled successfully", { name });
+      const resource = await this.loadResource(topicId);
+      if (!resource.contentType.includes("javascript") && !resource.contentType.includes("ecmascript")) {
+        throw new Error(
+          `Expected JavaScript resource, got ${resource.contentType}`
+        );
+      }
+      const content = resource.content;
+      if (content.length > this.options.maxResourceSize) {
+        throw new Error("JavaScript resource too large");
+      }
+      const sanitized = this.sanitizeJavaScript(content);
+      this.logger.debug("JavaScript resource loaded successfully", {
+        topicId,
+        size: content.length,
+        sanitized: sanitized.length !== content.length
+      });
+      return sanitized;
     } catch (error) {
-      this.logger.error("Template precompilation failed", { error, name });
+      this.logger.error("Failed to load JavaScript resource", {
+        topicId,
+        error
+      });
       throw new Error(
-        `Template precompilation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to load JavaScript resource: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   /**
-   * Render a precompiled template
+   * Load image resource from HCS-3 as Blob
    */
-  async renderCompiled(name, context = {}) {
-    const compiled = this.compiledTemplates.get(name);
-    if (!compiled) {
-      throw new Error(`Precompiled template '${name}' not found`);
-    }
-    this.logger.debug("Rendering precompiled template", { name });
+  async loadImage(topicId) {
+    this.logger.debug("Loading image resource", { topicId });
     try {
-      const result = compiled.render(this.sanitizeContext(context));
-      this.logger.debug("Precompiled template rendered successfully", { name });
-      return result;
-    } catch (error) {
-      this.logger.error("Precompiled template rendering failed", {
-        error,
-        name
+      const resource = await this.loadResource(topicId);
+      if (!this.supportedImageTypes.has(resource.contentType)) {
+        throw new Error(`Unsupported image format: ${resource.contentType}`);
+      }
+      const content = resource.content;
+      const view = new Uint8Array(content);
+      const blob = new Blob([view.buffer], { type: resource.contentType });
+      this.logger.debug("Image resource loaded successfully", {
+        topicId,
+        size: content.length,
+        type: resource.contentType
       });
+      return blob;
+    } catch (error) {
+      this.logger.error("Failed to load image resource", { topicId, error });
       throw new Error(
-        `Template rendering failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to load image resource: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   /**
-   * Register a custom helper function
+   * Load template resource from HCS-3
    */
-  registerHelper(name, helper) {
-    this.helpers.set(name, helper);
-    this.logger.debug("Helper registered", { name });
+  async loadTemplate(topicId) {
+    this.logger.debug("Loading template resource", { topicId });
+    try {
+      const resource = await this.loadResource(topicId);
+      const content = resource.content;
+      this.validateTemplateSyntax(content);
+      const sanitized = this.sanitizeTemplate(content);
+      this.logger.debug("Template resource loaded successfully", {
+        topicId,
+        size: content.length
+      });
+      return sanitized;
+    } catch (error) {
+      this.logger.error("Failed to load template resource", { topicId, error });
+      throw new Error(
+        `Failed to load template resource: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
   }
   /**
-   * Clear template cache
+   * Load resource with integrity verification
    */
-  clearCache() {
-    this.templateCache.clear();
-    this.logger.debug("Template cache cleared");
+  async loadWithIntegrityCheck(topicId, expectedHash) {
+    this.logger.debug("Loading resource with integrity check", {
+      topicId,
+      expectedHash
+    });
+    try {
+      const resource = await this.loadResource(topicId);
+      const verified = await this.verifyIntegrity(
+        resource.content,
+        expectedHash
+      );
+      if (!verified) {
+        throw new Error("Resource integrity verification failed");
+      }
+      this.logger.debug("Resource integrity verified", { topicId });
+      return {
+        content: resource.content,
+        verified,
+        contentType: resource.contentType
+      };
+    } catch (error) {
+      this.logger.error("Resource integrity check failed", { topicId, error });
+      throw error;
+    }
   }
   /**
-   * Get cache size for testing
+   * Verify content integrity using SHA-256 hash
    */
-  getCacheSize() {
-    return this.templateCache.size;
+  async verifyIntegrity(content, expectedHash) {
+    try {
+      if (isSSREnvironment()) {
+        this.logger.warn("Integrity verification skipped in SSR environment");
+        return true;
+      }
+      const webCrypto = globalThis.crypto;
+      if (typeof webCrypto === "undefined" || !webCrypto.subtle) {
+        this.logger.warn(
+          "WebCrypto not available, skipping integrity verification"
+        );
+        return true;
+      }
+      const buffer = typeof content === "string" ? new TextEncoder().encode(content) : content;
+      const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+      const copy = new Uint8Array(bytes);
+      const hashBuffer = await webCrypto.subtle.digest("SHA-256", copy.buffer);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const actualHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+      return actualHash === expectedHash.toLowerCase();
+    } catch (error) {
+      this.logger.error("Error verifying integrity", { error });
+      return false;
+    }
   }
   /**
-   * Compile a template string into executable function
+   * Load multiple dependencies in correct order
    */
-  async compileTemplate(template) {
-    this.validateTemplate(template);
-    const compiled = {
-      source: template,
-      compiled: true,
-      render: (context) => this.executeTemplate(template, context)
-    };
-    return compiled;
+  async loadDependencies(dependencies) {
+    this.logger.debug("Loading dependencies", { count: dependencies.length });
+    try {
+      this.detectCircularDependencies(dependencies);
+      const sorted = this.topologicalSort(dependencies);
+      const results = [];
+      for (const dep of sorted) {
+        let content;
+        switch (dep.type) {
+          case "css":
+            content = await this.loadCSS(dep.topicId);
+            break;
+          case "js":
+            content = await this.loadJS(dep.topicId);
+            break;
+          case "template":
+            content = await this.loadTemplate(dep.topicId);
+            break;
+          case "image":
+            const blob = await this.loadImage(dep.topicId);
+            content = new Uint8Array(await blob.arrayBuffer());
+            break;
+          default:
+            throw new Error(`Unsupported dependency type: ${dep.type}`);
+        }
+        results.push({
+          topicId: dep.topicId,
+          content,
+          contentType: this.getContentTypeForType(dep.type),
+          type: dep.type
+        });
+      }
+      this.logger.debug("Dependencies loaded successfully", {
+        count: results.length
+      });
+      return results;
+    } catch (error) {
+      this.logger.error("Failed to load dependencies", { error });
+      throw error;
+    }
   }
   /**
-   * Execute template rendering logic
+   * Clear resource cache
    */
-  executeTemplate(template, context) {
-    let result = template;
-    result = this.processHelpers(result, context);
-    result = this.processLoops(result, context);
-    result = this.processConditionals(result, context);
-    result = this.processVariables(result, context);
-    return result;
+  clearCache() {
+    this.cache.clear();
+    this.currentCacheSize = 0;
+    this.logger.debug("Resource cache cleared");
   }
   /**
-   * Process conditional statements (if/unless/else)
+   * Get current cache size for testing
    */
-  processConditionals(template, context) {
-    let result = template;
-    const nestedIfElseRegex = /\{\{#if\s+([^}]+)\}\}((?:[^{]|\{(?!\{)|\{\{(?!#if|\{#else|\{\/if))*?)\{\{#if\s+([^}]+)\}\}((?:[^{]|\{(?!\{)|\{\{(?!#if|#else|\/if))*?)\{\{else\}\}((?:[^{]|\{(?!\{)|\{\{(?!#if|#else|\/if))*?)\{\{\/if\}\}((?:[^{]|\{(?!\{)|\{\{(?!\/if))*?)\{\{\/if\}\}/gs;
-    result = result.replace(
-      nestedIfElseRegex,
-      (match, outerCondition, beforeInner, innerCondition, innerTrue, innerFalse, afterInner) => {
-        const outerValue = this.evaluateCondition(outerCondition, context);
-        if (!outerValue) return "";
-        const innerValue = this.evaluateCondition(innerCondition, context);
-        const innerResult = innerValue ? innerTrue : innerFalse;
-        return beforeInner + innerResult + afterInner;
-      }
-    );
-    const ifElseRegex = /\{\{#if\s+([^}]+)\}\}((?:[^{]|\{(?!\{)|\{\{(?!else|\/if))*?)\{\{else\}\}((?:[^{]|\{(?!\{)|\{\{(?!\/if))*?)\{\{\/if\}\}/gs;
-    result = result.replace(
-      ifElseRegex,
-      (match, condition, trueBranch, falseBranch) => {
-        const conditionValue = this.evaluateCondition(condition, context);
-        return conditionValue ? trueBranch : falseBranch;
-      }
-    );
-    const ifRegex = /\{\{#if\s+([^}]+)\}\}((?:[^{]|\{(?!\{)|\{\{(?!\/if))*?)\{\{\/if\}\}/gs;
-    result = result.replace(ifRegex, (match, condition, content) => {
-      const conditionValue = this.evaluateCondition(condition, context);
-      return conditionValue ? content : "";
-    });
-    const unlessRegex = /\{\{#unless\s+([^}]+)\}\}((?:[^{]|\{(?!\{)|\{\{(?!\/unless))*?)\{\{\/unless\}\}/gs;
-    result = result.replace(unlessRegex, (match, condition, content) => {
-      const conditionValue = this.evaluateCondition(condition, context);
-      return !conditionValue ? content : "";
-    });
-    return result;
+  getCacheSize() {
+    return this.currentCacheSize;
   }
   /**
-   * Process loop statements (each)
+   * Load resource with caching
    */
-  processLoops(template, context) {
-    let result = template;
-    const eachRegex = /\{\{#each\s+([^}]+)\}\}(.*?)\{\{\/each\}\}/gs;
-    result = result.replace(eachRegex, (match, variable, content) => {
-      const items = this.getNestedValue(variable, context);
-      if (!items) return "";
-      let loopResult = "";
-      if (Array.isArray(items)) {
-        items.forEach((item, index) => {
-          let itemContent = content;
-          itemContent = itemContent.replace(
-            /\{\{this\}\}/g,
-            this.escapeHtml(String(item))
-          );
-          itemContent = itemContent.replace(/\{\{@index\}\}/g, String(index));
-          if (typeof item === "object" && item !== null) {
-            for (const [key, value] of Object.entries(item)) {
-              const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
-              itemContent = itemContent.replace(
-                regex,
-                this.escapeHtml(String(value))
-              );
-            }
-          }
-          itemContent = itemContent.replace(
-            /\{\{\.\.\/([^}]+)\}\}/g,
-            (parentMatch, parentPath) => {
-              const parentValue = this.getNestedValue(parentPath, context);
-              return this.escapeHtml(String(parentValue || ""));
-            }
-          );
-          loopResult += itemContent;
-        });
-      } else if (typeof items === "object") {
-        for (const [key, value] of Object.entries(items)) {
-          let itemContent = content;
-          itemContent = itemContent.replace(
-            /\{\{@key\}\}/g,
-            this.escapeHtml(key)
-          );
-          itemContent = itemContent.replace(
-            /\{\{this\}\}/g,
-            this.escapeHtml(String(value))
-          );
-          loopResult += itemContent;
-        }
-      }
-      return loopResult;
-    });
-    return result;
+  async loadResource(topicId) {
+    const cached = this.getFromCache(topicId);
+    if (cached) {
+      this.logger.debug("Resource loaded from cache", { topicId });
+      return cached;
+    }
+    const blob = await this.hcs.retrieveHCS1Data(topicId);
+    const contentType = blob.type || "application/octet-stream";
+    let content;
+    if (contentType.startsWith("text/") || contentType.includes("javascript") || contentType.includes("json")) {
+      content = await blob.text();
+    } else {
+      content = new Uint8Array(await blob.arrayBuffer());
+    }
+    const resource = {
+      content,
+      contentType,
+      size: blob.size
+    };
+    this.addToCache(topicId, resource);
+    return resource;
   }
   /**
-   * Process variable substitutions
+   * Get resource from cache if valid
    */
-  processVariables(template, context) {
-    let result = template;
-    const tripleRegex = /\{\{\{([^}]+)\}\}\}/g;
-    result = result.replace(tripleRegex, (match, variable) => {
-      const value = this.getNestedValue(variable.trim(), context);
-      return this.sanitizeHtml(String(value || ""));
-    });
-    const doubleRegex = /\{\{([^}#/]+)\}\}/g;
-    result = result.replace(doubleRegex, (match, variable) => {
-      const trimmed = variable.trim();
-      if (trimmed.startsWith("#") || trimmed.startsWith("/") || trimmed.startsWith("else")) {
-        return match;
-      }
-      const value = this.getNestedValue(trimmed, context);
-      if (value === 0 || value === false) {
-        return this.escapeHtml(String(value));
-      }
-      return this.escapeHtml(String(value || ""));
-    });
-    return result;
+  getFromCache(topicId) {
+    const entry = this.cache.get(topicId);
+    if (!entry) return null;
+    if (Date.now() - entry.timestamp > this.options.cacheTTL) {
+      this.removeFromCache(topicId);
+      return null;
+    }
+    return entry.data;
   }
   /**
-   * Process helper functions
+   * Add resource to cache with size management
    */
-  processHelpers(template, context) {
-    let result = template;
-    const withRegex = /\{\{#with\s+([^}]+)\}\}(.*?)\{\{\/with\}\}/gs;
-    result = result.replace(withRegex, (match, variable, content) => {
-      const newContext = this.getNestedValue(variable.trim(), context);
-      if (!newContext) return "";
-      return this.executeTemplate(content, newContext);
-    });
-    for (const [helperName, helperFunc] of this.helpers) {
-      const helperRegex = new RegExp(
-        `\\{\\{${helperName}\\s+([^}]+)\\}\\}`,
-        "g"
-      );
-      result = result.replace(helperRegex, (match, args) => {
-        try {
-          const argValue = this.getNestedValue(args.trim(), context);
-          return this.escapeHtml(helperFunc.call(context, argValue));
-        } catch (error) {
-          this.logger.warn("Helper execution failed", { helperName, error });
-          return "";
-        }
-      });
+  addToCache(topicId, resource) {
+    const size = typeof resource.content === "string" ? resource.content.length : resource.content.byteLength;
+    if (size > this.options.maxCacheSize / 2) {
+      this.logger.warn("Resource too large for cache", { topicId, size });
+      return;
+    }
+    while (this.currentCacheSize + size > this.options.maxCacheSize && this.cache.size > 0) {
+      this.evictOldestEntry();
     }
-    return result;
+    const entry = {
+      data: resource,
+      timestamp: Date.now(),
+      size
+    };
+    this.cache.set(topicId, entry);
+    this.currentCacheSize += size;
+    this.logger.debug("Resource added to cache", {
+      topicId,
+      size,
+      totalCacheSize: this.currentCacheSize
+    });
   }
   /**
-   * Evaluate condition for if/unless statements
+   * Remove resource from cache
    */
-  evaluateCondition(condition, context) {
-    const value = this.getNestedValue(condition.trim(), context);
-    return Boolean(value);
+  removeFromCache(topicId) {
+    const entry = this.cache.get(topicId);
+    if (entry) {
+      this.cache.delete(topicId);
+      this.currentCacheSize -= entry.size;
+    }
   }
   /**
-   * Get nested value from context using dot notation
+   * Evict oldest cache entry
    */
-  getNestedValue(path, context) {
-    if (!path || !context) return void 0;
-    const keys = path.split(".");
-    let current = context;
-    for (const key of keys) {
-      if (current === null || current === void 0 || typeof current !== "object") {
-        return void 0;
+  evictOldestEntry() {
+    let oldest = null;
+    let oldestTime = Date.now();
+    for (const [topicId, entry] of this.cache) {
+      if (entry.timestamp < oldestTime) {
+        oldestTime = entry.timestamp;
+        oldest = topicId;
       }
-      current = current[key];
     }
-    return current;
+    if (oldest) {
+      this.removeFromCache(oldest);
+      this.logger.debug("Evicted oldest cache entry", { topicId: oldest });
+    }
   }
   /**
-   * Sanitize context to prevent XSS
+   * Sanitize CSS content
    */
-  sanitizeContext(context) {
-    if (context === null || context === void 0) return context;
-    const seen = /* @__PURE__ */ new WeakSet();
-    const sanitize = (obj) => {
-      if (obj === null || typeof obj !== "object") return obj;
-      if (seen.has(obj)) return "[Circular]";
-      seen.add(obj);
-      if (Array.isArray(obj)) {
-        return obj.map(sanitize);
-      }
-      const sanitized = {};
-      for (const [key, value] of Object.entries(obj)) {
-        sanitized[key] = sanitize(value);
-      }
-      return sanitized;
-    };
-    return sanitize(context);
+  sanitizeCSS(css) {
+    let sanitized = css;
+    for (const pattern of this.dangerousCSSPatterns) {
+      sanitized = sanitized.replace(pattern, "");
+    }
+    return sanitized;
   }
   /**
-   * Escape HTML to prevent XSS
+   * Sanitize JavaScript content
    */
-  escapeHtml(text) {
-    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+  sanitizeJavaScript(js) {
+    let sanitized = js;
+    for (const pattern of this.dangerousJSPatterns) {
+      sanitized = sanitized.replace(pattern, "");
+    }
+    return sanitized;
   }
   /**
-   * Sanitize HTML to allow safe tags only
+   * Sanitize template content
    */
-  sanitizeHtml(html) {
-    return html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/javascript:/gi, "").replace(/on\w+\s*=/gi, "");
+  sanitizeTemplate(template) {
+    return template.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/on\w+\s*=\s*["'][^"']*["']/gi, "").replace(/javascript\s*:/gi, "");
   }
   /**
    * Validate template syntax
    */
-  validateTemplate(template) {
+  validateTemplateSyntax(template) {
+    const openBraces = (template.match(/\{\{/g) || []).length;
+    const closeBraces = (template.match(/\}\}/g) || []).length;
+    if (openBraces !== closeBraces) {
+      throw new Error("Invalid template syntax: unmatched braces");
+    }
     const openBlocks = (template.match(/\{\{#\w+/g) || []).length;
     const closeBlocks = (template.match(/\{\{\/\w+/g) || []).length;
     if (openBlocks !== closeBlocks) {
       throw new Error("Invalid template syntax: unclosed block helpers");
     }
-    const malformed = /\{\{[^}]*$|\{\{[^}]*\{\{/.test(template);
-    if (malformed) {
-      throw new Error("Invalid template syntax: malformed handlebars");
+  }
+  /**
+   * Detect circular dependencies
+   */
+  detectCircularDependencies(dependencies) {
+    const dependencyMap = /* @__PURE__ */ new Map();
+    for (const dep of dependencies) {
+      dependencyMap.set(dep.topicId, dep.depends || []);
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (topicId) => {
+      if (visiting.has(topicId)) {
+        throw new Error("Circular dependency detected");
+      }
+      if (visited.has(topicId)) return;
+      visiting.add(topicId);
+      const deps = dependencyMap.get(topicId) || [];
+      for (const dep of deps) {
+        visit(dep);
+      }
+      visiting.delete(topicId);
+      visited.add(topicId);
+    };
+    for (const dep of dependencies) {
+      visit(dep.topicId);
     }
   }
   /**
-   * Generate cache key for template
+   * Topological sort of dependencies
    */
-  getCacheKey(template) {
-    let hash = 0;
-    for (let i = 0; i < template.length; i++) {
-      const char = template.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
+  topologicalSort(dependencies) {
+    const dependencyMap = /* @__PURE__ */ new Map();
+    const dependsMap = /* @__PURE__ */ new Map();
+    for (const dep of dependencies) {
+      dependencyMap.set(dep.topicId, dep);
+      dependsMap.set(dep.topicId, dep.depends || []);
     }
-    return hash.toString();
+    const sorted = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (topicId) => {
+      if (visited.has(topicId)) return;
+      const deps = dependsMap.get(topicId) || [];
+      for (const dep of deps) {
+        visit(dep);
+      }
+      visited.add(topicId);
+      const depObj = dependencyMap.get(topicId);
+      if (depObj) {
+        sorted.push(depObj);
+      }
+    };
+    for (const dep of dependencies) {
+      visit(dep.topicId);
+    }
+    return sorted;
   }
   /**
-   * Setup builtin helper functions
+   * Get content type for dependency type
    */
-  setupBuiltinHelpers() {
+  getContentTypeForType(type) {
+    switch (type) {
+      case "css":
+        return "text/css";
+      case "js":
+        return "application/javascript";
+      case "template":
+        return "text/html";
+      case "image":
+        return "image/*";
+      default:
+        return "application/octet-stream";
+    }
   }
 }
 export {
-  TemplateEngine
+  ResourceManager
 };
 //# sourceMappingURL=standards-sdk.es46.js.map