extwee 2.3.10 → 2.3.12

package/test/Web/web-core-coverage.test.js

@@ -1,175 +0,0 @@
-/**
- * @jest-environment node
- */
-
-// Test the global object detection logic more comprehensively
-// by testing the function directly rather than trying to manipulate the environment
-
-describe('web-core.js comprehensive global detection coverage', () => {
-  
-  it('should test all branches of global object detection function', () => {
-    // Recreate the exact global object detection logic from web-core.js
-    const globalObjectDetectionFunction = function() {
-      if (typeof globalThis !== 'undefined') return globalThis;
-      if (typeof window !== 'undefined') return window;  
-      if (typeof global !== 'undefined') return global;
-      if (typeof self !== 'undefined') return self;
-      return null;
-    };
-
-    // Test the function logic
-    const result = globalObjectDetectionFunction();
-    
-    // In Node.js environment, should return global
-    expect(result).toBe(global);
-    
-    // Verify that global exists
-    expect(typeof global).toBe('object');
-    expect(global).toBeTruthy();
-  });
-
-  it('should test globalThis branch when globalThis is defined', () => {
-    // Test what happens when globalThis is available
-    const mockGlobalThisTest = function() {
-      // Simulate having globalThis available
-      const fakeGlobalThis = { type: 'globalThis' };
-      
-      // Mock the detection logic
-      const detect = function(mockGlobalThis, mockWindow, mockGlobal, mockSelf) {
-        if (typeof mockGlobalThis !== 'undefined' && mockGlobalThis !== null) return 'globalThis';
-        if (typeof mockWindow !== 'undefined' && mockWindow !== null) return 'window';
-        if (typeof mockGlobal !== 'undefined' && mockGlobal !== null) return 'global';
-        if (typeof mockSelf !== 'undefined' && mockSelf !== null) return 'self';
-        return 'null';
-      };
-      
-      return detect(fakeGlobalThis, undefined, undefined, undefined);
-    };
-    
-    expect(mockGlobalThisTest()).toBe('globalThis');
-  });
-
-  it('should test self branch when only self is available', () => {
-    // Test what happens when only self is available (Web Worker scenario)
-    const mockSelfTest = function() {
-      const fakeSelf = { type: 'self' };
-      
-      const detect = function(mockGlobalThis, mockWindow, mockGlobal, mockSelf) {
-        if (typeof mockGlobalThis !== 'undefined' && mockGlobalThis !== null) return 'globalThis';
-        if (typeof mockWindow !== 'undefined' && mockWindow !== null) return 'window';
-        if (typeof mockGlobal !== 'undefined' && mockGlobal !== null) return 'global';
-        if (typeof mockSelf !== 'undefined' && mockSelf !== null) return 'self';
-        return 'null';
-      };
-      
-      return detect(undefined, undefined, undefined, fakeSelf);
-    };
-    
-    expect(mockSelfTest()).toBe('self');
-  });
-
-  it('should test null return when no global objects are available', () => {
-    // Test what happens when no global objects are available
-    const mockNullTest = function() {
-      const detect = function(mockGlobalThis, mockWindow, mockGlobal, mockSelf) {
-        if (typeof mockGlobalThis !== 'undefined' && mockGlobalThis !== null) return 'globalThis';
-        if (typeof mockWindow !== 'undefined' && mockWindow !== null) return 'window';
-        if (typeof mockGlobal !== 'undefined' && mockGlobal !== null) return 'global';
-        if (typeof mockSelf !== 'undefined' && mockSelf !== null) return 'self';
-        return null;
-      };
-      
-      return detect(undefined, undefined, undefined, undefined);
-    };
-    
-    expect(mockNullTest()).toBeNull();
-  });
-
-  it('should test priority order of global object detection', () => {
-    // Test that globalThis > window > global > self priority is maintained
-    const mockPriorityTest = function() {
-      const fakeGlobalThis = { type: 'globalThis' };
-      const fakeWindow = { type: 'window' };
-      const fakeGlobal = { type: 'global' };
-      const fakeSelf = { type: 'self' };
-      
-      const detect = function(mockGlobalThis, mockWindow, mockGlobal, mockSelf) {
-        if (typeof mockGlobalThis !== 'undefined' && mockGlobalThis !== null) return mockGlobalThis;
-        if (typeof mockWindow !== 'undefined' && mockWindow !== null) return mockWindow;
-        if (typeof mockGlobal !== 'undefined' && mockGlobal !== null) return mockGlobal;
-        if (typeof mockSelf !== 'undefined' && mockSelf !== null) return mockSelf;
-        return null;
-      };
-      
-      // When all are available, should return globalThis
-      const result1 = detect(fakeGlobalThis, fakeWindow, fakeGlobal, fakeSelf);
-      expect(result1.type).toBe('globalThis');
-      
-      // When globalThis not available, should return window
-      const result2 = detect(undefined, fakeWindow, fakeGlobal, fakeSelf);
-      expect(result2.type).toBe('window');
-      
-      // When globalThis and window not available, should return global
-      const result3 = detect(undefined, undefined, fakeGlobal, fakeSelf);
-      expect(result3.type).toBe('global');
-      
-      // When only self available, should return self
-      const result4 = detect(undefined, undefined, undefined, fakeSelf);
-      expect(result4.type).toBe('self');
-    };
-    
-    mockPriorityTest();
-  });
-
-  it('should verify that global object assignment logic works', () => {
-    // Test the assignment logic without requiring module import
-    const mockAssignmentScenario = function() {
-      // Simulate Node.js environment where global is available
-      const fakeGlobal = {};
-      const fakeExtwee = { version: '2.3.3' };
-      
-      // Simulate the assignment from web-core.js
-      if (fakeGlobal) {
-        fakeGlobal.Extwee = fakeExtwee;
-      }
-      
-      return fakeGlobal;
-    };
-    
-    const result = mockAssignmentScenario();
-    expect(result.Extwee).toBeDefined();
-    expect(result.Extwee.version).toBe('2.3.3');
-  });
-
-  it('should test that assignment is conditional on globalObject being truthy', () => {
-    // This tests the `if (globalObject)` condition in the web-core.js
-    const mockAssignmentTest = function() {
-      let assignmentCalled = false;
-      
-      const mockAssign = function(globalObj, extweeObj) {
-        if (globalObj) {
-          globalObj.Extwee = extweeObj;
-          assignmentCalled = true;
-        }
-      };
-      
-      // Test with truthy global object
-      const fakeGlobal = {};
-      const fakeExtwee = { version: '2.3.3' };
-      mockAssign(fakeGlobal, fakeExtwee);
-      
-      expect(assignmentCalled).toBe(true);
-      expect(fakeGlobal.Extwee).toBe(fakeExtwee);
-      
-      // Test with null global object
-      assignmentCalled = false;
-      const fakeGlobal2 = {};
-      mockAssign(null, fakeExtwee);
-      
-      expect(assignmentCalled).toBe(false);
-      expect(fakeGlobal2.Extwee).toBeUndefined();
-    };
-    
-    mockAssignmentTest();
-  });
-});

package/test/Web/web-core-global.test.js

@@ -1,93 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-// Import the module to test global assignment in jsdom environment
-import '../../src/Web/web-core.js';
-
-describe('web-core.js global assignment in browser environment', () => {
-  it('should assign Extwee to window in jsdom environment', () => {
-    // Should have assigned to window automatically on import
-    expect(window.Extwee).toBeDefined();
-    expect(window.Extwee.version).toBe('2.3.3');
-    expect(typeof window.Extwee).toBe('object');
-  });
-
-  it('should have all expected properties on window.Extwee', () => {
-    expect(window.Extwee.parseTwee).toBeDefined();
-    expect(window.Extwee.parseJSON).toBeDefined();
-    expect(window.Extwee.parseStoryFormat).toBeDefined();
-    expect(window.Extwee.parseTwine2HTML).toBeDefined();
-    expect(window.Extwee.compileTwine2HTML).toBeDefined();
-    expect(window.Extwee.generateIFID).toBeDefined();
-    expect(window.Extwee.Story).toBeDefined();
-    expect(window.Extwee.Passage).toBeDefined();
-    expect(window.Extwee.StoryFormat).toBeDefined();
-  });
-
-  it('should verify global object detection logic ran (window branch)', () => {
-    // This test verifies that the globalObject detection function found window
-    // and assigned Extwee to it
-    expect(typeof window).toBe('object');
-    expect(window).not.toBeNull();
-    expect(window.Extwee).toBeDefined();
-  });
-
-  it('should have working functions on window.Extwee', () => {
-    // Test that the assigned functions work correctly
-    const ifid = window.Extwee.generateIFID();
-    expect(ifid).toMatch(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/);
-    
-    const story = new window.Extwee.Story();
-    expect(story).toBeDefined();
-    expect(Array.isArray(story.passages)).toBe(true);
-  });
-
-  // Test to exercise the globalObject detection function
-  it('should test global object detection function directly', () => {
-    // This is a test to simulate what the global object detection function does
-    // We can't easily mock the environment during module loading, but we can
-    // verify the logic by recreating it
-    
-    const globalObjectDetectionLogic = function() {
-      if (typeof globalThis !== 'undefined') return 'globalThis';
-      if (typeof window !== 'undefined') return 'window'; 
-      if (typeof global !== 'undefined') return 'global';
-      if (typeof self !== 'undefined') return 'self';
-      return null;
-    };
-
-    // In jsdom environment, could return 'globalThis' or 'window' depending on Node.js version
-    const result = globalObjectDetectionLogic();
-    expect(['globalThis', 'window']).toContain(result);
-    
-    // Verify window exists and is truthy
-    expect(typeof window).toBe('object');
-    expect(window).toBeTruthy();
-  });
-
-  // Test for globalThis availability (Modern browsers/Node.js 12+)
-  it('should handle globalThis when available', () => {
-    // Test the globalThis branch logic
-    if (typeof globalThis !== 'undefined') {
-      expect(globalThis).toBeDefined();
-      expect(typeof globalThis).toBe('object');
-      
-      // In environments with globalThis, it should be preferred
-      const mockGlobalDetection = function() {
-        if (typeof globalThis !== 'undefined') return 'globalThis';
-        if (typeof window !== 'undefined') return 'window';
-        if (typeof global !== 'undefined') return 'global';
-        if (typeof self !== 'undefined') return 'self';
-        return null;
-      };
-      
-      // Should prefer globalThis if available
-      const detectionResult = mockGlobalDetection();
-      expect(['globalThis', 'window']).toContain(detectionResult);
-    } else {
-      // If globalThis not available, should fall back to window in jsdom
-      expect(typeof window).toBe('object');
-    }
-  });
-});

package/test/Web/web-core.test.js

@@ -1,156 +0,0 @@
-/**
- * @jest-environment node
- */
-
-// Import to test basic functionality
-import { parseTwee, parseJSON, parseStoryFormat, parseTwine2HTML, compileTwine2HTML, generateIFID, Story, Passage, StoryFormat } from '../../src/Web/web-core.js';
-import Extwee from '../../src/Web/web-core.js';
-
-describe('web-core.js Node.js environment tests', () => {
-  describe('ES6 module exports', () => {
-    it('should export all individual functions and classes', () => {
-      expect(parseTwee).toBeDefined();
-      expect(typeof parseTwee).toBe('function');
-      
-      expect(parseJSON).toBeDefined();
-      expect(typeof parseJSON).toBe('function');
-      
-      expect(parseStoryFormat).toBeDefined();
-      expect(typeof parseStoryFormat).toBe('function');
-      
-      expect(parseTwine2HTML).toBeDefined();
-      expect(typeof parseTwine2HTML).toBe('function');
-      
-      expect(compileTwine2HTML).toBeDefined();
-      expect(typeof compileTwine2HTML).toBe('function');
-      
-      expect(generateIFID).toBeDefined();
-      expect(typeof generateIFID).toBe('function');
-      
-      expect(Story).toBeDefined();
-      expect(typeof Story).toBe('function');
-      
-      expect(Passage).toBeDefined();
-      expect(typeof Passage).toBe('function');
-      
-      expect(StoryFormat).toBeDefined();
-      expect(typeof StoryFormat).toBe('function');
-    });
-
-    it('should export default Extwee object with all properties', () => {
-      expect(Extwee).toBeDefined();
-      expect(typeof Extwee).toBe('object');
-      
-      expect(Extwee.parseTwee).toBeDefined();
-      expect(Extwee.parseJSON).toBeDefined();
-      expect(Extwee.parseStoryFormat).toBeDefined();
-      expect(Extwee.parseTwine2HTML).toBeDefined();
-      expect(Extwee.compileTwine2HTML).toBeDefined();
-      expect(Extwee.generateIFID).toBeDefined();
-      expect(Extwee.Story).toBeDefined();
-      expect(Extwee.Passage).toBeDefined();
-      expect(Extwee.StoryFormat).toBeDefined();
-      expect(Extwee.version).toBe('2.3.3');
-    });
-
-    it('should have same functions in default export as individual exports', () => {
-      expect(Extwee.parseTwee).toBe(parseTwee);
-      expect(Extwee.parseJSON).toBe(parseJSON);
-      expect(Extwee.parseStoryFormat).toBe(parseStoryFormat);
-      expect(Extwee.parseTwine2HTML).toBe(parseTwine2HTML);
-      expect(Extwee.compileTwine2HTML).toBe(compileTwine2HTML);
-      expect(Extwee.generateIFID).toBe(generateIFID);
-      expect(Extwee.Story).toBe(Story);
-      expect(Extwee.Passage).toBe(Passage);
-      expect(Extwee.StoryFormat).toBe(StoryFormat);
-    });
-  });
-
-  describe('Functional integration tests', () => {
-    it('should have working parseTwee function', () => {
-      const tweeContent = `:: Start
-This is the start passage.`;
-      
-      const result = parseTwee(tweeContent);
-      expect(result).toBeDefined();
-      expect(result.passages).toBeDefined();
-      expect(result.passages.length).toBe(1);
-      expect(result.passages[0].name).toBe('Start');
-    });
-
-    it('should have working parseJSON function', () => {
-      const jsonContent = JSON.stringify({
-        passages: [{
-          name: 'Start',
-          text: 'This is the start passage.',
-          tags: [],
-          metadata: {}
-        }],
-        name: 'Test Story',
-        IFID: '12345678-1234-5678-9012-123456789012'
-      });
-      
-      const result = parseJSON(jsonContent);
-      expect(result).toBeDefined();
-      expect(result.passages).toBeDefined();
-      expect(result.passages.length).toBe(1);
-      expect(result.name).toBe('Test Story');
-    });
-
-    it('should have working generateIFID function', () => {
-      const ifid = generateIFID();
-      expect(ifid).toMatch(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/);
-    });
-
-    it('should have working Story constructor', () => {
-      const story = new Story();
-      expect(story).toBeDefined();
-      expect(story.passages).toBeDefined();
-      expect(Array.isArray(story.passages)).toBe(true);
-    });
-
-    it('should have working Passage constructor', () => {
-      const passage = new Passage();
-      expect(passage).toBeDefined();
-      expect(passage.name).toBeDefined();
-      expect(passage.text).toBeDefined();
-      expect(passage.tags).toBeDefined();
-      expect(Array.isArray(passage.tags)).toBe(true);
-    });
-
-    it('should have working StoryFormat constructor', () => {
-      const storyFormat = new StoryFormat();
-      expect(storyFormat).toBeDefined();
-      expect(storyFormat.name).toBeDefined();
-      expect(storyFormat.version).toBeDefined();
-    });
-  });
-
-  describe('Global assignment in Node.js environment', () => {
-    it('should assign to global.global in Node.js environment', () => {
-      // In Node.js environment, it should assign to global.global
-      expect(global.global.Extwee).toBeDefined();
-      expect(global.global.Extwee.version).toBe('2.3.3');
-      expect(global.global.Extwee).toBe(Extwee);
-    });
-    
-    it('should verify global object detection logic execution', () => {
-      // This test ensures the global object detection function runs
-      // In Node.js, typeof globalThis is 'undefined' (in older versions), 
-      // typeof window is 'undefined', typeof global is 'object', typeof self is 'undefined'
-      expect(typeof global).toBe('object');
-      expect(global.global).toBeDefined();
-    });
-  });
-
-  describe('Version consistency', () => {
-    it('should have consistent version across exports', () => {
-      expect(Extwee.version).toBe('2.3.3');
-    });
-
-    it('should have version property as string', () => {
-      expect(typeof Extwee.version).toBe('string');
-      expect(Extwee.version.length).toBeGreaterThan(0);
-    });
-  });
-});

package/test/Web/web-exports.test.js

@@ -1,136 +0,0 @@
-/**
- * @jest-environment node
- */
-
-/**
- * Tests for package.json web exports
- * These tests verify that users can import the web builds directly
- */
-
-import { describe, expect, it } from '@jest/globals';
-import fs from 'node:fs';
-import path from 'node:path';
-
-describe('Web build exports', () => {
-  const buildDir = path.resolve(process.cwd(), 'build');
-  
-  describe('Web build files exist', () => {
-    it('should have core web build file', () => {
-      const corePath = path.join(buildDir, 'extwee.core.min.js');
-      expect(fs.existsSync(corePath)).toBe(true);
-    });
-
-    it('should have twine1html web build file', () => {
-      const twine1Path = path.join(buildDir, 'extwee.twine1html.min.js');
-      expect(fs.existsSync(twine1Path)).toBe(true);
-    });
-
-    it('should have twine2archive web build file', () => {
-      const twine2ArchivePath = path.join(buildDir, 'extwee.twine2archive.min.js');
-      expect(fs.existsSync(twine2ArchivePath)).toBe(true);
-    });
-
-    it('should have tws web build file', () => {
-      const twsPath = path.join(buildDir, 'extwee.tws.min.js');
-      expect(fs.existsSync(twsPath)).toBe(true);
-    });
-  });
-
-  describe('Web build content validation', () => {
-    it('should have UMD wrapper in core build', () => {
-      const corePath = path.join(buildDir, 'extwee.core.min.js');
-      const content = fs.readFileSync(corePath, 'utf8');
-      
-      // Should contain UMD pattern
-      expect(content).toMatch(/function.*webpackUniversalModuleDefinition|define.*function|module\.exports.*function/);
-      
-      // Should be minified (no excessive whitespace)
-      expect(content.split('\n').length).toBeLessThan(10);
-    });
-
-    it('should have Extwee functionality in core build', () => {
-      const corePath = path.join(buildDir, 'extwee.core.min.js');
-      const content = fs.readFileSync(corePath, 'utf8');
-      
-      // Should contain core Extwee functionality
-      expect(content).toMatch(/parseTwee|parseJSON|generateIFID|Story/);
-    });
-
-    it('should have appropriate size for minified builds', () => {
-      const corePath = path.join(buildDir, 'extwee.core.min.js');
-      const stats = fs.statSync(corePath);
-      
-      // Core build should be substantial but not excessive (roughly 50-150KB)
-      expect(stats.size).toBeGreaterThan(50000); // > 50KB
-      expect(stats.size).toBeLessThan(150000);   // < 150KB
-    });
-
-    it('should have smaller specialized builds', () => {
-      const corePath = path.join(buildDir, 'extwee.core.min.js');
-      const twine1Path = path.join(buildDir, 'extwee.twine1html.min.js');
-      const coreStats = fs.statSync(corePath);
-      const twine1Stats = fs.statSync(twine1Path);
-      
-      // Specialized builds should be smaller than core
-      expect(twine1Stats.size).toBeLessThan(coreStats.size);
-    });
-  });
-
-  describe('Package.json exports configuration', () => {
-    it('should have exports field in package.json', () => {
-      const packagePath = path.resolve(process.cwd(), 'package.json');
-      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-      
-      expect(packageJson.exports).toBeDefined();
-      expect(typeof packageJson.exports).toBe('object');
-    });
-
-    it('should have correct web export paths', () => {
-      const packagePath = path.resolve(process.cwd(), 'package.json');
-      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-      
-      expect(packageJson.exports['.']).toBe('./index.js');
-      expect(packageJson.exports['./web']).toBe('./build/extwee.core.min.js');
-      expect(packageJson.exports['./web/core']).toBe('./build/extwee.core.min.js');
-      expect(packageJson.exports['./web/twine1html']).toBe('./build/extwee.twine1html.min.js');
-      expect(packageJson.exports['./web/twine2archive']).toBe('./build/extwee.twine2archive.min.js');
-      expect(packageJson.exports['./web/tws']).toBe('./build/extwee.tws.min.js');
-    });
-
-    it('should point to files that actually exist', () => {
-      const packagePath = path.resolve(process.cwd(), 'package.json');
-      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-      
-      // Check each web export path exists
-      const webExports = [
-        packageJson.exports['./web'],
-        packageJson.exports['./web/core'],
-        packageJson.exports['./web/twine1html'],
-        packageJson.exports['./web/twine2archive'],
-        packageJson.exports['./web/tws']
-      ];
-      
-      for (const exportPath of webExports) {
-        const fullPath = path.resolve(process.cwd(), exportPath);
-        expect(fs.existsSync(fullPath)).toBe(true);
-      }
-    });
-  });
-
-  describe('Documentation for web exports', () => {
-    it('should provide clear usage examples', () => {
-      // This test documents how users can import the web builds
-      const usageExamples = {
-        'import Extwee from "extwee/web"': 'Core web build with most functionality',
-        'import Extwee from "extwee/web/core"': 'Same as above (explicit)',
-        'import Extwee from "extwee/web/twine1html"': 'Twine 1 HTML parsing only',
-        'import Extwee from "extwee/web/twine2archive"': 'Twine 2 Archive HTML parsing only',
-        'import Extwee from "extwee/web/tws"': 'TWS (Twine 1 workspace) parsing only'
-      };
-      
-      // Just verify we have documented the usage patterns
-      expect(Object.keys(usageExamples)).toHaveLength(5);
-      expect(usageExamples['import Extwee from "extwee/web"']).toContain('Core web build');
-    });
-  });
-});

package/test/Web/web-twine1html.test.js

@@ -1,105 +0,0 @@
-/**
- * @jest-environment node
- */
-
-/**
- * Tests for web-twine1html.js module
- * Tests module exports and functionality
- */
-
-import { describe, expect, it } from '@jest/globals';
-
-// Import to test basic functionality
-import { parse, compile } from '../../src/Web/web-twine1html.js';
-import Extwee from '../../src/Web/web-twine1html.js';
-
-describe('web-twine1html.js module tests', () => {
-
-  describe('ES6 module exports', () => {
-    it('should export parse and compile functions', () => {
-      expect(parse).toBeDefined();
-      expect(compile).toBeDefined();
-      expect(typeof parse).toBe('function');
-      expect(typeof compile).toBe('function');
-    });
-
-    it('should export default object with parseTwine1HTML and compileTwine1HTML', () => {
-      expect(Extwee.parseTwine1HTML).toBeDefined();
-      expect(Extwee.compileTwine1HTML).toBeDefined();
-      expect(Extwee.parse).toBeDefined();
-      expect(Extwee.compile).toBeDefined();
-      expect(typeof Extwee.parseTwine1HTML).toBe('function');
-      expect(typeof Extwee.compileTwine1HTML).toBe('function');
-    });
-  });
-
-  describe('Global object assignment', () => {
-    it('should assign functions to global object when available', () => {
-      // In Node.js environment, should assign to globalThis
-      expect(globalThis.Extwee).toBeDefined();
-      expect(globalThis.Extwee.parseTwine1HTML).toBeDefined();
-      expect(globalThis.Extwee.compileTwine1HTML).toBeDefined();
-      expect(typeof globalThis.Extwee.parseTwine1HTML).toBe('function');
-      expect(typeof globalThis.Extwee.compileTwine1HTML).toBe('function');
-    });
-
-    it('should preserve existing Extwee properties', () => {
-      // Should not overwrite the entire object, just add properties
-      if (globalThis.Extwee && globalThis.Extwee.version) {
-        expect(globalThis.Extwee.version).toBeDefined();
-      }
-      expect(globalThis.Extwee.parseTwine1HTML).toBeDefined();
-      expect(globalThis.Extwee.compileTwine1HTML).toBeDefined();
-    });
-  });
-
-  describe('Functional integration tests', () => {
-    it('should have working parseTwine1HTML function', () => {
-      // Test with valid Twine 1 HTML
-      const sampleHtml = `
-        <html>
-          <head><title>Test</title></head>
-          <body>
-            <div id="storeArea" data-size="2">
-              <div tiddler="Start" tags="" twine-position="100,100">Start passage</div>
-            </div>
-          </body>
-        </html>
-      `;
-      
-      expect(() => {
-        const result = parse(sampleHtml);
-        expect(result).toBeDefined();
-        expect(result.passages).toBeDefined();
-      }).not.toThrow();
-    });
-
-    it('should have working compileTwine1HTML function', async () => {
-      // Import required classes dynamically to avoid circular imports
-      const { Story } = await import('../../src/Story.js');
-      const { default: Passage } = await import('../../src/Passage.js');
-      const { default: StoryFormat } = await import('../../src/StoryFormat.js');
-      
-      const story = new Story();
-      story.name = "Test Story";
-      story.addPassage(new Passage("Start", "This is the start", [], {}));
-      
-      const storyFormat = new StoryFormat();
-      storyFormat.source = "window.story = STORY;";
-      storyFormat.version = "1.0.0";
-      
-      expect(() => {
-        const result = compile(story, storyFormat, '', '', '');
-        expect(typeof result).toBe('string');
-      }).not.toThrow();
-    });
-
-    it('should have same functions in exports and global', () => {
-      // Test that parse and compile are the same functions
-      expect(parse).toBe(Extwee.parse);
-      expect(compile).toBe(Extwee.compile);
-      expect(parse).toBe(Extwee.parseTwine1HTML);
-      expect(compile).toBe(Extwee.compileTwine1HTML);
-    });
-  });
-});