pax_global_header00006660000000000000000000000064151475234310014517gustar00rootroot0000000000000052 comment=a02f6a0dd67e77f7cdb87dafdcb1927aea794866 PyJavaBridge-2a/000077500000000000000000000000001514752343100136725ustar00rootroot00000000000000PyJavaBridge-2a/.github/000077500000000000000000000000001514752343100152325ustar00rootroot00000000000000PyJavaBridge-2a/.github/workflows/000077500000000000000000000000001514752343100172675ustar00rootroot00000000000000PyJavaBridge-2a/.github/workflows/deploy-pages.yml000066400000000000000000000016361514752343100224110ustar00rootroot00000000000000name: Deploy static content to Pages on: push: branches: ["main"] workflow_dispatch: permissions: contents: read pages: write id-token: write concurrency: group: "pages" cancel-in-progress: false jobs: deploy: environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4 - name: Setup Python uses: actions/setup-python@v5 with: python-version: '3.12' - name: Build docs run: | pip install markdown python docs/build.py - name: Setup Pages uses: actions/configure-pages@v5 - name: Upload artifact uses: actions/upload-pages-artifact@v3 with: path: 'docs/site' - name: Deploy to GitHub Pages id: deployment uses: actions/deploy-pages@v4 PyJavaBridge-2a/.gitignore000066400000000000000000000001411514752343100156560ustar00rootroot00000000000000# Gradle .gradle gradle gradlew.bat # Build build bin # MC Server server # Cache __pycache__/ PyJavaBridge-2a/.markdownlint.json000066400000000000000000000001151514752343100173510ustar00rootroot00000000000000{ "MD024": false, "MD013": {"line_length": 500}, "MD001": false }PyJavaBridge-2a/.vscode/000077500000000000000000000000001514752343100152335ustar00rootroot00000000000000PyJavaBridge-2a/.vscode/settings.json000066400000000000000000000003241514752343100177650ustar00rootroot00000000000000{ "yaml.schemas": { "https://www.schemastore.org/bukkit-plugin.json": "file:///home/omena0/Github/PyJavaBridge/src/main/resources/plugin.yml" }, "java.compile.nullAnalysis.mode": "automatic" }PyJavaBridge-2a/README.md000066400000000000000000000006551514752343100151570ustar00rootroot00000000000000 # PyJavaBridge **Expose bukkit APIs to python scripts via easy-to-use wrappers.** ```py from bridge import * # Use via /helloworld @command("Hello world command") async def helloworld(event: Event): event.player.send_message("Hello, World!") ``` The entire API is, at core, asynchronous. ## Documentation See [The Docs](https://omena0.github.io/PyJavaBridge/index.html) ## Changelog See [changelog.md](changelog.md) PyJavaBridge-2a/build.gradle000066400000000000000000000034441514752343100161560ustar00rootroot00000000000000plugins { id 'java' } group = 'com.pyjavabridge' def resolveVersionFromGit = { def versionPattern = ~/^(\d+[A-Z])\s*-\s*.*$/ def result = providers.exec { commandLine 'git', 'log', '-1', '--pretty=%s' ignoreExitValue = true } def lastSubject = result.standardOutput.asText.get().trim() if (lastSubject ==~ versionPattern) { def matcher = (lastSubject =~ versionPattern) return matcher[0][1] } return 'dev' } version = resolveVersionFromGit() def paperVersion = '1.21.4-R0.1-SNAPSHOT' dependencies { compileOnly "io.papermc.paper:paper-api:${paperVersion}" } repositories { mavenCentral() maven { url = 'https://repo.papermc.io/repository/maven-public/' } } java { toolchain { languageVersion = JavaLanguageVersion.of(21) } } tasks.withType(JavaCompile).configureEach { options.encoding = 'UTF-8' options.release = 21 } tasks.named('processResources') { filesMatching('plugin.yml') { expand(version: project.version) } } tasks.named('jar') { archiveFileName = "${project.name}-${project.version}.jar" } tasks.register('copyPluginJar', Copy) { dependsOn tasks.named('jar') from tasks.named('jar').flatMap { it.archiveFile } def pluginsDir = layout.projectDirectory.dir("server/plugins") into pluginsDir doFirst { pluginsDir.asFile.mkdirs() delete(fileTree(pluginsDir) { include "pyjavabridge-*.jar" }) } } tasks.register('copyReleaseJar', Copy) { dependsOn tasks.named('jar') from tasks.named('jar').flatMap { it.archiveFile } into "${rootDir}/releases" doFirst { file("${rootDir}/releases").mkdirs() } } tasks.named('build') { finalizedBy tasks.named('copyPluginJar'), tasks.named('copyReleaseJar') } PyJavaBridge-2a/changelog.md000066400000000000000000000051161514752343100161460ustar00rootroot00000000000000 # Changelog ## 2A Feature update ### Changes #### Networking - Optimized for single request latency - Use batching to speed up multiple requests - Now uses orjson for faster parsing - Automatic handle management #### New APIs - Tab list API on Player - Region utils on World: .set_block, .fill, .replace, .fill_sphere, .fill_cylinder, .fill_line - Particle shapes on World - Entity spawn helpers on World: spawn_at_player, spawn_projectile, spawn_with_nbt. - Support for command execution on Server - world.entities property - RaycastResult.distance and .hit_face #### New helpers - Sidebar: Scoreboard helper - Config: TOML config helper - Cooldown: Automatically manage cooldowns - Hologram: Show floating text - Menu / MenuItem: Create easy chest GUIs - ActionBarDisplay: Manage action bars easily - BossBarDisplay: Manage boss bars easily - BlockDisplay: Show fake blocks - ItemDisplay: Show floating items - ImageDisplay: Show images in the world - ItemBuilder: Easily create items - Shutdown event #### API improvements - Fixed type errors regarding EnumValue not matching its child classes - EntityGoneException now extends BridgeError - @task decorator: Run tasks on an interval - Added event priority and throttle_ms parameters - Added command description parameter - Location: .add, .clone, .distance, .distance_squared are now sync - Scoreboard, Team, Objective, and BossBar creation methods are now sync - Config: Added support for multiple formats, toml (default), json, and properties. - Commands can be now executes as console #### Cleanup - Entity class moved before Player - Moved most of the code from a single file to multiple - Improved typing across python bridge #### Misc - Added dev versioning for non-release commits - Added wiki site ## 1D Damage event Changes: - Added damage override to damage events - Added damage source and damager attributes to damage events - Added shooter attribute to projectile entities - Added owner attribute to tamed entities - Added is_tamed attribute to entities ## 1C API cleanup Changes: - Added call_sync and field_or_call_sync helpers - Turned most attribute-like methods into attributes - Made all attributes synchronous - Added create classmethods to most classes - Added optional args to world.spawn_entity - Allowed spawning of non-living entities - Fixed player UUID lookups - Chat event return value is now the chat message format for that event - Bugfixes ## 1B API expansion Changes: - Implemented most missing APIs - Added proper command argument parsing - Added docs - Bugfixes ## 1A Initial release Changes: - Added most common APIs PyJavaBridge-2a/docs/000077500000000000000000000000001514752343100146225ustar00rootroot00000000000000PyJavaBridge-2a/docs/build.py000066400000000000000000000350051514752343100162760ustar00rootroot00000000000000#!/usr/bin/env python3 """ Build script for PyJavaBridge documentation. Converts Markdown source files in docs/src/ into a static HTML site in docs/. Requirements: pip install markdown Usage: python docs/build.py """ import os import re import sys try: import markdown from markdown.extensions.fenced_code import FencedCodeExtension from markdown.extensions.tables import TableExtension from markdown.extensions.toc import TocExtension except ImportError: print("Installing markdown library...") import subprocess subprocess.check_call([sys.executable, "-m", "pip", "install", "markdown"]) import markdown from markdown.extensions.fenced_code import FencedCodeExtension from markdown.extensions.tables import TableExtension from markdown.extensions.toc import TocExtension # ── Paths ──────────────────────────────────────────────────────────────────── DOCS_DIR = os.path.dirname(os.path.abspath(__file__)) SRC_DIR = os.path.join(DOCS_DIR, "src") OUT_DIR = os.path.join(DOCS_DIR, "site") # ── Sidebar definition (order matters) ────────────────────────────────────── SIDEBAR = [ ("Getting Started", [ ("index", "Home"), ("decorators", "Decorators"), ("exceptions", "Exceptions"), ("examples", "Examples"), ]), ("Core", [ ("server", "Server"), ("event", "Event"), ("entity", "Entity"), ("player", "Player"), ]), ("World & Space", [ ("world", "World"), ("location", "Location"), ("block", "Block"), ("chunk", "Chunk"), ("vector", "Vector"), ]), ("Items & Inventory", [ ("item", "Item"), ("itembuilder", "ItemBuilder"), ("inventory", "Inventory"), ("menu", "Menu"), ]), ("Effects & Attributes", [ ("effect", "Effect"), ("potion", "Potion"), ("attribute", "Attribute"), ("advancement", "Advancement"), ]), ("Scoreboards & UI", [ ("bossbar", "BossBar"), ("scoreboard", "Scoreboard"), ("objective", "Objective"), ("team", "Team"), ("sidebar", "Sidebar"), ]), ("Helpers", [ ("config", "Config"), ("cooldown", "Cooldown"), ("hologram", "Hologram"), ("enumvalue", "EnumValue"), ("enums", "Enums"), ]), ("Display Entities", [ ("actionbardisplay", "ActionBarDisplay"), ("bossbardisplay", "BossBarDisplay"), ("blockdisplay", "BlockDisplay"), ("itemdisplay", "ItemDisplay"), ("imagedisplay", "ImageDisplay"), ]), ("Utilities", [ ("raycast", "Raycast"), ("chat", "Chat"), ("reflect", "Reflect"), ]), ] # ── Frontmatter parser ────────────────────────────────────────────────────── def parse_frontmatter(text): """Extract YAML-like frontmatter and return (metadata_dict, remaining_text).""" if not text.startswith("---"): return {}, text end = text.find("---", 3) if end == -1: return {}, text fm_block = text[3:end].strip() body = text[end + 3:].strip() meta = {} for line in fm_block.splitlines(): if ":" in line: key, val = line.split(":", 1) meta[key.strip()] = val.strip() return meta, body # ── Syntax highlighter (simple Python-aware) ──────────────────────────────── PYTHON_KEYWORDS = { 'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield', } def highlight_python(code): """Python syntax highlighter using single-pass tokenization. Input is already HTML-escaped by the markdown library, so we must NOT escape again. A single combined regex ensures that once a token is matched (e.g. a string containing the word 'class'), later patterns cannot corrupt it by matching inside the replacement HTML. """ token_specs = [ # Order matters – earlier patterns take priority ('st', r'""".*?"""|'''.*?''''), ('st', r'f?"(?:[^&]|&(?!quot;))*?"|f?'(?:[^&]|&(?!#x27;))*?''), ('cm', r'#[^\n]*'), ('dc', r'@\w+'), ('nb', r'\b\d+\.?\d*\b'), ('kw', r'\b(?:' + '|'.join(sorted(PYTHON_KEYWORDS, key=len, reverse=True)) + r')\b'), ] combined = '|'.join( f'(?P{pat})' for i, (_, pat) in enumerate(token_specs) ) classes = [cls for cls, _ in token_specs] def _replacer(m): for i, cls in enumerate(classes): if m.group(f'g{i}') is not None: return f'{m.group(f"g{i}")}' return m.group(0) return re.sub(combined, _replacer, code, flags=re.DOTALL) def highlight_code_blocks(html_text): """Find 
 blocks and apply highlighting."""
    def replace_block(m):
        lang = m.group(1) or ""
        inner = m.group(2)
        if "python" in lang or "py" in lang:
            inner = highlight_python(inner)
        return f'
{inner}
'

    html_text = re.sub(
        r'
(.*?)
',
        replace_block, html_text, flags=re.DOTALL
    )
    # Also handle bare 
 blocks (no language) — don't highlight
    return html_text

# ── Markdown → HTML conversion ──────────────────────────────────────────────

def convert_markdown(text):
    """Convert markdown text to HTML with extensions."""
    md = markdown.Markdown(extensions=[
        FencedCodeExtension(),
        TableExtension(),
        TocExtension(permalink=False, toc_depth="2-3"),
    ])
    html = md.convert(text)
    toc_tokens = md.toc_tokens
    md.reset()
    return html, toc_tokens


def rewrite_md_links(html_text):
    """Rewrite .md links to .html links."""
    return re.sub(r'href="([^"#]+)\.md(#[^"]*)?"', lambda m: f'href="{m.group(1)}.html{m.group(2) or ""}"', html_text)


def process_blockquotes(html_text):
    """Convert blockquotes starting with bold markers into styled callouts."""
    def classify(m):
        content = m.group(1)
        if content.strip().startswith("Warning"):
            cls = "callout callout-warn"
        elif content.strip().startswith("Tip"):
            cls = "callout callout-tip"
        elif content.strip().startswith("Note"):
            cls = "callout callout-info"
        elif content.strip().startswith("See also"):
            cls = "callout callout-info"
        else:
            cls = "callout callout-info"
        return f'
{content}
'
    return re.sub(r'
\s*(.*?)\s*
', classify, html_text, flags=re.DOTALL)


# ── HTML template ────────────────────────────────────────────────────────────

def _section_key(name):
    """Turn a section name into a compact localStorage key."""
    return re.sub(r'[^a-z0-9]+', '-', name.lower()).strip('-')


def build_sidebar_html(current_slug):
    """Generate the sidebar HTML."""
    parts = [
        '
',
        '  ',
        '  ',
        '
',
    ]

    for section_name, pages in SIDEBAR:
        key = _section_key(section_name)
        # Collapsed by default
        parts.extend(
            (
                '
',
                f'  ',
                '  
    ',
            )
        )
        for slug, label in pages:
            active = ' class="active"' if slug == current_slug else ''
            href = "index.html" if slug == "index" else f"{slug}.html"
            parts.append(f'    
  • {label}
    • ')

        parts.extend(('  
', '
'))
    return "\n".join(parts)


def build_toc_sidebar(toc_tokens, current_slug):
    """Build the sidebar with 'On This Page' TOC at the top, then nav sections."""
    nav = build_sidebar_html(current_slug)
    if not toc_tokens:
        return nav

    # Build the TOC block (always expanded, inserted before nav links)
    toc_parts = [
        '
',
        '  
On This Page
',
        '  
    ',
    ]
    for token in toc_tokens:
        toc_parts.append(f'    
  • {token["name"]}
    • ')
        toc_parts.extend(
            f'    
  • {child["name"]}
    • '
            for child in token.get("children", [])
        )
    toc_parts.extend(('  
', '
'))

    # Insert TOC right after the search box (first )
    search_end = nav.find('') + len('')
    return nav[:search_end] + '\n' + '\n'.join(toc_parts) + '\n' + nav[search_end:]


TEMPLATE = """\



  
  
  {page_title} — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      {subtitle_html}
      {body}
    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


"""

# ── Builder ──────────────────────────────────────────────────────────────────

def build_page(slug):
    """Build a single page from its markdown source."""
    src_path = os.path.join(SRC_DIR, f"{slug}.md")
    if not os.path.exists(src_path):
        print(f"  ⚠ Skipping {slug}.md (not found)")
        return

    with open(src_path, "r", encoding="utf-8") as f:
        raw = f.read()

    meta, body_md = parse_frontmatter(raw)
    title = meta.get("title", slug.capitalize())
    subtitle = meta.get("subtitle", "")
    page_title = meta.get("page_title", title)
    og_title = meta.get("og_title", title)

    # Convert markdown to HTML
    body_html, toc_tokens = convert_markdown(body_md)

    # Post-processing
    body_html = rewrite_md_links(body_html)
    body_html = highlight_code_blocks(body_html)
    body_html = process_blockquotes(body_html)

    # Build subtitle HTML
    subtitle_html = f'
{subtitle}
' if subtitle else ""

    # Build sidebar
    sidebar = build_toc_sidebar(toc_tokens, slug)

    # Build OG description from subtitle or first paragraph
    og_description = subtitle if subtitle else f"{title} — PyJavaBridge documentation"

    # Render template
    out_html = TEMPLATE.format(
        title=title,
        page_title=page_title,
        og_title=og_title,
        og_description=og_description,
        subtitle_html=subtitle_html,
        body=body_html,
        sidebar=sidebar,
    )

    out_name = "index.html" if slug == "index" else f"{slug}.html"
    out_path = os.path.join(OUT_DIR, out_name)
    with open(out_path, "w", encoding="utf-8") as f:
        f.write(out_html)


def get_all_slugs():
    """Get all markdown file slugs from the sidebar definition."""
    slugs = []
    for _, pages in SIDEBAR:
        slugs.extend(slug for slug, _ in pages)
    return slugs


def main():
    print("📖 Building PyJavaBridge docs...")
    print(f"   Source: {SRC_DIR}")
    print(f"   Output: {OUT_DIR}")
    print()

    slugs = get_all_slugs()

    # Also check for any .md files not in the sidebar
    if os.path.isdir(SRC_DIR):
        for fname in os.listdir(SRC_DIR):
            if fname.endswith(".md"):
                s = fname[:-3]
                if s not in slugs:
                    slugs.append(s)

    built = 0
    for slug in slugs:
        src = os.path.join(SRC_DIR, f"{slug}.md")
        if os.path.exists(src):
            build_page(slug)
            print(f"  ✓ {slug}.html")
            built += 1

    print(f"\n✅ Built {built} pages")


if __name__ == "__main__":
    main()
PyJavaBridge-2a/docs/site/000077500000000000000000000000001514752343100155665ustar00rootroot00000000000000PyJavaBridge-2a/docs/site/actionbardisplay.html000066400000000000000000000231461514752343100220120ustar00rootroot00000000000000


  
  
  ActionBarDisplay — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Persistent action bar text

      
ActionBarDisplay


ActionBarDisplay manages persistent action bar messages per player. Unlike player.send_action_bar() which fades after a few seconds, ActionBarDisplay continuously re-sends the message to keep it visible.




Constructor


ActionBarDisplay()



Create a new action bar display manager.


status = ActionBarDisplay()





Player Access


ActionBarDisplay uses [] notation with players as keys.


Set text


display[player] = text



Start showing persistent action bar text to a player.


    

  • Parameters:
    • 

  • player (Player) — Target player.
    • 

  • text (str) — Action bar text. Supports § color codes.
    • 



Get text


text = display[player]



Get the current action bar text for a player.


    

  • Returns: str
    • 



Remove


del display[player]



Stop showing action bar text to a player.




Example: Status bar


from bridge import *

status_bar = ActionBarDisplay()

@event
async def player_join(e: Event):
    p = e.player
    status_bar[p] = f"§a❤ {int(p.health)}/20 §7| §e⚔ Kills: 0"

@event
async def entity_damage(e: Event):
    if hasattr(e.player, 'name'):
        p = e.player
        status_bar[p] = f"§a❤ {int(p.health)}/20 §7| §c-{e.damage}"

@event
async def player_quit(e: Event):
    del status_bar[e.player]



Example: Ability cooldown indicator


from bridge import *

cd_display = ActionBarDisplay()
ability_cd = Cooldown(seconds=5.0)

@command("Use ability")
async def ability(player: Player, args: list[str]):
    if not ability_cd.check(player):
        r = ability_cd.remaining(player)
        cd_display[player] = f"§c⏳ Cooldown: {r:.1f}s"
        return

    cd_display[player] = "§a✓ Ability used!"
    await player.send_message("§aAbility activated!")


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/advancement.html000066400000000000000000000260141514752343100207440ustar00rootroot00000000000000


  
  
  Advancement — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Advancement grant/revoke API

      
Advancement


The Advancement class lets you grant or revoke Minecraft advancements (achievements) for players, and inspect their progress.




Class Methods


grant


progress = await Advancement.grant(player, key)



Grant an advancement to a player (awards all remaining criteria).


    

  • Parameters:
    • 

  • player (Player) — Target player.
    • 

  • key (str) — Advancement key in namespace:path format.
    • 

  • Returns: Awaitable[AdvancementProgress]
    • 



progress = await Advancement.grant(player, "minecraft:story/mine_stone")



revoke


progress = await Advancement.revoke(player, key)



Revoke an advancement from a player (removes all awarded criteria).


    

  • Parameters:
    • 

  • player (Player) — Target player.
    • 

  • key (str) — Advancement key in namespace:path format.
    • 

  • Returns: Awaitable[AdvancementProgress]
    • 



await Advancement.revoke(player, "minecraft:story/mine_stone")





Attributes


key


    

  • Type: Any
    • 



The advancement's namespaced key.




AdvancementProgress


Returned by grant() and revoke(), this object tracks per-criterion completion.


Attributes


is_done


    

  • Type: bool
    • 



Whether all criteria have been awarded.


remaining_criteria


    

  • Type: set[str]
    • 



Criteria names that have not been awarded yet.


awarded_criteria


    

  • Type: set[str]
    • 



Criteria names that have been awarded.


Methods


award_criteria


result = await progress.award_criteria(name)



Award a single criterion.


    

  • Parameters:
    • 

  • name (str) — Criterion name.
    • 

  • Returns: Awaitable[bool] — True if the criterion was newly awarded.
    • 



revoke_criteria


result = await progress.revoke_criteria(name)



Revoke a single criterion.


    

  • Parameters:
    • 

  • name (str) — Criterion name.
    • 

  • Returns: Awaitable[bool] — True if the criterion was newly revoked.
    • 





Common Advancement Keys






Key
Description






minecraft:story/mine_stone
Mine stone with a pickaxe




minecraft:story/upgrade_tools
Craft a stone pickaxe




minecraft:story/smelt_iron
Smelt an iron ingot




minecraft:story/obtain_armor
Craft any armor piece




minecraft:story/enter_the_nether
Enter the Nether




minecraft:story/enter_the_end
Enter the End




minecraft:end/kill_dragon
Kill the Ender Dragon






You can also use server.get_advancement(key) to get the advancement object:


adv = await server.get_advancement("minecraft:story/mine_stone")


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/attribute.html000066400000000000000000000250351514752343100204640ustar00rootroot00000000000000


  
  
  Attribute — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Entity attribute modifiers

      
Attribute


An Attribute represents a Minecraft entity attribute (max health, movement speed, attack damage, etc.) and its current value. Use it to modify player or entity stats.




Class Methods


apply


await Attribute.apply(player, attribute_type, base_value)



Set an attribute's base value for a player.


    

  • Parameters:
    • 

  • player (Player) — Target player.
    • 

  • attribute_type (AttributeType | str) — Attribute to modify.
    • 

  • base_value (float) — New base value.
    • 

  • Returns: Awaitable[Any]
    • 



# Set max health to 40 (20 hearts)
await Attribute.apply(player, "GENERIC_MAX_HEALTH", 40.0)

# Double movement speed
await Attribute.apply(player, AttributeType.GENERIC_MOVEMENT_SPEED, 0.2)





Attributes


attribute_type



The type of this attribute.


value


    

  • Type: float
    • 



The current effective value (base + modifiers).


base_value


    

  • Type: float
    • 



The base value before modifiers.




Methods


set_base_value


await attribute.set_base_value(value)



Change the base value of this attribute.


    

  • Parameters:
    • 

  • value (float) — New base value.
    • 

  • Returns: Awaitable[None]
    • 





Common Attribute Types






AttributeType
Default
Description






GENERIC_MAX_HEALTH
20.0
Maximum health (1.0 = half heart)




GENERIC_MOVEMENT_SPEED
0.1
Walk speed




GENERIC_ATTACK_DAMAGE
1.0
Base melee damage




GENERIC_ATTACK_SPEED
4.0
Attack cooldown speed




GENERIC_ARMOR
0.0
Armor points




GENERIC_ARMOR_TOUGHNESS
0.0
Armor toughness




GENERIC_KNOCKBACK_RESISTANCE
0.0
Knockback resistance (0–1)




GENERIC_LUCK
0.0
Luck for loot tables




GENERIC_FLYING_SPEED
0.4
Creative fly speed






# Tank build
await Attribute.apply(player, "GENERIC_MAX_HEALTH", 40.0)
await Attribute.apply(player, "GENERIC_ARMOR", 20.0)
await Attribute.apply(player, "GENERIC_KNOCKBACK_RESISTANCE", 0.5)

# Speed runner build
await Attribute.apply(player, "GENERIC_MOVEMENT_SPEED", 0.2)
await Attribute.apply(player, "GENERIC_ATTACK_SPEED", 8.0)


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/block.html000066400000000000000000000300411514752343100175440ustar00rootroot00000000000000


  
  
  Block — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Block in the world

      
Block


A Block represents a single block in the world. You get block references from World.block_at() or event properties.




Constructor


Block(world=None, x=None, y=None, z=None, material=None)



Create a block reference.


    

  • Parameters:
    • 

  • world (World | str | None) — World reference.
    • 

  • x (int | None) — X coordinate.
    • 

  • y (int | None) — Y coordinate.
    • 

  • z (int | None) — Z coordinate.
    • 

  • material (Material | str | None) — Block material.
    • 





Class Methods


create


block = await Block.create(location, material)



Create (place) a block at a location.


    

  • Parameters:
    • 

  • location (Location) — Where to place the block.
    • 

  • material (Material | str) — Block material.
    • 

  • Returns: Awaitable[Block]
    • 



block = await Block.create(player.location.add(0, -1, 0), Material.DIAMOND_BLOCK)





Attributes


x


    

  • Type: int
    • 



Block X coordinate.


y


    

  • Type: int
    • 



Block Y coordinate.


z


    

  • Type: int
    • 



Block Z coordinate.


type



The block's material type.


location



The block's location.


world



The world this block is in.


is_solid


    

  • Type: bool
    • 



Whether the block is solid (not air, water, etc.).


data


    

  • Type: any
    • 



The block's data state (e.g., slab halves, stair direction). Varies by block type.


light_level


    

  • Type: int
    • 



Light level at this block (0–15).


biome



The biome at this block's location.




Methods


break_naturally


await block.break_naturally()



Break the block as if a player mined it (drops items).


    

  • Returns: Awaitable[None]
    • 



set_type


await block.set_type(material)



Change the block's material.


    

  • Parameters:
    • 

  • material (Material) — The new material.
    • 

  • Returns: Awaitable[None]
    • 



await block.set_type(Material.AIR)  # Delete the block



set_data


await block.set_data(data)



Set the block's data state.


    

  • Parameters:
    • 

  • data (any) — Block data value.
    • 

  • Returns: Awaitable[None]
    • 



set_biome


await block.set_biome(biome)



Change the biome at this block's position.


    

  • Parameters:
    • 

  • biome (Biome) — The new biome.
    • 

  • Returns: Awaitable[None]
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/blockdisplay.html000066400000000000000000000224161514752343100211410ustar00rootroot00000000000000


  
  
  BlockDisplay — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Block display entity

      
BlockDisplay


A BlockDisplay renders a block as a display entity in the world (1.19.4+). Unlike placed blocks, display entities don't have collision and can be positioned at any coordinates.




Constructor


BlockDisplay(location, block_type, billboard="FIXED")



Create and spawn a block display entity.


    

  • Parameters:
    • 

  • location (Location) — Spawn position.
    • 

  • block_type (str) — Block material name (e.g. "DIAMOND_BLOCK", "STONE").
    • 

  • billboard (str) — Billboard mode. Default "FIXED".
    • 







Billboard
Description






"FIXED"
No rotation (default for blocks)




"CENTER"
Always faces the player




"HORIZONTAL"
Only rotates horizontally




"VERTICAL"
Only rotates vertically






display = BlockDisplay(
    Location(100, 70, 200, "world"),
    "DIAMOND_BLOCK",
    billboard="FIXED"
)





Attributes


billboard


    

  • Type: str
    • 



Current billboard mode.




Methods


teleport


display.teleport(location)



Move the display entity. This is synchronous.


    

  • Parameters:
    • 

  • location (Location) — New position.
    • 



remove


display.remove()



Despawn and destroy the display entity. This is synchronous.




Example: Floating block marker


from bridge import *

@command("Place a marker")
async def marker(player: Player, args: list[str]):
    loc = player.location.add(0, 3, 0)
    block = BlockDisplay(loc, "BEACON", billboard="FIXED")
    await player.send_message("§aMarker placed above you!")


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/bossbar.html000066400000000000000000000342431514752343100201150ustar00rootroot00000000000000


  
  
  BossBar — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Boss bar display API

      
BossBar


A BossBar is the bar displayed at the top of the screen (like the Ender Dragon or Wither health bar). You can create custom boss bars with custom titles, colors, and progress.




Class Methods


create


bar = BossBar.create(title, color=None, style=None, players=None)



Create a new boss bar. This is synchronous.


    

  • Parameters:
    • 

  • title (str) — Bar title text. Supports § color codes.
    • 

  • color (BarColor | None) — Bar color. Default None (PINK).
    • 

  • style (BarStyle | None) — Bar segmentation style. Default None (SOLID).
    • 

  • players (list[Player] | None) — Players who can see the bar. Default None.
    • 

  • Returns: BossBar
    • 



bar = BossBar.create(
    "§c§lRaid Boss",
    color=BarColor.RED,
    style=BarStyle.SEGMENTED_10
)





Attributes


title


    

  • Type: str
    • 



Current title text.


progress


    

  • Type: float
    • 



Progress value from 0.0 (empty) to 1.0 (full).


color



Current bar color.


style



Current segmentation style.


visible


    

  • Type: bool
    • 



Whether the bar is currently visible.




Methods


add_player


await bar.add_player(player)



Show this bar to a player.


    

  • Parameters:
    • 

  • player (Player) — Player to add.
    • 

  • Returns: Awaitable[None]
    • 



remove_player


await bar.remove_player(player)



Hide this bar from a player.


    

  • Parameters:
    • 

  • player (Player) — Player to remove.
    • 

  • Returns: Awaitable[None]
    • 



set_title


await bar.set_title(title)



Change the bar title.


    

  • Parameters:
    • 

  • title (str) — New title text.
    • 

  • Returns: Awaitable[None]
    • 



set_progress


await bar.set_progress(value)



Set the bar progress.


    

  • Parameters:
    • 

  • value (float) — Progress from 0.0 to 1.0.
    • 

  • Returns: Awaitable[None]
    • 



await bar.set_progress(0.5)  # Half full



set_color


await bar.set_color(color)



Change the bar color.


    

  • Parameters:
    • 

  • color (BarColor) — New color.
    • 

  • Returns: Awaitable[None]
    • 



set_style


await bar.set_style(style)



Change the bar segmentation style.


    

  • Parameters:
    • 

  • style (BarStyle) — New style.
    • 

  • Returns: Awaitable[None]
    • 



set_visible


await bar.set_visible(value)



Show or hide the bar without removing players.


    

  • Parameters:
    • 

  • value (bool) — Visibility.
    • 

  • Returns: Awaitable[None]
    • 





BarColor Options






Name
Description






PINK
Default pink




BLUE
Blue




RED
Red




GREEN
Green




YELLOW
Yellow




PURPLE
Purple




WHITE
White






BarStyle Options






Name
Description






SOLID
No segments




SEGMENTED_6
6 segments




SEGMENTED_10
10 segments




SEGMENTED_12
12 segments




SEGMENTED_20
20 segments








Example: Health bar for a boss fight


from bridge import *

boss_bar = BossBar.create("§c§lDragon §7- §c100%", color=BarColor.RED, style=BarStyle.SEGMENTED_10)

@event
async def entity_damage(e: Event):
    entity = e.entity
    if entity.custom_name == "Dragon":
        hp_pct = entity.health / 100
        await boss_bar.set_progress(hp_pct)
        await boss_bar.set_title(f"§c§lDragon §7- §c{int(hp_pct * 100)}%")



See also: BossBarDisplay for a higher-level wrapper with cooldown linking.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/bossbardisplay.html000066400000000000000000000352121514752343100215000ustar00rootroot00000000000000


  
  
  BossBarDisplay — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Per-player boss bar manager

      
BossBarDisplay


BossBarDisplay is a high-level wrapper around BossBar that manages per-player visibility and integrates with Cooldown for automatic progress animation.




Constructor


BossBarDisplay(title="", color="PINK", style="SOLID")



Create a boss bar display.


    

  • Parameters:
    • 

  • title (str) — Bar title. Supports § color codes. Default "".
    • 

  • color (str) — Bar color name. Default "PINK". Options: "PINK", "BLUE", "RED", "GREEN", "YELLOW", "PURPLE", "WHITE".
    • 

  • style (str) — Bar style name. Default "SOLID". Options: "SOLID", "SEGMENTED_6", "SEGMENTED_10", "SEGMENTED_12", "SEGMENTED_20".
    • 



ability_bar = BossBarDisplay("§6Fireball", color="RED", style="SOLID")





Attributes


text


    

  • Type: str
    • 



Current title text.


color


    

  • Type: str
    • 



Current color name.


style


    

  • Type: str
    • 



Current style name.


value


    

  • Type: float
    • 



Current value.


max


    

  • Type: float
    • 



Maximum value.


progress


    

  • Type: float
    • 



Progress from 0.0 to 1.0 (calculated as value / max).


visible


    

  • Type: bool
    • 



Whether the bar is currently visible.




Methods


show


display.show(player)



Show the boss bar to a player. This is synchronous.


    

  • Parameters:
    • 

  • player (Player) — Player to show the bar to.
    • 



hide


display.hide(player)



Hide the boss bar from a player. This is synchronous.


    

  • Parameters:
    • 

  • player (Player) — Player to hide from.
    • 




display.link_cooldown(cooldown, player)



Link this bar to a Cooldown — the bar progress will automatically animate to reflect the remaining cooldown time.


    

  • Parameters:
    • 

  • cooldown (Cooldown) — The cooldown to track.
    • 

  • player (Player) — The player to display the cooldown bar to.
    • 



cd = Cooldown(seconds=10.0)
bar = BossBarDisplay("§6Fireball Cooldown", color="RED")

@command("Fireball")
async def fireball(player: Player, args: list[str]):
    if not cd.check(player):
        return

    bar.link_cooldown(cd, player)
    await player.send_message("§6🔥 Fireball!")





Example: Ability cooldown bar


from bridge import *

fireball_cd = Cooldown(seconds=8.0)
fireball_bar = BossBarDisplay("§6§lFireball", color="RED", style="SOLID")

@command("Shoot a fireball")
async def fireball(player: Player, args: list[str]):
    if not fireball_cd.check(player):
        r = fireball_cd.remaining(player)
        await player.send_message(f"§c{r:.1f}s cooldown!")
        return

    fireball_bar.link_cooldown(fireball_cd, player)
    await world.spawn_projectile(player, "FIREBALL")
    await player.send_message("§6🔥 Fireball launched!")



Example: Multiple ability bars


from bridge import *

abilities = {
    "fireball": {
        "cd": Cooldown(seconds=8.0),
        "bar": BossBarDisplay("§6Fireball", color="RED"),
    },
    "heal": {
        "cd": Cooldown(seconds=15.0),
        "bar": BossBarDisplay("§aHeal", color="GREEN"),
    },
    "dash": {
        "cd": Cooldown(seconds=3.0),
        "bar": BossBarDisplay("§bDash", color="BLUE"),
    },
}

@command("Use an ability")
async def ability(player: Player, args: list[str]):
    if not args or args[0] not in abilities:
        await player.send_message("§cUsage: /ability <fireball|heal|dash>")
        return

    ab = abilities[args[0]]
    if not ab["cd"].check(player):
        return

    ab["bar"].link_cooldown(ab["cd"], player)
    await player.send_message(f"§aUsed {args[0]}!")



See also: BossBar for the lower-level boss bar API, Cooldown for standalone cooldown tracking.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/chat.html000066400000000000000000000207211514752343100173750ustar00rootroot00000000000000


  
  
  Chat — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Chat broadcast helper

      
Chat


The Chat helper provides broadcast functionality. An instance is available as the global chat variable.




Global Instance


from bridge import chat





Methods


broadcast


await chat.broadcast(message)



Send a message to all online players.


    

  • Parameters:
    • 

  • message (str) — Message text. Supports § color codes.
    • 

  • Returns: Awaitable[None]
    • 



await chat.broadcast("§a§lServer restarting in 5 minutes!")





Chat vs Server.broadcast


Both chat.broadcast() and server.broadcast() send messages to all players:


# These are equivalent
await chat.broadcast("Hello everyone!")
await server.broadcast("Hello everyone!")



The chat helper exists for convenience and semantic clarity when your script is focused on chat operations.




Example: Announcement system


from bridge import *

@command("Announce a message")
async def announce(player: Player, args: list[str]):
    if not args:
        await player.send_message("§cUsage: /announce <message>")
        return

    message = " ".join(args)
    await chat.broadcast(f"§6§l[Announcement] §f{message}")


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/chunk.html000066400000000000000000000225331514752343100175710ustar00rootroot00000000000000


  
  
  Chunk — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
World chunk API

      
Chunk


A Chunk represents a 16×256×16 (or 16×384×16 in 1.18+) column of blocks in a world. Use it to force-load or release terrain.




Constructor


Chunk(world=None, x=None, z=None)



Reference a chunk by world and chunk coordinates.


    

  • Parameters:
    • 

  • world (World | str | None) — The world.
    • 

  • x (int | None) — Chunk X coordinate (block X ÷ 16).
    • 

  • z (int | None) — Chunk Z coordinate (block Z ÷ 16).
    • 



Note: Chunk coordinates are block coordinates divided by 16. A block at X=100 is in chunk X=6.


chunk = Chunk("world", 5, 10)



You can also get a chunk from a world:


chunk = await world.chunk_at(5, 10)





Attributes


x


    

  • Type: int
    • 



Chunk X coordinate.


z


    

  • Type: int
    • 



Chunk Z coordinate.


world



The world this chunk is in.


is_loaded


    

  • Type: bool
    • 



Whether this chunk is currently loaded in memory.




Methods


load


result = await chunk.load()



Force-load this chunk into memory. If the chunk is already loaded, this is a no-op.


    

  • Returns: Awaitable[bool] — True if the chunk was loaded successfully.
    • 



chunk = await world.chunk_at(0, 0)
await chunk.load()



unload


result = await chunk.unload()



Allow this chunk to be unloaded from memory. The server will unload it when no players are nearby.


    

  • Returns: Awaitable[bool] — True if the chunk was unloaded successfully.
    • 



Warning: Unloading a chunk with players in it may cause issues. Only unload chunks you know are safe to release.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/config.html000066400000000000000000000372061514752343100177310ustar00rootroot00000000000000


  
  
  Config — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Configuration files (TOML, JSON, properties)

      
Config


Config provides a simple interface for reading and writing configuration files. Config files are stored in the plugin's data folder and persist across server restarts.


Supported formats: TOML (default), JSON, and properties.




Constructor


Config(name=None, defaults=None, format="toml")



Load or create a configuration file.


    

  • Parameters:
    • 

  • name (str | None) — File name (without extension). If None, uses the script name.
    • 

  • defaults (dict[str, Any] | None) — Default values to merge into the config if they don't already exist.
    • 

  • format (str) — File format: "toml" (default), "json", or "properties".
    • 



# Default config.toml
config = Config()

# Named config
bans = Config("bans")

# JSON format
data = Config("data", format="json")

# Properties format
props = Config("server", format="properties")

# With defaults
settings = Config("settings", defaults={
    "spawn_protection_radius": 16,
    "max_homes": 3,
    "welcome_message": "§aWelcome to the server!"
})





Attributes


data


    

  • Type: dict[str, Any]
    • 



The entire config as a dictionary.


path


    

  • Type: str
    • 



Absolute file path to the config file.




Methods


get


value = config.get(path, default=None)



Get a value by dot-separated path.


    

  • Parameters:
    • 

  • path (str) — Dot-separated key path (e.g. "database.host").
    • 

  • default (Any) — Fallback if the key doesn't exist. Default None.
    • 

  • Returns: Any
    • 



radius = config.get("spawn_protection_radius", 16)
db_host = config.get("database.host", "localhost")



get_int


value = config.get_int(path, default=0)



Get a value as an integer.


    

  • Parameters:
    • 

  • path (str) — Dot-separated key path.
    • 

  • default (int) — Fallback. Default 0.
    • 

  • Returns: int
    • 



get_float


value = config.get_float(path, default=0.0)



Get a value as a float.


    

  • Parameters:
    • 

  • path (str) — Dot-separated key path.
    • 

  • default (float) — Fallback. Default 0.0.
    • 

  • Returns: float
    • 



get_bool


value = config.get_bool(path, default=False)



Get a value as a boolean.


    

  • Parameters:
    • 

  • path (str) — Dot-separated key path.
    • 

  • default (bool) — Fallback. Default False.
    • 

  • Returns: bool
    • 



get_list


value = config.get_list(path, default=None)



Get a value as a list.


    

  • Parameters:
    • 

  • path (str) — Dot-separated key path.
    • 

  • default (list[Any] | None) — Fallback. Default None.
    • 

  • Returns: list[Any]
    • 



set


config.set(path, value)



Set a value by dot-separated path. Creates intermediate keys as needed.


    

  • Parameters:
    • 

  • path (str) — Dot-separated key path.
    • 

  • value (Any) — Value to set.
    • 



config.set("database.host", "localhost")
config.set("database.port", 3306)



delete


result = config.delete(path)



Delete a key.


    

  • Parameters:
    • 

  • path (str) — Dot-separated key path.
    • 

  • Returns: bool — True if the key existed and was deleted.
    • 



save


config.save()



Write changes to disk. This is synchronous.


config.set("last_restart", "2024-01-15")
config.save()



reload


config.reload()



Reload the config from disk, discarding unsaved changes. This is synchronous.




Dict-style Access


Config supports [] notation and in checks:


# These are equivalent
value = config["key"]
value = config.get("key")

# Set values
config["key"] = "value"
config.set("key", "value")

# Check existence
if "key" in config:
    print("Key exists!")





Example: Ban system config


from bridge import *

bans = Config("bans", defaults={"banned_players": {}})

@command("Ban a player")
async def ban(player: Player, args: list[str]):
    if not args:
        await player.send_message("§cUsage: /ban <player> [reason]")
        return

    target = args[0]
    reason = " ".join(args[1:]) or "No reason given"

    bans.set(f"banned_players.{target}", {
        "reason": reason,
        "banned_by": player.name,
    })
    bans.save()
    await player.send_message(f"§aBanned {target}: {reason}")

@event
async def player_login(e: Event):
    ban_info = bans.get(f"banned_players.{e.player.name}")
    if ban_info:
        await e.player.kick(f"§cBanned: {ban_info['reason']}")


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/cooldown.html000066400000000000000000000303321514752343100203010ustar00rootroot00000000000000


  
  
  Cooldown — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Rate limiting helper

      
Cooldown


Cooldown is a helper that tracks per-player cooldowns. Use it to prevent ability spam, command abuse, or add skill cooldown timers.




Constructor


Cooldown(seconds=1.0, on_expire=None)



Create a cooldown tracker.


    

  • Parameters:
    • 

  • seconds (float) — Cooldown duration in seconds. Default 1.0.
    • 

  • on_expire (Callable[[Player], Any] | None) — Callback invoked when a player's cooldown expires. Default None.
    • 



ability_cd = Cooldown(seconds=5.0)

fireball_cd = Cooldown(
    seconds=10.0,
    on_expire=lambda p: p.send_message("§aFireball ready!")
)





Attributes


seconds


    

  • Type: float
    • 



The cooldown duration in seconds.


on_expire


    

  • Type: Callable[[Player], Any] | None
    • 



Callback invoked when the cooldown expires for a player.




Methods


check


is_ready = cooldown.check(player)



Check if the player's cooldown has expired. If ready, automatically starts a new cooldown.


    

  • Parameters:
    • 

  • player (Player) — Player to check.
    • 

  • Returns: bool — True if the cooldown was ready (and has now been reset), False if still on cooldown.
    • 



cd = Cooldown(seconds=5.0)

@command("Use special ability")
async def ability(player: Player, args: list[str]):
    if not cd.check(player):
        remaining = cd.remaining(player)
        await player.send_message(f"§cOn cooldown! {remaining:.1f}s remaining")
        return
    await player.send_message("§aAbility activated!")



remaining


time_left = cooldown.remaining(player)



Get the remaining cooldown time for a player.


    

  • Parameters:
    • 

  • player (Player) — Player to check.
    • 

  • Returns: float — Remaining seconds, or 0.0 if ready.
    • 



reset


cooldown.reset(player)



Manually reset (clear) a player's cooldown, making the ability immediately available.


    

  • Parameters:
    • 

  • player (Player) — Player to reset.
    • 





Example: Ability with boss bar indicator


from bridge import *

fireball_cd = Cooldown(seconds=8.0)

@command("Shoot a fireball")
async def fireball(player: Player, args: list[str]):
    if not fireball_cd.check(player):
        r = fireball_cd.remaining(player)
        await player.send_message(f"§c{r:.1f}s cooldown remaining!")
        return

    loc = player.location
    await world.spawn_projectile(player, "FIREBALL")
    await player.send_message("§6🔥 Fireball launched!")



Example: On-expire callback


from bridge import *

dash_cd = Cooldown(
    seconds=3.0,
    on_expire=lambda p: p.send_action_bar("§aDash ready!")
)

@command("Dash forward")
async def dash(player: Player, args: list[str]):
    if not dash_cd.check(player):
        await player.send_action_bar(f"§c{dash_cd.remaining(player):.1f}s")
        return

    await player.set_velocity(Vector(0, 0.5, 1.5))
    await player.send_action_bar("§6Dash!")



See also: BossBarDisplay.link_cooldown() to visually display cooldown progress.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/decorators.html000066400000000000000000000365721514752343100206360ustar00rootroot00000000000000


  
  
  Decorators — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Register event handlers, commands, and repeating tasks

      
Decorators


PyJavaBridge uses Python decorators to register event handlers, commands, and repeating tasks. Your decorated functions are discovered automatically when the script loads.




@event


@event
async def player_join(e):
    await e.player.send_message("Welcome!")



Register a function as an event handler. The function name determines the event type — it is converted from snake_case to PascalCase and Event is appended. For example, player_join becomes PlayerJoinEvent.


Signature


@event(*, once_per_tick=False, priority="NORMAL", throttle_ms=0)



Parameters


once_per_tick


    

  • Type: bool
    • 

  • Default: False
    • 



When True, the handler is called at most once per server tick, even if the event fires multiple times. Useful for high-frequency events like player_move.


@event(once_per_tick=True)
async def player_move(e):
    # Called at most once per tick per event, not every micro-movement
    pass



priority


    

  • Type: str
    • 

  • Default: "NORMAL"
    • 



The Bukkit event priority. Determines the order in which handlers run. Options (lowest runs first):






Priority
Description






LOWEST
Runs first. Use for early cancellation.




LOW
Runs before normal handlers.




NORMAL
Default priority.




HIGH
Runs after normal handlers.




HIGHEST
Runs last before monitor.




MONITOR
Read-only observation. Do not modify the event.






@event(priority="HIGH")
async def block_break(e):
    # This runs after NORMAL-priority handlers
    pass



throttle_ms


    

  • Type: int
    • 

  • Default: 0
    • 



Minimum milliseconds between handler invocations. If the event fires more frequently, extra invocations are silently dropped.


@event(throttle_ms=500)
async def player_interact(e):
    # At most once every 500ms, prevents spam-clicking abuse
    pass



Bare decorator


You can use @event without parentheses for the default settings:


@event
async def player_quit(e):
    await server.broadcast(f"{e.player.name} left!")





@command


@command("Greet a player", permission="myplugin.greet")
async def greet(e):
    await e.player.send_message("Hello!")



Register a function as a script command. The command is automatically available as /functionname (or as specified via the name parameter). Command arguments are parsed from the function's additional parameters after event.


Signature


@command(description=None, *, name=None, permission=None)



Parameters


description


    

  • Type: str | None
    • 

  • Default: None
    • 



A human-readable description of the command. This is the first positional argument.


@command("Teleport to spawn")
async def spawn(e):
    ...



name


    

  • Type: str | None
    • 

  • Default: None (uses function name)
    • 



Override the command name. By default the function name is used.


@command("Teleport home", name="home")
async def teleport_home(e):
    # Registered as /home, not /teleport_home
    ...



permission


    

  • Type: str | None
    • 

  • Default: None
    • 



Permission node required to use the command. Players without this permission cannot execute it.


@command("Ban a player", permission="admin.ban")
async def ban(e, target: str):
    ...



Command arguments


Extra function parameters after the event become command arguments. They are parsed positionally from the player's input:


@command("Give items")
async def give(e, material: str, amount: str = "1"):
    # /give diamond 64
    # material = "diamond", amount = "64"
    await Item.give(e.player, material, int(amount))



All arguments are passed as strings. You handle type conversion yourself.




@task


@task(interval=20, delay=0)
async def tick_loop():
    ...



Register a repeating async task. The function is called repeatedly at the specified interval after an optional initial delay.


Signature


@task(*, interval=20, delay=0)



Parameters


interval


    

  • Type: int
    • 

  • Default: 20
    • 



Ticks between invocations. Minecraft runs at 20 ticks per second, so interval=20 means once per second, interval=1 means every tick.


delay


    

  • Type: int
    • 

  • Default: 0
    • 



Initial delay in ticks before the first invocation. Use this to wait for the server to fully start.


@task(interval=20*60, delay=20*5)
async def auto_save():
    # Runs every 60 seconds, starting 5 seconds after script load
    await server.execute("save-all")



Notes


    

  • Task functions take no arguments (unlike event/command handlers).
    • 

  • The task is cancelled automatically when the script is unloaded.
    • 

  • If the function is still running when the next invocation is due, the next invocation is skipped.
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/effect.html000066400000000000000000000334631514752343100177210ustar00rootroot00000000000000


  
  
  Effect — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Potion effects API

      
Effect


An Effect represents a potion effect (speed, strength, invisibility, etc.) that can be applied to players. Effects have a type, duration, amplifier, and visual settings.




Constructor


Effect(effect_type=None, duration=0, amplifier=0, ambient=False, particles=True, icon=True)



Create an effect.


    

  • Parameters:
    • 

  • effect_type (EffectType | str | None) — The effect type (e.g. "SPEED", EffectType.INVISIBILITY).
    • 

  • duration (int) — Duration in ticks (20 ticks = 1 second). Default 0.
    • 

  • amplifier (int) — Effect level minus 1. Speed II = amplifier 1. Default 0.
    • 

  • ambient (bool) — Whether the effect came from a beacon (translucent particles). Default False.
    • 

  • particles (bool) — Whether to show particles. Default True.
    • 

  • icon (bool) — Whether to show the effect icon in the HUD. Default True.
    • 



speed = Effect("SPEED", duration=600, amplifier=1)         # Speed II for 30 seconds
invis = Effect(EffectType.INVISIBILITY, duration=1200)      # Invisibility for 60 seconds
silent = Effect("REGENERATION", 200, particles=False, icon=False) # Hidden regen





Class Methods


apply


await Effect.apply(player, effect_type=None, duration=0, amplifier=0, ambient=False, particles=True, icon=True)



Create and apply an effect to a player in one call.


    

  • Parameters:
    • 

  • player (Player) — Target player.
    • 

  • effect_type (EffectType | str | None) — Effect type.
    • 

  • duration (int) — Duration in ticks. Default 0.
    • 

  • amplifier (int) — Effect level minus 1. Default 0.
    • 

  • ambient (bool) — Beacon-style particles. Default False.
    • 

  • particles (bool) — Show particles. Default True.
    • 

  • icon (bool) — Show icon. Default True.
    • 

  • Returns: Awaitable[Any]
    • 



await Effect.apply(player, "SPEED", duration=600, amplifier=1)





Attributes


type



The effect type.


duration


    

  • Type: int
    • 



Remaining duration in ticks.


amplifier


    

  • Type: int
    • 



Effect amplifier (level minus 1).


ambient


    

  • Type: bool
    • 



Whether particles are translucent (beacon-style).


particles


    

  • Type: bool
    • 



Whether particles are visible.


icon


    

  • Type: bool
    • 



Whether the HUD icon is shown.




Methods


with_duration


new_effect = await effect.with_duration(duration)



Create a copy of this effect with a different duration.


    

  • Parameters:
    • 

  • duration (int) — New duration in ticks.
    • 

  • Returns: Awaitable[Effect]
    • 



base = Effect("SPEED", 100, amplifier=2)
long_speed = await base.with_duration(6000)  # 5 minutes



with_amplifier


new_effect = await effect.with_amplifier(amplifier)



Create a copy of this effect with a different amplifier.


    

  • Parameters:
    • 

  • amplifier (int) — New amplifier.
    • 

  • Returns: Awaitable[Effect]
    • 





Applying to Players


You can apply effects in two ways:


# 1. Using the class method shortcut
await Effect.apply(player, "SPEED", duration=200, amplifier=1)

# 2. Construct then apply via Player
speed = Effect("SPEED", duration=200, amplifier=1)
await player.add_effect(speed)



To remove an effect:


await player.remove_effect(EffectType.SPEED)



To list active effects:


for effect in player.effects:
    print(f"{effect.type.name}: {effect.duration} ticks remaining")





Duration Reference






Duration
Ticks






1 second
20




5 seconds
100




30 seconds
600




1 minute
1200




5 minutes
6000




10 minutes
12000





    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/entity.html000066400000000000000000000434251514752343100200000ustar00rootroot00000000000000


  
  
  Entity — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Base entity proxy

      
Entity


Entity is the base class for all entities in the game — mobs, animals, projectiles, dropped items, etc. Player extends this class.




Constructor


Entity(uuid: str | None = None)



Resolve an existing entity by its UUID.


    

  • Parameters:
    • 

  • uuid (str | None) — The entity's UUID string.
    • 



entity = Entity("550e8400-e29b-41d4-a716-446655440000")





Class Methods


spawn


entity = await Entity.spawn(entity_type, location, **kwargs)



Spawn a new entity at a location.


    

  • Parameters:
    • 

  • entity_type (EntityType | str) — The type of entity to spawn.
    • 

  • location (Location) — Where to spawn the entity.
    • 

  • **kwargs — Additional spawn options.
    • 

  • Returns: Awaitable[Entity]
    • 



zombie = await Entity.spawn(EntityType.ZOMBIE, player.location)
zombie = await Entity.spawn("ZOMBIE", Location(0, 64, 0, "world"))





Attributes


uuid


    

  • Type: str
    • 



The entity's universally unique identifier.


type



The entity type (e.g. EntityType.ZOMBIE, EntityType.ARROW).


location



The entity's current location. Re-fetched each access.


world



The world the entity is in.


velocity



The entity's current velocity vector.


is_dead


    

  • Type: bool
    • 



Whether the entity is dead.


is_alive


    

  • Type: bool
    • 



Whether the entity is alive.


is_valid


    

  • Type: bool
    • 



Whether the entity handle is still valid. Becomes False when the entity is removed from the server. Always check this before interacting with an entity you've stored across ticks.


fire_ticks


    

  • Type: int
    • 



Remaining fire ticks. 0 means not on fire. Each tick at 20 TPS, so 100 = 5 seconds of fire.


passengers



Entities riding on top of this entity.


custom_name


    

  • Type: any
    • 



The entity's custom name, or None if not set.


is_projectile


    

  • Type: bool
    • 



Whether this entity is a projectile (arrow, snowball, trident, etc.).


shooter



For projectiles, the entity or block that launched it. None for non-projectiles.


is_tamed


    

  • Type: bool
    • 



Whether this entity is a tameable animal that has been tamed.


owner



The player who owns this tamed entity, if the owner is online.


owner_uuid


    

  • Type: str | None
    • 



UUID of the taming player, even if they're offline.


owner_name


    

  • Type: str | None
    • 



Name of the taming player, if known.


source



The entity that created this entity. For example, the player who lit a TNT block, or the witch that threw a potion.




Methods


teleport


await entity.teleport(location)



Teleport the entity to a new location.


    

  • Parameters:
    • 

  • location (Location) — Destination.
    • 

  • Returns: Awaitable[None]
    • 



await zombie.teleport(Location(0, 100, 0, "world"))



remove


await entity.remove()



Remove the entity from the world permanently.


    

  • Returns: Awaitable[None]
    • 



set_velocity


await entity.set_velocity(vector)



Set the entity's velocity. Useful for launching entities, knockback effects, etc.


    

  • Parameters:
    • 

  • vector (Vector) — The velocity vector. Each component is in blocks/tick.
    • 

  • Returns: Awaitable[None]
    • 



# Launch entity upward
await entity.set_velocity(Vector(0, 1.5, 0))



set_fire_ticks


await entity.set_fire_ticks(ticks)



Set the entity on fire for a duration.


    

  • Parameters:
    • 

  • ticks (int) — Duration in ticks (20 ticks = 1 second). Set to 0 to extinguish.
    • 

  • Returns: Awaitable[None]
    • 



await entity.set_fire_ticks(100)  # 5 seconds of fire
await entity.set_fire_ticks(0)    # Extinguish



add_passenger


success = await entity.add_passenger(entity)



Make another entity ride on top of this one.


    

  • Parameters:
    • 

  • entity (Entity) — The entity to add as a passenger.
    • 

  • Returns: Awaitable[bool] — True if the passenger was added successfully.
    • 



remove_passenger


success = await entity.remove_passenger(entity)



Remove a riding entity.


    

  • Parameters:
    • 

  • entity (Entity) — The passenger to remove.
    • 

  • Returns: Awaitable[bool]
    • 



set_custom_name


await entity.set_custom_name(name)



Set the entity's custom name tag.


    

  • Parameters:
    • 

  • name (str) — The name to display. Supports § color codes.
    • 

  • Returns: Awaitable[None]
    • 



await zombie.set_custom_name("§cBoss Zombie")



set_custom_name_visible


await entity.set_custom_name_visible(value)



Show or hide the custom name tag. When True, the name is visible through walls and at a distance.


    

  • Parameters:
    • 

  • value (bool) — Whether the name should be visible.
    • 

  • Returns: Awaitable[None]
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/enums.html000066400000000000000000000437521514752343100176160ustar00rootroot00000000000000


  
  
  Enums — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Enum types reference

      
Enums


PyJavaBridge wraps Minecraft's Java enums as EnumValue subclasses. Each enum type supports attribute-style access (EnumType.VALUE_NAME) and from_name("VALUE_NAME").




How Enums Work


All enum types inherit from EnumValue:


# Attribute-style access
material = Material.DIAMOND_SWORD
sound = Sound.ENTITY_EXPERIENCE_ORB_PICKUP

# from_name (useful for dynamic values)
material = Material.from_name("DIAMOND_SWORD")



See the EnumValue page for full details.




Material


from bridge import Material



Block and item types. Minecraft has hundreds of materials.


Common materials:






Category
Examples






Ores
DIAMOND_ORE, IRON_ORE, GOLD_ORE, COAL_ORE




Blocks
STONE, DIRT, GRASS_BLOCK, OAK_PLANKS, COBBLESTONE




Items
DIAMOND_SWORD, IRON_PICKAXE, BOW, ARROW, STICK




Food
GOLDEN_APPLE, COOKED_BEEF, BREAD, CAKE




Armor
DIAMOND_HELMET, IRON_CHESTPLATE, LEATHER_BOOTS




Glass
GLASS, RED_STAINED_GLASS, GLASS_PANE




Wool
WHITE_WOOL, RED_WOOL, BLUE_WOOL




Misc
BEACON, ENDER_PEARL, NETHER_STAR, TOTEM_OF_UNDYING






sword = Item(Material.DIAMOND_SWORD)
await world.set_block(0, 60, 0, Material.STONE)





EntityType


from bridge import EntityType



Mob and entity types.






Category
Examples






Hostile
ZOMBIE, SKELETON, CREEPER, SPIDER, ENDERMAN, WITCH




Passive
COW, PIG, SHEEP, CHICKEN, VILLAGER, HORSE




Projectiles
ARROW, FIREBALL, SNOWBALL, ENDER_PEARL, TRIDENT




Misc
ITEM, EXPERIENCE_ORB, ARMOR_STAND, LIGHTNING_BOLT






await Entity.spawn(EntityType.ZOMBIE, location)
await world.spawn_projectile(player, EntityType.FIREBALL)





EffectType


from bridge import EffectType



Potion effect types.






Name
Description






SPEED
Increases movement speed




SLOWNESS
Decreases movement speed




HASTE
Increases mining speed




MINING_FATIGUE
Decreases mining speed




STRENGTH
Increases attack damage




INSTANT_HEALTH
Heals instantly




INSTANT_DAMAGE
Damages instantly




JUMP_BOOST
Increases jump height




REGENERATION
Restores health over time




RESISTANCE
Reduces damage taken




FIRE_RESISTANCE
Immunity to fire damage




WATER_BREATHING
Breathe underwater




INVISIBILITY
Invisible to other players




BLINDNESS
Restricts vision




NIGHT_VISION
See in the dark




POISON
Deals damage over time




WITHER
Deals wither damage over time




ABSORPTION
Adds absorption hearts




SATURATION
Restores hunger




GLOWING
Glowing outline




LEVITATION
Float upward




SLOW_FALLING
Fall slowly






await Effect.apply(player, EffectType.SPEED, duration=600, amplifier=1)





AttributeType


from bridge import AttributeType



Entity attribute types for stat modification.






Name
Default
Description






GENERIC_MAX_HEALTH
20.0
Maximum health




GENERIC_MOVEMENT_SPEED
0.1
Walking speed




GENERIC_ATTACK_DAMAGE
1.0
Melee damage




GENERIC_ATTACK_SPEED
4.0
Attack cooldown




GENERIC_ARMOR
0.0
Armor points




GENERIC_ARMOR_TOUGHNESS
0.0
Armor toughness




GENERIC_KNOCKBACK_RESISTANCE
0.0
Knockback resistance




GENERIC_LUCK
0.0
Loot table luck




GENERIC_FLYING_SPEED
0.4
Creative fly speed








GameMode


from bridge import GameMode







Name
Description






SURVIVAL
Normal survival




CREATIVE
Creative mode




ADVENTURE
Adventure mode




SPECTATOR
Spectator mode






await player.set_game_mode(GameMode.CREATIVE)





Sound


from bridge import Sound



Minecraft sound effects. Examples:






Name
Description






ENTITY_EXPERIENCE_ORB_PICKUP
XP orb




BLOCK_NOTE_BLOCK_BASS
Note block bass




BLOCK_NOTE_BLOCK_PLING
Note block pling




ENTITY_PLAYER_LEVELUP
Level up




ITEM_TOTEM_USE
Totem activation




ENTITY_ENDER_DRAGON_GROWL
Dragon growl




UI_BUTTON_CLICK
Button click






await player.play_sound(Sound.ENTITY_EXPERIENCE_ORB_PICKUP)
await world.play_sound(location, Sound.ENTITY_ENDER_DRAGON_GROWL, volume=2.0)





Particle


from bridge import Particle



Particle effects.






Name
Description






FLAME
Fire particles




HEART
Heart particles




VILLAGER_HAPPY
Green sparkles




EXPLOSION_LARGE
Large explosion




REDSTONE
Redstone dust




SMOKE_NORMAL
Normal smoke




CRIT
Critical hit sparkles




SPELL_MOB
Potion effect swirls




END_ROD
End rod particles




TOTEM
Totem of Undying particles






await world.spawn_particle(Particle.FLAME, location, count=50)
await world.particle_sphere(location, 3.0, Particle.END_ROD)





Difficulty


from bridge import Difficulty







Name






PEACEFUL




EASY




NORMAL




HARD








Biome


from bridge import Biome



World biomes. Examples: PLAINS, FOREST, DESERT, OCEAN, MOUNTAINS, SWAMP, JUNGLE, TAIGA, SAVANNA, BADLANDS, THE_NETHER, THE_END.


await block.set_biome(Biome.DESERT)





BarColor


from bridge import BarColor







Name






PINK




BLUE




RED




GREEN




YELLOW




PURPLE




WHITE








BarStyle


from bridge import BarStyle







Name
Description






SOLID
No segments




SEGMENTED_6
6 segments




SEGMENTED_10
10 segments




SEGMENTED_12
12 segments




SEGMENTED_20
20 segments





    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/enumvalue.html000066400000000000000000000250001514752343100204520ustar00rootroot00000000000000


  
  
  EnumValue — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Base class for all enum-like types

      
EnumValue


EnumValue is the base class for all Minecraft enum types exposed by the bridge: Material, EntityType, Biome, EffectType, GameMode, Sound, Particle, Difficulty, BarColor, BarStyle, and AttributeType.




Constructor


EnumValue(type: str, name: str)



Create an enum value with a specific type and name. You rarely need this directly — use the subclass attribute syntax instead.


Parameters


type


    

  • Type: str
    • 



The enum type name (e.g. "Material", "EntityType").


name


    

  • Type: str
    • 



The enum value name (e.g. "DIAMOND", "ZOMBIE").




Class Methods


from_name


@classmethod
EnumValue.from_name(name: str) -> EnumValue



Create an enum value from a name string. The type is inferred from the subclass.


mat = Material.from_name("DIAMOND")





Attributes


type


    

  • Type: str
    • 



The enum type name.


m = Material.DIAMOND
print(m.type)  # "Material"



name


    

  • Type: str
    • 



The enum value name.


m = Material.DIAMOND
print(m.name)  # "DIAMOND"





Attribute Access


All EnumValue subclasses support attribute-style access to create values:


Material.DIAMOND          # EnumValue("Material", "DIAMOND")
EntityType.ZOMBIE         # EnumValue("EntityType", "ZOMBIE")
GameMode.CREATIVE         # EnumValue("GameMode", "CREATIVE")
Sound.ENTITY_EXPERIENCE_ORB_PICKUP
Particle.FLAME
Difficulty.HARD
BarColor.RED
BarStyle.SEGMENTED_6
AttributeType.GENERIC_MAX_HEALTH
EffectType.POISON
Biome.PLAINS



Name lookup is case-insensitive on the Java side, but by convention use UPPER_SNAKE_CASE.




Subclasses






Class
Description
Example






Material
Block/item materials
Material.DIAMOND




EntityType
Entity types
EntityType.ZOMBIE




Biome
World biomes
Biome.PLAINS




EffectType
Potion effect types
EffectType.POISON




GameMode
Player game modes
GameMode.CREATIVE




Sound
Minecraft sounds
Sound.ENTITY_EXPERIENCE_ORB_PICKUP




Particle
Particle types
Particle.FLAME




Difficulty
World difficulties
Difficulty.HARD




BarColor
Boss bar colors
BarColor.RED




BarStyle
Boss bar styles
BarStyle.SEGMENTED_6




AttributeType
Entity attribute types
AttributeType.GENERIC_MAX_HEALTH





    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/event.html000066400000000000000000000365071514752343100176100ustar00rootroot00000000000000


  
  
  Event — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Event proxy and event type mapping

      
Event


The Event class is the proxy object passed to your @event handlers. It exposes fields relevant to the specific Bukkit event that fired. Fields that don't apply to the current event type are None.




Attributes


player



The player involved in the event. Available for all player-related events (player_join, player_chat, player_interact, etc.).


@event
async def player_join(e):
    await e.player.send_message(f"Welcome, {e.player.name}!")



entity



The entity involved in the event. Available for entity events (entity_damage, entity_death, etc.).


block



The block involved in the event. Available for block events (block_break, block_place, etc.).


world



The world where the event occurred.


location



The location relevant to the event.


item



The item involved in the event. Available for interact events, inventory events, etc.


inventory



The inventory involved in the event. Available for inventory_click, inventory_close, etc.


chunk



The chunk involved in the event.


slot


    

  • Type: int
    • 



The inventory slot index for inventory_click events.


damager



The source of damage for entity_damage events. Can be an entity (attacker, projectile) or a block (cactus, lava).


damage


    

  • Type: float
    • 



The raw damage amount for entity_damage events (before armor/enchantment modifiers).


final_damage


    

  • Type: float
    • 



The final damage after all modifiers for entity_damage events.


damage_cause


    

  • Type: str | None
    • 



The DamageCause for damage events (e.g. "ENTITY_ATTACK", "FALL", "FIRE").




Methods


cancel


await event.cancel()



Cancel the event, preventing its default action. Only works on cancellable events.


    

  • Returns: Awaitable[None]
    • 



@event
async def block_break(e):
    if e.block.type.name == "BEDROCK":
        await e.cancel()
        await e.player.send_message("You can't break bedrock!")





Damage Override


For entity_damage events, returning a number from the handler overrides the final damage:


@event
async def entity_damage(e):
    if e.damage_cause == "FALL":
        return 0  # Cancel all fall damage
    if e.player:
        return e.damage * 0.5  # Half damage for players





Chat Override


For player_chat events, returning a string cancels the original message and broadcasts your string instead:


@event
async def player_chat(e):
    return f"[VIP] {e.player.name}: {e.message}"



Returning None (or not returning) leaves the chat message unchanged.




Event Type Mapping


Events are resolved from handler function names: snake_case → PascalCase + Event.






Function name
Bukkit event






player_join
PlayerJoinEvent




player_quit
PlayerQuitEvent




player_chat
AsyncPlayerChatEvent




player_move
PlayerMoveEvent




player_interact
PlayerInteractEvent




block_break
BlockBreakEvent




block_place
BlockPlaceEvent




entity_damage
EntityDamageEvent / EntityDamageByEntityEvent




entity_death
EntityDeathEvent




inventory_click
InventoryClickEvent




inventory_close
InventoryCloseEvent




world_load
WorldLoadEvent




weather_change
WeatherChangeEvent






Special cases


    

  • server_boot maps to ServerLoadEvent
    • 

  • block_explode is dispatched for both BlockExplodeEvent and EntityExplodeEvent
    • 



Supported packages


The bridge discovers events from all standard Bukkit event packages:


    

  • org.bukkit.event.player.*
    • 

  • org.bukkit.event.block.*
    • 

  • org.bukkit.event.entity.*
    • 

  • org.bukkit.event.inventory.*
    • 

  • org.bukkit.event.server.*
    • 

  • org.bukkit.event.world.*
    • 

  • org.bukkit.event.weather.*
    • 

  • org.bukkit.event.vehicle.*
    • 

  • org.bukkit.event.hanging.*
    • 

  • org.bukkit.event.enchantment.*
    • 

  • org.bukkit.event.*
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/examples.html000066400000000000000000000461731514752343100203050ustar00rootroot00000000000000


  
  
  Examples — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Complete script examples

      
Examples


Full working scripts that demonstrate PyJavaBridge features.




Commands & GUI


A script demonstrating commands, raycast teleportation, inventory GUIs, and inventory click events.


from bridge import *

# Simple hello world command
@command("Hello world command")
async def helloworld(event: Event):
    event.player.send_message("Hello, World!")

# Command with arguments
@command("Greet command")
async def greet(event: Event, name: str = None):
    event.player.send_message(f"Hello, {name or event.player.name}!")

# Raycast to find ground level, then teleport
@command("Teleport to spawn")
async def spawn(event: Event):
    ray = await raycast('world', (0.5, 320, 0.5), (0, 90), 384, 0.5, False)
    event.player.teleport((0.5, ray.y + 0.5, 0.5))

# Custom inventory GUI
@command("open test gui")
async def gui(event: Event):
    inv = Inventory(
        3 * 9,
        title="Test GUI",
        contents=[
            Item('light_gray_stained_glass_pane').set_name(" ")
            for _ in range(3 * 9)
        ]
    )
    inv.set_item(9 + 4, Item('totem_of_undying').set_name("Bing chilling"))
    inv.open(event.player)

# Handle clicks in the GUI
@event
async def inventory_click(event: Event):
    if event.inventory.title != 'Test GUI':
        return

    event.cancel()

    if event.slot == 9 + 4:
        event.player.play_sound('item_totem_use')
        event.player.send_message('Bing chilling')
        event.inventory.close()

# Prevent dragging in the GUI
@event
async def inventory_drag(event: Event):
    if event.inventory.title == 'Test GUI':
        event.cancel()

# View another player's inventory
@command("Open someones inv")
async def invsee(event: Event, p: str):
    if p == event.player.name:
        event.player.send_message("You cannot open your own inventory!")
        event.player.play_sound('block_note_block_bass')
        return

    Player(p).inventory.open(event.player)



Concepts demonstrated:
- @command with and without arguments
- raycast() for finding ground level
- Inventory with custom contents
- @event for inventory_click and inventory_drag
- Event.cancel() to prevent default behavior
- Player messaging, sounds, and teleportation




Spawn Protection


A script that prevents building near spawn using block events.


from bridge import *

@event
async def load(event: Event):
    server.broadcast("server start")

@event
async def block_break(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.player.send_message("You cannot break blocks there!")
        await event.cancel()

@event
async def block_place(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.player.send_message("You cannot place blocks there!")
        await event.cancel()

@event
async def block_explode(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.cancel()



Concepts demonstrated:
- @event for block_break, block_place, block_explode, and load
- Event.cancel() to prevent block modification
- Event.block to access block coordinates
- server.broadcast() for server-wide messages
- Diamond (taxicab) distance check for a protection zone




Temporary Ban System


A full ban system with configurable durations and persistence.


"""Ban users for customizable amounts of time."""
from humanfriendly import format_timespan
from time import time as time_now
from bridge import *
import re

bans = {}

def parse_time(time: str) -> int:
    """Parse a time string like '1h30m' into seconds."""
    if not time:
        raise ValueError('Time string is required')

    units = {
        's': 1, 'm': 60, 'h': 3600,
        'd': 86400, 'w': 604800,
        'mo': 2592000, 'y': 31536000,
    }

    pattern = re.compile(r'(\d+)(mo|[smhdwy])', re.IGNORECASE)
    total = 0
    time_str = time.strip().lower()
    idx = 0

    for match in pattern.finditer(time_str):
        if match.start() != idx:
            raise ValueError(f"Invalid time format: {time}")
        value = int(match.group(1))
        unit = match.group(2)
        if unit not in units:
            raise ValueError(f"Unknown time unit: {unit}")
        total += value * units[unit]
        idx = match.end()

    if idx != len(time_str):
        raise ValueError(f"Invalid time format: {time}")
    return total

@command('Ban someone for a specified time or permanently')
async def ban(event: Event, user: str, t: str = None, r: str = None):
    global bans

    if not event.player.is_op():
        event.player.send_message('No permission!')
        event.player.play_sound('block_note_block_bass')
        return

    target = Player(user)
    duration = parse_time(t) if t else None
    reason = r or "Ban hammer has spoken!"

    reason_text = (
        f"You have been {'permanently ' if not duration else ''}banned"
        f"{f' for {format_timespan(duration)}' if duration else ''}"
        f"\nReason: {reason}"
    )

    await target.kick(reason_text)
    bans[target.uuid] = (time_now() + duration if duration else None, reason)

    event.player.send_message(
        f"{user} has been {'permanently ' if not duration else ''}banned"
        f"{f' for {format_timespan(duration)}' if duration else ''}"
    )

@command('Unban someone')
async def unban(event: Event, user: str):
    global bans

    if not event.player.is_op():
        event.player.send_message('No permission!')
        event.player.play_sound('block_note_block_bass')
        return

    target = Player(user)
    if target.uuid not in bans:
        event.player.send_message("That user is not banned")
        event.player.play_sound('block_note_block_bass')
        return

    bans.pop(target.uuid)
    event.player.send_message(f"{user} has been unbanned.")

@event
async def player_join(event: Event):
    global bans
    uuid = event.player.uuid

    if uuid not in bans:
        return

    time, reason = bans[uuid]
    if time:
        time -= time_now()

    if time and time <= 0:
        bans.pop(uuid)
        return

    event.player.kick(
        f"You have been {'permanently ' if not time else ''}banned"
        f"{f' for {format_timespan(time)}' if time else ''}"
        f"\nReason: {reason}"
    )



Concepts demonstrated:
- @command with multiple optional arguments
- Player creation by name for offline lookups
- Player.kick() with a formatted reason
- Player.is_op for permission checking
- @event for player_join to enforce bans on login
- Python standard library usage (re, time)
- Third-party library usage (humanfriendly)
- State management with a global dictionary




Tips for Writing Scripts


    

  1. Always import from bridge: from bridge import *
    2. 

  2. Use async/await: Most bridge methods return awaitables
    3. 

  3. Name your event handlers after the event: async def block_break(event) handles block_break events
    4. 

  4. Commands auto-register: The function name becomes the command name
    5. 

  5. Cancel events to prevent default behavior: await event.cancel()
    6. 

  6. Use the Config class for persistence instead of global dictionaries
    7. 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/exceptions.html000066400000000000000000000213601514752343100206370ustar00rootroot00000000000000


  
  
  Exceptions — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Error types raised by the bridge

      
Exceptions


The bridge defines a small exception hierarchy for errors that originate from the Java side.




BridgeError


class BridgeError(Exception)



Base exception for all bridge-related errors. Catch this to handle any error that comes from the Java ↔ Python communication layer.


try:
    await entity.teleport(location)
except BridgeError as e:
    print(f"Bridge call failed: {e}")





EntityGoneException


class EntityGoneException(BridgeError)



Raised when you try to interact with an entity that no longer exists on the server. This happens when:


    

  • The entity was killed or removed between when you got the reference and when you used it.
    • 

  • The entity's chunk was unloaded.
    • 

  • The entity despawned naturally.
    • 



from bridge import *

@event
async def entity_damage(e):
    await server.after(20)  # Wait 1 second
    try:
        await e.entity.set_fire_ticks(100)
    except EntityGoneException:
        # Entity died or despawned during the wait
        pass



When to expect it


Any awaitable method on Entity or Player can raise EntityGoneException if the underlying Java entity has been garbage collected. This is especially common when:


    

  • You store entity references across ticks
    • 

  • You use server.after() between getting a reference and using it
    • 

  • You handle events where the entity might die (e.g. entity_damage)
    • 



Best practice


If you need to use an entity reference after a delay, check is_valid first or wrap the call in a try/except:


if entity.is_valid:
    await entity.teleport(location)


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/favicon.svg000066400000000000000000000007111514752343100177330ustar00rootroot00000000000000
  
    
      
      
    
  
  
  Py

PyJavaBridge-2a/docs/site/hologram.html000066400000000000000000000343161514752343100202730ustar00rootroot00000000000000


  
  
  Hologram — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Floating text displays

      
Hologram


A Hologram is a floating text display entity. It supports multiple lines, configurable billboard mode, and can be moved or removed.


Uses display entities (1.19.4+) internally for crisp rendering.




Constructor


Hologram(location, *lines, billboard="CENTER")



Create and spawn a hologram.


    

  • Parameters:
    • 

  • location (Location) — Where to spawn the hologram.
    • 

  • *lines (str) — Text lines to display. Supports § color codes.
    • 

  • billboard (str) — Billboard mode. Default "CENTER".
    • 







Billboard
Description






"CENTER"
Always faces the player (default)




"FIXED"
Fixed orientation




"HORIZONTAL"
Only rotates horizontally




"VERTICAL"
Only rotates vertically






holo = Hologram(
    Location(100, 70, 200, "world"),
    "§6§lWelcome!",
    "§7to our server",
    billboard="CENTER"
)





Attributes


billboard


    

  • Type: str
    • 



Current billboard mode.


see_through


    

  • Type: bool
    • 



Whether the text can be seen through blocks. Default False.


shadowed


    

  • Type: bool
    • 



Whether the text has a shadow. Default True for most setups.


alignment


    

  • Type: str
    • 



Text alignment: "CENTER", "LEFT", or "RIGHT".


line_width


    

  • Type: int
    • 



Maximum line width in pixels before wrapping.


background


    

  • Type: int | None
    • 



Background color as an ARGB integer, or None for default.




Line Access


Hologram supports index-based access for lines using [] notation.


Set a line


holo[index] = text



Get a line


text = holo[index]



Delete a line


del holo[index]



Get line count


count = len(holo)



Append a line


holo.append(text)



Add a new line to the bottom.


    

  • Parameters:
    • 

  • text (str) — Line text.
    • 





Methods


teleport


holo.teleport(location)



Move the hologram to a new location. This is synchronous.


    

  • Parameters:
    • 

  • location (Location) — New position.
    • 



holo.teleport(Location(100, 75, 200, "world"))



remove


holo.remove()



Despawn and destroy the hologram. This is synchronous.




Example: Welcome hologram


from bridge import *

spawn = Location(0, 65, 0, "world")
welcome = Hologram(
    spawn,
    "§6§l✦ My Server ✦",
    "",
    "§fType §a/help §fto get started",
    "§7play.example.com"
)



Example: Dynamic leaderboard


from bridge import *

lb_loc = Location(50, 70, 50, "world")
leaderboard = Hologram(lb_loc, "§e§lTop Kills", "§7Loading...")

kills = {}

@event
async def entity_death(e: Event):
    d = e.damager
    if d and hasattr(d, 'name'):
        kills[d.name] = kills.get(d.name, 0) + 1
        # Update hologram
        sorted_kills = sorted(kills.items(), key=lambda x: -x[1])[:5]
        leaderboard[0] = "§e§l⚔ Top Kills ⚔"
        for i, (name, count) in enumerate(sorted_kills):
            leaderboard[i + 1] = f"§f#{i+1} §a{name} §7- §e{count}"



Example: Per-player welcome


from bridge import *

holograms = {}

@event
async def player_join(e: Event):
    p = e.player
    loc = p.location.add(0, 2.5, 0)
    holograms[p.name] = Hologram(loc, f"§aWelcome, {p.name}!")

@event
async def player_quit(e: Event):
    h = holograms.pop(e.player.name, None)
    if h:
        h.remove()


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/imagedisplay.html000066400000000000000000000211171514752343100211260ustar00rootroot00000000000000


  
  
  ImageDisplay — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Image rendering in-world

      
ImageDisplay


An ImageDisplay renders an image file as a display entity in the world. It converts image pixels to colored map-like displays.




Constructor


ImageDisplay(location, image_path, pixel_size=..., dual_sided=False, dual_side_mode="mirror")



Create and spawn an image display.


    

  • Parameters:
    • 

  • location (Location) — Spawn position.
    • 

  • image_path (str) — Path to the image file (relative to plugin data folder, or absolute).
    • 

  • pixel_size (float) — Size of each pixel in blocks. Smaller = more detail but more entities.
    • 

  • dual_sided (bool) — Whether the image is visible from both sides. Default False.
    • 

  • dual_side_mode (str) — How the back side renders. Default "mirror".
    • 







dual_side_mode
Description






"mirror"
Back side is a mirror image






display = ImageDisplay(
    Location(100, 70, 200, "world"),
    "images/logo.png",
    pixel_size=0.1,
    dual_sided=True
)





Methods


teleport


display.teleport(location)



Move the display. This is synchronous.


    

  • Parameters:
    • 

  • location (Location) — New position.
    • 



remove


display.remove()



Despawn and destroy the display. This is synchronous.




Notes


    

  • Large images with small pixel_size can create many display entities and impact performance
    • 

  • Supported formats depend on the Java ImageIO library (PNG, JPEG, GIF, BMP)
    • 

  • Place the image files in the plugin's data folder or use an absolute path
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/index.html000066400000000000000000000337431514752343100175750ustar00rootroot00000000000000


  
  
  QuickStart — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Expose Bukkit APIs to Python scripts via easy-to-use wrappers

      
PyJavaBridge


PyJavaBridge is a Minecraft server plugin that lets you write Python scripts that interact with the Bukkit/Spigot/Paper API through a high-level async bridge. Every API call is asynchronous under the hood — you write clean async/await Python and the bridge handles the Java ↔ Python communication transparently.


Quick Start


from bridge import *

@command("Say hello")
async def hello(event: Event):
    await event.player.send_message("Hello from Python!")



Drop your .py file into the server's scripts/ folder and reload. The bridge discovers your @command and @event handlers automatically.


Key Features


    

  • Full Bukkit API — Players, worlds, blocks, entities, inventories, scoreboards, boss bars, advancements, and more.
    • 

  • Async by default — All Java calls are awaitable. Use async/await naturally.
    • 

  • Decorator-driven — Register commands, events, and repeating tasks with simple decorators.
    • 

  • Helper classes — ItemBuilder, Sidebar, Hologram, Menu, Cooldown, Config, and display entities for common patterns.
    • 

  • Region utilities — Fill, replace, and shape operations on the world (spheres, cylinders, lines).
    • 

  • Particle shapes — Draw particle lines, spheres, cubes, and rings with one call.
    • 

  • Permission integration — LuckPerms-aware permission and group management.
    • 

  • Tab list control — Full control over player tab list headers, footers, and display names.
    • 



Pages


Decorators & Core






Page
Description






Decorators
@event, @command, @task




Exceptions
BridgeError, EntityGoneException




EnumValue
Base class for all enum types




Event
Event proxy and event types






Server & Entities






Page
Description






Server
Global server API




Entity
Base entity proxy




Player
Player API (extends Entity)






World & Space






Page
Description






World
World API, region utilities, particle shapes, spawn helpers




Location
3D position with world, yaw, and pitch




Block
Block in the world




Chunk
World chunk loading/unloading




Vector
3D vector






Items & Inventory






Page
Description






Item
ItemStack API




ItemBuilder
Fluent item construction




Inventory
Inventory management




Material
Material enum






Effects & Attributes






Page
Description






Effect
Potion effects




Potion
Legacy potion API




Attribute
Entity attributes






Scoreboards & UI






Page
Description






BossBar
Boss bar API




Scoreboard
Scoreboard API




Team
Team API




Objective
Objective API




Sidebar
Sidebar helper




Advancement
Advancement API






Helpers






Page
Description






Config
Configuration files (TOML, JSON, properties)




Cooldown
Per-player cooldowns




Hologram
Floating text entities




Menu
Chest GUI builder




ActionBarDisplay
Persistent action bar messages




BossBarDisplay
Boss bar wrapper with cooldown linking






Display Entities






Page
Description






BlockDisplay
Block display entity




ItemDisplay
Item display entity




ImageDisplay
Pixel art display






Utilities






Page
Description






Raycast
Ray tracing in the world




Chat
Chat broadcast helper




Reflect
Java reflection access




Enums
All enum types






Examples






Page
Description






Examples
Full script examples





    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/inventory.html000066400000000000000000000361261514752343100205210ustar00rootroot00000000000000


  
  
  Inventory — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Container and GUI API

      
Inventory


An Inventory represents a chest-like container that can be opened as a GUI for players. Use it for custom menus, storage views, or item manipulation.




Constructor


Inventory(size=9, title="", contents=None)



Create a new inventory.


    

  • Parameters:
    • 

  • size (int) — Number of slots. Must be a multiple of 9 (9, 18, 27, 36, 45, 54). Default 9.
    • 

  • title (str) — Display title shown when opened. Supports § color codes. Default "".
    • 

  • contents (list[Item] | None) — Initial items. Default None (empty).
    • 



gui = Inventory(27, "§6Rewards Chest")





Attributes


size


    

  • Type: int
    • 



Total number of slots.


contents



List of items in the inventory. Empty slots are None.


holder


    

  • Type: Any
    • 



The holder of this inventory (player, chest block, etc.), or None for virtual inventories.


title


    

  • Type: str
    • 



Display title of the inventory.


first_empty


    

  • Type: int
    • 



Index of the first empty slot, or -1 if the inventory is full.




Methods


open


await inventory.open(player)



Open this inventory as a GUI for a player.


    

  • Parameters:
    • 

  • player (Player) — The player who will see the GUI.
    • 

  • Returns: Awaitable[Any]
    • 



gui = Inventory(27, "§bShop")
gui_contents = [Item("DIAMOND", name="§bBuy Diamond")]
await gui.open(player)



close


await inventory.close(player=None)



Close this inventory for a player.


    

  • Parameters:
    • 

  • player (Player | None) — The player to close for, or None to close for all viewers.
    • 

  • Returns: Awaitable[Any]
    • 



add_item


await inventory.add_item(item)



Add an item to the first available slot.


    

  • Parameters:
    • 

  • item (Item) — The item to add.
    • 

  • Returns: Awaitable[Any] — Any items that didn't fit.
    • 



await inventory.add_item(Item("DIAMOND", 64))



remove_item


await inventory.remove_item(item)



Remove an item from the inventory.


    

  • Parameters:
    • 

  • item (Item) — The item to remove.
    • 

  • Returns: Awaitable[Any] — Any items that couldn't be removed.
    • 



get_item


item = await inventory.get_item(slot)



Get the item in a specific slot.


    

  • Parameters:
    • 

  • slot (int) — Slot index (0-based).
    • 

  • Returns: Awaitable[Item] — The item, or None if empty.
    • 



set_item


await inventory.set_item(slot, item)



Set the item in a specific slot.


    

  • Parameters:
    • 

  • slot (int) — Slot index (0-based).
    • 

  • item (Item) — The item to place.
    • 

  • Returns: Awaitable[None]
    • 



await inventory.set_item(13, Item("NETHER_STAR", name="§eSpecial"))



contains


result = await inventory.contains(material, amount=1)



Check if the inventory contains at least amount of the given material.


    

  • Parameters:
    • 

  • material (Material) — Material to check for.
    • 

  • amount (int) — Minimum amount. Default 1.
    • 

  • Returns: Awaitable[bool]
    • 



clear


await inventory.clear()



Remove all items from the inventory.


    

  • Returns: Awaitable[None]
    • 





Example: Custom GUI


from bridge import *

@command("Open a shop GUI")
async def shop(player: Player, args: list[str]):
    gui = Inventory(27, "§6§lItem Shop")

    # Set border
    for i in range(27):
        if i < 9 or i >= 18 or i % 9 == 0 or i % 9 == 8:
            await gui.set_item(i, Item("GRAY_STAINED_GLASS_PANE", name=" "))

    # Set shop items
    await gui.set_item(11, Item("DIAMOND_SWORD", name="§bSword §7- §a$100"))
    await gui.set_item(13, Item("DIAMOND_CHESTPLATE", name="§bArmor §7- §a$500"))
    await gui.set_item(15, Item("GOLDEN_APPLE", name="§6Apple §7- §a$50"))

    await gui.open(player)



Tip: For a higher-level GUI system with click handlers, see the Menu class.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/item.html000066400000000000000000000357401514752343100174230ustar00rootroot00000000000000


  
  
  Item — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
ItemStack API

      
Item


An Item represents a Minecraft item stack with material, amount, name, lore, and NBT data.




Constructor


Item(material=None, amount=1, name=None, lore=None, custom_model_data=None, attributes=None, nbt=None)



Create an item.


    

  • Parameters:
    • 

  • material (Material | str | None) — Item material.
    • 

  • amount (int) — Stack size. Default 1.
    • 

  • name (str | None) — Display name. Supports § color codes.
    • 

  • lore (list[str] | None) — Lore lines.
    • 

  • custom_model_data (int | None) — Custom model data for resource packs.
    • 

  • attributes (list[dict] | None) — Attribute modifiers.
    • 

  • nbt (dict | None) — Raw NBT data.
    • 



sword = Item("DIAMOND_SWORD", name="§bFrostbrand", lore=["§7A blade of ice"])
blocks = Item(Material.STONE, amount=64)





Class Methods


drop


entity = await Item.drop(material, location, amount=1, **kwargs)



Drop an item entity at a location.


    

  • Parameters:
    • 

  • material (Material | str) — Item material.
    • 

  • location (Location) — Where to drop.
    • 

  • amount (int) — Stack size. Default 1.
    • 

  • **kwargs — Additional item properties.
    • 

  • Returns: Awaitable[Entity] — The dropped item entity.
    • 



await Item.drop("DIAMOND", player.location, amount=5)



give


await Item.give(player, material, amount=1, **kwargs)



Give an item directly to a player's inventory.


    

  • Parameters:
    • 

  • player (Player) — The recipient.
    • 

  • material (Material | str) — Item material.
    • 

  • amount (int) — Stack size. Default 1.
    • 

  • **kwargs — Additional item properties.
    • 

  • Returns: Awaitable[None]
    • 



await Item.give(player, "GOLDEN_APPLE", 3)





Attributes


type



The item's material type.


amount


    

  • Type: int
    • 



Current stack size.


name


    

  • Type: str | None
    • 



Display name, or None for the default name.


lore


    

  • Type: list[str]
    • 



Lore lines displayed below the item name.


custom_model_data


    

  • Type: int | None
    • 



Custom model data value for resource packs.


attributes


    

  • Type: list[dict]
    • 



Attribute modifiers (attack damage, armor, etc.).


nbt


    

  • Type: dict
    • 



The item's NBT data as a dictionary.


max_stack_size


    

  • Type: int
    • 



Maximum stack size for this item type (e.g. 64 for blocks, 16 for ender pearls, 1 for tools).




Methods


set_amount


await item.set_amount(value)



Set the stack size.


    

  • Parameters:
    • 

  • value (int) — New amount.
    • 

  • Returns: Awaitable[None]
    • 



set_name


await item.set_name(name)



Set the display name.


    

  • Parameters:
    • 

  • name (str) — Name text. Supports § color codes.
    • 

  • Returns: Awaitable[None]
    • 



set_lore


await item.set_lore(lore)



Set the lore lines.


    

  • Parameters:
    • 

  • lore (list[str]) — List of lore lines.
    • 

  • Returns: Awaitable[None]
    • 



set_custom_model_data


await item.set_custom_model_data(value)



Set custom model data.


    

  • Parameters:
    • 

  • value (int) — Model data value.
    • 

  • Returns: Awaitable[None]
    • 



set_attributes


await item.set_attributes(attributes)



Set attribute modifiers.


    

  • Parameters:
    • 

  • attributes (list[dict]) — Attribute modifier list.
    • 

  • Returns: Awaitable[None]
    • 



set_nbt


await item.set_nbt(nbt)



Set raw NBT data.


    

  • Parameters:
    • 

  • nbt (dict) — NBT data dictionary.
    • 

  • Returns: Awaitable[None]
    • 



clone


copy = await item.clone()



Create a deep copy of this item.


    

  • Returns: Awaitable[Item]
    • 



is_similar


result = await item.is_similar(other)



Check if two items are similar (same type, name, lore — ignoring amount).


    

  • Parameters:
    • 

  • other (Item) — The item to compare.
    • 

  • Returns: Awaitable[bool]
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/itembuilder.html000066400000000000000000000342161514752343100207670ustar00rootroot00000000000000


  
  
  ItemBuilder — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Fluent item construction

      
ItemBuilder


A fluent builder for constructing Item objects. Every setter method returns self, allowing chained calls.




Constructor


ItemBuilder(material)



Start building an item with the given material.


    

  • Parameters:
    • 

  • material (Material | str) — Item material.
    • 



sword = (
    ItemBuilder("DIAMOND_SWORD")
    .name("§6Excalibur")
    .lore("§7Legendary blade", "§7of kings")
    .enchant("SHARPNESS", 5)
    .unbreakable()
    .glow()
    .build()
)





Class Methods


from_item


builder = ItemBuilder.from_item(item)



Create a builder pre-filled with settings from an existing item.



builder = ItemBuilder.from_item(existing_item)
upgraded = builder.enchant("SHARPNESS", 10).build()





Chain Methods


All chain methods return the builder, so you can chain them:


item = (
    ItemBuilder("IRON_CHESTPLATE")
    .name("§bFrost Armor")
    .lore("§7Chills attackers")
    .enchant("PROTECTION", 4)
    .enchant("THORNS", 3)
    .unbreakable()
    .custom_model_data(1001)
    .add_attribute("GENERIC_ARMOR", 12, "ADD_NUMBER")
    .flag("HIDE_ENCHANTS", "HIDE_ATTRIBUTES")
    .build()
)



amount


builder.amount(n)



Set the stack size.


    

  • Parameters:
    • 

  • n (int) — Stack amount.
    • 



name


builder.name(n)



Set the display name.


    

  • Parameters:
    • 

  • n (str) — Display name. Supports § color codes.
    • 



lore


builder.lore(*lines)



Set lore lines (replaces any existing lore).


    

  • Parameters:
    • 

  • *lines (str) — One or more lore lines.
    • 



add_lore


builder.add_lore(line)



Append a single lore line.


    

  • Parameters:
    • 

  • line (str) — Lore line to add.
    • 



enchant


builder.enchant(enchantment, level=1)



Add an enchantment.


    

  • Parameters:
    • 

  • enchantment (str) — Enchantment name (e.g. "SHARPNESS", "PROTECTION").
    • 

  • level (int) — Enchantment level. Default 1.
    • 



unbreakable


builder.unbreakable(value=True)



Set the unbreakable flag.


    

  • Parameters:
    • 

  • value (bool) — Whether the item is unbreakable. Default True.
    • 



glow


builder.glow(value=True)



Add a glow effect (enchantment glint without visible enchantments).


    

  • Parameters:
    • 

  • value (bool) — Whether to add glow. Default True.
    • 



custom_model_data


builder.custom_model_data(value)



Set custom model data for resource packs.


    

  • Parameters:
    • 

  • value (int) — Model data value.
    • 



attributes


builder.attributes(attrs)



Set attribute modifiers (replaces any existing).


    

  • Parameters:
    • 

  • attrs (list[dict[str, Any]]) — Attribute modifier list.
    • 



add_attribute


builder.add_attribute(attribute, amount, operation="ADD_NUMBER")



Add a single attribute modifier.


    

  • Parameters:
    • 

  • attribute (str) — Attribute name (e.g. "GENERIC_ARMOR", "GENERIC_ATTACK_DAMAGE").
    • 

  • amount (float) — Modifier amount.
    • 

  • operation (str) — Operation type. Default "ADD_NUMBER". Options: "ADD_NUMBER", "ADD_SCALAR", "MULTIPLY_SCALAR_1".
    • 



nbt


builder.nbt(data)



Set raw NBT data.


    

  • Parameters:
    • 

  • data (dict[str, Any]) — NBT data dictionary.
    • 



flag


builder.flag(*flags)



Add item flags to hide information from the tooltip.


    

  • Parameters:
    • 

  • *flags (str) — Flag names: "HIDE_ENCHANTS", "HIDE_ATTRIBUTES", "HIDE_UNBREAKABLE", "HIDE_DESTROYS", "HIDE_PLACED_ON", "HIDE_DYE".
    • 





build


item = builder.build()



Construct the final Item from the builder state.



Note: build() is synchronous. The resulting Item can be used immediately in inventory operations, give, drop, etc.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/itemdisplay.html000066400000000000000000000225471514752343100210120ustar00rootroot00000000000000


  
  
  ItemDisplay — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Item display entity

      
ItemDisplay


An ItemDisplay renders an item as a display entity in the world (1.19.4+). Unlike dropped items, display entities don't have physics, don't despawn, and can use billboard modes.




Constructor


ItemDisplay(location, item, billboard="FIXED")



Create and spawn an item display entity.


    

  • Parameters:
    • 

  • location (Location) — Spawn position.
    • 

  • item (Item | str) — The item to display. If a string, interprets as a material name.
    • 

  • billboard (str) — Billboard mode. Default "FIXED".
    • 







Billboard
Description






"FIXED"
No rotation (default)




"CENTER"
Always faces the player




"HORIZONTAL"
Only rotates horizontally




"VERTICAL"
Only rotates vertically






display = ItemDisplay(
    Location(100, 70, 200, "world"),
    Item("DIAMOND_SWORD", name="§bExcalibur"),
    billboard="CENTER"
)





Attributes


billboard


    

  • Type: str
    • 



Current billboard mode.




Methods


teleport


display.teleport(location)



Move the display entity. This is synchronous.


    

  • Parameters:
    • 

  • location (Location) — New position.
    • 



remove


display.remove()



Despawn and destroy the display entity. This is synchronous.




Example: Floating reward indicator


from bridge import *

@command("Show reward")
async def reward(player: Player, args: list[str]):
    loc = player.location.add(0, 2, 0)
    display = ItemDisplay(loc, "NETHER_STAR", billboard="CENTER")
    await player.send_message("§e⭐ Reward available above you!")


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/location.html000066400000000000000000000271531514752343100202740ustar00rootroot00000000000000


  
  
  Location — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
3D position with world reference, yaw, and pitch

      
Location


A Location represents a position in a world with rotation angles. It is used for teleportation, block lookups, spawning, and spatial calculations.




Constructor


Location(x=0.0, y=0.0, z=0.0, world=None, yaw=0.0, pitch=0.0)



Create a new location.


    

  • Parameters:
    • 

  • x (float) — X coordinate. Default 0.
    • 

  • y (float) — Y coordinate. Default 0.
    • 

  • z (float) — Z coordinate. Default 0.
    • 

  • world (World | str | None) — World reference or name. Default None.
    • 

  • yaw (float) — Horizontal rotation in degrees. Default 0.
    • 

  • pitch (float) — Vertical rotation in degrees. Default 0. Negative = looking up.
    • 



loc = Location(100, 64, -200, "world")
loc = Location(0, 64, 0, "world_nether", yaw=90, pitch=-45)





Attributes


x


    

  • Type: float
    • 



X coordinate (East-West).


y


    

  • Type: float
    • 



Y coordinate (altitude).


z


    

  • Type: float
    • 



Z coordinate (North-South).


world



The world this location is in.


yaw


    

  • Type: float
    • 



Horizontal rotation in degrees. 0 = South, 90 = West, 180 = North, 270 = East.


pitch


    

  • Type: float
    • 



Vertical rotation in degrees. 0 = level, -90 = straight up, 90 = straight down.




Methods


add


new_loc = location.add(x, y, z)



Create a new location with the given offsets added. This is synchronous — no await needed.


    

  • Parameters:
    • 

  • x (float) — X offset.
    • 

  • y (float) — Y offset.
    • 

  • z (float) — Z offset.
    • 

  • Returns: Location — A new location (the original is not modified).
    • 



above = player.location.add(0, 2, 0)



clone


copy = location.clone()



Create an independent copy of this location. Synchronous.



distance


d = location.distance(other)



Calculate the Euclidean distance to another location. Synchronous.


    

  • Parameters:
    • 

  • other (Location) — The other location.
    • 

  • Returns: float
    • 



dist = player.location.distance(spawn_location)
if dist < 10:
    await player.send_message("You're near spawn!")



distance_squared


d2 = location.distance_squared(other)



Calculate the squared distance to another location. Synchronous. Faster than distance() when you only need to compare distances (avoids square root).


    

  • Parameters:
    • 

  • other (Location) — The other location.
    • 

  • Returns: float
    • 



# More efficient than: if loc.distance(other) < 10
if loc.distance_squared(other) < 100:
    ...


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/menu.html000066400000000000000000000372761514752343100174370ustar00rootroot00000000000000


  
  
  Menu — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
GUI menu system

      
Menu


Menu is a high-level inventory GUI system with click handlers. It wraps Inventory with per-slot click callbacks using MenuItem.




Constructor


Menu(title="", rows=3)



Create a menu.


    

  • Parameters:
    • 

  • title (str) — Title displayed at the top. Supports § color codes.
    • 

  • rows (int) — Number of rows (1–6). Each row has 9 slots. Default 3.
    • 



shop = Menu("§6§lItem Shop", rows=3)





Attributes


title


    

  • Type: str
    • 



Menu title.


rows


    

  • Type: int
    • 



Number of rows.




Slot Access


Menu supports index-based access using [] notation.


Set a slot


menu[slot] = menu_item



    

  • Parameters:
    • 

  • slot (int) — Slot index (0-based, left-to-right, top-to-bottom).
    • 

  • menu_item (MenuItem) — Item with click handler.
    • 



Get a slot


item = menu[slot]




Delete a slot


del menu[slot]





Methods


fill_border


menu.fill_border(item)



Fill the border slots with a decorative item. This is synchronous.


    

  • Parameters:
    • 

  • item (Item) — Item to use for the border.
    • 



shop = Menu("§6§lShop", rows=3)
shop.fill_border(Item("GRAY_STAINED_GLASS_PANE", name=" "))



open


menu.open(player)



Open this menu for a player. This is synchronous.


    

  • Parameters:
    • 

  • player (Player) — Player to show the menu to.
    • 





MenuItem


A MenuItem wraps an Item with an optional click callback.


Constructor


MenuItem(item, on_click=None)



    

  • Parameters:
    • 

  • item (Item | str) — The display item. If a string, creates an Item with that material.
    • 

  • on_click (Callable[[Player,Event], Any] | None) — Click callback. Receives the clicking player and the click event. Default None.
    • 



# Simple display item
MenuItem(Item("DIAMOND", name="§bShiny"))

# With click handler
MenuItem(
    Item("GOLDEN_APPLE", name="§6Buy Apple §7- §a$50"),
    on_click=lambda player, event: player.send_message("§aPurchased!")
)



Attributes


item



The display item.


on_click



Click callback.




Example: Shop menu


from bridge import *

async def buy_sword(player, event):
    await Item.give(player, "DIAMOND_SWORD")
    await player.send_message("§aYou bought a Diamond Sword!")

async def buy_armor(player, event):
    await Item.give(player, "DIAMOND_CHESTPLATE")
    await player.send_message("§aYou bought Diamond Armor!")

@command("Open the shop")
async def shop(player: Player, args: list[str]):
    menu = Menu("§6§lItem Shop", rows=3)
    menu.fill_border(Item("BLACK_STAINED_GLASS_PANE", name=" "))

    menu[10] = MenuItem(
        Item("DIAMOND_SWORD", name="§bDiamond Sword", lore=["§7Price: §a$100"]),
        on_click=buy_sword
    )
    menu[12] = MenuItem(
        Item("DIAMOND_CHESTPLATE", name="§bDiamond Armor", lore=["§7Price: §a$500"]),
        on_click=buy_armor
    )
    menu[14] = MenuItem(
        Item("GOLDEN_APPLE", name="§6Golden Apple", lore=["§7Price: §a$50"]),
        on_click=lambda p, e: Item.give(p, "GOLDEN_APPLE")
    )
    menu[16] = MenuItem(
        Item("BARRIER", name="§cClose"),
        on_click=lambda p, e: p.inventory.close()
    )

    menu.open(player)



Example: Confirmation dialog


from bridge import *

def confirm_menu(title, on_confirm, on_cancel):
    menu = Menu(title, rows=3)
    menu.fill_border(Item("GRAY_STAINED_GLASS_PANE", name=" "))

    menu[11] = MenuItem(
        Item("LIME_WOOL", name="§a§lConfirm"),
        on_click=on_confirm
    )
    menu[15] = MenuItem(
        Item("RED_WOOL", name="§c§lCancel"),
        on_click=on_cancel
    )
    return menu

@command("Delete your home")
async def delhome(player: Player, args: list[str]):
    async def confirm(p, e):
        await p.send_message("§aHome deleted!")
        await p.inventory.close()

    async def cancel(p, e):
        await p.send_message("§cCancelled.")
        await p.inventory.close()

    menu = confirm_menu("§c§lDelete Home?", confirm, cancel)
    menu.open(player)



Tip: For lower-level inventory control without click handlers, see Inventory.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/objective.html000066400000000000000000000313111514752343100204250ustar00rootroot00000000000000


  
  
  Objective — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Scoreboard objective API

      
Objective


An Objective tracks a score for each player on a Scoreboard. Objectives can be displayed in the sidebar, below name tags, or in the tab list.




Class Methods


create


obj = Objective.create(name, criteria, display_name="", scoreboard=None)



Create a new objective. This is synchronous.


    

  • Parameters:
    • 

  • name (str) — Internal objective name (unique per scoreboard).
    • 

  • criteria (str) — Score criteria. See Criteria table below.
    • 

  • display_name (str) — Name displayed to players. Default "".
    • 

  • scoreboard (Scoreboard | None) — Scoreboard to register on. If None, uses the main scoreboard.
    • 

  • Returns: Objective
    • 



obj = Objective.create("kills", "dummy", "§6Kill Count")





Attributes


name


    

  • Type: str
    • 



Internal name of the objective.


criteria


    

  • Type: str
    • 



The criteria type (e.g. "dummy", "health").


display_slot


    

  • Type: Any
    • 



Current display slot, or None if not displayed.




Methods


set_display_name


await obj.set_display_name(name)



Change the display name.


    

  • Parameters:
    • 

  • name (str) — New display name. Supports § color codes.
    • 

  • Returns: Awaitable[None]
    • 



set_display_slot


await obj.set_display_slot(slot)



Set where this objective is displayed.


    

  • Parameters:
    • 

  • slot (Any) — Display slot. Common values: "SIDEBAR", "BELOW_NAME", "PLAYER_LIST".
    • 

  • Returns: Awaitable[None]
    • 



await obj.set_display_slot("SIDEBAR")     # Right side of screen
await obj.set_display_slot("BELOW_NAME")  # Under name tags
await obj.set_display_slot("PLAYER_LIST") # In tab list



get_score


score = obj.get_score(entry)



Get the score tracker for a player. This is synchronous and returns a score object.


    

  • Parameters:
    • 

  • entry (str) — Player name.
    • 

  • Returns: Score object
    • 



score = obj.get_score(player.name)





Criteria Types






Criteria
Description






dummy
Manual scores only — set by commands/plugins




health
Player health (auto-updated)




playerKillCount
Player kills (auto-updated)




totalKillCount
Total kills (auto-updated)




deathCount
Deaths (auto-updated)




food
Food level (auto-updated)




air
Air remaining (auto-updated)




armor
Armor points (auto-updated)




xp
XP level (auto-updated)








Example: Custom sidebar


from bridge import *

board = Scoreboard.create()
sidebar = board.register_objective("display", "dummy", "§6§lMy Server")
await sidebar.set_display_slot("SIDEBAR")

# Set lines (higher score = higher position)
sidebar.get_score("§7───────────").score = 10
sidebar.get_score("§fKills: §a0").score = 9
sidebar.get_score("§fDeaths: §c0").score = 8
sidebar.get_score("§fCoins: §e0").score = 7
sidebar.get_score("§7───────────").score = 6

@event
async def player_join(e: Event):
    await e.player.set_scoreboard(board)



Tip: For a simpler sidebar API that handles line management automatically, see Sidebar.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/player.html000066400000000000000000000743651514752343100177670ustar00rootroot00000000000000


  
  
  Player — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Player API — extends Entity

      
Player


Player extends Entity with player-specific functionality: health, hunger, experience, permissions, inventory, tab list, game mode, and more.




Constructor


Player(uuid: str | None = None, name: str | None = None)



Resolve a player by UUID or name. At least one must be provided. The player must be online.


    

  • Parameters:
    • 

  • uuid (str | None) — The player's UUID.
    • 

  • name (str | None) — The player's name (case-insensitive lookup).
    • 



p = Player(name="Steve")
p = Player(uuid="550e8400-e29b-41d4-a716-446655440000")





Attributes


name


    

  • Type: str
    • 



The player's display name.


uuid


    

  • Type: str
    • 



The player's UUID.


location



Current player location.


world



The world the player is in.


health


    

  • Type: float
    • 



Current health (0–20 by default, 0 = dead).


food_level


    

  • Type: int
    • 



Hunger level (0–20, 20 = full).


game_mode



Current game mode (e.g. GameMode.SURVIVAL, GameMode.CREATIVE).


inventory



The player's inventory (36 slots + armor + offhand).


level


    

  • Type: int
    • 



Player experience level (the green number).


exp


    

  • Type: float
    • 



Experience progress within the current level (0.0 to 1.0).


is_op


    

  • Type: bool
    • 



Whether the player is a server operator.


is_flying


    

  • Type: bool
    • 



Whether the player is currently flying.


is_sneaking


    

  • Type: bool
    • 



Whether the player is sneaking (shift held).


is_sprinting


    

  • Type: bool
    • 



Whether the player is sprinting.


scoreboard



The player's current scoreboard.


permission_groups


    

  • Type: list[str]
    • 



The player's permission groups. LuckPerms-aware — returns LuckPerms groups if available, otherwise falls back to the basic permission system.


primary_group


    

  • Type: str | None
    • 



The player's primary permission group (LuckPerms). None if LuckPerms is not installed.


tab_list_header


    

  • Type: str
    • 



The player's tab list header text.



    

  • Type: str
    • 



The player's tab list footer text.


tab_list_name


    

  • Type: str
    • 



The player's display name in the tab list.




Methods


send_message


await player.send_message(message)



Send a chat message to the player.


    

  • Parameters:
    • 

  • message (str) — The message. Supports § color codes.
    • 

  • Returns: Awaitable[None]
    • 



await player.send_message("§aYou found a secret!")



chat


await player.chat(message)



Make the player send a chat message (as if they typed it).


    

  • Parameters:
    • 

  • message (str) — The message to send.
    • 

  • Returns: Awaitable[None]
    • 



kick


await player.kick(reason="")



Kick the player from the server.


    

  • Parameters:
    • 

  • reason (str) — Kick reason shown to the player. Default empty.
    • 

  • Returns: Awaitable[None]
    • 



await player.kick("§cYou have been banned!")



teleport


await player.teleport(location)



Teleport the player. Inherited from Entity.


    

  • Parameters:
    • 

  • location (Location) — Destination.
    • 

  • Returns: Awaitable[None]
    • 



give_exp


await player.give_exp(amount)



Give raw experience points to the player.


    

  • Parameters:
    • 

  • amount (int) — XP points to add.
    • 

  • Returns: Awaitable[None]
    • 



set_exp


await player.set_exp(exp)



Set the experience progress bar within the current level.


    

  • Parameters:
    • 

  • exp (float) — Progress from 0.0 to 1.0.
    • 

  • Returns: Awaitable[None]
    • 



set_level


await player.set_level(level)



Set the player's experience level.


    

  • Parameters:
    • 

  • level (int) — The level number.
    • 

  • Returns: Awaitable[None]
    • 



set_health


await player.set_health(health)



Set the player's health.


    

  • Parameters:
    • 

  • health (float) — Health from 0.0 to 20.0 (default max).
    • 

  • Returns: Awaitable[None]
    • 



set_food_level


await player.set_food_level(level)



Set the player's hunger level.


    

  • Parameters:
    • 

  • level (int) — Food level from 0 to 20.
    • 

  • Returns: Awaitable[None]
    • 



set_game_mode


await player.set_game_mode(mode)



Set the player's game mode.


    

  • Parameters:
    • 

  • mode (GameMode) — The game mode.
    • 

  • Returns: Awaitable[None]
    • 



await player.set_game_mode(GameMode.CREATIVE)



set_op


await player.set_op(value)



Set operator status.


    

  • Parameters:
    • 

  • value (bool) — True for op, False to deop.
    • 

  • Returns: Awaitable[None]
    • 



set_flying


await player.set_flying(value)



Set flying state. The player must be allowed to fly (creative mode or flight allowed).


    

  • Parameters:
    • 

  • value (bool)
    • 

  • Returns: Awaitable[None]
    • 



set_sneaking


await player.set_sneaking(value)



Force the sneaking state.


    

  • Parameters:
    • 

  • value (bool)
    • 

  • Returns: Awaitable[None]
    • 



set_sprinting


await player.set_sprinting(value)



Force the sprinting state.


    

  • Parameters:
    • 

  • value (bool)
    • 

  • Returns: Awaitable[None]
    • 



set_walk_speed


await player.set_walk_speed(speed)



Set walking speed.


    

  • Parameters:
    • 

  • speed (float) — Speed multiplier. Default is 0.2. Range: -1.0 to 1.0.
    • 

  • Returns: Awaitable[None]
    • 



set_fly_speed


await player.set_fly_speed(speed)



Set flying speed.


    

  • Parameters:
    • 

  • speed (float) — Speed multiplier. Default is 0.1. Range: -1.0 to 1.0.
    • 

  • Returns: Awaitable[None]
    • 



set_scoreboard


await player.set_scoreboard(scoreboard)



Set the player's active scoreboard.


    

  • Parameters:
    • 

  • scoreboard (Scoreboard) — The scoreboard to display.
    • 

  • Returns: Awaitable[None]
    • 





Effects


add_effect


await player.add_effect(effect)



Apply a potion effect to the player.


    

  • Parameters:
    • 

  • effect (Effect) — The effect to apply.
    • 

  • Returns: Awaitable[None]
    • 



await player.add_effect(Effect(EffectType.SPEED, duration=200, amplifier=1))



remove_effect


await player.remove_effect(effect_type)



Remove an active potion effect.


    

  • Parameters:
    • 

  • effect_type (EffectType) — The effect type to remove.
    • 

  • Returns: Awaitable[None]
    • 





Sounds & UI


play_sound


await player.play_sound(sound, volume=1.0, pitch=1.0)



Play a sound to the player at their location.


    

  • Parameters:
    • 

  • sound (Sound) — The sound to play.
    • 

  • volume (float) — Volume. Default 1.0.
    • 

  • pitch (float) — Pitch. Default 1.0.
    • 

  • Returns: Awaitable[None]
    • 



await player.play_sound(Sound.ENTITY_EXPERIENCE_ORB_PICKUP)
await player.play_sound('block_note_block_bass', volume=0.5, pitch=2.0)



send_action_bar


await player.send_action_bar(message)



Display a message in the action bar (above the hotbar).


    

  • Parameters:
    • 

  • message (str) — The message. Supports § color codes.
    • 

  • Returns: Awaitable[None]
    • 



send_title


await player.send_title(title, subtitle="", fade_in=10, stay=70, fade_out=20)



Display a title and subtitle on the player's screen.


    

  • Parameters:
    • 

  • title (str) — The main title text.
    • 

  • subtitle (str) — Subtitle text below the title.
    • 

  • fade_in (int) — Fade-in time in ticks. Default 10 (0.5s).
    • 

  • stay (int) — Display time in ticks. Default 70 (3.5s).
    • 

  • fade_out (int) — Fade-out time in ticks. Default 20 (1s).
    • 

  • Returns: Awaitable[None]
    • 



await player.send_title("§6Victory!", "§eYou won the game", fade_in=5, stay=40, fade_out=10)





Tab List


set_tab_list_header


await player.set_tab_list_header(header)



Set the header text shown above the player list in the tab screen.


    

  • Parameters:
    • 

  • header (str) — Header text. Supports § color codes and \n for multiple lines.
    • 

  • Returns: Awaitable[None]
    • 




await player.set_tab_list_footer(footer)



Set the footer text shown below the player list.


    

  • Parameters:
    • 

  • footer (str) — Footer text.
    • 

  • Returns: Awaitable[None]
    • 




await player.set_tab_list_header_footer(header="", footer="")



Set both header and footer in a single call.


    

  • Parameters:
    • 

  • header (str) — Header text.
    • 

  • footer (str) — Footer text.
    • 

  • Returns: Awaitable[None]
    • 



set_tab_list_name


await player.set_tab_list_name(name)



Set the player's display name in the tab list.


    

  • Parameters:
    • 

  • name (str) — Display name. Supports § color codes.
    • 

  • Returns: Awaitable[None]
    • 



await player.set_tab_list_name("§c[Admin]§r Steve")





Permissions


has_permission


result = await player.has_permission(permission)



Check if the player has a permission node.


    

  • Parameters:
    • 

  • permission (str) — The permission node (e.g. "myplugin.use").
    • 

  • Returns: Awaitable[bool]
    • 



add_permission


result = await player.add_permission(permission, value=True)



Add or set a permission on the player. LuckPerms-aware.


    

  • Parameters:
    • 

  • permission (str) — The permission node.
    • 

  • value (bool) — True to grant, False to negate. Default True.
    • 

  • Returns: Awaitable[bool]
    • 



remove_permission


result = await player.remove_permission(permission)



Remove a permission from the player. LuckPerms-aware.


    

  • Parameters:
    • 

  • permission (str) — The permission node to remove.
    • 

  • Returns: Awaitable[bool]
    • 



has_group


result = await player.has_group(group)



Check if the player belongs to a permission group. LuckPerms only.


    

  • Parameters:
    • 

  • group (str) — The group name.
    • 

  • Returns: Awaitable[bool]
    • 



add_group


result = await player.add_group(group)



Add the player to a permission group. LuckPerms only.


    

  • Parameters:
    • 

  • group (str) — The group name.
    • 

  • Returns: Awaitable[bool]
    • 



remove_group


result = await player.remove_group(group)



Remove the player from a permission group. LuckPerms only.


    

  • Parameters:
    • 

  • group (str) — The group name.
    • 

  • Returns: Awaitable[bool]
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/potion.html000066400000000000000000000217311514752343100177700ustar00rootroot00000000000000


  
  
  Potion — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Legacy potion API

      
Potion


The Potion class provides a legacy interface for applying potion effects. For new code, prefer using Effect directly.




Class Methods


apply


await Potion.apply(player, effect_type=None, duration=0, amplifier=0, ambient=False, particles=True, icon=True)



Apply a potion effect to a player. This is functionally identical to Effect.apply.


    

  • Parameters:
    • 

  • player (Player) — Target player.
    • 

  • effect_type (EffectType | str | None) — Effect type.
    • 

  • duration (int) — Duration in ticks (20 ticks = 1 second). Default 0.
    • 

  • amplifier (int) — Effect level minus 1. Default 0.
    • 

  • ambient (bool) — Beacon-style translucent particles. Default False.
    • 

  • particles (bool) — Show particles. Default True.
    • 

  • icon (bool) — Show HUD icon. Default True.
    • 

  • Returns: Awaitable[Any]
    • 



await Potion.apply(player, "POISON", duration=100, amplifier=0)





Attributes


type


    

  • Type: Any
    • 



The potion's effect type.


level


    

  • Type: int
    • 



The potion level.




Recommendation


Use Effect for all new code:


# Preferred
await Effect.apply(player, "SPEED", duration=600, amplifier=1)

# Legacy (still works)
await Potion.apply(player, "SPEED", duration=600, amplifier=1)



Both are equivalent, but Effect provides additional methods like with_duration() and with_amplifier().

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/raycast.html000066400000000000000000000403651514752343100201320ustar00rootroot00000000000000


  
  
  Raycast — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Ray tracing function

      
raycast


The raycast function traces a ray through the world, detecting entities and blocks along the path. Useful for line-of-sight checks, targeting systems, and custom projectiles.




Function Signature


result = await raycast(
    world,
    start,
    direction,
    max_distance=64.0,
    ray_size=0.2,
    include_entities=True,
    include_blocks=True,
    ignore_passable=True
)



    

  • Parameters:
    • 

  • world (World | str) — The world to raycast in.
    • 

  • start (Vector | tuple[float,float,float]) — Ray origin (x, y, z).
    • 

  • direction (tuple[float, float]) — Direction as (yaw, pitch) in degrees.
    • 

  • max_distance (float) — Maximum ray distance in blocks. Default 64.0.
    • 

  • ray_size (float) — Ray thickness for entity detection. Default 0.2.
    • 

  • include_entities (bool) — Whether to detect entities. Default True.
    • 

  • include_blocks (bool) — Whether to detect blocks. Default True.
    • 

  • ignore_passable (bool) — Whether to ignore passable blocks (grass, flowers, etc.). Default True.
    • 

  • Returns: Awaitable[RaycastResult| None] — Hit result, or None if nothing was hit.
    • 



from bridge import *

# Raycast from a player's eye position in their look direction
result = await raycast(
    player.world,
    (player.location.x, player.location.y + 1.62, player.location.z),
    (player.location.yaw, player.location.pitch),
    max_distance=50.0
)

if result:
    if result.entity:
        await player.send_message(f"§aLooking at: {result.entity.type.name}")
    elif result.block:
        await player.send_message(f"§aLooking at block: {result.block.type.name}")





RaycastResult


Returned by raycast() when a hit occurs.


Attributes


x


    

  • Type: float
    • 



X coordinate of the hit point.


y


    

  • Type: float
    • 



Y coordinate of the hit point.


z


    

  • Type: float
    • 



Z coordinate of the hit point.


entity



The entity that was hit, or None if a block was hit.


block



The block that was hit, or None if an entity was hit.


start_x


    

  • Type: float
    • 



X coordinate of the ray origin.


start_y


    

  • Type: float
    • 



Y coordinate of the ray origin.


start_z


    

  • Type: float
    • 



Z coordinate of the ray origin.


yaw


    

  • Type: float
    • 



Yaw direction of the ray.


pitch


    

  • Type: float
    • 



Pitch direction of the ray.


distance


    

  • Type: float
    • 



Distance from the ray origin to the hit point.


hit_face


    

  • Type: str | None
    • 



The face of the block that was hit (e.g. "NORTH", "UP"), or None for entity hits.




Example: Target selector


from bridge import *

@command("Smite what you're looking at")
async def smite(player: Player, args: list[str]):
    loc = player.location
    result = await raycast(
        player.world,
        (loc.x, loc.y + 1.62, loc.z),
        (loc.yaw, loc.pitch),
        max_distance=100.0,
        include_entities=True,
        include_blocks=False
    )

    if result and result.entity:
        hit_loc = Location(result.x, result.y, result.z, player.world.name)
        await player.world.strike_lightning(hit_loc)
        await player.send_message(f"§e⚡ Smited {result.entity.type.name}!")
    else:
        await player.send_message("§cNo entity in sight!")



Example: Build tool


from bridge import *

@command("Place a block where you look")
async def place(player: Player, args: list[str]):
    material = args[0] if args else "STONE"
    loc = player.location
    result = await raycast(
        player.world,
        (loc.x, loc.y + 1.62, loc.z),
        (loc.yaw, loc.pitch),
        max_distance=50.0,
        include_entities=False,
        include_blocks=True
    )

    if result and result.block:
        # Place block on the hit face
        bx, by, bz = int(result.x), int(result.y), int(result.z)
        if result.hit_face == "UP": by += 1
        elif result.hit_face == "DOWN": by -= 1
        elif result.hit_face == "NORTH": bz -= 1
        elif result.hit_face == "SOUTH": bz += 1
        elif result.hit_face == "EAST": bx += 1
        elif result.hit_face == "WEST": bx -= 1

        await player.world.set_block(bx, by, bz, material)
        await player.send_message(f"§aPlaced {material}!")
    else:
        await player.send_message("§cNo block in range!")



Example: Line of sight check


from bridge import *

async def can_see(player, target_location):
    """Check if a player has line of sight to a location."""
    loc = player.location
    # Calculate direction (simplified — yaw/pitch calculation)
    result = await raycast(
        player.world,
        (loc.x, loc.y + 1.62, loc.z),
        (loc.yaw, loc.pitch),
        max_distance=64.0,
        include_entities=False,
        include_blocks=True,
        ignore_passable=True
    )

    if result is None:
        return True  # Nothing blocking
    return result.distance > loc.distance(target_location)


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/reflect.html000066400000000000000000000215241514752343100201040ustar00rootroot00000000000000


  
  
  Reflect — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Java reflection helper

      
Reflect


The Reflect helper provides access to Java classes for advanced interop. An instance is available as the global reflect variable.


Warning: Reflection is a low-level API. Most scripts won't need it. Use the higher-level bridge classes when possible.




Global Instance


from bridge import reflect





Methods


clazz


cls = await reflect.clazz(name)



Get a Java class by its fully qualified name.


    

  • Parameters:
    • 

  • name (str) — Fully qualified Java class name.
    • 

  • Returns: Awaitable[Any] — The Java class object.
    • 



# Access Bukkit classes
bukkit = await reflect.clazz("org.bukkit.Bukkit")

# Access NMS (net.minecraft.server) classes
# The exact path depends on server version
nms = await reflect.clazz("net.minecraft.server.MinecraftServer")





Use Cases


Accessing unsupported Bukkit API


If the bridge doesn't wrap a specific Bukkit method, you can access it directly:


bukkit = await reflect.clazz("org.bukkit.Bukkit")
# Call static methods on the class



Checking server internals


server_cls = await reflect.clazz("org.bukkit.Bukkit")
# Useful for debugging or version-specific code





Notes


    

  • Reflection accesses the underlying Java runtime — incorrect class names will raise errors
    • 

  • The available classes depend on the server implementation (Spigot, Paper, etc.)
    • 

  • NMS class paths change between Minecraft versions
    • 

  • Prefer using bridge-provided APIs over reflection when possible
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/scoreboard.html000066400000000000000000000274531514752343100206120ustar00rootroot00000000000000


  
  
  Scoreboard — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Scoreboard management

      
Scoreboard


A Scoreboard manages objectives and teams. Each player can see one scoreboard at a time — assign a custom scoreboard to show custom sidebar content, name tags, or tab list formatting.




Class Methods


create


board = Scoreboard.create()



Create a new empty scoreboard. This is synchronous.



board = Scoreboard.create()
await player.set_scoreboard(board)





Attributes


objectives



All objectives registered on this scoreboard.


teams



All teams registered on this scoreboard.




Methods


register_objective


objective = board.register_objective(name, criteria, display_name="")



Register a new objective. This is synchronous.


    

  • Parameters:
    • 

  • name (str) — Internal name (unique per scoreboard).
    • 

  • criteria (str) — Criteria type (e.g. "dummy", "health", "playerKillCount").
    • 

  • display_name (str) — Display name shown in the sidebar/tab. Default "".
    • 

  • Returns: Objective
    • 



obj = board.register_objective("kills", "dummy", "§c§lKill Count")



get_objective


objective = board.get_objective(name)



Get an existing objective by name.


    

  • Parameters:
    • 

  • name (str) — Internal objective name.
    • 

  • Returns: Objective
    • 



register_team


team = board.register_team(name)



Register a new team. This is synchronous.


    

  • Parameters:
    • 

  • name (str) — Internal name (unique per scoreboard).
    • 

  • Returns: Team
    • 



red_team = board.register_team("red")
await red_team.set_prefix("§c[RED] ")
await red_team.set_color("RED")



get_team


team = board.get_team(name)



Get an existing team by name.


    

  • Parameters:
    • 

  • name (str) — Internal team name.
    • 

  • Returns: Team
    • 



clear_slot


await board.clear_slot(slot)



Clear the display in a specific slot.


    

  • Parameters:
    • 

  • slot (Any) — Display slot to clear.
    • 

  • Returns: Awaitable[None]
    • 





Example: Kill counter sidebar


from bridge import *

board = Scoreboard.create()
obj = board.register_objective("kills", "dummy", "§6§lKill Count")
await obj.set_display_slot("SIDEBAR")

@event
async def player_join(e: Event):
    await e.player.set_scoreboard(board)

@event
async def entity_death(e: Event):
    killer = e.damager
    if killer and hasattr(killer, 'name'):
        score = obj.get_score(killer.name)
        # Score tracking happens automatically via the scoreboard API



See also: Sidebar for a simpler high-level sidebar helper.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/script.js000066400000000000000000000145531514752343100174400ustar00rootroot00000000000000document.addEventListener('DOMContentLoaded', () => {
  const STORAGE_KEY = 'pjb-sidebar-state';

  // ── Helpers ──────────────────────────────────────────────────
  function loadState() {
    try { return JSON.parse(localStorage.getItem(STORAGE_KEY)) || {}; } catch { return {}; }
  }
  function saveState(state) {
    try { localStorage.setItem(STORAGE_KEY, JSON.stringify(state)); } catch {}
  }

  // ── Restore sidebar collapsed/expanded state ────────────────
  const state = loadState();
  document.querySelectorAll('.sidebar-heading[data-section]').forEach(h => {
    const key = h.dataset.section;
    if (key in state) {
      h.classList.toggle('collapsed', state[key]);
    }
    // Measure natural height so CSS max-height animation works
    const ul = h.nextElementSibling;
    if (ul && ul.classList.contains('sidebar-links')) {
      if (!h.classList.contains('collapsed')) {
        ul.style.maxHeight = ul.scrollHeight + 'px';
      }
    }
  });

  // ── Highlight current page ──────────────────────────────────
  const currentPage = location.pathname.split('/').pop() || 'index.html';
  document.querySelectorAll('.sidebar-links a').forEach(a => {
    const href = a.getAttribute('href');
    if (href && !href.startsWith('#')) {
      if (href.split('/').pop() === currentPage) a.classList.add('active');
    }
  });

  // ── Sidebar search filter ───────────────────────────────────
  const input = document.getElementById('sidebar-search');
  if (input) {
    input.addEventListener('input', () => {
      const q = input.value.toLowerCase().trim();
      document.querySelectorAll('.sidebar-links a').forEach(a => {
        a.style.display = (!q || a.textContent.toLowerCase().includes(q)) ? '' : 'none';
      });
      document.querySelectorAll('.sidebar-section').forEach(sec => {
        const links = sec.querySelectorAll('.sidebar-links a');
        const anyVisible = Array.from(links).some(a => a.style.display !== 'none');
        sec.style.display = anyVisible || !q ? '' : 'none';
        if (q) {
          const heading = sec.querySelector('.sidebar-heading');
          if (heading) expandSection(heading);
        }
      });
    });
  }

  // ── Collapsible sections with animation ─────────────────────
  function expandSection(heading) {
    heading.classList.remove('collapsed');
    const ul = heading.nextElementSibling;
    if (ul && ul.classList.contains('sidebar-links')) {
      ul.style.maxHeight = ul.scrollHeight + 'px';
    }
  }
  function collapseSection(heading) {
    heading.classList.add('collapsed');
    const ul = heading.nextElementSibling;
    if (ul && ul.classList.contains('sidebar-links')) {
      // Force a reflow so the transition starts from the current height
      ul.style.maxHeight = ul.scrollHeight + 'px';
      ul.offsetHeight; // reflow
      ul.style.maxHeight = '0';
    }
  }

  document.querySelectorAll('.sidebar-heading').forEach(h => {
    h.addEventListener('click', () => {
      const willCollapse = !h.classList.contains('collapsed');
      if (willCollapse) {
        collapseSection(h);
      } else {
        expandSection(h);
      }
      // Persist
      const key = h.dataset.section;
      if (key) {
        const s = loadState();
        s[key] = willCollapse;
        saveState(s);
      }
    });
  });

  // After expand animation ends, set max-height to none so dynamically
  // added content (e.g. search results) isn't clipped
  document.querySelectorAll('.sidebar-links').forEach(ul => {
    ul.addEventListener('transitionend', () => {
      const heading = ul.previousElementSibling;
      if (heading && !heading.classList.contains('collapsed')) {
        ul.style.maxHeight = 'none';
      }
    });
  });

  // ── Mobile menu toggle ──────────────────────────────────────
  const toggle = document.querySelector('.menu-toggle');
  const sidebar = document.querySelector('.sidebar');
  const overlay = document.querySelector('.sidebar-overlay');
  if (toggle && sidebar) {
    toggle.addEventListener('click', () => {
      sidebar.classList.toggle('open');
      if (overlay) overlay.classList.toggle('open');
    });
    if (overlay) {
      overlay.addEventListener('click', () => {
        sidebar.classList.remove('open');
        overlay.classList.remove('open');
      });
    }
  }

  // ── Back to top ─────────────────────────────────────────────
  const btn = document.querySelector('.back-to-top');
  if (btn) {
    window.addEventListener('scroll', () => {
      btn.classList.toggle('visible', window.scrollY > 400);
    });
    btn.addEventListener('click', () => window.scrollTo({ top: 0, behavior: 'smooth' }));
  }

  // ── Active sidebar link tracking ────────────────────────────
  const sections = document.querySelectorAll('.api-section, h2[id]');
  const allLinks = document.querySelectorAll('.sidebar-links a');
  if (sections.length && allLinks.length) {
    const observer = new IntersectionObserver(entries => {
      entries.forEach(entry => {
        if (entry.isIntersecting) {
          const id = entry.target.id;
          allLinks.forEach(l => {
            l.classList.toggle('active', l.getAttribute('href') === '#' + id);
          });
        }
      });
    }, { rootMargin: '-80px 0px -60% 0px', threshold: 0 });
    sections.forEach(s => { if (s.id) observer.observe(s); });
  }

  // ── Smooth scroll for sidebar links ─────────────────────────
  document.querySelectorAll('.sidebar-links a[href^="#"]').forEach(a => {
    a.addEventListener('click', e => {
      const target = document.querySelector(a.getAttribute('href'));
      if (target) {
        e.preventDefault();
        target.scrollIntoView({ behavior: 'smooth' });
        if (sidebar) sidebar.classList.remove('open');
        if (overlay) overlay.classList.remove('open');
        history.replaceState(null, '', a.getAttribute('href'));
      }
    });
  });
});
PyJavaBridge-2a/docs/site/server.html000066400000000000000000000412571514752343100177730ustar00rootroot00000000000000


  
  
  Server — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Global server API

      
Server


The server object is a module-level global available in every script. It provides access to players, worlds, boss bars, and server-wide operations.


from bridge import *
# `server` is available immediately
players = server.players





Attributes


players



All currently online players. This is a snapshot — the list is re-fetched each time you access it.


for p in server.players:
    await p.send_message("Hello everyone!")



worlds



All loaded worlds.


name


    

  • Type: str
    • 



The server name as configured in server.properties.


version


    

  • Type: str
    • 



The full server version string (e.g. "git-Paper-123 (MC: 1.21.4)").


motd


    

  • Type: str
    • 



The server's Message of the Day.


max_players


    

  • Type: int
    • 



Maximum number of players allowed.


tps


    

  • Type: list[float]
    • 



Server TPS (ticks per second) values. Typically contains 1-minute, 5-minute, and 15-minute averages. A healthy server runs at 20 TPS.


mspt


    

  • Type: float
    • 



Milliseconds per tick. Lower is better. At 20 TPS, this should be ≤ 50ms.


last_tick_time


    

  • Type: float
    • 



Duration of the last tick in milliseconds.


queue_len


    

  • Type: int
    • 



Number of tasks currently in the main thread queue.


boss_bars



All active boss bars on the server.


plugin_manager


    

  • Type: any
    • 



The Bukkit plugin manager. Primarily useful for advanced reflection use cases.


scheduler


    

  • Type: any
    • 



The Bukkit scheduler. Rarely needed — use server.after() and @task instead.


scoreboard_manager


    

  • Type: any
    • 



The server's scoreboard manager.




Methods


broadcast


await server.broadcast(message: str)



Broadcast a message to all online players and the server console.


    

  • Parameters:
    • 

  • message (str) — The message to broadcast. Supports Minecraft color codes with §.
    • 

  • Returns: Awaitable[None]
    • 



await server.broadcast("§a[Server]§r Restarting in 10 seconds!")



execute


result = await server.execute(command: str)



Execute a command as the server console. This runs with full server permissions.


    

  • Parameters:
    • 

  • command (str) — The command to execute, without the leading /.
    • 

  • Returns: Awaitable[bool] — True if the command was recognized.
    • 



await server.execute("weather clear")
await server.execute("give Steve diamond 64")



world


w = await server.world(name: str)



Get a world by name.


    

  • Parameters:
    • 

  • name (str) — The world name (e.g. "world", "world_nether").
    • 

  • Returns: Awaitable[World]
    • 



nether = await server.world("world_nether")



create_boss_bar


bar = await server.create_boss_bar(title: str, color: BarColor, style: BarStyle)



Create a new boss bar.


    

  • Parameters:
    • 

  • title (str) — Display title.
    • 

  • color (BarColor) — Bar color.
    • 

  • style (BarStyle) — Bar style.
    • 

  • Returns: Awaitable[BossBar]
    • 



bar = await server.create_boss_bar("Event Timer", BarColor.RED, BarStyle.SEGMENTED_6)



get_advancement


adv = await server.get_advancement(key: str)



Get an advancement by its namespaced key.


    

  • Parameters:
    • 

  • key (str) — The advancement key (e.g. "minecraft:story/mine_diamond").
    • 

  • Returns: Awaitable[Advancement]
    • 



after


await server.after(ticks: int = 1, after: callable | None = None)



Pause execution for a number of ticks. Optionally run a callback after the wait.


    

  • Parameters:
    • 

  • ticks (int) — Number of ticks to wait. Default 1. (20 ticks = 1 second)
    • 

  • after (callable | None) — Optional callback to run after the wait completes.
    • 

  • Returns: Awaitable[None]
    • 



await server.after(20)  # Wait 1 second
await server.after(60)  # Wait 3 seconds

# With callback
await server.after(20, after=lambda: print("Done waiting!"))



frame


async with server.frame():
    await player.send_message("Line 1")
    await player.send_message("Line 2")



Async context manager that batches multiple bridge calls into a single network send. Useful for reducing round-trips when making many calls at once.


atomic


async with server.atomic():
    await player.set_health(20)
    await player.set_food_level(20)



Async context manager that batches calls as an atomic group. All calls succeed or fail together.


flush


await server.flush()



Send all pending batched requests immediately. Use this inside a frame() or atomic() block if you need partial results before the block ends.


    

  • Returns: Awaitable[None]
    • 


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/sidebar.html000066400000000000000000000271611514752343100200740ustar00rootroot00000000000000


  
  
  Sidebar — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Simple sidebar helper

      
Sidebar


Sidebar is a high-level helper that wraps Scoreboard and Objective to make creating sidebar displays simple. It handles score ordering and line management automatically.




Constants


MAX_LINES


Sidebar.MAX_LINES  # 15



Maximum number of lines a sidebar can display (Minecraft limitation).




Constructor


Sidebar(title="")



Create a new sidebar.


    

  • Parameters:
    • 

  • title (str) — Title displayed at the top. Supports § color codes.
    • 



sidebar = Sidebar("§6§lMy Server")





Attributes


title


    

  • Type: str
    • 



The sidebar title.




Item Access


Sidebar supports index-based access using [] notation. Slot 0 is the bottom line, higher slots are higher lines.


Set a line


sidebar[slot] = text



    

  • Parameters:
    • 

  • slot (int) — Line position (0 = bottom, higher = above).
    • 

  • text (str) — Line text. Supports § color codes.
    • 



Get a line


text = sidebar[slot]



    

  • Returns: str — Text at the given slot.
    • 



Delete a line


del sidebar[slot]



Removes the line at the given slot.




Methods


show


sidebar.show(player)



Display this sidebar to a player. This is synchronous — it assigns a scoreboard to the player.


    

  • Parameters:
    • 

  • player (Player) — Player to show the sidebar to.
    • 





Example: Server info sidebar


from bridge import *

sidebar = Sidebar("§6§lMy Server")
sidebar[6] = "§7──────────"
sidebar[5] = "§fOnline: §a0"
sidebar[4] = "§fTPS: §a20.0"
sidebar[3] = ""
sidebar[2] = "§fKills: §c0"
sidebar[1] = "§fDeaths: §c0"
sidebar[0] = "§7──────────"

@event
async def player_join(e: Event):
    sidebar[5] = f"§fOnline: §a{len(server.players)}"
    sidebar.show(e.player)

@event
async def player_quit(e: Event):
    sidebar[5] = f"§fOnline: §a{len(server.players) - 1}"



Example: Per-player stats


from bridge import *

kills = {}

@event
async def player_join(e: Event):
    p = e.player
    kills.setdefault(p.name, 0)
    sb = Sidebar("§c§lPvP Stats")
    sb[3] = f"§fPlayer: §a{p.name}"
    sb[2] = f"§fKills: §e{kills[p.name]}"
    sb[1] = f"§fHealth: §c{int(p.health)}❤"
    sb[0] = "§7play.example.com"
    sb.show(p)



Note: Sidebar creates its own internal scoreboard and objective. If you need multiple objectives or teams, use the lower-level Scoreboard API.

    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/style.css000066400000000000000000000355421514752343100174510ustar00rootroot00000000000000/* ===== Reset & Base ===== */
*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}

:root {
  color-scheme: dark;
  --sidebar-w: 280px;
  --header-h: 56px;
  --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
  --font-mono: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', Consolas, monospace;

  /* Colors — dark */
  --bg: #0d1117;
  --bg-soft: #161b22;
  --bg-muted: #1c2128;
  --text: #e6edf3;
  --text-soft: #a8b2c1;
  --text-muted: #6b7b8d;
  --border: #30363d;

  --sidebar-bg: #0f172a;
  --sidebar-text: #cbd5e1;
  --sidebar-heading: #f8fafc;
  --sidebar-hover: rgba(99,102,241,.12);
  --sidebar-active: rgba(99,102,241,.22);
  --sidebar-accent: #818cf8;
  --sidebar-border: #1e293b;

  --primary: #6366f1;
  --primary-soft: rgba(99,102,241,.15);
  --primary-hover: #818cf8;
  --green: #3fb950;
  --green-soft: rgba(63,185,80,.15);
  --amber: #d29922;
  --amber-soft: rgba(210,153,34,.15);
  --red: #f85149;
  --red-soft: rgba(248,81,73,.15);

  --code-bg: #161b22;
  --code-text: #e6edf3;
  --inline-code-bg: rgba(99,102,241,.12);
  --inline-code-text: #a5b4fc;

  --shadow-sm: 0 1px 2px rgba(0,0,0,.05);
  --shadow-md: 0 4px 6px -1px rgba(0,0,0,.1), 0 2px 4px -2px rgba(0,0,0,.1);
  --radius: 8px;
  --radius-sm: 6px;
}

html { scroll-behavior: smooth; scroll-padding-top: calc(var(--header-h) + 24px); }
body {
  font-family: var(--font-sans);
  color: var(--text);
  background: var(--bg);
  line-height: 1.7;
  -webkit-font-smoothing: antialiased;
}

/* ===== Header ===== */
.site-header {
  position: fixed; top: 0; left: 0; right: 0;
  height: var(--header-h);
  background: var(--sidebar-bg);
  border-bottom: 1px solid var(--sidebar-border);
  display: flex; align-items: center;
  padding: 0 24px;
  z-index: 1000;
  gap: 16px;
}
.header-brand {
  display: flex; align-items: center; gap: 10px;
  text-decoration: none;
  font-weight: 700; font-size: 1.15rem;
  color: #fff;
  white-space: nowrap;
}
.header-brand .logo {
  width: 28px; height: 28px;
  background: linear-gradient(135deg, var(--primary), #a78bfa);
  border-radius: 6px;
  display: flex; align-items: center; justify-content: center;
  font-size: 14px; color: #fff; font-weight: 800;
}
.header-nav {
  display: flex; align-items: center; gap: 4px;
  margin-left: auto;
}
.header-nav a {
  color: var(--sidebar-text);
  text-decoration: none;
  font-size: .875rem;
  font-weight: 500;
  padding: 6px 14px;
  border-radius: var(--radius-sm);
  transition: .15s;
}
.header-nav a:hover, .header-nav a.active {
  color: #fff;
  background: var(--sidebar-hover);
}
.header-nav a.active { background: var(--sidebar-active); }

.menu-toggle {
  display: none;
  background: none; border: none;
  color: #fff; cursor: pointer;
  padding: 4px;
}
.menu-toggle svg { width: 24px; height: 24px; }

/* ===== Sidebar ===== */
.sidebar {
  position: fixed;
  top: var(--header-h);
  left: 0;
  width: var(--sidebar-w);
  height: calc(100vh - var(--header-h));
  background: var(--sidebar-bg);
  border-right: 1px solid var(--sidebar-border);
  overflow-y: auto;
  padding: 16px 0;
  z-index: 900;
  transition: transform .25s ease;
}
.sidebar::-webkit-scrollbar { width: 4px; }
.sidebar::-webkit-scrollbar-thumb { background: rgba(255,255,255,.12); border-radius: 4px; }

.sidebar-section { margin-bottom: 6px; }
.sidebar-heading {
  display: flex; align-items: center; gap: 6px;
  padding: 8px 20px 4px;
  font-size: .7rem;
  font-weight: 700;
  text-transform: uppercase;
  letter-spacing: .08em;
  color: var(--text-muted);
  cursor: pointer;
  user-select: none;
}
.sidebar-heading::before {
  content: '';
  display: inline-block;
  width: 5px; height: 5px;
  border-right: 1.5px solid var(--text-muted);
  border-bottom: 1.5px solid var(--text-muted);
  transform: rotate(45deg);
  transition: transform .2s;
  flex-shrink: 0;
}
.sidebar-heading.collapsed::before { transform: rotate(-45deg); }

.sidebar-links {
  overflow: hidden;
  max-height: 600px;
  transition: max-height .25s ease, opacity .2s ease;
  opacity: 1;
}
.sidebar-heading.collapsed + .sidebar-links {
  max-height: 0;
  opacity: 0;
}

.sidebar-links { list-style: none; padding: 0; margin: 0 0 4px; }
.sidebar-links a {
  display: block;
  padding: 5px 20px 5px 28px;
  color: var(--sidebar-text);
  text-decoration: none;
  font-size: .835rem;
  border-left: 2px solid transparent;
  transition: .15s;
}
.sidebar-links a:hover {
  color: #fff;
  background: var(--sidebar-hover);
  border-left-color: rgba(99,102,241,.4);
}
.sidebar-links a.active {
  color: var(--sidebar-accent);
  background: var(--sidebar-active);
  border-left-color: var(--sidebar-accent);
  font-weight: 600;
}

.sidebar-overlay {
  display: none;
  position: fixed; inset: 0;
  background: rgba(0,0,0,.5);
  z-index: 899;
}

/* ===== Main content ===== */
.main {
  margin-left: var(--sidebar-w);
  margin-top: var(--header-h);
  min-height: calc(100vh - var(--header-h));
}
.content {
  max-width: 860px;
  margin: 0 auto;
  padding: 40px 48px 80px;
}

/* ===== Typography ===== */
h1 { font-size: 2.2rem; font-weight: 800; letter-spacing: -.02em; margin-bottom: 12px; line-height: 1.2; }
h2 {
  font-size: 1.55rem; font-weight: 700;
  margin: 56px 0 16px;
  padding-bottom: 10px;
  border-bottom: 1px solid var(--border);
  scroll-margin-top: calc(var(--header-h) + 24px);
}
h3 { font-size: 1.15rem; font-weight: 650; margin: 32px 0 10px; color: var(--text); }
h4 { font-size: 1rem; font-weight: 600; margin: 24px 0 8px; color: var(--text-soft); }
p { margin: 0 0 16px; }
a { color: var(--primary); text-decoration: none; }
a:hover { text-decoration: underline; }

.subtitle {
  font-size: 1.15rem;
  color: var(--text-soft);
  margin-bottom: 32px;
  line-height: 1.6;
}

/* ===== Anchor links ===== */
h2 .anchor, h3 .anchor {
  opacity: 0; margin-left: 6px;
  color: var(--text-muted);
  text-decoration: none;
  font-weight: 400;
  transition: .15s;
}
h2:hover .anchor, h3:hover .anchor { opacity: 1; }
h2 .anchor:hover, h3 .anchor:hover { color: var(--primary); }

/* ===== Badge ===== */
.badge {
  display: inline-block;
  padding: 2px 8px;
  border-radius: 4px;
  font-size: .7rem;
  font-weight: 600;
  text-transform: uppercase;
  letter-spacing: .04em;
  vertical-align: middle;
  margin-left: 6px;
}
.badge-async { background: var(--primary-soft); color: var(--primary); }
.badge-sync  { background: var(--green-soft); color: var(--green); }
.badge-class { background: var(--amber-soft); color: var(--amber); }
.badge-enum  { background: rgba(147,51,234,.15); color: #a855f7; }
.badge-decorator { background: var(--red-soft); color: var(--red); }
.badge-new   { background: rgba(56,139,253,.15); color: #58a6ff; }

/* ===== Code ===== */
code {
  font-family: var(--font-mono);
  font-size: .85em;
  background: var(--inline-code-bg);
  color: var(--inline-code-text);
  padding: 2px 6px;
  border-radius: 4px;
}

pre {
  background: var(--code-bg);
  border-radius: var(--radius);
  padding: 20px 24px;
  margin: 0 0 20px;
  overflow-x: auto;
  line-height: 1.6;
  border: 1px solid rgba(255,255,255,.06);
}
pre code {
  background: none;
  color: var(--code-text);
  padding: 0;
  font-size: .84rem;
}

/* Syntax highlighting */
.kw  { color: #c792ea; }   /* keyword */
.fn  { color: #82aaff; }   /* function */
.st  { color: #c3e88d; }   /* string */
.cm  { color: #546e7a; }   /* comment */
.nb  { color: #f78c6c; }   /* number / builtin */
.op  { color: #89ddff; }   /* operator */
.ty  { color: #ffcb6b; }   /* type */
.dc  { color: #c792ea; }   /* decorator */
.pr  { color: #f07178; }   /* param */

/* ===== API entry blocks ===== */
.api-section {
  scroll-margin-top: calc(var(--header-h) + 24px);
}

.api-entry {
  margin: 12px 0;
  padding: 12px 16px;
  background: var(--bg-soft);
  border-radius: var(--radius-sm);
  border-left: 3px solid var(--border);
}
.api-entry.constructor { border-left-color: var(--amber); }
.api-entry.classmethod { border-left-color: var(--primary); }
.api-entry.method      { border-left-color: var(--green); }
.api-entry.attribute   { border-left-color: var(--text-muted); }

.api-entry .sig {
  font-family: var(--font-mono);
  font-size: .84rem;
  color: var(--text);
  margin-bottom: 4px;
  word-break: break-word;
}
.api-entry .sig .name { font-weight: 700; color: var(--text); }
.api-entry .sig .param { color: var(--text-soft); }
.api-entry .sig .ret { color: var(--text-muted); font-style: italic; }
.api-entry .desc {
  font-size: .875rem;
  color: var(--text-soft);
  margin: 0;
}

/* ===== Attribute table ===== */
.attr-table {
  width: 100%;
  border-collapse: collapse;
  margin: 12px 0 20px;
  font-size: .875rem;
}
.attr-table th {
  text-align: left;
  padding: 8px 12px;
  background: var(--bg-muted);
  border-bottom: 2px solid var(--border);
  font-weight: 600;
  font-size: .8rem;
  text-transform: uppercase;
  letter-spacing: .04em;
  color: var(--text-soft);
}
.attr-table td {
  padding: 8px 12px;
  border-bottom: 1px solid var(--border);
  vertical-align: top;
}
.attr-table tr:last-child td { border-bottom: none; }
.attr-table .attr-name {
  font-family: var(--font-mono);
  font-size: .84rem;
  color: var(--text);
  font-weight: 600;
  white-space: nowrap;
}
.attr-table .attr-type {
  font-family: var(--font-mono);
  font-size: .8rem;
  color: var(--primary);
  white-space: nowrap;
}
.attr-table .attr-desc { color: var(--text-soft); }

/* ===== Cards ===== */
.card-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
  gap: 16px;
  margin: 24px 0;
}
.card {
  background: var(--bg);
  border: 1px solid var(--border);
  border-radius: var(--radius);
  padding: 20px;
  transition: .2s;
}
.card:hover {
  border-color: var(--primary);
  box-shadow: var(--shadow-md);
  transform: translateY(-2px);
}
.card h3 {
  margin: 0 0 6px;
  font-size: 1rem;
  font-weight: 700;
}
.card h3 a { color: var(--text); }
.card h3 a:hover { color: var(--primary); text-decoration: none; }
.card p { margin: 0; font-size: .875rem; color: var(--text-soft); }

/* ===== Feature rows (landing page) ===== */
.features {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
  gap: 20px;
  margin: 32px 0;
}
.feature {
  padding: 24px;
  border-radius: var(--radius);
  background: var(--bg-soft);
  border: 1px solid var(--border);
}
.feature .icon {
  width: 40px; height: 40px;
  border-radius: 10px;
  display: flex; align-items: center; justify-content: center;
  font-size: 1.3rem;
  margin-bottom: 12px;
}
.feature h3 { margin: 0 0 6px; font-size: 1.05rem; }
.feature p { margin: 0; font-size: .88rem; color: var(--text-soft); }

/* ===== Hero (landing) ===== */
.hero {
  text-align: center;
  padding: 60px 0 40px;
}
.hero h1 { font-size: 2.8rem; margin-bottom: 16px; }
.hero .subtitle { max-width: 600px; margin: 0 auto 28px; }
.hero-actions {
  display: flex; justify-content: center; gap: 12px; flex-wrap: wrap;
}
.btn {
  display: inline-flex; align-items: center; gap: 6px;
  padding: 10px 24px;
  border-radius: var(--radius-sm);
  font-weight: 600; font-size: .95rem;
  text-decoration: none;
  transition: .2s;
  border: none; cursor: pointer;
}
.btn-primary {
  background: var(--primary);
  color: #fff;
}
.btn-primary:hover { background: var(--primary-hover); text-decoration: none; }
.btn-outline {
  background: transparent;
  color: var(--text);
  border: 1px solid var(--border);
}
.btn-outline:hover { border-color: var(--primary); color: var(--primary); text-decoration: none; }

/* ===== Callout boxes ===== */
.callout {
  padding: 16px 20px;
  border-radius: var(--radius-sm);
  margin: 16px 0;
  font-size: .9rem;
  border-left: 4px solid;
}
.callout-info  { background: rgba(56,139,253,.1); border-left-color: #388bfd; }
.callout-warn  { background: rgba(210,153,34,.1); border-left-color: #d29922; }
.callout-tip   { background: rgba(63,185,80,.1); border-left-color: #3fb950; }

.callout strong { display: block; margin-bottom: 4px; }

/* ===== Search ===== */
.search-box {
  position: relative;
  margin: 12px 16px 8px;
}
.search-box input {
  width: 100%;
  padding: 8px 12px 8px 34px;
  background: rgba(255,255,255,.08);
  border: 1px solid rgba(255,255,255,.1);
  border-radius: var(--radius-sm);
  color: #fff;
  font-size: .84rem;
  font-family: var(--font-sans);
  outline: none;
  transition: .15s;
}
.search-box input::placeholder { color: var(--text-muted); }
.search-box input:focus {
  border-color: var(--sidebar-accent);
  background: rgba(255,255,255,.12);
}
.search-box .search-icon {
  position: absolute;
  left: 10px; top: 50%;
  transform: translateY(-50%);
  width: 16px; height: 16px;
  color: var(--text-muted);
}

/* ===== Tables (general) ===== */
table {
  width: 100%;
  border-collapse: collapse;
  margin: 12px 0 20px;
  font-size: .88rem;
}
th, td { padding: 10px 14px; text-align: left; border-bottom: 1px solid var(--border); }
th { background: var(--bg-muted); font-weight: 600; font-size: .82rem; text-transform: uppercase; letter-spacing: .04em; color: var(--text-soft); }

/* ===== Lists ===== */
ul, ol { margin: 0 0 16px; padding-left: 24px; }
li { margin-bottom: 4px; }
li code { font-size: .82em; }

/* ===== Param list style ===== */
.param-list { list-style: none; padding: 0; margin: 8px 0 16px; }
.param-list li {
  padding: 6px 0;
  border-bottom: 1px solid var(--border);
  font-size: .88rem;
}
.param-list li:last-child { border-bottom: none; }
.param-list .pname {
  font-family: var(--font-mono);
  font-weight: 600;
  color: var(--text);
}
.param-list .ptype {
  font-family: var(--font-mono);
  font-size: .82em;
  color: var(--primary);
}
.param-list .pdesc { color: var(--text-soft); }

/* ===== Back to top ===== */
.back-to-top {
  position: fixed;
  bottom: 24px; right: 24px;
  width: 40px; height: 40px;
  background: var(--primary);
  color: #fff;
  border: none; border-radius: 50%;
  cursor: pointer;
  display: flex; align-items: center; justify-content: center;
  opacity: 0; pointer-events: none;
  transition: .25s;
  box-shadow: var(--shadow-md);
  z-index: 100;
}
.back-to-top.visible { opacity: 1; pointer-events: auto; }
.back-to-top:hover { background: var(--primary-hover); }

/* ===== Footer ===== */
.site-footer {
  border-top: 1px solid var(--border);
  padding: 24px 48px;
  font-size: .84rem;
  color: var(--text-muted);
  text-align: center;
}

/* ===== Responsive ===== */
@media (max-width: 1024px) {
  .sidebar { transform: translateX(-100%); }
  .sidebar.open { transform: translateX(0); }
  .sidebar-overlay.open { display: block; }
  .main { margin-left: 0; }
  .menu-toggle { display: block; }
}
@media (max-width: 640px) {
  .content { padding: 24px 20px 60px; }
  h1 { font-size: 1.8rem; }
  h2 { font-size: 1.3rem; }
  .hero { padding: 36px 0 24px; }
  .hero h1 { font-size: 2rem; }
  .card-grid { grid-template-columns: 1fr; }
  .features { grid-template-columns: 1fr; }
  .header-nav { display: none; }
}

/* ===== No-sidebar layout ===== */
.no-sidebar .main { margin-left: 0; }
.no-sidebar .sidebar { display: none; }
.no-sidebar .content { max-width: 960px; }

/* ===== Highlight.js overrides ===== */
.hljs { background: transparent !important; padding: 0 !important; }
PyJavaBridge-2a/docs/site/team.html000066400000000000000000000301001514752343100173740ustar00rootroot00000000000000


  
  
  Team — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
Scoreboard team API

      
Team


A Team groups players on a Scoreboard for shared prefixes, suffixes, colors, and friendly-fire settings.




Class Methods


create


team = Team.create(name, scoreboard=None)



Create a new team. This is synchronous.


    

  • Parameters:
    • 

  • name (str) — Internal team name.
    • 

  • scoreboard (Scoreboard | None) — Scoreboard to register on. If None, uses the main scoreboard.
    • 

  • Returns: Team
    • 



red = Team.create("red")
await red.set_prefix("§c[RED] ")
await red.set_color("RED")





Attributes


color


    

  • Type: Any
    • 



The team's color used for name tag coloring.


entries


    

  • Type: set[str]
    • 



Player names currently on this team.




Methods


add_entry


await team.add_entry(entry)



Add a player to this team.


    

  • Parameters:
    • 

  • entry (str) — Player name.
    • 

  • Returns: Awaitable[None]
    • 



await red_team.add_entry(player.name)



remove_entry


await team.remove_entry(entry)



Remove a player from this team.


    

  • Parameters:
    • 

  • entry (str) — Player name.
    • 

  • Returns: Awaitable[None]
    • 



set_prefix


await team.set_prefix(prefix)



Set the name tag prefix for all team members.


    

  • Parameters:
    • 

  • prefix (str) — Prefix text. Supports § color codes.
    • 

  • Returns: Awaitable[None]
    • 



await team.set_prefix("§a[VIP] ")



set_suffix


await team.set_suffix(suffix)



Set the name tag suffix for all team members.


    

  • Parameters:
    • 

  • suffix (str) — Suffix text.
    • 

  • Returns: Awaitable[None]
    • 



set_color


await team.set_color(color)



Set the team color (affects name tag color and tab list).


    

  • Parameters:
    • 

  • color (Any) — Color name (e.g. "RED", "BLUE", "GREEN").
    • 

  • Returns: Awaitable[None]
    • 





Example: PvP teams


from bridge import *

board = Scoreboard.create()
red_team = board.register_team("red")
blue_team = board.register_team("blue")

@command("Join a team")
async def team_join(player: Player, args: list[str]):
    if not args:
        await player.send_message("§cUsage: /team <red|blue>")
        return

    name = args[0].lower()
    if name == "red":
        await red_team.add_entry(player.name)
        await red_team.set_prefix("§c[RED] ")
        await red_team.set_color("RED")
        await player.send_message("§cYou joined the Red team!")
    elif name == "blue":
        await blue_team.add_entry(player.name)
        await blue_team.set_prefix("§9[BLUE] ")
        await blue_team.set_color("BLUE")
        await player.send_message("§9You joined the Blue team!")

    await player.set_scoreboard(board)


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/vector.html000066400000000000000000000233711514752343100177640ustar00rootroot00000000000000


  
  
  Vector — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
3D direction and velocity

      
Vector


A Vector is a simple 3D coordinate used for velocities, offsets, and directional calculations. Unlike Location, a Vector has no world, yaw, or pitch.




Constructor


Vector(x=0.0, y=0.0, z=0.0)



Create a vector.


    

  • Parameters:
    • 

  • x (float) — X component. Default 0.
    • 

  • y (float) — Y component. Default 0.
    • 

  • z (float) — Z component. Default 0.
    • 



velocity = Vector(0, 1.5, 0)       # Straight up
direction = Vector(0.5, 0.2, -0.3) # Angled





Attributes


x


    

  • Type: float
    • 



X component.


y


    

  • Type: float
    • 



Y component.


z


    

  • Type: float
    • 



Z component.




Common Uses


Setting entity velocity


# Launch a player upward
await player.set_velocity(Vector(0, 2.0, 0))



Spawning projectiles with velocity


arrow = await world.spawn_projectile(
    player,
    "ARROW",
    velocity=Vector(0, 1, 0)
)



As position tuples


Many methods accept Vector | tuple[int,int,int] interchangeably:


# Both are equivalent
await world.fill(Vector(0, 60, 0), Vector(10, 65, 10), "STONE")
await world.fill((0, 60, 0), (10, 65, 10), "STONE")



Player spawn offset


await world.spawn_at_player(player, "ZOMBIE", offset=Vector(3, 0, 0))


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/site/world.html000066400000000000000000001022431514752343100176050ustar00rootroot00000000000000


  
  
  World — PyJavaBridge
  
  
  
  
  
  
  
  
  
  
  


  
  

    
    
      
      PyJavaBridge
    
    
  


  
  
  


  
  

    

      
World API with region utilities, particle shapes, and spawn helpers

      
World


The World class provides access to world properties, blocks, entities, weather, time, and advanced utilities for working with regions, particles, and entity spawning.




Constructor


World(name: str | None = None)



Resolve a world by name. You can also get worlds from server.worlds or server.world("name").


    

  • Parameters:
    • 

  • name (str | None) — The world name (e.g. "world", "world_nether", "world_the_end").
    • 





Attributes


name


    

  • Type: str
    • 



The world name.


uuid


    

  • Type: str
    • 



The world's unique identifier.


environment


    

  • Type: any
    • 



The world environment (NORMAL, NETHER, THE_END).


entities



All entities currently in the world, including players, mobs, dropped items, etc.


players



All players currently in this world.


time


    

  • Type: int
    • 



Current world time (0–24000). 0 = dawn, 6000 = noon, 12000 = dusk, 18000 = midnight.


full_time


    

  • Type: int
    • 



Absolute world time that is not reset by sleeping.


difficulty



World difficulty level.


spawn_location



The world's spawn location.


has_storm


    

  • Type: bool
    • 



Whether it is currently raining/snowing.


is_thundering


    

  • Type: bool
    • 



Whether there is a thunderstorm.


weather_duration


    

  • Type: int
    • 



Remaining weather duration in ticks.


thunder_duration


    

  • Type: int
    • 



Remaining thunder duration in ticks.




Methods


block_at


block = await world.block_at(x, y, z)



Get the block at specific coordinates.


    

  • Parameters:
    • 

  • x (int) — X coordinate.
    • 

  • y (int) — Y coordinate.
    • 

  • z (int) — Z coordinate.
    • 

  • Returns: Awaitable[Block]
    • 



block = await world.block_at(0, 64, 0)
print(block.type)  # Material.GRASS_BLOCK



chunk_at


chunk = await world.chunk_at(x, z)



Get the chunk at chunk coordinates.


    

  • Parameters:
    • 

  • x (int) — Chunk X (block X ÷ 16).
    • 

  • z (int) — Chunk Z (block Z ÷ 16).
    • 

  • Returns: Awaitable[Chunk]
    • 



spawn


entity = await world.spawn(location, entity_cls, **kwargs)



Spawn an entity at a location.


    

  • Parameters:
    • 

  • location (Location) — Spawn position.
    • 

  • entity_cls (type | EntityType | str) — Entity type to spawn.
    • 

  • **kwargs — Additional spawn options.
    • 

  • Returns: Awaitable[Entity]
    • 



zombie = await world.spawn(Location(0, 64, 0), EntityType.ZOMBIE)



spawn_entity


entity = await world.spawn_entity(location, entity_type, **kwargs)



Spawn an entity by type name.


    

  • Parameters:
    • 

  • location (Location) — Spawn position.
    • 

  • entity_type (EntityType | str) — Entity type.
    • 

  • **kwargs — Additional options.
    • 

  • Returns: Awaitable[Entity]
    • 



spawn_particle


await world.spawn_particle(particle, location, count=1, offset_x=0, offset_y=0, offset_z=0, extra=0)



Spawn particles visible to all players in the world.


    

  • Parameters:
    • 

  • particle (Particle) — Particle type.
    • 

  • location (Location) — Center position.
    • 

  • count (int) — Number of particles.
    • 

  • offset_x/y/z (float) — Random offset range on each axis.
    • 

  • extra (float) — Extra data (usually speed).
    • 

  • Returns: Awaitable[None]
    • 



await world.spawn_particle(Particle.FLAME, player.location, count=50, offset_x=0.5, offset_y=1, offset_z=0.5)



play_sound


await world.play_sound(location, sound, volume=1.0, pitch=1.0)



Play a sound at a location, audible to nearby players.


    

  • Parameters:
    • 

  • location (Location) — Sound source position.
    • 

  • sound (Sound) — Sound to play.
    • 

  • volume (float) — Volume. Default 1.0.
    • 

  • pitch (float) — Pitch. Default 1.0.
    • 

  • Returns: Awaitable[None]
    • 



strike_lightning


entity = await world.strike_lightning(location)



Strike lightning at a location. This deals damage and starts fires.


    

  • Parameters:
    • 

  • location (Location) — Strike position.
    • 

  • Returns: Awaitable[Entity] — The lightning entity.
    • 



strike_lightning_effect


await world.strike_lightning_effect(location)



Strike visual-only lightning (no damage, no fire).


    

  • Parameters:
    • 

  • location (Location) — Strike position.
    • 

  • Returns: Awaitable[None]
    • 





Time & Weather Setters


set_time


await world.set_time(time)



Set the world time.


    

  • Parameters:
    • 

  • time (int) — Time value (0–24000).
    • 

  • Returns: Awaitable[None]
    • 



set_full_time


await world.set_full_time(time)



Set the absolute (non-resetting) time.


    

  • Parameters:
    • 

  • time (int) — Absolute time value.
    • 

  • Returns: Awaitable[None]
    • 



set_difficulty


await world.set_difficulty(difficulty)



Set the world difficulty.


    

  • Parameters:
    • 

  • difficulty (Difficulty) — Difficulty level.
    • 

  • Returns: Awaitable[None]
    • 



set_spawn_location


await world.set_spawn_location(location)



Set the world spawn point.


    

  • Parameters:
    • 

  • location (Location) — New spawn location.
    • 

  • Returns: Awaitable[None]
    • 



set_storm


await world.set_storm(value)



Start or stop rain/snow.


    

  • Parameters:
    • 

  • value (bool) — True = start storm, False = clear.
    • 

  • Returns: Awaitable[None]
    • 



set_thundering


await world.set_thundering(value)



Start or stop thunderstorm.


    

  • Parameters:
    • 

  • value (bool)
    • 

  • Returns: Awaitable[None]
    • 



set_weather_duration


await world.set_weather_duration(ticks)



Set how long the current weather lasts.


    

  • Parameters:
    • 

  • ticks (int) — Duration in ticks.
    • 

  • Returns: Awaitable[None]
    • 



set_thunder_duration


await world.set_thunder_duration(ticks)



Set how long the current thunder lasts.


    

  • Parameters:
    • 

  • ticks (int) — Duration in ticks.
    • 

  • Returns: Awaitable[None]
    • 





Region Utilities


These methods operate on regions of blocks in the world. Position arguments accept Location, tuple[int,int,int], or Vector.


set_block


count = await world.set_block(x, y, z, material, apply_physics=False)



Set a single block.


    

  • Parameters:
    • 

  • x, y, z (int) — Block coordinates.
    • 

  • material (Material | str) — Block material.
    • 

  • apply_physics (bool) — Whether to trigger physics updates. Default False.
    • 

  • Returns: Awaitable[int] — Number of blocks changed (0 or 1).
    • 



fill


count = await world.fill(pos1, pos2, material, apply_physics=False)



Fill a cuboid region with a material.


    

  • Parameters:
    • 

  • pos1 — First corner.
    • 

  • pos2 — Opposite corner.
    • 

  • material (Material | str) — Block material.
    • 

  • apply_physics (bool) — Default False.
    • 

  • Returns: Awaitable[int] — Number of blocks changed.
    • 



await world.fill((0, 60, 0), (10, 70, 10), Material.STONE)



replace


count = await world.replace(pos1, pos2, from_material, to_material)



Replace all blocks of one material with another in a region.


    

  • Parameters:
    • 

  • pos1 — First corner.
    • 

  • pos2 — Opposite corner.
    • 

  • from_material (Material | str) — Material to replace.
    • 

  • to_material (Material | str) — Replacement material.
    • 

  • Returns: Awaitable[int] — Number of blocks replaced.
    • 



await world.replace((0, 60, 0), (10, 70, 10), "DIRT", "GRASS_BLOCK")



fill_sphere


count = await world.fill_sphere(center, radius, material, hollow=False)



Fill a sphere with a material.


    

  • Parameters:
    • 

  • center — Center position.
    • 

  • radius (float) — Sphere radius in blocks.
    • 

  • material (Material | str) — Block material.
    • 

  • hollow (bool) — If True, only the shell is filled.
    • 

  • Returns: Awaitable[int] — Number of blocks changed.
    • 



await world.fill_sphere(player.location, 5, Material.GLASS, hollow=True)



fill_cylinder


count = await world.fill_cylinder(center, radius, height, material, hollow=False)



Fill a vertical cylinder.


    

  • Parameters:
    • 

  • center — Center of the base.
    • 

  • radius (float) — Cylinder radius.
    • 

  • height (int) — Height in blocks.
    • 

  • material (Material | str) — Block material.
    • 

  • hollow (bool) — If True, only the walls are filled.
    • 

  • Returns: Awaitable[int]
    • 



fill_line


count = await world.fill_line(start, end, material)



Place blocks along a line between two points.


    

  • Parameters:
    • 

  • start — Start position.
    • 

  • end — End position.
    • 

  • material (Material | str) — Block material.
    • 

  • Returns: Awaitable[int]
    • 





Particle Shape Utilities


All particle shape methods accept optional offset_x, offset_y, offset_z, extra parameters for per-particle randomization.


particle_line


count = await world.particle_line(start, end, particle, density=4.0)



Draw a line of particles between two points.


    

  • Parameters:
    • 

  • start — Start position.
    • 

  • end — End position.
    • 

  • particle (Particle | str) — Particle type.
    • 

  • density (float) — Particles per block. Default 4.0.
    • 

  • Returns: Awaitable[int] — Number of particles spawned.
    • 



particle_sphere


count = await world.particle_sphere(center, radius, particle, density=4.0, hollow=True)



Draw a sphere of particles.


    

  • Parameters:
    • 

  • center — Center position.
    • 

  • radius (float) — Sphere radius.
    • 

  • particle (Particle | str) — Particle type.
    • 

  • density (float) — Particles per block. Default 4.0.
    • 

  • hollow (bool) — If True, only surface particles. Default True.
    • 

  • Returns: Awaitable[int]
    • 



particle_cube


count = await world.particle_cube(pos1, pos2, particle, density=4.0, hollow=True)



Draw a cuboid of particles.


    

  • Parameters:
    • 

  • pos1 — First corner.
    • 

  • pos2 — Opposite corner.
    • 

  • particle (Particle | str) — Particle type.
    • 

  • density (float) — Default 4.0.
    • 

  • hollow (bool) — Default True.
    • 

  • Returns: Awaitable[int]
    • 



particle_ring


count = await world.particle_ring(center, radius, particle, density=4.0)



Draw a horizontal ring of particles.


    

  • Parameters:
    • 

  • center — Center position.
    • 

  • radius (float) — Ring radius.
    • 

  • particle (Particle | str) — Particle type.
    • 

  • density (float) — Default 4.0.
    • 

  • Returns: Awaitable[int]
    • 





Entity Spawn Helpers


spawn_at_player


entity = await world.spawn_at_player(player, entity_type, offset=None, **kwargs)



Spawn an entity at a player's current position with an optional offset.


    

  • Parameters:
    • 

  • player (Player) — The player.
    • 

  • entity_type (EntityType | str) — Entity type to spawn.
    • 

  • offset (Vector | tuple | None) — Offset from player position.
    • 

  • **kwargs — Additional spawn options.
    • 

  • Returns: Awaitable[Entity]
    • 



zombie = await world.spawn_at_player(player, "ZOMBIE", offset=(2, 0, 0))



spawn_projectile


entity = await world.spawn_projectile(shooter, entity_type, velocity=None, **kwargs)



Spawn a projectile from an entity with an optional initial velocity.


    

  • Parameters:
    • 

  • shooter (Entity) — The entity shooting the projectile.
    • 

  • entity_type (EntityType | str) — Projectile type (e.g. "ARROW", "FIREBALL").
    • 

  • velocity (Vector | tuple | None) — Initial velocity.
    • 

  • **kwargs — Additional options.
    • 

  • Returns: Awaitable[Entity]
    • 



spawn_with_nbt


entity = await world.spawn_with_nbt(location, entity_type, nbt, **kwargs)



Spawn an entity with custom SNBT (Stringified NBT) data.


    

  • Parameters:
    • 

  • location (Location) — Spawn position.
    • 

  • entity_type (EntityType | str) — Entity type.
    • 

  • nbt (str) — SNBT string.
    • 

  • **kwargs — Additional options.
    • 

  • Returns: Awaitable[Entity]
    • 



await world.spawn_with_nbt(loc, "ZOMBIE", '{IsBaby:1b,CustomName:\'{"text":"Baby Zombie"}\'}')


    

    

      © Omena0 2026 · PyJavaBridge Documentation
    

  


  
  

  


PyJavaBridge-2a/docs/src/000077500000000000000000000000001514752343100154115ustar00rootroot00000000000000PyJavaBridge-2a/docs/src/actionbardisplay.md000066400000000000000000000036051514752343100212670ustar00rootroot00000000000000---
title: ActionBarDisplay
subtitle: Persistent action bar text
---

# ActionBarDisplay

`ActionBarDisplay` manages persistent action bar messages per player. Unlike `player.send_action_bar()` which fades after a few seconds, `ActionBarDisplay` continuously re-sends the message to keep it visible.

---

## Constructor

```python
ActionBarDisplay()
```

Create a new action bar display manager.

```python
status = ActionBarDisplay()
```

---

## Player Access

ActionBarDisplay uses `[]` notation with players as keys.

### Set text

```python
display[player] = text
```

Start showing persistent action bar text to a player.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Target player.
  - `text` (`str`) — Action bar text. Supports `§` color codes.

### Get text

```python
text = display[player]
```

Get the current action bar text for a player.

- **Returns:** `str`

### Remove

```python
del display[player]
```

Stop showing action bar text to a player.

---

## Example: Status bar

```python
from bridge import *

status_bar = ActionBarDisplay()

@event
async def player_join(e: Event):
    p = e.player
    status_bar[p] = f"§a❤ {int(p.health)}/20 §7| §e⚔ Kills: 0"

@event
async def entity_damage(e: Event):
    if hasattr(e.player, 'name'):
        p = e.player
        status_bar[p] = f"§a❤ {int(p.health)}/20 §7| §c-{e.damage}"

@event
async def player_quit(e: Event):
    del status_bar[e.player]
```

## Example: Ability cooldown indicator

```python
from bridge import *

cd_display = ActionBarDisplay()
ability_cd = Cooldown(seconds=5.0)

@command("Use ability")
async def ability(player: Player, args: list[str]):
    if not ability_cd.check(player):
        r = ability_cd.remaining(player)
        cd_display[player] = f"§c⏳ Cooldown: {r:.1f}s"
        return

    cd_display[player] = "§a✓ Ability used!"
    await player.send_message("§aAbility activated!")
```
PyJavaBridge-2a/docs/src/advancement.md000066400000000000000000000052601514752343100202230ustar00rootroot00000000000000---
title: Advancement
subtitle: Advancement grant/revoke API
---

# Advancement

The `Advancement` class lets you grant or revoke Minecraft advancements (achievements) for players, and inspect their progress.

---

## Class Methods

### grant

```python
progress = await Advancement.grant(player, key)
```

Grant an advancement to a player (awards all remaining criteria).

- **Parameters:**
  - `player` ([`Player`](player.md)) — Target player.
  - `key` (`str`) — Advancement key in `namespace:path` format.
- **Returns:** `Awaitable[`[`AdvancementProgress`](#advancementprogress)`]`

```python
progress = await Advancement.grant(player, "minecraft:story/mine_stone")
```

### revoke

```python
progress = await Advancement.revoke(player, key)
```

Revoke an advancement from a player (removes all awarded criteria).

- **Parameters:**
  - `player` ([`Player`](player.md)) — Target player.
  - `key` (`str`) — Advancement key in `namespace:path` format.
- **Returns:** `Awaitable[`[`AdvancementProgress`](#advancementprogress)`]`

```python
await Advancement.revoke(player, "minecraft:story/mine_stone")
```

---

## Attributes

### key

- **Type:** `Any`

The advancement's namespaced key.

---

## AdvancementProgress

Returned by `grant()` and `revoke()`, this object tracks per-criterion completion.

### Attributes

#### is_done

- **Type:** `bool`

Whether all criteria have been awarded.

#### remaining_criteria

- **Type:** `set[str]`

Criteria names that have not been awarded yet.

#### awarded_criteria

- **Type:** `set[str]`

Criteria names that have been awarded.

### Methods

#### award_criteria

```python
result = await progress.award_criteria(name)
```

Award a single criterion.

- **Parameters:**
  - `name` (`str`) — Criterion name.
- **Returns:** `Awaitable[bool]` — `True` if the criterion was newly awarded.

#### revoke_criteria

```python
result = await progress.revoke_criteria(name)
```

Revoke a single criterion.

- **Parameters:**
  - `name` (`str`) — Criterion name.
- **Returns:** `Awaitable[bool]` — `True` if the criterion was newly revoked.

---

## Common Advancement Keys

| Key | Description |
|-----|-------------|
| `minecraft:story/mine_stone` | Mine stone with a pickaxe |
| `minecraft:story/upgrade_tools` | Craft a stone pickaxe |
| `minecraft:story/smelt_iron` | Smelt an iron ingot |
| `minecraft:story/obtain_armor` | Craft any armor piece |
| `minecraft:story/enter_the_nether` | Enter the Nether |
| `minecraft:story/enter_the_end` | Enter the End |
| `minecraft:end/kill_dragon` | Kill the Ender Dragon |

You can also use `server.get_advancement(key)` to get the advancement object:

```python
adv = await server.get_advancement("minecraft:story/mine_stone")
```
PyJavaBridge-2a/docs/src/attribute.md000066400000000000000000000043621514752343100177430ustar00rootroot00000000000000---
title: Attribute
subtitle: Entity attribute modifiers
---

# Attribute

An `Attribute` represents a Minecraft entity attribute (max health, movement speed, attack damage, etc.) and its current value. Use it to modify player or entity stats.

---

## Class Methods

### apply

```python
await Attribute.apply(player, attribute_type, base_value)
```

Set an attribute's base value for a player.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Target player.
  - `attribute_type` ([`AttributeType`](enums.md) `| str`) — Attribute to modify.
  - `base_value` (`float`) — New base value.
- **Returns:** `Awaitable[Any]`

```python
# Set max health to 40 (20 hearts)
await Attribute.apply(player, "GENERIC_MAX_HEALTH", 40.0)

# Double movement speed
await Attribute.apply(player, AttributeType.GENERIC_MOVEMENT_SPEED, 0.2)
```

---

## Attributes

### attribute_type

- **Type:** [`AttributeType`](enums.md)

The type of this attribute.

### value

- **Type:** `float`

The current effective value (base + modifiers).

### base_value

- **Type:** `float`

The base value before modifiers.

---

## Methods

### set_base_value

```python
await attribute.set_base_value(value)
```

Change the base value of this attribute.

- **Parameters:**
  - `value` (`float`) — New base value.
- **Returns:** `Awaitable[None]`

---

## Common Attribute Types

| AttributeType | Default | Description |
|---------------|---------|-------------|
| `GENERIC_MAX_HEALTH` | 20.0 | Maximum health (1.0 = half heart) |
| `GENERIC_MOVEMENT_SPEED` | 0.1 | Walk speed |
| `GENERIC_ATTACK_DAMAGE` | 1.0 | Base melee damage |
| `GENERIC_ATTACK_SPEED` | 4.0 | Attack cooldown speed |
| `GENERIC_ARMOR` | 0.0 | Armor points |
| `GENERIC_ARMOR_TOUGHNESS` | 0.0 | Armor toughness |
| `GENERIC_KNOCKBACK_RESISTANCE` | 0.0 | Knockback resistance (0–1) |
| `GENERIC_LUCK` | 0.0 | Luck for loot tables |
| `GENERIC_FLYING_SPEED` | 0.4 | Creative fly speed |

```python
# Tank build
await Attribute.apply(player, "GENERIC_MAX_HEALTH", 40.0)
await Attribute.apply(player, "GENERIC_ARMOR", 20.0)
await Attribute.apply(player, "GENERIC_KNOCKBACK_RESISTANCE", 0.5)

# Speed runner build
await Attribute.apply(player, "GENERIC_MOVEMENT_SPEED", 0.2)
await Attribute.apply(player, "GENERIC_ATTACK_SPEED", 8.0)
```
PyJavaBridge-2a/docs/src/block.md000066400000000000000000000050661514752343100170340ustar00rootroot00000000000000---
title: Block
subtitle: Block in the world
---

# Block

A `Block` represents a single block in the world. You get block references from [`World.block_at()`](world.md#block_at) or event properties.

---

## Constructor

```python
Block(world=None, x=None, y=None, z=None, material=None)
```

Create a block reference.

- **Parameters:**
  - `world` ([`World`](world.md) `| str | None`) — World reference.
  - `x` (`int | None`) — X coordinate.
  - `y` (`int | None`) — Y coordinate.
  - `z` (`int | None`) — Z coordinate.
  - `material` ([`Material`](enums.md) `| str | None`) — Block material.

---

## Class Methods

### create

```python
block = await Block.create(location, material)
```

Create (place) a block at a location.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Where to place the block.
  - `material` ([`Material`](enums.md) `| str`) — Block material.
- **Returns:** `Awaitable[`[`Block`](#)`]`

```python
block = await Block.create(player.location.add(0, -1, 0), Material.DIAMOND_BLOCK)
```

---

## Attributes

### x

- **Type:** `int`

Block X coordinate.

### y

- **Type:** `int`

Block Y coordinate.

### z

- **Type:** `int`

Block Z coordinate.

### type

- **Type:** [`Material`](enums.md)

The block's material type.

### location

- **Type:** [`Location`](location.md)

The block's location.

### world

- **Type:** [`World`](world.md)

The world this block is in.

### is_solid

- **Type:** `bool`

Whether the block is solid (not air, water, etc.).

### data

- **Type:** `any`

The block's data state (e.g., slab halves, stair direction). Varies by block type.

### light_level

- **Type:** `int`

Light level at this block (0–15).

### biome

- **Type:** [`Biome`](enums.md)

The biome at this block's location.

---

## Methods

### break_naturally

```python
await block.break_naturally()
```

Break the block as if a player mined it (drops items).

- **Returns:** `Awaitable[None]`

### set_type

```python
await block.set_type(material)
```

Change the block's material.

- **Parameters:**
  - `material` ([`Material`](enums.md)) — The new material.
- **Returns:** `Awaitable[None]`

```python
await block.set_type(Material.AIR)  # Delete the block
```

### set_data

```python
await block.set_data(data)
```

Set the block's data state.

- **Parameters:**
  - `data` (`any`) — Block data value.
- **Returns:** `Awaitable[None]`

### set_biome

```python
await block.set_biome(biome)
```

Change the biome at this block's position.

- **Parameters:**
  - `biome` ([`Biome`](enums.md)) — The new biome.
- **Returns:** `Awaitable[None]`
PyJavaBridge-2a/docs/src/blockdisplay.md000066400000000000000000000032131514752343100204120ustar00rootroot00000000000000---
title: BlockDisplay
subtitle: Block display entity
---

# BlockDisplay

A `BlockDisplay` renders a block as a display entity in the world (1.19.4+). Unlike placed blocks, display entities don't have collision and can be positioned at any coordinates.

---

## Constructor

```python
BlockDisplay(location, block_type, billboard="FIXED")
```

Create and spawn a block display entity.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Spawn position.
  - `block_type` (`str`) — Block material name (e.g. `"DIAMOND_BLOCK"`, `"STONE"`).
  - `billboard` (`str`) — Billboard mode. Default `"FIXED"`.

| Billboard | Description |
|-----------|-------------|
| `"FIXED"` | No rotation (default for blocks) |
| `"CENTER"` | Always faces the player |
| `"HORIZONTAL"` | Only rotates horizontally |
| `"VERTICAL"` | Only rotates vertically |

```python
display = BlockDisplay(
    Location(100, 70, 200, "world"),
    "DIAMOND_BLOCK",
    billboard="FIXED"
)
```

---

## Attributes

### billboard

- **Type:** `str`

Current billboard mode.

---

## Methods

### teleport

```python
display.teleport(location)
```

Move the display entity. This is synchronous.

- **Parameters:**
  - `location` ([`Location`](location.md)) — New position.

### remove

```python
display.remove()
```

Despawn and destroy the display entity. This is synchronous.

---

## Example: Floating block marker

```python
from bridge import *

@command("Place a marker")
async def marker(player: Player, args: list[str]):
    loc = player.location.add(0, 3, 0)
    block = BlockDisplay(loc, "BEACON", billboard="FIXED")
    await player.send_message("§aMarker placed above you!")
```
PyJavaBridge-2a/docs/src/bossbar.md000066400000000000000000000071741514752343100173770ustar00rootroot00000000000000---
title: BossBar
subtitle: Boss bar display API
---

# BossBar

A `BossBar` is the bar displayed at the top of the screen (like the Ender Dragon or Wither health bar). You can create custom boss bars with custom titles, colors, and progress.

---

## Class Methods

### create

```python
bar = BossBar.create(title, color=None, style=None, players=None)
```

Create a new boss bar. This is synchronous.

- **Parameters:**
  - `title` (`str`) — Bar title text. Supports `§` color codes.
  - `color` ([`BarColor`](enums.md) `| None`) — Bar color. Default `None` (PINK).
  - `style` ([`BarStyle`](enums.md) `| None`) — Bar segmentation style. Default `None` (SOLID).
  - `players` (`list[`[`Player`](player.md)`] | None`) — Players who can see the bar. Default `None`.
- **Returns:** [`BossBar`](#)

```python
bar = BossBar.create(
    "§c§lRaid Boss",
    color=BarColor.RED,
    style=BarStyle.SEGMENTED_10
)
```

---

## Attributes

### title

- **Type:** `str`

Current title text.

### progress

- **Type:** `float`

Progress value from 0.0 (empty) to 1.0 (full).

### color

- **Type:** [`BarColor`](enums.md)

Current bar color.

### style

- **Type:** [`BarStyle`](enums.md)

Current segmentation style.

### visible

- **Type:** `bool`

Whether the bar is currently visible.

---

## Methods

### add_player

```python
await bar.add_player(player)
```

Show this bar to a player.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to add.
- **Returns:** `Awaitable[None]`

### remove_player

```python
await bar.remove_player(player)
```

Hide this bar from a player.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to remove.
- **Returns:** `Awaitable[None]`

### set_title

```python
await bar.set_title(title)
```

Change the bar title.

- **Parameters:**
  - `title` (`str`) — New title text.
- **Returns:** `Awaitable[None]`

### set_progress

```python
await bar.set_progress(value)
```

Set the bar progress.

- **Parameters:**
  - `value` (`float`) — Progress from 0.0 to 1.0.
- **Returns:** `Awaitable[None]`

```python
await bar.set_progress(0.5)  # Half full
```

### set_color

```python
await bar.set_color(color)
```

Change the bar color.

- **Parameters:**
  - `color` ([`BarColor`](enums.md)) — New color.
- **Returns:** `Awaitable[None]`

### set_style

```python
await bar.set_style(style)
```

Change the bar segmentation style.

- **Parameters:**
  - `style` ([`BarStyle`](enums.md)) — New style.
- **Returns:** `Awaitable[None]`

### set_visible

```python
await bar.set_visible(value)
```

Show or hide the bar without removing players.

- **Parameters:**
  - `value` (`bool`) — Visibility.
- **Returns:** `Awaitable[None]`

---

## BarColor Options

| Name | Description |
|------|-------------|
| `PINK` | Default pink |
| `BLUE` | Blue |
| `RED` | Red |
| `GREEN` | Green |
| `YELLOW` | Yellow |
| `PURPLE` | Purple |
| `WHITE` | White |

## BarStyle Options

| Name | Description |
|------|-------------|
| `SOLID` | No segments |
| `SEGMENTED_6` | 6 segments |
| `SEGMENTED_10` | 10 segments |
| `SEGMENTED_12` | 12 segments |
| `SEGMENTED_20` | 20 segments |

---

## Example: Health bar for a boss fight

```python
from bridge import *

boss_bar = BossBar.create("§c§lDragon §7- §c100%", color=BarColor.RED, style=BarStyle.SEGMENTED_10)

@event
async def entity_damage(e: Event):
    entity = e.entity
    if entity.custom_name == "Dragon":
        hp_pct = entity.health / 100
        await boss_bar.set_progress(hp_pct)
        await boss_bar.set_title(f"§c§lDragon §7- §c{int(hp_pct * 100)}%")
```

> **See also:** [`BossBarDisplay`](bossbardisplay.md) for a higher-level wrapper with cooldown linking.
PyJavaBridge-2a/docs/src/bossbardisplay.md000066400000000000000000000075321514752343100207630ustar00rootroot00000000000000---
title: BossBarDisplay
subtitle: Per-player boss bar manager
---

# BossBarDisplay

`BossBarDisplay` is a high-level wrapper around [`BossBar`](bossbar.md) that manages per-player visibility and integrates with [`Cooldown`](cooldown.md) for automatic progress animation.

---

## Constructor

```python
BossBarDisplay(title="", color="PINK", style="SOLID")
```

Create a boss bar display.

- **Parameters:**
  - `title` (`str`) — Bar title. Supports `§` color codes. Default `""`.
  - `color` (`str`) — Bar color name. Default `"PINK"`. Options: `"PINK"`, `"BLUE"`, `"RED"`, `"GREEN"`, `"YELLOW"`, `"PURPLE"`, `"WHITE"`.
  - `style` (`str`) — Bar style name. Default `"SOLID"`. Options: `"SOLID"`, `"SEGMENTED_6"`, `"SEGMENTED_10"`, `"SEGMENTED_12"`, `"SEGMENTED_20"`.

```python
ability_bar = BossBarDisplay("§6Fireball", color="RED", style="SOLID")
```

---

## Attributes

### text

- **Type:** `str`

Current title text.

### color

- **Type:** `str`

Current color name.

### style

- **Type:** `str`

Current style name.

### value

- **Type:** `float`

Current value.

### max

- **Type:** `float`

Maximum value.

### progress

- **Type:** `float`

Progress from 0.0 to 1.0 (calculated as `value / max`).

### visible

- **Type:** `bool`

Whether the bar is currently visible.

---

## Methods

### show

```python
display.show(player)
```

Show the boss bar to a player. This is synchronous.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to show the bar to.

### hide

```python
display.hide(player)
```

Hide the boss bar from a player. This is synchronous.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to hide from.

### link_cooldown

```python
display.link_cooldown(cooldown, player)
```

Link this bar to a [`Cooldown`](cooldown.md) — the bar progress will automatically animate to reflect the remaining cooldown time.

- **Parameters:**
  - `cooldown` ([`Cooldown`](cooldown.md)) — The cooldown to track.
  - `player` ([`Player`](player.md)) — The player to display the cooldown bar to.

```python
cd = Cooldown(seconds=10.0)
bar = BossBarDisplay("§6Fireball Cooldown", color="RED")

@command("Fireball")
async def fireball(player: Player, args: list[str]):
    if not cd.check(player):
        return

    bar.link_cooldown(cd, player)
    await player.send_message("§6🔥 Fireball!")
```

---

## Example: Ability cooldown bar

```python
from bridge import *

fireball_cd = Cooldown(seconds=8.0)
fireball_bar = BossBarDisplay("§6§lFireball", color="RED", style="SOLID")

@command("Shoot a fireball")
async def fireball(player: Player, args: list[str]):
    if not fireball_cd.check(player):
        r = fireball_cd.remaining(player)
        await player.send_message(f"§c{r:.1f}s cooldown!")
        return

    fireball_bar.link_cooldown(fireball_cd, player)
    await world.spawn_projectile(player, "FIREBALL")
    await player.send_message("§6🔥 Fireball launched!")
```

## Example: Multiple ability bars

```python
from bridge import *

abilities = {
    "fireball": {
        "cd": Cooldown(seconds=8.0),
        "bar": BossBarDisplay("§6Fireball", color="RED"),
    },
    "heal": {
        "cd": Cooldown(seconds=15.0),
        "bar": BossBarDisplay("§aHeal", color="GREEN"),
    },
    "dash": {
        "cd": Cooldown(seconds=3.0),
        "bar": BossBarDisplay("§bDash", color="BLUE"),
    },
}

@command("Use an ability")
async def ability(player: Player, args: list[str]):
    if not args or args[0] not in abilities:
        await player.send_message("§cUsage: /ability ")
        return

    ab = abilities[args[0]]
    if not ab["cd"].check(player):
        return

    ab["bar"].link_cooldown(ab["cd"], player)
    await player.send_message(f"§aUsed {args[0]}!")
```

> **See also:** [`BossBar`](bossbar.md) for the lower-level boss bar API, [`Cooldown`](cooldown.md) for standalone cooldown tracking.
PyJavaBridge-2a/docs/src/chat.md000066400000000000000000000023311514752343100166510ustar00rootroot00000000000000---
title: Chat
subtitle: Chat broadcast helper
---

# Chat

The `Chat` helper provides broadcast functionality. An instance is available as the global `chat` variable.

---

## Global Instance

```python
from bridge import chat
```

---

## Methods

### broadcast

```python
await chat.broadcast(message)
```

Send a message to all online players.

- **Parameters:**
  - `message` (`str`) — Message text. Supports `§` color codes.
- **Returns:** `Awaitable[None]`

```python
await chat.broadcast("§a§lServer restarting in 5 minutes!")
```

---

## Chat vs Server.broadcast

Both `chat.broadcast()` and `server.broadcast()` send messages to all players:

```python
# These are equivalent
await chat.broadcast("Hello everyone!")
await server.broadcast("Hello everyone!")
```

The `chat` helper exists for convenience and semantic clarity when your script is focused on chat operations.

---

## Example: Announcement system

```python
from bridge import *

@command("Announce a message")
async def announce(player: Player, args: list[str]):
    if not args:
        await player.send_message("§cUsage: /announce ")
        return

    message = " ".join(args)
    await chat.broadcast(f"§6§l[Announcement] §f{message}")
```
PyJavaBridge-2a/docs/src/chunk.md000066400000000000000000000032421514752343100170440ustar00rootroot00000000000000---
title: Chunk
subtitle: World chunk API
---

# Chunk

A `Chunk` represents a 16×256×16 (or 16×384×16 in 1.18+) column of blocks in a world. Use it to force-load or release terrain.

---

## Constructor

```python
Chunk(world=None, x=None, z=None)
```

Reference a chunk by world and chunk coordinates.

- **Parameters:**
  - `world` ([`World`](world.md) `| str | None`) — The world.
  - `x` (`int | None`) — Chunk X coordinate (block X ÷ 16).
  - `z` (`int | None`) — Chunk Z coordinate (block Z ÷ 16).

> **Note:** Chunk coordinates are block coordinates divided by 16. A block at X=100 is in chunk X=6.

```python
chunk = Chunk("world", 5, 10)
```

You can also get a chunk from a world:

```python
chunk = await world.chunk_at(5, 10)
```

---

## Attributes

### x

- **Type:** `int`

Chunk X coordinate.

### z

- **Type:** `int`

Chunk Z coordinate.

### world

- **Type:** [`World`](world.md)

The world this chunk is in.

### is_loaded

- **Type:** `bool`

Whether this chunk is currently loaded in memory.

---

## Methods

### load

```python
result = await chunk.load()
```

Force-load this chunk into memory. If the chunk is already loaded, this is a no-op.

- **Returns:** `Awaitable[bool]` — `True` if the chunk was loaded successfully.

```python
chunk = await world.chunk_at(0, 0)
await chunk.load()
```

### unload

```python
result = await chunk.unload()
```

Allow this chunk to be unloaded from memory. The server will unload it when no players are nearby.

- **Returns:** `Awaitable[bool]` — `True` if the chunk was unloaded successfully.

> **Warning:** Unloading a chunk with players in it may cause issues. Only unload chunks you know are safe to release.
PyJavaBridge-2a/docs/src/config.md000066400000000000000000000106671514752343100172120ustar00rootroot00000000000000---
title: Config
subtitle: Configuration files (TOML, JSON, properties)
---

# Config

`Config` provides a simple interface for reading and writing configuration files. Config files are stored in the plugin's data folder and persist across server restarts.

Supported formats: **TOML** (default), **JSON**, and **properties**.

---

## Constructor

```python
Config(name=None, defaults=None, format="toml")
```

Load or create a configuration file.

- **Parameters:**
  - `name` (`str | None`) — File name (without extension). If `None`, uses the script name.
  - `defaults` (`dict[str, Any] | None`) — Default values to merge into the config if they don't already exist.
  - `format` (`str`) — File format: `"toml"` (default), `"json"`, or `"properties"`.

```python
# Default config.toml
config = Config()

# Named config
bans = Config("bans")

# JSON format
data = Config("data", format="json")

# Properties format
props = Config("server", format="properties")

# With defaults
settings = Config("settings", defaults={
    "spawn_protection_radius": 16,
    "max_homes": 3,
    "welcome_message": "§aWelcome to the server!"
})
```

---

## Attributes

### data

- **Type:** `dict[str, Any]`

The entire config as a dictionary.

### path

- **Type:** `str`

Absolute file path to the config file.

---

## Methods

### get

```python
value = config.get(path, default=None)
```

Get a value by dot-separated path.

- **Parameters:**
  - `path` (`str`) — Dot-separated key path (e.g. `"database.host"`).
  - `default` (`Any`) — Fallback if the key doesn't exist. Default `None`.
- **Returns:** `Any`

```python
radius = config.get("spawn_protection_radius", 16)
db_host = config.get("database.host", "localhost")
```

### get_int

```python
value = config.get_int(path, default=0)
```

Get a value as an integer.

- **Parameters:**
  - `path` (`str`) — Dot-separated key path.
  - `default` (`int`) — Fallback. Default 0.
- **Returns:** `int`

### get_float

```python
value = config.get_float(path, default=0.0)
```

Get a value as a float.

- **Parameters:**
  - `path` (`str`) — Dot-separated key path.
  - `default` (`float`) — Fallback. Default 0.0.
- **Returns:** `float`

### get_bool

```python
value = config.get_bool(path, default=False)
```

Get a value as a boolean.

- **Parameters:**
  - `path` (`str`) — Dot-separated key path.
  - `default` (`bool`) — Fallback. Default `False`.
- **Returns:** `bool`

### get_list

```python
value = config.get_list(path, default=None)
```

Get a value as a list.

- **Parameters:**
  - `path` (`str`) — Dot-separated key path.
  - `default` (`list[Any] | None`) — Fallback. Default `None`.
- **Returns:** `list[Any]`

### set

```python
config.set(path, value)
```

Set a value by dot-separated path. Creates intermediate keys as needed.

- **Parameters:**
  - `path` (`str`) — Dot-separated key path.
  - `value` (`Any`) — Value to set.

```python
config.set("database.host", "localhost")
config.set("database.port", 3306)
```

### delete

```python
result = config.delete(path)
```

Delete a key.

- **Parameters:**
  - `path` (`str`) — Dot-separated key path.
- **Returns:** `bool` — `True` if the key existed and was deleted.

### save

```python
config.save()
```

Write changes to disk. This is synchronous.

```python
config.set("last_restart", "2024-01-15")
config.save()
```

### reload

```python
config.reload()
```

Reload the config from disk, discarding unsaved changes. This is synchronous.

---

## Dict-style Access

Config supports `[]` notation and `in` checks:

```python
# These are equivalent
value = config["key"]
value = config.get("key")

# Set values
config["key"] = "value"
config.set("key", "value")

# Check existence
if "key" in config:
    print("Key exists!")
```

---

## Example: Ban system config

```python
from bridge import *

bans = Config("bans", defaults={"banned_players": {}})

@command("Ban a player")
async def ban(player: Player, args: list[str]):
    if not args:
        await player.send_message("§cUsage: /ban  [reason]")
        return

    target = args[0]
    reason = " ".join(args[1:]) or "No reason given"

    bans.set(f"banned_players.{target}", {
        "reason": reason,
        "banned_by": player.name,
    })
    bans.save()
    await player.send_message(f"§aBanned {target}: {reason}")

@event
async def player_login(e: Event):
    ban_info = bans.get(f"banned_players.{e.player.name}")
    if ban_info:
        await e.player.kick(f"§cBanned: {ban_info['reason']}")
```
PyJavaBridge-2a/docs/src/cooldown.md000066400000000000000000000061751514752343100175700ustar00rootroot00000000000000---
title: Cooldown
subtitle: Rate limiting helper
---

# Cooldown

`Cooldown` is a helper that tracks per-player cooldowns. Use it to prevent ability spam, command abuse, or add skill cooldown timers.

---

## Constructor

```python
Cooldown(seconds=1.0, on_expire=None)
```

Create a cooldown tracker.

- **Parameters:**
  - `seconds` (`float`) — Cooldown duration in seconds. Default 1.0.
  - `on_expire` (`Callable[[`[`Player`](player.md)`], Any] | None`) — Callback invoked when a player's cooldown expires. Default `None`.

```python
ability_cd = Cooldown(seconds=5.0)

fireball_cd = Cooldown(
    seconds=10.0,
    on_expire=lambda p: p.send_message("§aFireball ready!")
)
```

---

## Attributes

### seconds

- **Type:** `float`

The cooldown duration in seconds.

### on_expire

- **Type:** `Callable[[`[`Player`](player.md)`], Any] | None`

Callback invoked when the cooldown expires for a player.

---

## Methods

### check

```python
is_ready = cooldown.check(player)
```

Check if the player's cooldown has expired. If ready, **automatically starts a new cooldown**.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to check.
- **Returns:** `bool` — `True` if the cooldown was ready (and has now been reset), `False` if still on cooldown.

```python
cd = Cooldown(seconds=5.0)

@command("Use special ability")
async def ability(player: Player, args: list[str]):
    if not cd.check(player):
        remaining = cd.remaining(player)
        await player.send_message(f"§cOn cooldown! {remaining:.1f}s remaining")
        return
    await player.send_message("§aAbility activated!")
```

### remaining

```python
time_left = cooldown.remaining(player)
```

Get the remaining cooldown time for a player.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to check.
- **Returns:** `float` — Remaining seconds, or 0.0 if ready.

### reset

```python
cooldown.reset(player)
```

Manually reset (clear) a player's cooldown, making the ability immediately available.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to reset.

---

## Example: Ability with boss bar indicator

```python
from bridge import *

fireball_cd = Cooldown(seconds=8.0)

@command("Shoot a fireball")
async def fireball(player: Player, args: list[str]):
    if not fireball_cd.check(player):
        r = fireball_cd.remaining(player)
        await player.send_message(f"§c{r:.1f}s cooldown remaining!")
        return

    loc = player.location
    await world.spawn_projectile(player, "FIREBALL")
    await player.send_message("§6🔥 Fireball launched!")
```

## Example: On-expire callback

```python
from bridge import *

dash_cd = Cooldown(
    seconds=3.0,
    on_expire=lambda p: p.send_action_bar("§aDash ready!")
)

@command("Dash forward")
async def dash(player: Player, args: list[str]):
    if not dash_cd.check(player):
        await player.send_action_bar(f"§c{dash_cd.remaining(player):.1f}s")
        return

    await player.set_velocity(Vector(0, 0.5, 1.5))
    await player.send_action_bar("§6Dash!")
```

> **See also:** [`BossBarDisplay.link_cooldown()`](bossbardisplay.md#link_cooldown) to visually display cooldown progress.
PyJavaBridge-2a/docs/src/decorators.md000066400000000000000000000115141514752343100201020ustar00rootroot00000000000000---
title: Decorators
subtitle: Register event handlers, commands, and repeating tasks
---

# Decorators

PyJavaBridge uses Python decorators to register event handlers, commands, and repeating tasks. Your decorated functions are discovered automatically when the script loads.

---

## @event

```python
@event
async def player_join(e):
    await e.player.send_message("Welcome!")
```

Register a function as an event handler. The function name determines the event type — it is converted from `snake_case` to `PascalCase` and `Event` is appended. For example, `player_join` becomes `PlayerJoinEvent`.

### Signature

```
@event(*, once_per_tick=False, priority="NORMAL", throttle_ms=0)
```

### Parameters

#### once_per_tick

- **Type:** `bool`
- **Default:** `False`

When `True`, the handler is called at most once per server tick, even if the event fires multiple times. Useful for high-frequency events like `player_move`.

```python
@event(once_per_tick=True)
async def player_move(e):
    # Called at most once per tick per event, not every micro-movement
    pass
```

#### priority

- **Type:** `str`
- **Default:** `"NORMAL"`

The Bukkit event priority. Determines the order in which handlers run. Options (lowest runs first):

| Priority | Description |
|----------|-------------|
| `LOWEST` | Runs first. Use for early cancellation. |
| `LOW` | Runs before normal handlers. |
| `NORMAL` | Default priority. |
| `HIGH` | Runs after normal handlers. |
| `HIGHEST` | Runs last before monitor. |
| `MONITOR` | Read-only observation. Do not modify the event. |

```python
@event(priority="HIGH")
async def block_break(e):
    # This runs after NORMAL-priority handlers
    pass
```

#### throttle_ms

- **Type:** `int`
- **Default:** `0`

Minimum milliseconds between handler invocations. If the event fires more frequently, extra invocations are silently dropped.

```python
@event(throttle_ms=500)
async def player_interact(e):
    # At most once every 500ms, prevents spam-clicking abuse
    pass
```

### Bare decorator

You can use `@event` without parentheses for the default settings:

```python
@event
async def player_quit(e):
    await server.broadcast(f"{e.player.name} left!")
```

---

## @command

```python
@command("Greet a player", permission="myplugin.greet")
async def greet(e):
    await e.player.send_message("Hello!")
```

Register a function as a script command. The command is automatically available as `/functionname` (or as specified via the `name` parameter). Command arguments are parsed from the function's additional parameters after `event`.

### Signature

```
@command(description=None, *, name=None, permission=None)
```

### Parameters

#### description

- **Type:** `str | None`
- **Default:** `None`

A human-readable description of the command. This is the first positional argument.

```python
@command("Teleport to spawn")
async def spawn(e):
    ...
```

#### name

- **Type:** `str | None`
- **Default:** `None` (uses function name)

Override the command name. By default the function name is used.

```python
@command("Teleport home", name="home")
async def teleport_home(e):
    # Registered as /home, not /teleport_home
    ...
```

#### permission

- **Type:** `str | None`
- **Default:** `None`

Permission node required to use the command. Players without this permission cannot execute it.

```python
@command("Ban a player", permission="admin.ban")
async def ban(e, target: str):
    ...
```

### Command arguments

Extra function parameters after the event become command arguments. They are parsed positionally from the player's input:

```python
@command("Give items")
async def give(e, material: str, amount: str = "1"):
    # /give diamond 64
    # material = "diamond", amount = "64"
    await Item.give(e.player, material, int(amount))
```

All arguments are passed as strings. You handle type conversion yourself.

---

## @task

```python
@task(interval=20, delay=0)
async def tick_loop():
    ...
```

Register a repeating async task. The function is called repeatedly at the specified interval after an optional initial delay.

### Signature

```
@task(*, interval=20, delay=0)
```

### Parameters

#### interval

- **Type:** `int`
- **Default:** `20`

Ticks between invocations. Minecraft runs at 20 ticks per second, so `interval=20` means once per second, `interval=1` means every tick.

#### delay

- **Type:** `int`
- **Default:** `0`

Initial delay in ticks before the first invocation. Use this to wait for the server to fully start.

```python
@task(interval=20*60, delay=20*5)
async def auto_save():
    # Runs every 60 seconds, starting 5 seconds after script load
    await server.execute("save-all")
```

### Notes

- Task functions take **no arguments** (unlike event/command handlers).
- The task is cancelled automatically when the script is unloaded.
- If the function is still running when the next invocation is due, the next invocation is skipped.
PyJavaBridge-2a/docs/src/effect.md000066400000000000000000000073011514752343100171700ustar00rootroot00000000000000---
title: Effect
subtitle: Potion effects API
---

# Effect

An `Effect` represents a potion effect (speed, strength, invisibility, etc.) that can be applied to players. Effects have a type, duration, amplifier, and visual settings.

---

## Constructor

```python
Effect(effect_type=None, duration=0, amplifier=0, ambient=False, particles=True, icon=True)
```

Create an effect.

- **Parameters:**
  - `effect_type` ([`EffectType`](enums.md) `| str | None`) — The effect type (e.g. `"SPEED"`, `EffectType.INVISIBILITY`).
  - `duration` (`int`) — Duration in ticks (20 ticks = 1 second). Default 0.
  - `amplifier` (`int`) — Effect level minus 1. Speed II = amplifier 1. Default 0.
  - `ambient` (`bool`) — Whether the effect came from a beacon (translucent particles). Default `False`.
  - `particles` (`bool`) — Whether to show particles. Default `True`.
  - `icon` (`bool`) — Whether to show the effect icon in the HUD. Default `True`.

```python
speed = Effect("SPEED", duration=600, amplifier=1)         # Speed II for 30 seconds
invis = Effect(EffectType.INVISIBILITY, duration=1200)      # Invisibility for 60 seconds
silent = Effect("REGENERATION", 200, particles=False, icon=False) # Hidden regen
```

---

## Class Methods

### apply

```python
await Effect.apply(player, effect_type=None, duration=0, amplifier=0, ambient=False, particles=True, icon=True)
```

Create and apply an effect to a player in one call.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Target player.
  - `effect_type` ([`EffectType`](enums.md) `| str | None`) — Effect type.
  - `duration` (`int`) — Duration in ticks. Default 0.
  - `amplifier` (`int`) — Effect level minus 1. Default 0.
  - `ambient` (`bool`) — Beacon-style particles. Default `False`.
  - `particles` (`bool`) — Show particles. Default `True`.
  - `icon` (`bool`) — Show icon. Default `True`.
- **Returns:** `Awaitable[Any]`

```python
await Effect.apply(player, "SPEED", duration=600, amplifier=1)
```

---

## Attributes

### type

- **Type:** [`EffectType`](enums.md)

The effect type.

### duration

- **Type:** `int`

Remaining duration in ticks.

### amplifier

- **Type:** `int`

Effect amplifier (level minus 1).

### ambient

- **Type:** `bool`

Whether particles are translucent (beacon-style).

### particles

- **Type:** `bool`

Whether particles are visible.

### icon

- **Type:** `bool`

Whether the HUD icon is shown.

---

## Methods

### with_duration

```python
new_effect = await effect.with_duration(duration)
```

Create a copy of this effect with a different duration.

- **Parameters:**
  - `duration` (`int`) — New duration in ticks.
- **Returns:** `Awaitable[`[`Effect`](#)`]`

```python
base = Effect("SPEED", 100, amplifier=2)
long_speed = await base.with_duration(6000)  # 5 minutes
```

### with_amplifier

```python
new_effect = await effect.with_amplifier(amplifier)
```

Create a copy of this effect with a different amplifier.

- **Parameters:**
  - `amplifier` (`int`) — New amplifier.
- **Returns:** `Awaitable[`[`Effect`](#)`]`

---

## Applying to Players

You can apply effects in two ways:

```python
# 1. Using the class method shortcut
await Effect.apply(player, "SPEED", duration=200, amplifier=1)

# 2. Construct then apply via Player
speed = Effect("SPEED", duration=200, amplifier=1)
await player.add_effect(speed)
```

To remove an effect:

```python
await player.remove_effect(EffectType.SPEED)
```

To list active effects:

```python
for effect in player.effects:
    print(f"{effect.type.name}: {effect.duration} ticks remaining")
```

---

## Duration Reference

| Duration | Ticks |
|----------|-------|
| 1 second | 20 |
| 5 seconds | 100 |
| 30 seconds | 600 |
| 1 minute | 1200 |
| 5 minutes | 6000 |
| 10 minutes | 12000 |
PyJavaBridge-2a/docs/src/entity.md000066400000000000000000000122701514752343100172510ustar00rootroot00000000000000---
title: Entity
subtitle: Base entity proxy
---

# Entity

`Entity` is the base class for all entities in the game — mobs, animals, projectiles, dropped items, etc. [`Player`](player.md) extends this class.

---

## Constructor

```python
Entity(uuid: str | None = None)
```

Resolve an existing entity by its UUID.

- **Parameters:**
  - `uuid` (`str | None`) — The entity's UUID string.

```python
entity = Entity("550e8400-e29b-41d4-a716-446655440000")
```

---

## Class Methods

### spawn

```python
entity = await Entity.spawn(entity_type, location, **kwargs)
```

Spawn a new entity at a location.

- **Parameters:**
  - `entity_type` ([`EntityType`](enums.md) `| str`) — The type of entity to spawn.
  - `location` ([`Location`](location.md)) — Where to spawn the entity.
  - `**kwargs` — Additional spawn options.
- **Returns:** `Awaitable[`[`Entity`](#)`]`

```python
zombie = await Entity.spawn(EntityType.ZOMBIE, player.location)
zombie = await Entity.spawn("ZOMBIE", Location(0, 64, 0, "world"))
```

---

## Attributes

### uuid

- **Type:** `str`

The entity's universally unique identifier.

### type

- **Type:** [`EntityType`](enums.md)

The entity type (e.g. `EntityType.ZOMBIE`, `EntityType.ARROW`).

### location

- **Type:** [`Location`](location.md)

The entity's current location. Re-fetched each access.

### world

- **Type:** [`World`](world.md)

The world the entity is in.

### velocity

- **Type:** [`Vector`](vector.md)

The entity's current velocity vector.

### is_dead

- **Type:** `bool`

Whether the entity is dead.

### is_alive

- **Type:** `bool`

Whether the entity is alive.

### is_valid

- **Type:** `bool`

Whether the entity handle is still valid. Becomes `False` when the entity is removed from the server. Always check this before interacting with an entity you've stored across ticks.

### fire_ticks

- **Type:** `int`

Remaining fire ticks. 0 means not on fire. Each tick at 20 TPS, so 100 = 5 seconds of fire.

### passengers

- **Type:** `list[`[`Entity`](#)`]`

Entities riding on top of this entity.

### custom_name

- **Type:** `any`

The entity's custom name, or `None` if not set.

### is_projectile

- **Type:** `bool`

Whether this entity is a projectile (arrow, snowball, trident, etc.).

### shooter

- **Type:** [`Entity`](#) | [`Player`](player.md) | [`Block`](block.md) | `None`

For projectiles, the entity or block that launched it. `None` for non-projectiles.

### is_tamed

- **Type:** `bool`

Whether this entity is a tameable animal that has been tamed.

### owner

- **Type:** [`Player`](player.md) | `None`

The player who owns this tamed entity, if the owner is online.

### owner_uuid

- **Type:** `str | None`

UUID of the taming player, even if they're offline.

### owner_name

- **Type:** `str | None`

Name of the taming player, if known.

### source

- **Type:** [`Entity`](#) | [`Player`](player.md) | `None`

The entity that created this entity. For example, the player who lit a TNT block, or the witch that threw a potion.

---

## Methods

### teleport

```python
await entity.teleport(location)
```

Teleport the entity to a new location.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Destination.
- **Returns:** `Awaitable[None]`

```python
await zombie.teleport(Location(0, 100, 0, "world"))
```

### remove

```python
await entity.remove()
```

Remove the entity from the world permanently.

- **Returns:** `Awaitable[None]`

### set_velocity

```python
await entity.set_velocity(vector)
```

Set the entity's velocity. Useful for launching entities, knockback effects, etc.

- **Parameters:**
  - `vector` ([`Vector`](vector.md)) — The velocity vector. Each component is in blocks/tick.
- **Returns:** `Awaitable[None]`

```python
# Launch entity upward
await entity.set_velocity(Vector(0, 1.5, 0))
```

### set_fire_ticks

```python
await entity.set_fire_ticks(ticks)
```

Set the entity on fire for a duration.

- **Parameters:**
  - `ticks` (`int`) — Duration in ticks (20 ticks = 1 second). Set to 0 to extinguish.
- **Returns:** `Awaitable[None]`

```python
await entity.set_fire_ticks(100)  # 5 seconds of fire
await entity.set_fire_ticks(0)    # Extinguish
```

### add_passenger

```python
success = await entity.add_passenger(entity)
```

Make another entity ride on top of this one.

- **Parameters:**
  - `entity` ([`Entity`](#)) — The entity to add as a passenger.
- **Returns:** `Awaitable[bool]` — `True` if the passenger was added successfully.

### remove_passenger

```python
success = await entity.remove_passenger(entity)
```

Remove a riding entity.

- **Parameters:**
  - `entity` ([`Entity`](#)) — The passenger to remove.
- **Returns:** `Awaitable[bool]`

### set_custom_name

```python
await entity.set_custom_name(name)
```

Set the entity's custom name tag.

- **Parameters:**
  - `name` (`str`) — The name to display. Supports `§` color codes.
- **Returns:** `Awaitable[None]`

```python
await zombie.set_custom_name("§cBoss Zombie")
```

### set_custom_name_visible

```python
await entity.set_custom_name_visible(value)
```

Show or hide the custom name tag. When `True`, the name is visible through walls and at a distance.

- **Parameters:**
  - `value` (`bool`) — Whether the name should be visible.
- **Returns:** `Awaitable[None]`
PyJavaBridge-2a/docs/src/enums.md000066400000000000000000000135671514752343100170760ustar00rootroot00000000000000---
title: Enums
subtitle: Enum types reference
---

# Enums

PyJavaBridge wraps Minecraft's Java enums as [`EnumValue`](enumvalue.md) subclasses. Each enum type supports attribute-style access (`EnumType.VALUE_NAME`) and `from_name("VALUE_NAME")`.

---

## How Enums Work

All enum types inherit from [`EnumValue`](enumvalue.md):

```python
# Attribute-style access
material = Material.DIAMOND_SWORD
sound = Sound.ENTITY_EXPERIENCE_ORB_PICKUP

# from_name (useful for dynamic values)
material = Material.from_name("DIAMOND_SWORD")
```

See the [`EnumValue`](enumvalue.md) page for full details.

---

## Material

```python
from bridge import Material
```

Block and item types. Minecraft has hundreds of materials.

**Common materials:**

| Category | Examples |
|----------|----------|
| Ores | `DIAMOND_ORE`, `IRON_ORE`, `GOLD_ORE`, `COAL_ORE` |
| Blocks | `STONE`, `DIRT`, `GRASS_BLOCK`, `OAK_PLANKS`, `COBBLESTONE` |
| Items | `DIAMOND_SWORD`, `IRON_PICKAXE`, `BOW`, `ARROW`, `STICK` |
| Food | `GOLDEN_APPLE`, `COOKED_BEEF`, `BREAD`, `CAKE` |
| Armor | `DIAMOND_HELMET`, `IRON_CHESTPLATE`, `LEATHER_BOOTS` |
| Glass | `GLASS`, `RED_STAINED_GLASS`, `GLASS_PANE` |
| Wool | `WHITE_WOOL`, `RED_WOOL`, `BLUE_WOOL` |
| Misc | `BEACON`, `ENDER_PEARL`, `NETHER_STAR`, `TOTEM_OF_UNDYING` |

```python
sword = Item(Material.DIAMOND_SWORD)
await world.set_block(0, 60, 0, Material.STONE)
```

---

## EntityType

```python
from bridge import EntityType
```

Mob and entity types.

| Category | Examples |
|----------|----------|
| Hostile | `ZOMBIE`, `SKELETON`, `CREEPER`, `SPIDER`, `ENDERMAN`, `WITCH` |
| Passive | `COW`, `PIG`, `SHEEP`, `CHICKEN`, `VILLAGER`, `HORSE` |
| Projectiles | `ARROW`, `FIREBALL`, `SNOWBALL`, `ENDER_PEARL`, `TRIDENT` |
| Misc | `ITEM`, `EXPERIENCE_ORB`, `ARMOR_STAND`, `LIGHTNING_BOLT` |

```python
await Entity.spawn(EntityType.ZOMBIE, location)
await world.spawn_projectile(player, EntityType.FIREBALL)
```

---

## EffectType

```python
from bridge import EffectType
```

Potion effect types.

| Name | Description |
|------|-------------|
| `SPEED` | Increases movement speed |
| `SLOWNESS` | Decreases movement speed |
| `HASTE` | Increases mining speed |
| `MINING_FATIGUE` | Decreases mining speed |
| `STRENGTH` | Increases attack damage |
| `INSTANT_HEALTH` | Heals instantly |
| `INSTANT_DAMAGE` | Damages instantly |
| `JUMP_BOOST` | Increases jump height |
| `REGENERATION` | Restores health over time |
| `RESISTANCE` | Reduces damage taken |
| `FIRE_RESISTANCE` | Immunity to fire damage |
| `WATER_BREATHING` | Breathe underwater |
| `INVISIBILITY` | Invisible to other players |
| `BLINDNESS` | Restricts vision |
| `NIGHT_VISION` | See in the dark |
| `POISON` | Deals damage over time |
| `WITHER` | Deals wither damage over time |
| `ABSORPTION` | Adds absorption hearts |
| `SATURATION` | Restores hunger |
| `GLOWING` | Glowing outline |
| `LEVITATION` | Float upward |
| `SLOW_FALLING` | Fall slowly |

```python
await Effect.apply(player, EffectType.SPEED, duration=600, amplifier=1)
```

---

## AttributeType

```python
from bridge import AttributeType
```

Entity attribute types for stat modification.

| Name | Default | Description |
|------|---------|-------------|
| `GENERIC_MAX_HEALTH` | 20.0 | Maximum health |
| `GENERIC_MOVEMENT_SPEED` | 0.1 | Walking speed |
| `GENERIC_ATTACK_DAMAGE` | 1.0 | Melee damage |
| `GENERIC_ATTACK_SPEED` | 4.0 | Attack cooldown |
| `GENERIC_ARMOR` | 0.0 | Armor points |
| `GENERIC_ARMOR_TOUGHNESS` | 0.0 | Armor toughness |
| `GENERIC_KNOCKBACK_RESISTANCE` | 0.0 | Knockback resistance |
| `GENERIC_LUCK` | 0.0 | Loot table luck |
| `GENERIC_FLYING_SPEED` | 0.4 | Creative fly speed |

---

## GameMode

```python
from bridge import GameMode
```

| Name | Description |
|------|-------------|
| `SURVIVAL` | Normal survival |
| `CREATIVE` | Creative mode |
| `ADVENTURE` | Adventure mode |
| `SPECTATOR` | Spectator mode |

```python
await player.set_game_mode(GameMode.CREATIVE)
```

---

## Sound

```python
from bridge import Sound
```

Minecraft sound effects. Examples:

| Name | Description |
|------|-------------|
| `ENTITY_EXPERIENCE_ORB_PICKUP` | XP orb |
| `BLOCK_NOTE_BLOCK_BASS` | Note block bass |
| `BLOCK_NOTE_BLOCK_PLING` | Note block pling |
| `ENTITY_PLAYER_LEVELUP` | Level up |
| `ITEM_TOTEM_USE` | Totem activation |
| `ENTITY_ENDER_DRAGON_GROWL` | Dragon growl |
| `UI_BUTTON_CLICK` | Button click |

```python
await player.play_sound(Sound.ENTITY_EXPERIENCE_ORB_PICKUP)
await world.play_sound(location, Sound.ENTITY_ENDER_DRAGON_GROWL, volume=2.0)
```

---

## Particle

```python
from bridge import Particle
```

Particle effects.

| Name | Description |
|------|-------------|
| `FLAME` | Fire particles |
| `HEART` | Heart particles |
| `VILLAGER_HAPPY` | Green sparkles |
| `EXPLOSION_LARGE` | Large explosion |
| `REDSTONE` | Redstone dust |
| `SMOKE_NORMAL` | Normal smoke |
| `CRIT` | Critical hit sparkles |
| `SPELL_MOB` | Potion effect swirls |
| `END_ROD` | End rod particles |
| `TOTEM` | Totem of Undying particles |

```python
await world.spawn_particle(Particle.FLAME, location, count=50)
await world.particle_sphere(location, 3.0, Particle.END_ROD)
```

---

## Difficulty

```python
from bridge import Difficulty
```

| Name |
|------|
| `PEACEFUL` |
| `EASY` |
| `NORMAL` |
| `HARD` |

---

## Biome

```python
from bridge import Biome
```

World biomes. Examples: `PLAINS`, `FOREST`, `DESERT`, `OCEAN`, `MOUNTAINS`, `SWAMP`, `JUNGLE`, `TAIGA`, `SAVANNA`, `BADLANDS`, `THE_NETHER`, `THE_END`.

```python
await block.set_biome(Biome.DESERT)
```

---

## BarColor

```python
from bridge import BarColor
```

| Name |
|------|
| `PINK` |
| `BLUE` |
| `RED` |
| `GREEN` |
| `YELLOW` |
| `PURPLE` |
| `WHITE` |

---

## BarStyle

```python
from bridge import BarStyle
```

| Name | Description |
|------|-------------|
| `SOLID` | No segments |
| `SEGMENTED_6` | 6 segments |
| `SEGMENTED_10` | 10 segments |
| `SEGMENTED_12` | 12 segments |
| `SEGMENTED_20` | 20 segments |
PyJavaBridge-2a/docs/src/enumvalue.md000066400000000000000000000046531514752343100177440ustar00rootroot00000000000000---
title: EnumValue
subtitle: Base class for all enum-like types
---

# EnumValue

`EnumValue` is the base class for all Minecraft enum types exposed by the bridge: `Material`, `EntityType`, `Biome`, `EffectType`, `GameMode`, `Sound`, `Particle`, `Difficulty`, `BarColor`, `BarStyle`, and `AttributeType`.

---

## Constructor

```python
EnumValue(type: str, name: str)
```

Create an enum value with a specific type and name. You rarely need this directly — use the subclass attribute syntax instead.

### Parameters

#### type

- **Type:** `str`

The enum type name (e.g. `"Material"`, `"EntityType"`).

#### name

- **Type:** `str`

The enum value name (e.g. `"DIAMOND"`, `"ZOMBIE"`).

---

## Class Methods

### from_name

```python
@classmethod
EnumValue.from_name(name: str) -> EnumValue
```

Create an enum value from a name string. The type is inferred from the subclass.

```python
mat = Material.from_name("DIAMOND")
```

---

## Attributes

### type

- **Type:** `str`

The enum type name.

```python
m = Material.DIAMOND
print(m.type)  # "Material"
```

### name

- **Type:** `str`

The enum value name.

```python
m = Material.DIAMOND
print(m.name)  # "DIAMOND"
```

---

## Attribute Access

All `EnumValue` subclasses support attribute-style access to create values:

```python
Material.DIAMOND          # EnumValue("Material", "DIAMOND")
EntityType.ZOMBIE         # EnumValue("EntityType", "ZOMBIE")
GameMode.CREATIVE         # EnumValue("GameMode", "CREATIVE")
Sound.ENTITY_EXPERIENCE_ORB_PICKUP
Particle.FLAME
Difficulty.HARD
BarColor.RED
BarStyle.SEGMENTED_6
AttributeType.GENERIC_MAX_HEALTH
EffectType.POISON
Biome.PLAINS
```

Name lookup is case-insensitive on the Java side, but by convention use `UPPER_SNAKE_CASE`.

---

## Subclasses

| Class | Description | Example |
|-------|-------------|---------|
| `Material` | Block/item materials | `Material.DIAMOND` |
| `EntityType` | Entity types | `EntityType.ZOMBIE` |
| `Biome` | World biomes | `Biome.PLAINS` |
| `EffectType` | Potion effect types | `EffectType.POISON` |
| `GameMode` | Player game modes | `GameMode.CREATIVE` |
| `Sound` | Minecraft sounds | `Sound.ENTITY_EXPERIENCE_ORB_PICKUP` |
| `Particle` | Particle types | `Particle.FLAME` |
| `Difficulty` | World difficulties | `Difficulty.HARD` |
| `BarColor` | Boss bar colors | `BarColor.RED` |
| `BarStyle` | Boss bar styles | `BarStyle.SEGMENTED_6` |
| `AttributeType` | Entity attribute types | `AttributeType.GENERIC_MAX_HEALTH` |
PyJavaBridge-2a/docs/src/event.md000066400000000000000000000106571514752343100170650ustar00rootroot00000000000000---
title: Event
subtitle: Event proxy and event type mapping
---

# Event

The `Event` class is the proxy object passed to your `@event` handlers. It exposes fields relevant to the specific Bukkit event that fired. Fields that don't apply to the current event type are `None`.

---

## Attributes

### player

- **Type:** [`Player`](player.md) | `None`

The player involved in the event. Available for all player-related events (`player_join`, `player_chat`, `player_interact`, etc.).

```python
@event
async def player_join(e):
    await e.player.send_message(f"Welcome, {e.player.name}!")
```

### entity

- **Type:** [`Entity`](entity.md) | `None`

The entity involved in the event. Available for entity events (`entity_damage`, `entity_death`, etc.).

### block

- **Type:** [`Block`](block.md) | `None`

The block involved in the event. Available for block events (`block_break`, `block_place`, etc.).

### world

- **Type:** [`World`](world.md) | `None`

The world where the event occurred.

### location

- **Type:** [`Location`](location.md) | `None`

The location relevant to the event.

### item

- **Type:** [`Item`](item.md) | `None`

The item involved in the event. Available for interact events, inventory events, etc.

### inventory

- **Type:** [`Inventory`](inventory.md) | `None`

The inventory involved in the event. Available for `inventory_click`, `inventory_close`, etc.

### chunk

- **Type:** [`Chunk`](chunk.md) | `None`

The chunk involved in the event.

### slot

- **Type:** `int`

The inventory slot index for `inventory_click` events.

### damager

- **Type:** [`Entity`](entity.md) | [`Block`](block.md) | `None`

The source of damage for `entity_damage` events. Can be an entity (attacker, projectile) or a block (cactus, lava).

### damage

- **Type:** `float`

The raw damage amount for `entity_damage` events (before armor/enchantment modifiers).

### final_damage

- **Type:** `float`

The final damage after all modifiers for `entity_damage` events.

### damage_cause

- **Type:** `str | None`

The [DamageCause](https://hub.spigotmc.org/javadocs/spigot/org/bukkit/event/entity/EntityDamageEvent.DamageCause.html) for damage events (e.g. `"ENTITY_ATTACK"`, `"FALL"`, `"FIRE"`).

---

## Methods

### cancel

```python
await event.cancel()
```

Cancel the event, preventing its default action. Only works on cancellable events.

- **Returns:** `Awaitable[None]`

```python
@event
async def block_break(e):
    if e.block.type.name == "BEDROCK":
        await e.cancel()
        await e.player.send_message("You can't break bedrock!")
```

---

## Damage Override

For `entity_damage` events, returning a number from the handler overrides the final damage:

```python
@event
async def entity_damage(e):
    if e.damage_cause == "FALL":
        return 0  # Cancel all fall damage
    if e.player:
        return e.damage * 0.5  # Half damage for players
```

---

## Chat Override

For `player_chat` events, returning a string cancels the original message and broadcasts your string instead:

```python
@event
async def player_chat(e):
    return f"[VIP] {e.player.name}: {e.message}"
```

Returning `None` (or not returning) leaves the chat message unchanged.

---

## Event Type Mapping

Events are resolved from handler function names: `snake_case` → `PascalCase` + `Event`.

| Function name | Bukkit event |
|---------------|-------------|
| `player_join` | `PlayerJoinEvent` |
| `player_quit` | `PlayerQuitEvent` |
| `player_chat` | `AsyncPlayerChatEvent` |
| `player_move` | `PlayerMoveEvent` |
| `player_interact` | `PlayerInteractEvent` |
| `block_break` | `BlockBreakEvent` |
| `block_place` | `BlockPlaceEvent` |
| `entity_damage` | `EntityDamageEvent` / `EntityDamageByEntityEvent` |
| `entity_death` | `EntityDeathEvent` |
| `inventory_click` | `InventoryClickEvent` |
| `inventory_close` | `InventoryCloseEvent` |
| `world_load` | `WorldLoadEvent` |
| `weather_change` | `WeatherChangeEvent` |

### Special cases

- **`server_boot`** maps to `ServerLoadEvent`
- **`block_explode`** is dispatched for both `BlockExplodeEvent` and `EntityExplodeEvent`

### Supported packages

The bridge discovers events from all standard Bukkit event packages:

- `org.bukkit.event.player.*`
- `org.bukkit.event.block.*`
- `org.bukkit.event.entity.*`
- `org.bukkit.event.inventory.*`
- `org.bukkit.event.server.*`
- `org.bukkit.event.world.*`
- `org.bukkit.event.weather.*`
- `org.bukkit.event.vehicle.*`
- `org.bukkit.event.hanging.*`
- `org.bukkit.event.enchantment.*`
- `org.bukkit.event.*`
PyJavaBridge-2a/docs/src/examples.md000066400000000000000000000165351514752343100175630ustar00rootroot00000000000000---
title: Examples
subtitle: Complete script examples
---

# Examples

Full working scripts that demonstrate PyJavaBridge features.

---

## Commands & GUI

A script demonstrating commands, raycast teleportation, inventory GUIs, and inventory click events.

```python
from bridge import *

# Simple hello world command
@command("Hello world command")
async def helloworld(event: Event):
    event.player.send_message("Hello, World!")

# Command with arguments
@command("Greet command")
async def greet(event: Event, name: str = None):
    event.player.send_message(f"Hello, {name or event.player.name}!")

# Raycast to find ground level, then teleport
@command("Teleport to spawn")
async def spawn(event: Event):
    ray = await raycast('world', (0.5, 320, 0.5), (0, 90), 384, 0.5, False)
    event.player.teleport((0.5, ray.y + 0.5, 0.5))

# Custom inventory GUI
@command("open test gui")
async def gui(event: Event):
    inv = Inventory(
        3 * 9,
        title="Test GUI",
        contents=[
            Item('light_gray_stained_glass_pane').set_name(" ")
            for _ in range(3 * 9)
        ]
    )
    inv.set_item(9 + 4, Item('totem_of_undying').set_name("Bing chilling"))
    inv.open(event.player)

# Handle clicks in the GUI
@event
async def inventory_click(event: Event):
    if event.inventory.title != 'Test GUI':
        return

    event.cancel()

    if event.slot == 9 + 4:
        event.player.play_sound('item_totem_use')
        event.player.send_message('Bing chilling')
        event.inventory.close()

# Prevent dragging in the GUI
@event
async def inventory_drag(event: Event):
    if event.inventory.title == 'Test GUI':
        event.cancel()

# View another player's inventory
@command("Open someones inv")
async def invsee(event: Event, p: str):
    if p == event.player.name:
        event.player.send_message("You cannot open your own inventory!")
        event.player.play_sound('block_note_block_bass')
        return

    Player(p).inventory.open(event.player)
```

**Concepts demonstrated:**
- [`@command`](decorators.md) with and without arguments
- [`raycast()`](raycast.md) for finding ground level
- [`Inventory`](inventory.md) with custom contents
- [`@event`](decorators.md) for `inventory_click` and `inventory_drag`
- [`Event.cancel()`](event.md#cancel) to prevent default behavior
- [`Player`](player.md) messaging, sounds, and teleportation

---

## Spawn Protection

A script that prevents building near spawn using block events.

```python
from bridge import *

@event
async def load(event: Event):
    server.broadcast("server start")

@event
async def block_break(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.player.send_message("You cannot break blocks there!")
        await event.cancel()

@event
async def block_place(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.player.send_message("You cannot place blocks there!")
        await event.cancel()

@event
async def block_explode(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.cancel()
```

**Concepts demonstrated:**
- [`@event`](decorators.md) for `block_break`, `block_place`, `block_explode`, and `load`
- [`Event.cancel()`](event.md#cancel) to prevent block modification
- [`Event.block`](event.md#block) to access block coordinates
- [`server.broadcast()`](server.md#broadcast) for server-wide messages
- Diamond (taxicab) distance check for a protection zone

---

## Temporary Ban System

A full ban system with configurable durations and persistence.

```python
"""Ban users for customizable amounts of time."""
from humanfriendly import format_timespan
from time import time as time_now
from bridge import *
import re

bans = {}

def parse_time(time: str) -> int:
    """Parse a time string like '1h30m' into seconds."""
    if not time:
        raise ValueError('Time string is required')

    units = {
        's': 1, 'm': 60, 'h': 3600,
        'd': 86400, 'w': 604800,
        'mo': 2592000, 'y': 31536000,
    }

    pattern = re.compile(r'(\d+)(mo|[smhdwy])', re.IGNORECASE)
    total = 0
    time_str = time.strip().lower()
    idx = 0

    for match in pattern.finditer(time_str):
        if match.start() != idx:
            raise ValueError(f"Invalid time format: {time}")
        value = int(match.group(1))
        unit = match.group(2)
        if unit not in units:
            raise ValueError(f"Unknown time unit: {unit}")
        total += value * units[unit]
        idx = match.end()

    if idx != len(time_str):
        raise ValueError(f"Invalid time format: {time}")
    return total

@command('Ban someone for a specified time or permanently')
async def ban(event: Event, user: str, t: str = None, r: str = None):
    global bans

    if not event.player.is_op():
        event.player.send_message('No permission!')
        event.player.play_sound('block_note_block_bass')
        return

    target = Player(user)
    duration = parse_time(t) if t else None
    reason = r or "Ban hammer has spoken!"

    reason_text = (
        f"You have been {'permanently ' if not duration else ''}banned"
        f"{f' for {format_timespan(duration)}' if duration else ''}"
        f"\nReason: {reason}"
    )

    await target.kick(reason_text)
    bans[target.uuid] = (time_now() + duration if duration else None, reason)

    event.player.send_message(
        f"{user} has been {'permanently ' if not duration else ''}banned"
        f"{f' for {format_timespan(duration)}' if duration else ''}"
    )

@command('Unban someone')
async def unban(event: Event, user: str):
    global bans

    if not event.player.is_op():
        event.player.send_message('No permission!')
        event.player.play_sound('block_note_block_bass')
        return

    target = Player(user)
    if target.uuid not in bans:
        event.player.send_message("That user is not banned")
        event.player.play_sound('block_note_block_bass')
        return

    bans.pop(target.uuid)
    event.player.send_message(f"{user} has been unbanned.")

@event
async def player_join(event: Event):
    global bans
    uuid = event.player.uuid

    if uuid not in bans:
        return

    time, reason = bans[uuid]
    if time:
        time -= time_now()

    if time and time <= 0:
        bans.pop(uuid)
        return

    event.player.kick(
        f"You have been {'permanently ' if not time else ''}banned"
        f"{f' for {format_timespan(time)}' if time else ''}"
        f"\nReason: {reason}"
    )
```

**Concepts demonstrated:**
- [`@command`](decorators.md) with multiple optional arguments
- [`Player`](player.md) creation by name for offline lookups
- [`Player.kick()`](player.md#kick) with a formatted reason
- [`Player.is_op`](player.md#is_op) for permission checking
- [`@event`](decorators.md) for `player_join` to enforce bans on login
- Python standard library usage (`re`, `time`)
- Third-party library usage (`humanfriendly`)
- State management with a global dictionary

---

## Tips for Writing Scripts

1. **Always import from bridge:** `from bridge import *`
2. **Use async/await:** Most bridge methods return awaitables
3. **Name your event handlers after the event:** `async def block_break(event)` handles `block_break` events
4. **Commands auto-register:** The function name becomes the command name
5. **Cancel events to prevent default behavior:** `await event.cancel()`
6. **Use the [`Config`](config.md) class for persistence** instead of global dictionaries
PyJavaBridge-2a/docs/src/exceptions.md000066400000000000000000000032241514752343100201150ustar00rootroot00000000000000---
title: Exceptions
subtitle: Error types raised by the bridge
---

# Exceptions

The bridge defines a small exception hierarchy for errors that originate from the Java side.

---

## BridgeError

```python
class BridgeError(Exception)
```

Base exception for all bridge-related errors. Catch this to handle any error that comes from the Java ↔ Python communication layer.

```python
try:
    await entity.teleport(location)
except BridgeError as e:
    print(f"Bridge call failed: {e}")
```

---

## EntityGoneException

```python
class EntityGoneException(BridgeError)
```

Raised when you try to interact with an entity that no longer exists on the server. This happens when:

- The entity was killed or removed between when you got the reference and when you used it.
- The entity's chunk was unloaded.
- The entity despawned naturally.

```python
from bridge import *

@event
async def entity_damage(e):
    await server.after(20)  # Wait 1 second
    try:
        await e.entity.set_fire_ticks(100)
    except EntityGoneException:
        # Entity died or despawned during the wait
        pass
```

### When to expect it

Any awaitable method on `Entity` or `Player` can raise `EntityGoneException` if the underlying Java entity has been garbage collected. This is especially common when:

- You store entity references across ticks
- You use `server.after()` between getting a reference and using it
- You handle events where the entity might die (e.g. `entity_damage`)

### Best practice

If you need to use an entity reference after a delay, check `is_valid` first or wrap the call in a try/except:

```python
if entity.is_valid:
    await entity.teleport(location)
```
PyJavaBridge-2a/docs/src/hologram.md000066400000000000000000000067271514752343100175570ustar00rootroot00000000000000---
title: Hologram
subtitle: Floating text displays
---

# Hologram

A `Hologram` is a floating text display entity. It supports multiple lines, configurable billboard mode, and can be moved or removed.

Uses display entities (1.19.4+) internally for crisp rendering.

---

## Constructor

```python
Hologram(location, *lines, billboard="CENTER")
```

Create and spawn a hologram.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Where to spawn the hologram.
  - `*lines` (`str`) — Text lines to display. Supports `§` color codes.
  - `billboard` (`str`) — Billboard mode. Default `"CENTER"`.

| Billboard | Description |
|-----------|-------------|
| `"CENTER"` | Always faces the player (default) |
| `"FIXED"` | Fixed orientation |
| `"HORIZONTAL"` | Only rotates horizontally |
| `"VERTICAL"` | Only rotates vertically |

```python
holo = Hologram(
    Location(100, 70, 200, "world"),
    "§6§lWelcome!",
    "§7to our server",
    billboard="CENTER"
)
```

---

## Attributes

### billboard

- **Type:** `str`

Current billboard mode.

### see_through

- **Type:** `bool`

Whether the text can be seen through blocks. Default `False`.

### shadowed

- **Type:** `bool`

Whether the text has a shadow. Default `True` for most setups.

### alignment

- **Type:** `str`

Text alignment: `"CENTER"`, `"LEFT"`, or `"RIGHT"`.

### line_width

- **Type:** `int`

Maximum line width in pixels before wrapping.

### background

- **Type:** `int | None`

Background color as an ARGB integer, or `None` for default.

---

## Line Access

Hologram supports index-based access for lines using `[]` notation.

### Set a line

```python
holo[index] = text
```

### Get a line

```python
text = holo[index]
```

### Delete a line

```python
del holo[index]
```

### Get line count

```python
count = len(holo)
```

### Append a line

```python
holo.append(text)
```

Add a new line to the bottom.

- **Parameters:**
  - `text` (`str`) — Line text.

---

## Methods

### teleport

```python
holo.teleport(location)
```

Move the hologram to a new location. This is synchronous.

- **Parameters:**
  - `location` ([`Location`](location.md)) — New position.

```python
holo.teleport(Location(100, 75, 200, "world"))
```

### remove

```python
holo.remove()
```

Despawn and destroy the hologram. This is synchronous.

---

## Example: Welcome hologram

```python
from bridge import *

spawn = Location(0, 65, 0, "world")
welcome = Hologram(
    spawn,
    "§6§l✦ My Server ✦",
    "",
    "§fType §a/help §fto get started",
    "§7play.example.com"
)
```

## Example: Dynamic leaderboard

```python
from bridge import *

lb_loc = Location(50, 70, 50, "world")
leaderboard = Hologram(lb_loc, "§e§lTop Kills", "§7Loading...")

kills = {}

@event
async def entity_death(e: Event):
    d = e.damager
    if d and hasattr(d, 'name'):
        kills[d.name] = kills.get(d.name, 0) + 1
        # Update hologram
        sorted_kills = sorted(kills.items(), key=lambda x: -x[1])[:5]
        leaderboard[0] = "§e§l⚔ Top Kills ⚔"
        for i, (name, count) in enumerate(sorted_kills):
            leaderboard[i + 1] = f"§f#{i+1} §a{name} §7- §e{count}"
```

## Example: Per-player welcome

```python
from bridge import *

holograms = {}

@event
async def player_join(e: Event):
    p = e.player
    loc = p.location.add(0, 2.5, 0)
    holograms[p.name] = Hologram(loc, f"§aWelcome, {p.name}!")

@event
async def player_quit(e: Event):
    h = holograms.pop(e.player.name, None)
    if h:
        h.remove()
```
PyJavaBridge-2a/docs/src/imagedisplay.md000066400000000000000000000031501514752343100204020ustar00rootroot00000000000000---
title: ImageDisplay
subtitle: Image rendering in-world
---

# ImageDisplay

An `ImageDisplay` renders an image file as a display entity in the world. It converts image pixels to colored map-like displays.

---

## Constructor

```python
ImageDisplay(location, image_path, pixel_size=..., dual_sided=False, dual_side_mode="mirror")
```

Create and spawn an image display.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Spawn position.
  - `image_path` (`str`) — Path to the image file (relative to plugin data folder, or absolute).
  - `pixel_size` (`float`) — Size of each pixel in blocks. Smaller = more detail but more entities.
  - `dual_sided` (`bool`) — Whether the image is visible from both sides. Default `False`.
  - `dual_side_mode` (`str`) — How the back side renders. Default `"mirror"`.

| dual_side_mode | Description |
|----------------|-------------|
| `"mirror"` | Back side is a mirror image |

```python
display = ImageDisplay(
    Location(100, 70, 200, "world"),
    "images/logo.png",
    pixel_size=0.1,
    dual_sided=True
)
```

---

## Methods

### teleport

```python
display.teleport(location)
```

Move the display. This is synchronous.

- **Parameters:**
  - `location` ([`Location`](location.md)) — New position.

### remove

```python
display.remove()
```

Despawn and destroy the display. This is synchronous.

---

## Notes

- Large images with small `pixel_size` can create many display entities and impact performance
- Supported formats depend on the Java ImageIO library (PNG, JPEG, GIF, BMP)
- Place the image files in the plugin's data folder or use an absolute path
PyJavaBridge-2a/docs/src/index.md000066400000000000000000000104051514752343100170420ustar00rootroot00000000000000---
title: PyJavaBridge
page_title: QuickStart
og_title: Home
subtitle: Expose Bukkit APIs to Python scripts via easy-to-use wrappers
---

# PyJavaBridge

PyJavaBridge is a Minecraft server plugin that lets you write **Python scripts** that interact with the Bukkit/Spigot/Paper API through a high-level async bridge. Every API call is asynchronous under the hood — you write clean `async`/`await` Python and the bridge handles the Java ↔ Python communication transparently.

## Quick Start

```python
from bridge import *

@command("Say hello")
async def hello(event: Event):
    await event.player.send_message("Hello from Python!")
```

Drop your `.py` file into the server's `scripts/` folder and reload. The bridge discovers your `@command` and `@event` handlers automatically.

## Key Features

- **Full Bukkit API** — Players, worlds, blocks, entities, inventories, scoreboards, boss bars, advancements, and more.
- **Async by default** — All Java calls are awaitable. Use `async`/`await` naturally.
- **Decorator-driven** — Register commands, events, and repeating tasks with simple decorators.
- **Helper classes** — `ItemBuilder`, `Sidebar`, `Hologram`, `Menu`, `Cooldown`, `Config`, and display entities for common patterns.
- **Region utilities** — Fill, replace, and shape operations on the world (spheres, cylinders, lines).
- **Particle shapes** — Draw particle lines, spheres, cubes, and rings with one call.
- **Permission integration** — LuckPerms-aware permission and group management.
- **Tab list control** — Full control over player tab list headers, footers, and display names.

## Pages

### Decorators & Core

| Page | Description |
|------|-------------|
| [Decorators](decorators.md) | `@event`, `@command`, `@task` |
| [Exceptions](exceptions.md) | `BridgeError`, `EntityGoneException` |
| [EnumValue](enumvalue.md) | Base class for all enum types |
| [Event](event.md) | Event proxy and event types |

### Server & Entities

| Page | Description |
|------|-------------|
| [Server](server.md) | Global server API |
| [Entity](entity.md) | Base entity proxy |
| [Player](player.md) | Player API (extends Entity) |

### World & Space

| Page | Description |
|------|-------------|
| [World](world.md) | World API, region utilities, particle shapes, spawn helpers |
| [Location](location.md) | 3D position with world, yaw, and pitch |
| [Block](block.md) | Block in the world |
| [Chunk](chunk.md) | World chunk loading/unloading |
| [Vector](vector.md) | 3D vector |

### Items & Inventory

| Page | Description |
|------|-------------|
| [Item](item.md) | ItemStack API |
| [ItemBuilder](itembuilder.md) | Fluent item construction |
| [Inventory](inventory.md) | Inventory management |
| [Material](enums.md#material) | Material enum |

### Effects & Attributes

| Page | Description |
|------|-------------|
| [Effect](effect.md) | Potion effects |
| [Potion](potion.md) | Legacy potion API |
| [Attribute](attribute.md) | Entity attributes |

### Scoreboards & UI

| Page | Description |
|------|-------------|
| [BossBar](bossbar.md) | Boss bar API |
| [Scoreboard](scoreboard.md) | Scoreboard API |
| [Team](team.md) | Team API |
| [Objective](objective.md) | Objective API |
| [Sidebar](sidebar.md) | Sidebar helper |
| [Advancement](advancement.md) | Advancement API |

### Helpers

| Page | Description |
|------|-------------|
| [Config](config.md) | Configuration files (TOML, JSON, properties) |
| [Cooldown](cooldown.md) | Per-player cooldowns |
| [Hologram](hologram.md) | Floating text entities |
| [Menu](menu.md) | Chest GUI builder |
| [ActionBarDisplay](actionbardisplay.md) | Persistent action bar messages |
| [BossBarDisplay](bossbardisplay.md) | Boss bar wrapper with cooldown linking |

### Display Entities

| Page | Description |
|------|-------------|
| [BlockDisplay](blockdisplay.md) | Block display entity |
| [ItemDisplay](itemdisplay.md) | Item display entity |
| [ImageDisplay](imagedisplay.md) | Pixel art display |

### Utilities

| Page | Description |
|------|-------------|
| [Raycast](raycast.md) | Ray tracing in the world |
| [Chat](chat.md) | Chat broadcast helper |
| [Reflect](reflect.md) | Java reflection access |
| [Enums](enums.md) | All enum types |

### Examples

| Page | Description |
|------|-------------|
| [Examples](examples.md) | Full script examples |
PyJavaBridge-2a/docs/src/inventory.md000066400000000000000000000100311514752343100177630ustar00rootroot00000000000000---
title: Inventory
subtitle: Container and GUI API
---

# Inventory

An `Inventory` represents a chest-like container that can be opened as a GUI for players. Use it for custom menus, storage views, or item manipulation.

---

## Constructor

```python
Inventory(size=9, title="", contents=None)
```

Create a new inventory.

- **Parameters:**
  - `size` (`int`) — Number of slots. Must be a multiple of 9 (9, 18, 27, 36, 45, 54). Default 9.
  - `title` (`str`) — Display title shown when opened. Supports `§` color codes. Default `""`.
  - `contents` (`list[`[`Item`](item.md)`] | None`) — Initial items. Default `None` (empty).

```python
gui = Inventory(27, "§6Rewards Chest")
```

---

## Attributes

### size

- **Type:** `int`

Total number of slots.

### contents

- **Type:** `list[`[`Item`](item.md)`]`

List of items in the inventory. Empty slots are `None`.

### holder

- **Type:** `Any`

The holder of this inventory (player, chest block, etc.), or `None` for virtual inventories.

### title

- **Type:** `str`

Display title of the inventory.

### first_empty

- **Type:** `int`

Index of the first empty slot, or `-1` if the inventory is full.

---

## Methods

### open

```python
await inventory.open(player)
```

Open this inventory as a GUI for a player.

- **Parameters:**
  - `player` ([`Player`](player.md)) — The player who will see the GUI.
- **Returns:** `Awaitable[Any]`

```python
gui = Inventory(27, "§bShop")
gui_contents = [Item("DIAMOND", name="§bBuy Diamond")]
await gui.open(player)
```

### close

```python
await inventory.close(player=None)
```

Close this inventory for a player.

- **Parameters:**
  - `player` ([`Player`](player.md) `| None`) — The player to close for, or `None` to close for all viewers.
- **Returns:** `Awaitable[Any]`

### add_item

```python
await inventory.add_item(item)
```

Add an item to the first available slot.

- **Parameters:**
  - `item` ([`Item`](item.md)) — The item to add.
- **Returns:** `Awaitable[Any]` — Any items that didn't fit.

```python
await inventory.add_item(Item("DIAMOND", 64))
```

### remove_item

```python
await inventory.remove_item(item)
```

Remove an item from the inventory.

- **Parameters:**
  - `item` ([`Item`](item.md)) — The item to remove.
- **Returns:** `Awaitable[Any]` — Any items that couldn't be removed.

### get_item

```python
item = await inventory.get_item(slot)
```

Get the item in a specific slot.

- **Parameters:**
  - `slot` (`int`) — Slot index (0-based).
- **Returns:** `Awaitable[`[`Item`](item.md)`]` — The item, or `None` if empty.

### set_item

```python
await inventory.set_item(slot, item)
```

Set the item in a specific slot.

- **Parameters:**
  - `slot` (`int`) — Slot index (0-based).
  - `item` ([`Item`](item.md)) — The item to place.
- **Returns:** `Awaitable[None]`

```python
await inventory.set_item(13, Item("NETHER_STAR", name="§eSpecial"))
```

### contains

```python
result = await inventory.contains(material, amount=1)
```

Check if the inventory contains at least `amount` of the given material.

- **Parameters:**
  - `material` ([`Material`](enums.md)) — Material to check for.
  - `amount` (`int`) — Minimum amount. Default 1.
- **Returns:** `Awaitable[bool]`

### clear

```python
await inventory.clear()
```

Remove all items from the inventory.

- **Returns:** `Awaitable[None]`

---

## Example: Custom GUI

```python
from bridge import *

@command("Open a shop GUI")
async def shop(player: Player, args: list[str]):
    gui = Inventory(27, "§6§lItem Shop")

    # Set border
    for i in range(27):
        if i < 9 or i >= 18 or i % 9 == 0 or i % 9 == 8:
            await gui.set_item(i, Item("GRAY_STAINED_GLASS_PANE", name=" "))

    # Set shop items
    await gui.set_item(11, Item("DIAMOND_SWORD", name="§bSword §7- §a$100"))
    await gui.set_item(13, Item("DIAMOND_CHESTPLATE", name="§bArmor §7- §a$500"))
    await gui.set_item(15, Item("GOLDEN_APPLE", name="§6Apple §7- §a$50"))

    await gui.open(player)
```

> **Tip:** For a higher-level GUI system with click handlers, see the [`Menu`](menu.md) class.
PyJavaBridge-2a/docs/src/item.md000066400000000000000000000077711514752343100167050ustar00rootroot00000000000000---
title: Item
subtitle: ItemStack API
---

# Item

An `Item` represents a Minecraft item stack with material, amount, name, lore, and NBT data.

---

## Constructor

```python
Item(material=None, amount=1, name=None, lore=None, custom_model_data=None, attributes=None, nbt=None)
```

Create an item.

- **Parameters:**
  - `material` ([`Material`](enums.md) `| str | None`) — Item material.
  - `amount` (`int`) — Stack size. Default 1.
  - `name` (`str | None`) — Display name. Supports `§` color codes.
  - `lore` (`list[str] | None`) — Lore lines.
  - `custom_model_data` (`int | None`) — Custom model data for resource packs.
  - `attributes` (`list[dict] | None`) — Attribute modifiers.
  - `nbt` (`dict | None`) — Raw NBT data.

```python
sword = Item("DIAMOND_SWORD", name="§bFrostbrand", lore=["§7A blade of ice"])
blocks = Item(Material.STONE, amount=64)
```

---

## Class Methods

### drop

```python
entity = await Item.drop(material, location, amount=1, **kwargs)
```

Drop an item entity at a location.

- **Parameters:**
  - `material` ([`Material`](enums.md) `| str`) — Item material.
  - `location` ([`Location`](location.md)) — Where to drop.
  - `amount` (`int`) — Stack size. Default 1.
  - `**kwargs` — Additional item properties.
- **Returns:** `Awaitable[`[`Entity`](entity.md)`]` — The dropped item entity.

```python
await Item.drop("DIAMOND", player.location, amount=5)
```

### give

```python
await Item.give(player, material, amount=1, **kwargs)
```

Give an item directly to a player's inventory.

- **Parameters:**
  - `player` ([`Player`](player.md)) — The recipient.
  - `material` ([`Material`](enums.md) `| str`) — Item material.
  - `amount` (`int`) — Stack size. Default 1.
  - `**kwargs` — Additional item properties.
- **Returns:** `Awaitable[None]`

```python
await Item.give(player, "GOLDEN_APPLE", 3)
```

---

## Attributes

### type

- **Type:** [`Material`](enums.md)

The item's material type.

### amount

- **Type:** `int`

Current stack size.

### name

- **Type:** `str | None`

Display name, or `None` for the default name.

### lore

- **Type:** `list[str]`

Lore lines displayed below the item name.

### custom_model_data

- **Type:** `int | None`

Custom model data value for resource packs.

### attributes

- **Type:** `list[dict]`

Attribute modifiers (attack damage, armor, etc.).

### nbt

- **Type:** `dict`

The item's NBT data as a dictionary.

### max_stack_size

- **Type:** `int`

Maximum stack size for this item type (e.g. 64 for blocks, 16 for ender pearls, 1 for tools).

---

## Methods

### set_amount

```python
await item.set_amount(value)
```

Set the stack size.

- **Parameters:**
  - `value` (`int`) — New amount.
- **Returns:** `Awaitable[None]`

### set_name

```python
await item.set_name(name)
```

Set the display name.

- **Parameters:**
  - `name` (`str`) — Name text. Supports `§` color codes.
- **Returns:** `Awaitable[None]`

### set_lore

```python
await item.set_lore(lore)
```

Set the lore lines.

- **Parameters:**
  - `lore` (`list[str]`) — List of lore lines.
- **Returns:** `Awaitable[None]`

### set_custom_model_data

```python
await item.set_custom_model_data(value)
```

Set custom model data.

- **Parameters:**
  - `value` (`int`) — Model data value.
- **Returns:** `Awaitable[None]`

### set_attributes

```python
await item.set_attributes(attributes)
```

Set attribute modifiers.

- **Parameters:**
  - `attributes` (`list[dict]`) — Attribute modifier list.
- **Returns:** `Awaitable[None]`

### set_nbt

```python
await item.set_nbt(nbt)
```

Set raw NBT data.

- **Parameters:**
  - `nbt` (`dict`) — NBT data dictionary.
- **Returns:** `Awaitable[None]`

### clone

```python
copy = await item.clone()
```

Create a deep copy of this item.

- **Returns:** `Awaitable[`[`Item`](#)`]`

### is_similar

```python
result = await item.is_similar(other)
```

Check if two items are similar (same type, name, lore — ignoring amount).

- **Parameters:**
  - `other` ([`Item`](#)) — The item to compare.
- **Returns:** `Awaitable[bool]`
PyJavaBridge-2a/docs/src/itembuilder.md000066400000000000000000000077451514752343100202550ustar00rootroot00000000000000---
title: ItemBuilder
subtitle: Fluent item construction
---

# ItemBuilder

A fluent builder for constructing [`Item`](item.md) objects. Every setter method returns `self`, allowing chained calls.

---

## Constructor

```python
ItemBuilder(material)
```

Start building an item with the given material.

- **Parameters:**
  - `material` ([`Material`](enums.md) `| str`) — Item material.

```python
sword = (
    ItemBuilder("DIAMOND_SWORD")
    .name("§6Excalibur")
    .lore("§7Legendary blade", "§7of kings")
    .enchant("SHARPNESS", 5)
    .unbreakable()
    .glow()
    .build()
)
```

---

## Class Methods

### from_item

```python
builder = ItemBuilder.from_item(item)
```

Create a builder pre-filled with settings from an existing item.

- **Parameters:**
  - `item` ([`Item`](item.md)) — Existing item to copy.
- **Returns:** [`ItemBuilder`](#)

```python
builder = ItemBuilder.from_item(existing_item)
upgraded = builder.enchant("SHARPNESS", 10).build()
```

---

## Chain Methods

All chain methods return the builder, so you can chain them:

```python
item = (
    ItemBuilder("IRON_CHESTPLATE")
    .name("§bFrost Armor")
    .lore("§7Chills attackers")
    .enchant("PROTECTION", 4)
    .enchant("THORNS", 3)
    .unbreakable()
    .custom_model_data(1001)
    .add_attribute("GENERIC_ARMOR", 12, "ADD_NUMBER")
    .flag("HIDE_ENCHANTS", "HIDE_ATTRIBUTES")
    .build()
)
```

### amount

```python
builder.amount(n)
```

Set the stack size.

- **Parameters:**
  - `n` (`int`) — Stack amount.

### name

```python
builder.name(n)
```

Set the display name.

- **Parameters:**
  - `n` (`str`) — Display name. Supports `§` color codes.

### lore

```python
builder.lore(*lines)
```

Set lore lines (replaces any existing lore).

- **Parameters:**
  - `*lines` (`str`) — One or more lore lines.

### add_lore

```python
builder.add_lore(line)
```

Append a single lore line.

- **Parameters:**
  - `line` (`str`) — Lore line to add.

### enchant

```python
builder.enchant(enchantment, level=1)
```

Add an enchantment.

- **Parameters:**
  - `enchantment` (`str`) — Enchantment name (e.g. `"SHARPNESS"`, `"PROTECTION"`).
  - `level` (`int`) — Enchantment level. Default 1.

### unbreakable

```python
builder.unbreakable(value=True)
```

Set the unbreakable flag.

- **Parameters:**
  - `value` (`bool`) — Whether the item is unbreakable. Default `True`.

### glow

```python
builder.glow(value=True)
```

Add a glow effect (enchantment glint without visible enchantments).

- **Parameters:**
  - `value` (`bool`) — Whether to add glow. Default `True`.

### custom_model_data

```python
builder.custom_model_data(value)
```

Set custom model data for resource packs.

- **Parameters:**
  - `value` (`int`) — Model data value.

### attributes

```python
builder.attributes(attrs)
```

Set attribute modifiers (replaces any existing).

- **Parameters:**
  - `attrs` (`list[dict[str, Any]]`) — Attribute modifier list.

### add_attribute

```python
builder.add_attribute(attribute, amount, operation="ADD_NUMBER")
```

Add a single attribute modifier.

- **Parameters:**
  - `attribute` (`str`) — Attribute name (e.g. `"GENERIC_ARMOR"`, `"GENERIC_ATTACK_DAMAGE"`).
  - `amount` (`float`) — Modifier amount.
  - `operation` (`str`) — Operation type. Default `"ADD_NUMBER"`. Options: `"ADD_NUMBER"`, `"ADD_SCALAR"`, `"MULTIPLY_SCALAR_1"`.

### nbt

```python
builder.nbt(data)
```

Set raw NBT data.

- **Parameters:**
  - `data` (`dict[str, Any]`) — NBT data dictionary.

### flag

```python
builder.flag(*flags)
```

Add item flags to hide information from the tooltip.

- **Parameters:**
  - `*flags` (`str`) — Flag names: `"HIDE_ENCHANTS"`, `"HIDE_ATTRIBUTES"`, `"HIDE_UNBREAKABLE"`, `"HIDE_DESTROYS"`, `"HIDE_PLACED_ON"`, `"HIDE_DYE"`.

---

## build

```python
item = builder.build()
```

Construct the final [`Item`](item.md) from the builder state.

- **Returns:** [`Item`](item.md)

> **Note:** `build()` is synchronous. The resulting `Item` can be used immediately in inventory operations, give, drop, etc.
PyJavaBridge-2a/docs/src/itemdisplay.md000066400000000000000000000032671514752343100202670ustar00rootroot00000000000000---
title: ItemDisplay
subtitle: Item display entity
---

# ItemDisplay

An `ItemDisplay` renders an item as a display entity in the world (1.19.4+). Unlike dropped items, display entities don't have physics, don't despawn, and can use billboard modes.

---

## Constructor

```python
ItemDisplay(location, item, billboard="FIXED")
```

Create and spawn an item display entity.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Spawn position.
  - `item` ([`Item`](item.md) `| str`) — The item to display. If a string, interprets as a material name.
  - `billboard` (`str`) — Billboard mode. Default `"FIXED"`.

| Billboard | Description |
|-----------|-------------|
| `"FIXED"` | No rotation (default) |
| `"CENTER"` | Always faces the player |
| `"HORIZONTAL"` | Only rotates horizontally |
| `"VERTICAL"` | Only rotates vertically |

```python
display = ItemDisplay(
    Location(100, 70, 200, "world"),
    Item("DIAMOND_SWORD", name="§bExcalibur"),
    billboard="CENTER"
)
```

---

## Attributes

### billboard

- **Type:** `str`

Current billboard mode.

---

## Methods

### teleport

```python
display.teleport(location)
```

Move the display entity. This is synchronous.

- **Parameters:**
  - `location` ([`Location`](location.md)) — New position.

### remove

```python
display.remove()
```

Despawn and destroy the display entity. This is synchronous.

---

## Example: Floating reward indicator

```python
from bridge import *

@command("Show reward")
async def reward(player: Player, args: list[str]):
    loc = player.location.add(0, 2, 0)
    display = ItemDisplay(loc, "NETHER_STAR", billboard="CENTER")
    await player.send_message("§e⭐ Reward available above you!")
```
PyJavaBridge-2a/docs/src/location.md000066400000000000000000000052631514752343100175510ustar00rootroot00000000000000---
title: Location
subtitle: 3D position with world reference, yaw, and pitch
---

# Location

A `Location` represents a position in a world with rotation angles. It is used for teleportation, block lookups, spawning, and spatial calculations.

---

## Constructor

```python
Location(x=0.0, y=0.0, z=0.0, world=None, yaw=0.0, pitch=0.0)
```

Create a new location.

- **Parameters:**
  - `x` (`float`) — X coordinate. Default 0.
  - `y` (`float`) — Y coordinate. Default 0.
  - `z` (`float`) — Z coordinate. Default 0.
  - `world` ([`World`](world.md) `| str | None`) — World reference or name. Default `None`.
  - `yaw` (`float`) — Horizontal rotation in degrees. Default 0.
  - `pitch` (`float`) — Vertical rotation in degrees. Default 0. Negative = looking up.

```python
loc = Location(100, 64, -200, "world")
loc = Location(0, 64, 0, "world_nether", yaw=90, pitch=-45)
```

---

## Attributes

### x

- **Type:** `float`

X coordinate (East-West).

### y

- **Type:** `float`

Y coordinate (altitude).

### z

- **Type:** `float`

Z coordinate (North-South).

### world

- **Type:** [`World`](world.md)

The world this location is in.

### yaw

- **Type:** `float`

Horizontal rotation in degrees. 0 = South, 90 = West, 180 = North, 270 = East.

### pitch

- **Type:** `float`

Vertical rotation in degrees. 0 = level, -90 = straight up, 90 = straight down.

---

## Methods

### add

```python
new_loc = location.add(x, y, z)
```

Create a new location with the given offsets added. **This is synchronous** — no `await` needed.

- **Parameters:**
  - `x` (`float`) — X offset.
  - `y` (`float`) — Y offset.
  - `z` (`float`) — Z offset.
- **Returns:** [`Location`](#) — A new location (the original is not modified).

```python
above = player.location.add(0, 2, 0)
```

### clone

```python
copy = location.clone()
```

Create an independent copy of this location. **Synchronous.**

- **Returns:** [`Location`](#)

### distance

```python
d = location.distance(other)
```

Calculate the Euclidean distance to another location. **Synchronous.**

- **Parameters:**
  - `other` ([`Location`](#)) — The other location.
- **Returns:** `float`

```python
dist = player.location.distance(spawn_location)
if dist < 10:
    await player.send_message("You're near spawn!")
```

### distance_squared

```python
d2 = location.distance_squared(other)
```

Calculate the squared distance to another location. **Synchronous.** Faster than `distance()` when you only need to compare distances (avoids square root).

- **Parameters:**
  - `other` ([`Location`](#)) — The other location.
- **Returns:** `float`

```python
# More efficient than: if loc.distance(other) < 10
if loc.distance_squared(other) < 100:
    ...
```
PyJavaBridge-2a/docs/src/menu.md000066400000000000000000000107321514752343100167020ustar00rootroot00000000000000---
title: Menu
subtitle: GUI menu system
---

# Menu

`Menu` is a high-level inventory GUI system with click handlers. It wraps [`Inventory`](inventory.md) with per-slot click callbacks using [`MenuItem`](#menuitem).

---

## Constructor

```python
Menu(title="", rows=3)
```

Create a menu.

- **Parameters:**
  - `title` (`str`) — Title displayed at the top. Supports `§` color codes.
  - `rows` (`int`) — Number of rows (1–6). Each row has 9 slots. Default 3.

```python
shop = Menu("§6§lItem Shop", rows=3)
```

---

## Attributes

### title

- **Type:** `str`

Menu title.

### rows

- **Type:** `int`

Number of rows.

---

## Slot Access

Menu supports index-based access using `[]` notation.

### Set a slot

```python
menu[slot] = menu_item
```

- **Parameters:**
  - `slot` (`int`) — Slot index (0-based, left-to-right, top-to-bottom).
  - `menu_item` ([`MenuItem`](#menuitem)) — Item with click handler.

### Get a slot

```python
item = menu[slot]
```

- **Returns:** [`MenuItem`](#menuitem) `| None`

### Delete a slot

```python
del menu[slot]
```

---

## Methods

### fill_border

```python
menu.fill_border(item)
```

Fill the border slots with a decorative item. This is synchronous.

- **Parameters:**
  - `item` ([`Item`](item.md)) — Item to use for the border.

```python
shop = Menu("§6§lShop", rows=3)
shop.fill_border(Item("GRAY_STAINED_GLASS_PANE", name=" "))
```

### open

```python
menu.open(player)
```

Open this menu for a player. This is synchronous.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to show the menu to.

---

# MenuItem

A `MenuItem` wraps an [`Item`](item.md) with an optional click callback.

## Constructor

```python
MenuItem(item, on_click=None)
```

- **Parameters:**
  - `item` ([`Item`](item.md) `| str`) — The display item. If a string, creates an `Item` with that material.
  - `on_click` (`Callable[[`[`Player`](player.md)`, `[`Event`](event.md)`], Any] | None`) — Click callback. Receives the clicking player and the click event. Default `None`.

```python
# Simple display item
MenuItem(Item("DIAMOND", name="§bShiny"))

# With click handler
MenuItem(
    Item("GOLDEN_APPLE", name="§6Buy Apple §7- §a$50"),
    on_click=lambda player, event: player.send_message("§aPurchased!")
)
```

## Attributes

### item

- **Type:** [`Item`](item.md)

The display item.

### on_click

- **Type:** `Callable[[`[`Player`](player.md)`, `[`Event`](event.md)`], Any] | None`

Click callback.

---

## Example: Shop menu

```python
from bridge import *

async def buy_sword(player, event):
    await Item.give(player, "DIAMOND_SWORD")
    await player.send_message("§aYou bought a Diamond Sword!")

async def buy_armor(player, event):
    await Item.give(player, "DIAMOND_CHESTPLATE")
    await player.send_message("§aYou bought Diamond Armor!")

@command("Open the shop")
async def shop(player: Player, args: list[str]):
    menu = Menu("§6§lItem Shop", rows=3)
    menu.fill_border(Item("BLACK_STAINED_GLASS_PANE", name=" "))

    menu[10] = MenuItem(
        Item("DIAMOND_SWORD", name="§bDiamond Sword", lore=["§7Price: §a$100"]),
        on_click=buy_sword
    )
    menu[12] = MenuItem(
        Item("DIAMOND_CHESTPLATE", name="§bDiamond Armor", lore=["§7Price: §a$500"]),
        on_click=buy_armor
    )
    menu[14] = MenuItem(
        Item("GOLDEN_APPLE", name="§6Golden Apple", lore=["§7Price: §a$50"]),
        on_click=lambda p, e: Item.give(p, "GOLDEN_APPLE")
    )
    menu[16] = MenuItem(
        Item("BARRIER", name="§cClose"),
        on_click=lambda p, e: p.inventory.close()
    )

    menu.open(player)
```

## Example: Confirmation dialog

```python
from bridge import *

def confirm_menu(title, on_confirm, on_cancel):
    menu = Menu(title, rows=3)
    menu.fill_border(Item("GRAY_STAINED_GLASS_PANE", name=" "))

    menu[11] = MenuItem(
        Item("LIME_WOOL", name="§a§lConfirm"),
        on_click=on_confirm
    )
    menu[15] = MenuItem(
        Item("RED_WOOL", name="§c§lCancel"),
        on_click=on_cancel
    )
    return menu

@command("Delete your home")
async def delhome(player: Player, args: list[str]):
    async def confirm(p, e):
        await p.send_message("§aHome deleted!")
        await p.inventory.close()

    async def cancel(p, e):
        await p.send_message("§cCancelled.")
        await p.inventory.close()

    menu = confirm_menu("§c§lDelete Home?", confirm, cancel)
    menu.open(player)
```

> **Tip:** For lower-level inventory control without click handlers, see [`Inventory`](inventory.md).
PyJavaBridge-2a/docs/src/objective.md000066400000000000000000000063701514752343100177130ustar00rootroot00000000000000---
title: Objective
subtitle: Scoreboard objective API
---

# Objective

An `Objective` tracks a score for each player on a [`Scoreboard`](scoreboard.md). Objectives can be displayed in the sidebar, below name tags, or in the tab list.

---

## Class Methods

### create

```python
obj = Objective.create(name, criteria, display_name="", scoreboard=None)
```

Create a new objective. This is synchronous.

- **Parameters:**
  - `name` (`str`) — Internal objective name (unique per scoreboard).
  - `criteria` (`str`) — Score criteria. See [Criteria table](#criteria-types) below.
  - `display_name` (`str`) — Name displayed to players. Default `""`.
  - `scoreboard` ([`Scoreboard`](scoreboard.md) `| None`) — Scoreboard to register on. If `None`, uses the main scoreboard.
- **Returns:** [`Objective`](#)

```python
obj = Objective.create("kills", "dummy", "§6Kill Count")
```

---

## Attributes

### name

- **Type:** `str`

Internal name of the objective.

### criteria

- **Type:** `str`

The criteria type (e.g. `"dummy"`, `"health"`).

### display_slot

- **Type:** `Any`

Current display slot, or `None` if not displayed.

---

## Methods

### set_display_name

```python
await obj.set_display_name(name)
```

Change the display name.

- **Parameters:**
  - `name` (`str`) — New display name. Supports `§` color codes.
- **Returns:** `Awaitable[None]`

### set_display_slot

```python
await obj.set_display_slot(slot)
```

Set where this objective is displayed.

- **Parameters:**
  - `slot` (`Any`) — Display slot. Common values: `"SIDEBAR"`, `"BELOW_NAME"`, `"PLAYER_LIST"`.
- **Returns:** `Awaitable[None]`

```python
await obj.set_display_slot("SIDEBAR")     # Right side of screen
await obj.set_display_slot("BELOW_NAME")  # Under name tags
await obj.set_display_slot("PLAYER_LIST") # In tab list
```

### get_score

```python
score = obj.get_score(entry)
```

Get the score tracker for a player. This is synchronous and returns a score object.

- **Parameters:**
  - `entry` (`str`) — Player name.
- **Returns:** Score object

```python
score = obj.get_score(player.name)
```

---

## Criteria Types

| Criteria | Description |
|----------|-------------|
| `dummy` | Manual scores only — set by commands/plugins |
| `health` | Player health (auto-updated) |
| `playerKillCount` | Player kills (auto-updated) |
| `totalKillCount` | Total kills (auto-updated) |
| `deathCount` | Deaths (auto-updated) |
| `food` | Food level (auto-updated) |
| `air` | Air remaining (auto-updated) |
| `armor` | Armor points (auto-updated) |
| `xp` | XP level (auto-updated) |

---

## Example: Custom sidebar

```python
from bridge import *

board = Scoreboard.create()
sidebar = board.register_objective("display", "dummy", "§6§lMy Server")
await sidebar.set_display_slot("SIDEBAR")

# Set lines (higher score = higher position)
sidebar.get_score("§7───────────").score = 10
sidebar.get_score("§fKills: §a0").score = 9
sidebar.get_score("§fDeaths: §c0").score = 8
sidebar.get_score("§fCoins: §e0").score = 7
sidebar.get_score("§7───────────").score = 6

@event
async def player_join(e: Event):
    await e.player.set_scoreboard(board)
```

> **Tip:** For a simpler sidebar API that handles line management automatically, see [`Sidebar`](sidebar.md).
PyJavaBridge-2a/docs/src/player.md000066400000000000000000000250311514752343100172300ustar00rootroot00000000000000---
title: Player
subtitle: Player API — extends Entity
---

# Player

`Player` extends [`Entity`](entity.md) with player-specific functionality: health, hunger, experience, permissions, inventory, tab list, game mode, and more.

---

## Constructor

```python
Player(uuid: str | None = None, name: str | None = None)
```

Resolve a player by UUID or name. At least one must be provided. The player must be online.

- **Parameters:**
  - `uuid` (`str | None`) — The player's UUID.
  - `name` (`str | None`) — The player's name (case-insensitive lookup).

```python
p = Player(name="Steve")
p = Player(uuid="550e8400-e29b-41d4-a716-446655440000")
```

---

## Attributes

### name

- **Type:** `str`

The player's display name.

### uuid

- **Type:** `str`

The player's UUID.

### location

- **Type:** [`Location`](location.md)

Current player location.

### world

- **Type:** [`World`](world.md)

The world the player is in.

### health

- **Type:** `float`

Current health (0–20 by default, 0 = dead).

### food_level

- **Type:** `int`

Hunger level (0–20, 20 = full).

### game_mode

- **Type:** [`GameMode`](enums.md)

Current game mode (e.g. `GameMode.SURVIVAL`, `GameMode.CREATIVE`).

### inventory

- **Type:** [`Inventory`](inventory.md)

The player's inventory (36 slots + armor + offhand).

### level

- **Type:** `int`

Player experience level (the green number).

### exp

- **Type:** `float`

Experience progress within the current level (0.0 to 1.0).

### is_op

- **Type:** `bool`

Whether the player is a server operator.

### is_flying

- **Type:** `bool`

Whether the player is currently flying.

### is_sneaking

- **Type:** `bool`

Whether the player is sneaking (shift held).

### is_sprinting

- **Type:** `bool`

Whether the player is sprinting.

### scoreboard

- **Type:** [`Scoreboard`](scoreboard.md)

The player's current scoreboard.

### permission_groups

- **Type:** `list[str]`

The player's permission groups. LuckPerms-aware — returns LuckPerms groups if available, otherwise falls back to the basic permission system.

### primary_group

- **Type:** `str | None`

The player's primary permission group (LuckPerms). `None` if LuckPerms is not installed.

### tab_list_header

- **Type:** `str`

The player's tab list header text.

### tab_list_footer

- **Type:** `str`

The player's tab list footer text.

### tab_list_name

- **Type:** `str`

The player's display name in the tab list.

---

## Methods

### send_message

```python
await player.send_message(message)
```

Send a chat message to the player.

- **Parameters:**
  - `message` (`str`) — The message. Supports `§` color codes.
- **Returns:** `Awaitable[None]`

```python
await player.send_message("§aYou found a secret!")
```

### chat

```python
await player.chat(message)
```

Make the player send a chat message (as if they typed it).

- **Parameters:**
  - `message` (`str`) — The message to send.
- **Returns:** `Awaitable[None]`

### kick

```python
await player.kick(reason="")
```

Kick the player from the server.

- **Parameters:**
  - `reason` (`str`) — Kick reason shown to the player. Default empty.
- **Returns:** `Awaitable[None]`

```python
await player.kick("§cYou have been banned!")
```

### teleport

```python
await player.teleport(location)
```

Teleport the player. Inherited from [`Entity`](entity.md).

- **Parameters:**
  - `location` ([`Location`](location.md)) — Destination.
- **Returns:** `Awaitable[None]`

### give_exp

```python
await player.give_exp(amount)
```

Give raw experience points to the player.

- **Parameters:**
  - `amount` (`int`) — XP points to add.
- **Returns:** `Awaitable[None]`

### set_exp

```python
await player.set_exp(exp)
```

Set the experience progress bar within the current level.

- **Parameters:**
  - `exp` (`float`) — Progress from 0.0 to 1.0.
- **Returns:** `Awaitable[None]`

### set_level

```python
await player.set_level(level)
```

Set the player's experience level.

- **Parameters:**
  - `level` (`int`) — The level number.
- **Returns:** `Awaitable[None]`

### set_health

```python
await player.set_health(health)
```

Set the player's health.

- **Parameters:**
  - `health` (`float`) — Health from 0.0 to 20.0 (default max).
- **Returns:** `Awaitable[None]`

### set_food_level

```python
await player.set_food_level(level)
```

Set the player's hunger level.

- **Parameters:**
  - `level` (`int`) — Food level from 0 to 20.
- **Returns:** `Awaitable[None]`

### set_game_mode

```python
await player.set_game_mode(mode)
```

Set the player's game mode.

- **Parameters:**
  - `mode` ([`GameMode`](enums.md)) — The game mode.
- **Returns:** `Awaitable[None]`

```python
await player.set_game_mode(GameMode.CREATIVE)
```

### set_op

```python
await player.set_op(value)
```

Set operator status.

- **Parameters:**
  - `value` (`bool`) — `True` for op, `False` to deop.
- **Returns:** `Awaitable[None]`

### set_flying

```python
await player.set_flying(value)
```

Set flying state. The player must be allowed to fly (creative mode or flight allowed).

- **Parameters:**
  - `value` (`bool`)
- **Returns:** `Awaitable[None]`

### set_sneaking

```python
await player.set_sneaking(value)
```

Force the sneaking state.

- **Parameters:**
  - `value` (`bool`)
- **Returns:** `Awaitable[None]`

### set_sprinting

```python
await player.set_sprinting(value)
```

Force the sprinting state.

- **Parameters:**
  - `value` (`bool`)
- **Returns:** `Awaitable[None]`

### set_walk_speed

```python
await player.set_walk_speed(speed)
```

Set walking speed.

- **Parameters:**
  - `speed` (`float`) — Speed multiplier. Default is 0.2. Range: -1.0 to 1.0.
- **Returns:** `Awaitable[None]`

### set_fly_speed

```python
await player.set_fly_speed(speed)
```

Set flying speed.

- **Parameters:**
  - `speed` (`float`) — Speed multiplier. Default is 0.1. Range: -1.0 to 1.0.
- **Returns:** `Awaitable[None]`

### set_scoreboard

```python
await player.set_scoreboard(scoreboard)
```

Set the player's active scoreboard.

- **Parameters:**
  - `scoreboard` ([`Scoreboard`](scoreboard.md)) — The scoreboard to display.
- **Returns:** `Awaitable[None]`

---

## Effects

### add_effect

```python
await player.add_effect(effect)
```

Apply a potion effect to the player.

- **Parameters:**
  - `effect` ([`Effect`](effect.md)) — The effect to apply.
- **Returns:** `Awaitable[None]`

```python
await player.add_effect(Effect(EffectType.SPEED, duration=200, amplifier=1))
```

### remove_effect

```python
await player.remove_effect(effect_type)
```

Remove an active potion effect.

- **Parameters:**
  - `effect_type` ([`EffectType`](enums.md)) — The effect type to remove.
- **Returns:** `Awaitable[None]`

---

## Sounds & UI

### play_sound

```python
await player.play_sound(sound, volume=1.0, pitch=1.0)
```

Play a sound to the player at their location.

- **Parameters:**
  - `sound` ([`Sound`](enums.md)) — The sound to play.
  - `volume` (`float`) — Volume. Default 1.0.
  - `pitch` (`float`) — Pitch. Default 1.0.
- **Returns:** `Awaitable[None]`

```python
await player.play_sound(Sound.ENTITY_EXPERIENCE_ORB_PICKUP)
await player.play_sound('block_note_block_bass', volume=0.5, pitch=2.0)
```

### send_action_bar

```python
await player.send_action_bar(message)
```

Display a message in the action bar (above the hotbar).

- **Parameters:**
  - `message` (`str`) — The message. Supports `§` color codes.
- **Returns:** `Awaitable[None]`

### send_title

```python
await player.send_title(title, subtitle="", fade_in=10, stay=70, fade_out=20)
```

Display a title and subtitle on the player's screen.

- **Parameters:**
  - `title` (`str`) — The main title text.
  - `subtitle` (`str`) — Subtitle text below the title.
  - `fade_in` (`int`) — Fade-in time in ticks. Default 10 (0.5s).
  - `stay` (`int`) — Display time in ticks. Default 70 (3.5s).
  - `fade_out` (`int`) — Fade-out time in ticks. Default 20 (1s).
- **Returns:** `Awaitable[None]`

```python
await player.send_title("§6Victory!", "§eYou won the game", fade_in=5, stay=40, fade_out=10)
```

---

## Tab List

### set_tab_list_header

```python
await player.set_tab_list_header(header)
```

Set the header text shown above the player list in the tab screen.

- **Parameters:**
  - `header` (`str`) — Header text. Supports `§` color codes and `\n` for multiple lines.
- **Returns:** `Awaitable[None]`

### set_tab_list_footer

```python
await player.set_tab_list_footer(footer)
```

Set the footer text shown below the player list.

- **Parameters:**
  - `footer` (`str`) — Footer text.
- **Returns:** `Awaitable[None]`

### set_tab_list_header_footer

```python
await player.set_tab_list_header_footer(header="", footer="")
```

Set both header and footer in a single call.

- **Parameters:**
  - `header` (`str`) — Header text.
  - `footer` (`str`) — Footer text.
- **Returns:** `Awaitable[None]`

### set_tab_list_name

```python
await player.set_tab_list_name(name)
```

Set the player's display name in the tab list.

- **Parameters:**
  - `name` (`str`) — Display name. Supports `§` color codes.
- **Returns:** `Awaitable[None]`

```python
await player.set_tab_list_name("§c[Admin]§r Steve")
```

---

## Permissions

### has_permission

```python
result = await player.has_permission(permission)
```

Check if the player has a permission node.

- **Parameters:**
  - `permission` (`str`) — The permission node (e.g. `"myplugin.use"`).
- **Returns:** `Awaitable[bool]`

### add_permission

```python
result = await player.add_permission(permission, value=True)
```

Add or set a permission on the player. LuckPerms-aware.

- **Parameters:**
  - `permission` (`str`) — The permission node.
  - `value` (`bool`) — `True` to grant, `False` to negate. Default `True`.
- **Returns:** `Awaitable[bool]`

### remove_permission

```python
result = await player.remove_permission(permission)
```

Remove a permission from the player. LuckPerms-aware.

- **Parameters:**
  - `permission` (`str`) — The permission node to remove.
- **Returns:** `Awaitable[bool]`

### has_group

```python
result = await player.has_group(group)
```

Check if the player belongs to a permission group. **LuckPerms only.**

- **Parameters:**
  - `group` (`str`) — The group name.
- **Returns:** `Awaitable[bool]`

### add_group

```python
result = await player.add_group(group)
```

Add the player to a permission group. **LuckPerms only.**

- **Parameters:**
  - `group` (`str`) — The group name.
- **Returns:** `Awaitable[bool]`

### remove_group

```python
result = await player.remove_group(group)
```

Remove the player from a permission group. **LuckPerms only.**

- **Parameters:**
  - `group` (`str`) — The group name.
- **Returns:** `Awaitable[bool]`
PyJavaBridge-2a/docs/src/potion.md000066400000000000000000000030061514752343100172420ustar00rootroot00000000000000---
title: Potion
subtitle: Legacy potion API
---

# Potion

The `Potion` class provides a legacy interface for applying potion effects. For new code, prefer using [`Effect`](effect.md) directly.

---

## Class Methods

### apply

```python
await Potion.apply(player, effect_type=None, duration=0, amplifier=0, ambient=False, particles=True, icon=True)
```

Apply a potion effect to a player. This is functionally identical to [`Effect.apply`](effect.md#apply).

- **Parameters:**
  - `player` ([`Player`](player.md)) — Target player.
  - `effect_type` ([`EffectType`](enums.md) `| str | None`) — Effect type.
  - `duration` (`int`) — Duration in ticks (20 ticks = 1 second). Default 0.
  - `amplifier` (`int`) — Effect level minus 1. Default 0.
  - `ambient` (`bool`) — Beacon-style translucent particles. Default `False`.
  - `particles` (`bool`) — Show particles. Default `True`.
  - `icon` (`bool`) — Show HUD icon. Default `True`.
- **Returns:** `Awaitable[Any]`

```python
await Potion.apply(player, "POISON", duration=100, amplifier=0)
```

---

## Attributes

### type

- **Type:** `Any`

The potion's effect type.

### level

- **Type:** `int`

The potion level.

---

## Recommendation

Use [`Effect`](effect.md) for all new code:

```python
# Preferred
await Effect.apply(player, "SPEED", duration=600, amplifier=1)

# Legacy (still works)
await Potion.apply(player, "SPEED", duration=600, amplifier=1)
```

Both are equivalent, but `Effect` provides additional methods like `with_duration()` and `with_amplifier()`.
PyJavaBridge-2a/docs/src/raycast.md000066400000000000000000000120711514752343100174020ustar00rootroot00000000000000---
title: Raycast
subtitle: Ray tracing function
---

# raycast

The `raycast` function traces a ray through the world, detecting entities and blocks along the path. Useful for line-of-sight checks, targeting systems, and custom projectiles.

---

## Function Signature

```python
result = await raycast(
    world,
    start,
    direction,
    max_distance=64.0,
    ray_size=0.2,
    include_entities=True,
    include_blocks=True,
    ignore_passable=True
)
```

- **Parameters:**
  - `world` ([`World`](world.md) `| str`) — The world to raycast in.
  - `start` ([`Vector`](vector.md) `| tuple[float,float,float]`) — Ray origin (x, y, z).
  - `direction` (`tuple[float, float]`) — Direction as `(yaw, pitch)` in degrees.
  - `max_distance` (`float`) — Maximum ray distance in blocks. Default 64.0.
  - `ray_size` (`float`) — Ray thickness for entity detection. Default 0.2.
  - `include_entities` (`bool`) — Whether to detect entities. Default `True`.
  - `include_blocks` (`bool`) — Whether to detect blocks. Default `True`.
  - `ignore_passable` (`bool`) — Whether to ignore passable blocks (grass, flowers, etc.). Default `True`.
- **Returns:** `Awaitable[`[`RaycastResult`](#raycastresult)` | None]` — Hit result, or `None` if nothing was hit.

```python
from bridge import *

# Raycast from a player's eye position in their look direction
result = await raycast(
    player.world,
    (player.location.x, player.location.y + 1.62, player.location.z),
    (player.location.yaw, player.location.pitch),
    max_distance=50.0
)

if result:
    if result.entity:
        await player.send_message(f"§aLooking at: {result.entity.type.name}")
    elif result.block:
        await player.send_message(f"§aLooking at block: {result.block.type.name}")
```

---

# RaycastResult

Returned by `raycast()` when a hit occurs.

## Attributes

### x

- **Type:** `float`

X coordinate of the hit point.

### y

- **Type:** `float`

Y coordinate of the hit point.

### z

- **Type:** `float`

Z coordinate of the hit point.

### entity

- **Type:** [`Entity`](entity.md) `| None`

The entity that was hit, or `None` if a block was hit.

### block

- **Type:** [`Block`](block.md) `| None`

The block that was hit, or `None` if an entity was hit.

### start_x

- **Type:** `float`

X coordinate of the ray origin.

### start_y

- **Type:** `float`

Y coordinate of the ray origin.

### start_z

- **Type:** `float`

Z coordinate of the ray origin.

### yaw

- **Type:** `float`

Yaw direction of the ray.

### pitch

- **Type:** `float`

Pitch direction of the ray.

### distance

- **Type:** `float`

Distance from the ray origin to the hit point.

### hit_face

- **Type:** `str | None`

The face of the block that was hit (e.g. `"NORTH"`, `"UP"`), or `None` for entity hits.

---

## Example: Target selector

```python
from bridge import *

@command("Smite what you're looking at")
async def smite(player: Player, args: list[str]):
    loc = player.location
    result = await raycast(
        player.world,
        (loc.x, loc.y + 1.62, loc.z),
        (loc.yaw, loc.pitch),
        max_distance=100.0,
        include_entities=True,
        include_blocks=False
    )

    if result and result.entity:
        hit_loc = Location(result.x, result.y, result.z, player.world.name)
        await player.world.strike_lightning(hit_loc)
        await player.send_message(f"§e⚡ Smited {result.entity.type.name}!")
    else:
        await player.send_message("§cNo entity in sight!")
```

## Example: Build tool

```python
from bridge import *

@command("Place a block where you look")
async def place(player: Player, args: list[str]):
    material = args[0] if args else "STONE"
    loc = player.location
    result = await raycast(
        player.world,
        (loc.x, loc.y + 1.62, loc.z),
        (loc.yaw, loc.pitch),
        max_distance=50.0,
        include_entities=False,
        include_blocks=True
    )

    if result and result.block:
        # Place block on the hit face
        bx, by, bz = int(result.x), int(result.y), int(result.z)
        if result.hit_face == "UP": by += 1
        elif result.hit_face == "DOWN": by -= 1
        elif result.hit_face == "NORTH": bz -= 1
        elif result.hit_face == "SOUTH": bz += 1
        elif result.hit_face == "EAST": bx += 1
        elif result.hit_face == "WEST": bx -= 1

        await player.world.set_block(bx, by, bz, material)
        await player.send_message(f"§aPlaced {material}!")
    else:
        await player.send_message("§cNo block in range!")
```

## Example: Line of sight check

```python
from bridge import *

async def can_see(player, target_location):
    """Check if a player has line of sight to a location."""
    loc = player.location
    # Calculate direction (simplified — yaw/pitch calculation)
    result = await raycast(
        player.world,
        (loc.x, loc.y + 1.62, loc.z),
        (loc.yaw, loc.pitch),
        max_distance=64.0,
        include_entities=False,
        include_blocks=True,
        ignore_passable=True
    )

    if result is None:
        return True  # Nothing blocking
    return result.distance > loc.distance(target_location)
```
PyJavaBridge-2a/docs/src/reflect.md000066400000000000000000000030671514752343100173650ustar00rootroot00000000000000---
title: Reflect
subtitle: Java reflection helper
---

# Reflect

The `Reflect` helper provides access to Java classes for advanced interop. An instance is available as the global `reflect` variable.

> **Warning:** Reflection is a low-level API. Most scripts won't need it. Use the higher-level bridge classes when possible.

---

## Global Instance

```python
from bridge import reflect
```

---

## Methods

### clazz

```python
cls = await reflect.clazz(name)
```

Get a Java class by its fully qualified name.

- **Parameters:**
  - `name` (`str`) — Fully qualified Java class name.
- **Returns:** `Awaitable[Any]` — The Java class object.

```python
# Access Bukkit classes
bukkit = await reflect.clazz("org.bukkit.Bukkit")

# Access NMS (net.minecraft.server) classes
# The exact path depends on server version
nms = await reflect.clazz("net.minecraft.server.MinecraftServer")
```

---

## Use Cases

### Accessing unsupported Bukkit API

If the bridge doesn't wrap a specific Bukkit method, you can access it directly:

```python
bukkit = await reflect.clazz("org.bukkit.Bukkit")
# Call static methods on the class
```

### Checking server internals

```python
server_cls = await reflect.clazz("org.bukkit.Bukkit")
# Useful for debugging or version-specific code
```

---

## Notes

- Reflection accesses the underlying Java runtime — incorrect class names will raise errors
- The available classes depend on the server implementation (Spigot, Paper, etc.)
- NMS class paths change between Minecraft versions
- Prefer using bridge-provided APIs over reflection when possible
PyJavaBridge-2a/docs/src/scoreboard.md000066400000000000000000000054201514752343100200570ustar00rootroot00000000000000---
title: Scoreboard
subtitle: Scoreboard management
---

# Scoreboard

A `Scoreboard` manages objectives and teams. Each player can see one scoreboard at a time — assign a custom scoreboard to show custom sidebar content, name tags, or tab list formatting.

---

## Class Methods

### create

```python
board = Scoreboard.create()
```

Create a new empty scoreboard. This is synchronous.

- **Returns:** [`Scoreboard`](#)

```python
board = Scoreboard.create()
await player.set_scoreboard(board)
```

---

## Attributes

### objectives

- **Type:** `list[`[`Objective`](objective.md)`]`

All objectives registered on this scoreboard.

### teams

- **Type:** `list[`[`Team`](team.md)`]`

All teams registered on this scoreboard.

---

## Methods

### register_objective

```python
objective = board.register_objective(name, criteria, display_name="")
```

Register a new objective. This is synchronous.

- **Parameters:**
  - `name` (`str`) — Internal name (unique per scoreboard).
  - `criteria` (`str`) — Criteria type (e.g. `"dummy"`, `"health"`, `"playerKillCount"`).
  - `display_name` (`str`) — Display name shown in the sidebar/tab. Default `""`.
- **Returns:** [`Objective`](objective.md)

```python
obj = board.register_objective("kills", "dummy", "§c§lKill Count")
```

### get_objective

```python
objective = board.get_objective(name)
```

Get an existing objective by name.

- **Parameters:**
  - `name` (`str`) — Internal objective name.
- **Returns:** [`Objective`](objective.md)

### register_team

```python
team = board.register_team(name)
```

Register a new team. This is synchronous.

- **Parameters:**
  - `name` (`str`) — Internal name (unique per scoreboard).
- **Returns:** [`Team`](team.md)

```python
red_team = board.register_team("red")
await red_team.set_prefix("§c[RED] ")
await red_team.set_color("RED")
```

### get_team

```python
team = board.get_team(name)
```

Get an existing team by name.

- **Parameters:**
  - `name` (`str`) — Internal team name.
- **Returns:** [`Team`](team.md)

### clear_slot

```python
await board.clear_slot(slot)
```

Clear the display in a specific slot.

- **Parameters:**
  - `slot` (`Any`) — Display slot to clear.
- **Returns:** `Awaitable[None]`

---

## Example: Kill counter sidebar

```python
from bridge import *

board = Scoreboard.create()
obj = board.register_objective("kills", "dummy", "§6§lKill Count")
await obj.set_display_slot("SIDEBAR")

@event
async def player_join(e: Event):
    await e.player.set_scoreboard(board)

@event
async def entity_death(e: Event):
    killer = e.damager
    if killer and hasattr(killer, 'name'):
        score = obj.get_score(killer.name)
        # Score tracking happens automatically via the scoreboard API
```

> **See also:** [`Sidebar`](sidebar.md) for a simpler high-level sidebar helper.
PyJavaBridge-2a/docs/src/server.md000066400000000000000000000115461514752343100172500ustar00rootroot00000000000000---
title: Server
subtitle: Global server API
---

# Server

The `server` object is a module-level global available in every script. It provides access to players, worlds, boss bars, and server-wide operations.

```python
from bridge import *
# `server` is available immediately
players = server.players
```

---

## Attributes

### players

- **Type:** `list[`[`Player`](player.md)`]`

All currently online players. This is a snapshot — the list is re-fetched each time you access it.

```python
for p in server.players:
    await p.send_message("Hello everyone!")
```

### worlds

- **Type:** `list[`[`World`](world.md)`]`

All loaded worlds.

### name

- **Type:** `str`

The server name as configured in `server.properties`.

### version

- **Type:** `str`

The full server version string (e.g. `"git-Paper-123 (MC: 1.21.4)"`).

### motd

- **Type:** `str`

The server's Message of the Day.

### max_players

- **Type:** `int`

Maximum number of players allowed.

### tps

- **Type:** `list[float]`

Server TPS (ticks per second) values. Typically contains 1-minute, 5-minute, and 15-minute averages. A healthy server runs at 20 TPS.

### mspt

- **Type:** `float`

Milliseconds per tick. Lower is better. At 20 TPS, this should be ≤ 50ms.

### last_tick_time

- **Type:** `float`

Duration of the last tick in milliseconds.

### queue_len

- **Type:** `int`

Number of tasks currently in the main thread queue.

### boss_bars

- **Type:** `list[`[`BossBar`](bossbar.md)`]`

All active boss bars on the server.

### plugin_manager

- **Type:** `any`

The Bukkit plugin manager. Primarily useful for advanced reflection use cases.

### scheduler

- **Type:** `any`

The Bukkit scheduler. Rarely needed — use `server.after()` and `@task` instead.

### scoreboard_manager

- **Type:** `any`

The server's scoreboard manager.

---

## Methods

### broadcast

```python
await server.broadcast(message: str)
```

Broadcast a message to all online players and the server console.

- **Parameters:**
  - `message` (`str`) — The message to broadcast. Supports Minecraft color codes with `§`.
- **Returns:** `Awaitable[None]`

```python
await server.broadcast("§a[Server]§r Restarting in 10 seconds!")
```

### execute

```python
result = await server.execute(command: str)
```

Execute a command as the server console. This runs with full server permissions.

- **Parameters:**
  - `command` (`str`) — The command to execute, without the leading `/`.
- **Returns:** `Awaitable[bool]` — `True` if the command was recognized.

```python
await server.execute("weather clear")
await server.execute("give Steve diamond 64")
```

### world

```python
w = await server.world(name: str)
```

Get a world by name.

- **Parameters:**
  - `name` (`str`) — The world name (e.g. `"world"`, `"world_nether"`).
- **Returns:** `Awaitable[`[`World`](world.md)`]`

```python
nether = await server.world("world_nether")
```

### create_boss_bar

```python
bar = await server.create_boss_bar(title: str, color: BarColor, style: BarStyle)
```

Create a new boss bar.

- **Parameters:**
  - `title` (`str`) — Display title.
  - `color` ([`BarColor`](enums.md)) — Bar color.
  - `style` ([`BarStyle`](enums.md)) — Bar style.
- **Returns:** `Awaitable[`[`BossBar`](bossbar.md)`]`

```python
bar = await server.create_boss_bar("Event Timer", BarColor.RED, BarStyle.SEGMENTED_6)
```

### get_advancement

```python
adv = await server.get_advancement(key: str)
```

Get an advancement by its namespaced key.

- **Parameters:**
  - `key` (`str`) — The advancement key (e.g. `"minecraft:story/mine_diamond"`).
- **Returns:** `Awaitable[`[`Advancement`](advancement.md)`]`

### after

```python
await server.after(ticks: int = 1, after: callable | None = None)
```

Pause execution for a number of ticks. Optionally run a callback after the wait.

- **Parameters:**
  - `ticks` (`int`) — Number of ticks to wait. Default `1`. (20 ticks = 1 second)
  - `after` (`callable | None`) — Optional callback to run after the wait completes.
- **Returns:** `Awaitable[None]`

```python
await server.after(20)  # Wait 1 second
await server.after(60)  # Wait 3 seconds

# With callback
await server.after(20, after=lambda: print("Done waiting!"))
```

### frame

```python
async with server.frame():
    await player.send_message("Line 1")
    await player.send_message("Line 2")
```

Async context manager that batches multiple bridge calls into a single network send. Useful for reducing round-trips when making many calls at once.

### atomic

```python
async with server.atomic():
    await player.set_health(20)
    await player.set_food_level(20)
```

Async context manager that batches calls as an atomic group. All calls succeed or fail together.

### flush

```python
await server.flush()
```

Send all pending batched requests immediately. Use this inside a `frame()` or `atomic()` block if you need partial results before the block ends.

- **Returns:** `Awaitable[None]`
PyJavaBridge-2a/docs/src/sidebar.md000066400000000000000000000051001514752343100173400ustar00rootroot00000000000000---
title: Sidebar
subtitle: Simple sidebar helper
---

# Sidebar

`Sidebar` is a high-level helper that wraps [`Scoreboard`](scoreboard.md) and [`Objective`](objective.md) to make creating sidebar displays simple. It handles score ordering and line management automatically.

---

## Constants

### MAX_LINES

```python
Sidebar.MAX_LINES  # 15
```

Maximum number of lines a sidebar can display (Minecraft limitation).

---

## Constructor

```python
Sidebar(title="")
```

Create a new sidebar.

- **Parameters:**
  - `title` (`str`) — Title displayed at the top. Supports `§` color codes.

```python
sidebar = Sidebar("§6§lMy Server")
```

---

## Attributes

### title

- **Type:** `str`

The sidebar title.

---

## Item Access

Sidebar supports index-based access using `[]` notation. Slot 0 is the bottom line, higher slots are higher lines.

### Set a line

```python
sidebar[slot] = text
```

- **Parameters:**
  - `slot` (`int`) — Line position (0 = bottom, higher = above).
  - `text` (`str`) — Line text. Supports `§` color codes.

### Get a line

```python
text = sidebar[slot]
```

- **Returns:** `str` — Text at the given slot.

### Delete a line

```python
del sidebar[slot]
```

Removes the line at the given slot.

---

## Methods

### show

```python
sidebar.show(player)
```

Display this sidebar to a player. This is synchronous — it assigns a scoreboard to the player.

- **Parameters:**
  - `player` ([`Player`](player.md)) — Player to show the sidebar to.

---

## Example: Server info sidebar

```python
from bridge import *

sidebar = Sidebar("§6§lMy Server")
sidebar[6] = "§7──────────"
sidebar[5] = "§fOnline: §a0"
sidebar[4] = "§fTPS: §a20.0"
sidebar[3] = ""
sidebar[2] = "§fKills: §c0"
sidebar[1] = "§fDeaths: §c0"
sidebar[0] = "§7──────────"

@event
async def player_join(e: Event):
    sidebar[5] = f"§fOnline: §a{len(server.players)}"
    sidebar.show(e.player)

@event
async def player_quit(e: Event):
    sidebar[5] = f"§fOnline: §a{len(server.players) - 1}"
```

## Example: Per-player stats

```python
from bridge import *

kills = {}

@event
async def player_join(e: Event):
    p = e.player
    kills.setdefault(p.name, 0)
    sb = Sidebar("§c§lPvP Stats")
    sb[3] = f"§fPlayer: §a{p.name}"
    sb[2] = f"§fKills: §e{kills[p.name]}"
    sb[1] = f"§fHealth: §c{int(p.health)}❤"
    sb[0] = "§7play.example.com"
    sb.show(p)
```

> **Note:** `Sidebar` creates its own internal scoreboard and objective. If you need multiple objectives or teams, use the lower-level [`Scoreboard`](scoreboard.md) API.
PyJavaBridge-2a/docs/src/team.md000066400000000000000000000054011514752343100166610ustar00rootroot00000000000000---
title: Team
subtitle: Scoreboard team API
---

# Team

A `Team` groups players on a [`Scoreboard`](scoreboard.md) for shared prefixes, suffixes, colors, and friendly-fire settings.

---

## Class Methods

### create

```python
team = Team.create(name, scoreboard=None)
```

Create a new team. This is synchronous.

- **Parameters:**
  - `name` (`str`) — Internal team name.
  - `scoreboard` ([`Scoreboard`](scoreboard.md) `| None`) — Scoreboard to register on. If `None`, uses the main scoreboard.
- **Returns:** [`Team`](#)

```python
red = Team.create("red")
await red.set_prefix("§c[RED] ")
await red.set_color("RED")
```

---

## Attributes

### color

- **Type:** `Any`

The team's color used for name tag coloring.

### entries

- **Type:** `set[str]`

Player names currently on this team.

---

## Methods

### add_entry

```python
await team.add_entry(entry)
```

Add a player to this team.

- **Parameters:**
  - `entry` (`str`) — Player name.
- **Returns:** `Awaitable[None]`

```python
await red_team.add_entry(player.name)
```

### remove_entry

```python
await team.remove_entry(entry)
```

Remove a player from this team.

- **Parameters:**
  - `entry` (`str`) — Player name.
- **Returns:** `Awaitable[None]`

### set_prefix

```python
await team.set_prefix(prefix)
```

Set the name tag prefix for all team members.

- **Parameters:**
  - `prefix` (`str`) — Prefix text. Supports `§` color codes.
- **Returns:** `Awaitable[None]`

```python
await team.set_prefix("§a[VIP] ")
```

### set_suffix

```python
await team.set_suffix(suffix)
```

Set the name tag suffix for all team members.

- **Parameters:**
  - `suffix` (`str`) — Suffix text.
- **Returns:** `Awaitable[None]`

### set_color

```python
await team.set_color(color)
```

Set the team color (affects name tag color and tab list).

- **Parameters:**
  - `color` (`Any`) — Color name (e.g. `"RED"`, `"BLUE"`, `"GREEN"`).
- **Returns:** `Awaitable[None]`

---

## Example: PvP teams

```python
from bridge import *

board = Scoreboard.create()
red_team = board.register_team("red")
blue_team = board.register_team("blue")

@command("Join a team")
async def team_join(player: Player, args: list[str]):
    if not args:
        await player.send_message("§cUsage: /team ")
        return

    name = args[0].lower()
    if name == "red":
        await red_team.add_entry(player.name)
        await red_team.set_prefix("§c[RED] ")
        await red_team.set_color("RED")
        await player.send_message("§cYou joined the Red team!")
    elif name == "blue":
        await blue_team.add_entry(player.name)
        await blue_team.set_prefix("§9[BLUE] ")
        await blue_team.set_color("BLUE")
        await player.send_message("§9You joined the Blue team!")
    
    await player.set_scoreboard(board)
```
PyJavaBridge-2a/docs/src/vector.md000066400000000000000000000025321514752343100172370ustar00rootroot00000000000000---
title: Vector
subtitle: 3D direction and velocity
---

# Vector

A `Vector` is a simple 3D coordinate used for velocities, offsets, and directional calculations. Unlike [`Location`](location.md), a Vector has no world, yaw, or pitch.

---

## Constructor

```python
Vector(x=0.0, y=0.0, z=0.0)
```

Create a vector.

- **Parameters:**
  - `x` (`float`) — X component. Default 0.
  - `y` (`float`) — Y component. Default 0.
  - `z` (`float`) — Z component. Default 0.

```python
velocity = Vector(0, 1.5, 0)       # Straight up
direction = Vector(0.5, 0.2, -0.3) # Angled
```

---

## Attributes

### x

- **Type:** `float`

X component.

### y

- **Type:** `float`

Y component.

### z

- **Type:** `float`

Z component.

---

## Common Uses

### Setting entity velocity

```python
# Launch a player upward
await player.set_velocity(Vector(0, 2.0, 0))
```

### Spawning projectiles with velocity

```python
arrow = await world.spawn_projectile(
    player,
    "ARROW",
    velocity=Vector(0, 1, 0)
)
```

### As position tuples

Many methods accept `Vector | tuple[int,int,int]` interchangeably:

```python
# Both are equivalent
await world.fill(Vector(0, 60, 0), Vector(10, 65, 10), "STONE")
await world.fill((0, 60, 0), (10, 65, 10), "STONE")
```

### Player spawn offset

```python
await world.spawn_at_player(player, "ZOMBIE", offset=Vector(3, 0, 0))
```
PyJavaBridge-2a/docs/src/world.md000066400000000000000000000312561514752343100170710ustar00rootroot00000000000000---
title: World
subtitle: World API with region utilities, particle shapes, and spawn helpers
---

# World

The `World` class provides access to world properties, blocks, entities, weather, time, and advanced utilities for working with regions, particles, and entity spawning.

---

## Constructor

```python
World(name: str | None = None)
```

Resolve a world by name. You can also get worlds from `server.worlds` or `server.world("name")`.

- **Parameters:**
  - `name` (`str | None`) — The world name (e.g. `"world"`, `"world_nether"`, `"world_the_end"`).

---

## Attributes

### name

- **Type:** `str`

The world name.

### uuid

- **Type:** `str`

The world's unique identifier.

### environment

- **Type:** `any`

The world environment (NORMAL, NETHER, THE_END).

### entities

- **Type:** `list[`[`Entity`](entity.md)`]`

All entities currently in the world, including players, mobs, dropped items, etc.

### players

- **Type:** `list[`[`Player`](player.md)`]`

All players currently in this world.

### time

- **Type:** `int`

Current world time (0–24000). 0 = dawn, 6000 = noon, 12000 = dusk, 18000 = midnight.

### full_time

- **Type:** `int`

Absolute world time that is not reset by sleeping.

### difficulty

- **Type:** [`Difficulty`](enums.md)

World difficulty level.

### spawn_location

- **Type:** [`Location`](location.md)

The world's spawn location.

### has_storm

- **Type:** `bool`

Whether it is currently raining/snowing.

### is_thundering

- **Type:** `bool`

Whether there is a thunderstorm.

### weather_duration

- **Type:** `int`

Remaining weather duration in ticks.

### thunder_duration

- **Type:** `int`

Remaining thunder duration in ticks.

---

## Methods

### block_at

```python
block = await world.block_at(x, y, z)
```

Get the block at specific coordinates.

- **Parameters:**
  - `x` (`int`) — X coordinate.
  - `y` (`int`) — Y coordinate.
  - `z` (`int`) — Z coordinate.
- **Returns:** `Awaitable[`[`Block`](block.md)`]`

```python
block = await world.block_at(0, 64, 0)
print(block.type)  # Material.GRASS_BLOCK
```

### chunk_at

```python
chunk = await world.chunk_at(x, z)
```

Get the chunk at chunk coordinates.

- **Parameters:**
  - `x` (`int`) — Chunk X (block X ÷ 16).
  - `z` (`int`) — Chunk Z (block Z ÷ 16).
- **Returns:** `Awaitable[`[`Chunk`](chunk.md)`]`

### spawn

```python
entity = await world.spawn(location, entity_cls, **kwargs)
```

Spawn an entity at a location.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Spawn position.
  - `entity_cls` (`type | EntityType | str`) — Entity type to spawn.
  - `**kwargs` — Additional spawn options.
- **Returns:** `Awaitable[`[`Entity`](entity.md)`]`

```python
zombie = await world.spawn(Location(0, 64, 0), EntityType.ZOMBIE)
```

### spawn_entity

```python
entity = await world.spawn_entity(location, entity_type, **kwargs)
```

Spawn an entity by type name.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Spawn position.
  - `entity_type` ([`EntityType`](enums.md) `| str`) — Entity type.
  - `**kwargs` — Additional options.
- **Returns:** `Awaitable[`[`Entity`](entity.md)`]`

### spawn_particle

```python
await world.spawn_particle(particle, location, count=1, offset_x=0, offset_y=0, offset_z=0, extra=0)
```

Spawn particles visible to all players in the world.

- **Parameters:**
  - `particle` ([`Particle`](enums.md)) — Particle type.
  - `location` ([`Location`](location.md)) — Center position.
  - `count` (`int`) — Number of particles.
  - `offset_x/y/z` (`float`) — Random offset range on each axis.
  - `extra` (`float`) — Extra data (usually speed).
- **Returns:** `Awaitable[None]`

```python
await world.spawn_particle(Particle.FLAME, player.location, count=50, offset_x=0.5, offset_y=1, offset_z=0.5)
```

### play_sound

```python
await world.play_sound(location, sound, volume=1.0, pitch=1.0)
```

Play a sound at a location, audible to nearby players.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Sound source position.
  - `sound` ([`Sound`](enums.md)) — Sound to play.
  - `volume` (`float`) — Volume. Default 1.0.
  - `pitch` (`float`) — Pitch. Default 1.0.
- **Returns:** `Awaitable[None]`

### strike_lightning

```python
entity = await world.strike_lightning(location)
```

Strike lightning at a location. This deals damage and starts fires.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Strike position.
- **Returns:** `Awaitable[`[`Entity`](entity.md)`]` — The lightning entity.

### strike_lightning_effect

```python
await world.strike_lightning_effect(location)
```

Strike visual-only lightning (no damage, no fire).

- **Parameters:**
  - `location` ([`Location`](location.md)) — Strike position.
- **Returns:** `Awaitable[None]`

---

## Time & Weather Setters

### set_time

```python
await world.set_time(time)
```

Set the world time.

- **Parameters:**
  - `time` (`int`) — Time value (0–24000).
- **Returns:** `Awaitable[None]`

### set_full_time

```python
await world.set_full_time(time)
```

Set the absolute (non-resetting) time.

- **Parameters:**
  - `time` (`int`) — Absolute time value.
- **Returns:** `Awaitable[None]`

### set_difficulty

```python
await world.set_difficulty(difficulty)
```

Set the world difficulty.

- **Parameters:**
  - `difficulty` ([`Difficulty`](enums.md)) — Difficulty level.
- **Returns:** `Awaitable[None]`

### set_spawn_location

```python
await world.set_spawn_location(location)
```

Set the world spawn point.

- **Parameters:**
  - `location` ([`Location`](location.md)) — New spawn location.
- **Returns:** `Awaitable[None]`

### set_storm

```python
await world.set_storm(value)
```

Start or stop rain/snow.

- **Parameters:**
  - `value` (`bool`) — `True` = start storm, `False` = clear.
- **Returns:** `Awaitable[None]`

### set_thundering

```python
await world.set_thundering(value)
```

Start or stop thunderstorm.

- **Parameters:**
  - `value` (`bool`)
- **Returns:** `Awaitable[None]`

### set_weather_duration

```python
await world.set_weather_duration(ticks)
```

Set how long the current weather lasts.

- **Parameters:**
  - `ticks` (`int`) — Duration in ticks.
- **Returns:** `Awaitable[None]`

### set_thunder_duration

```python
await world.set_thunder_duration(ticks)
```

Set how long the current thunder lasts.

- **Parameters:**
  - `ticks` (`int`) — Duration in ticks.
- **Returns:** `Awaitable[None]`

---

## Region Utilities

These methods operate on regions of blocks in the world. Position arguments accept [`Location`](location.md), `tuple[int,int,int]`, or [`Vector`](vector.md).

### set_block

```python
count = await world.set_block(x, y, z, material, apply_physics=False)
```

Set a single block.

- **Parameters:**
  - `x, y, z` (`int`) — Block coordinates.
  - `material` ([`Material`](enums.md) `| str`) — Block material.
  - `apply_physics` (`bool`) — Whether to trigger physics updates. Default `False`.
- **Returns:** `Awaitable[int]` — Number of blocks changed (0 or 1).

### fill

```python
count = await world.fill(pos1, pos2, material, apply_physics=False)
```

Fill a cuboid region with a material.

- **Parameters:**
  - `pos1` — First corner.
  - `pos2` — Opposite corner.
  - `material` ([`Material`](enums.md) `| str`) — Block material.
  - `apply_physics` (`bool`) — Default `False`.
- **Returns:** `Awaitable[int]` — Number of blocks changed.

```python
await world.fill((0, 60, 0), (10, 70, 10), Material.STONE)
```

### replace

```python
count = await world.replace(pos1, pos2, from_material, to_material)
```

Replace all blocks of one material with another in a region.

- **Parameters:**
  - `pos1` — First corner.
  - `pos2` — Opposite corner.
  - `from_material` ([`Material`](enums.md) `| str`) — Material to replace.
  - `to_material` ([`Material`](enums.md) `| str`) — Replacement material.
- **Returns:** `Awaitable[int]` — Number of blocks replaced.

```python
await world.replace((0, 60, 0), (10, 70, 10), "DIRT", "GRASS_BLOCK")
```

### fill_sphere

```python
count = await world.fill_sphere(center, radius, material, hollow=False)
```

Fill a sphere with a material.

- **Parameters:**
  - `center` — Center position.
  - `radius` (`float`) — Sphere radius in blocks.
  - `material` ([`Material`](enums.md) `| str`) — Block material.
  - `hollow` (`bool`) — If `True`, only the shell is filled.
- **Returns:** `Awaitable[int]` — Number of blocks changed.

```python
await world.fill_sphere(player.location, 5, Material.GLASS, hollow=True)
```

### fill_cylinder

```python
count = await world.fill_cylinder(center, radius, height, material, hollow=False)
```

Fill a vertical cylinder.

- **Parameters:**
  - `center` — Center of the base.
  - `radius` (`float`) — Cylinder radius.
  - `height` (`int`) — Height in blocks.
  - `material` ([`Material`](enums.md) `| str`) — Block material.
  - `hollow` (`bool`) — If `True`, only the walls are filled.
- **Returns:** `Awaitable[int]`

### fill_line

```python
count = await world.fill_line(start, end, material)
```

Place blocks along a line between two points.

- **Parameters:**
  - `start` — Start position.
  - `end` — End position.
  - `material` ([`Material`](enums.md) `| str`) — Block material.
- **Returns:** `Awaitable[int]`

---

## Particle Shape Utilities

All particle shape methods accept optional `offset_x`, `offset_y`, `offset_z`, `extra` parameters for per-particle randomization.

### particle_line

```python
count = await world.particle_line(start, end, particle, density=4.0)
```

Draw a line of particles between two points.

- **Parameters:**
  - `start` — Start position.
  - `end` — End position.
  - `particle` ([`Particle`](enums.md) `| str`) — Particle type.
  - `density` (`float`) — Particles per block. Default 4.0.
- **Returns:** `Awaitable[int]` — Number of particles spawned.

### particle_sphere

```python
count = await world.particle_sphere(center, radius, particle, density=4.0, hollow=True)
```

Draw a sphere of particles.

- **Parameters:**
  - `center` — Center position.
  - `radius` (`float`) — Sphere radius.
  - `particle` ([`Particle`](enums.md) `| str`) — Particle type.
  - `density` (`float`) — Particles per block. Default 4.0.
  - `hollow` (`bool`) — If `True`, only surface particles. Default `True`.
- **Returns:** `Awaitable[int]`

### particle_cube

```python
count = await world.particle_cube(pos1, pos2, particle, density=4.0, hollow=True)
```

Draw a cuboid of particles.

- **Parameters:**
  - `pos1` — First corner.
  - `pos2` — Opposite corner.
  - `particle` ([`Particle`](enums.md) `| str`) — Particle type.
  - `density` (`float`) — Default 4.0.
  - `hollow` (`bool`) — Default `True`.
- **Returns:** `Awaitable[int]`

### particle_ring

```python
count = await world.particle_ring(center, radius, particle, density=4.0)
```

Draw a horizontal ring of particles.

- **Parameters:**
  - `center` — Center position.
  - `radius` (`float`) — Ring radius.
  - `particle` ([`Particle`](enums.md) `| str`) — Particle type.
  - `density` (`float`) — Default 4.0.
- **Returns:** `Awaitable[int]`

---

## Entity Spawn Helpers

### spawn_at_player

```python
entity = await world.spawn_at_player(player, entity_type, offset=None, **kwargs)
```

Spawn an entity at a player's current position with an optional offset.

- **Parameters:**
  - `player` ([`Player`](player.md)) — The player.
  - `entity_type` ([`EntityType`](enums.md) `| str`) — Entity type to spawn.
  - `offset` ([`Vector`](vector.md) `| tuple | None`) — Offset from player position.
  - `**kwargs` — Additional spawn options.
- **Returns:** `Awaitable[`[`Entity`](entity.md)`]`

```python
zombie = await world.spawn_at_player(player, "ZOMBIE", offset=(2, 0, 0))
```

### spawn_projectile

```python
entity = await world.spawn_projectile(shooter, entity_type, velocity=None, **kwargs)
```

Spawn a projectile from an entity with an optional initial velocity.

- **Parameters:**
  - `shooter` ([`Entity`](entity.md)) — The entity shooting the projectile.
  - `entity_type` ([`EntityType`](enums.md) `| str`) — Projectile type (e.g. `"ARROW"`, `"FIREBALL"`).
  - `velocity` ([`Vector`](vector.md) `| tuple | None`) — Initial velocity.
  - `**kwargs` — Additional options.
- **Returns:** `Awaitable[`[`Entity`](entity.md)`]`

### spawn_with_nbt

```python
entity = await world.spawn_with_nbt(location, entity_type, nbt, **kwargs)
```

Spawn an entity with custom SNBT (Stringified NBT) data.

- **Parameters:**
  - `location` ([`Location`](location.md)) — Spawn position.
  - `entity_type` ([`EntityType`](enums.md) `| str`) — Entity type.
  - `nbt` (`str`) — SNBT string.
  - `**kwargs` — Additional options.
- **Returns:** `Awaitable[`[`Entity`](entity.md)`]`

```python
await world.spawn_with_nbt(loc, "ZOMBIE", '{IsBaby:1b,CustomName:\'{"text":"Baby Zombie"}\'}')
```
PyJavaBridge-2a/examples/000077500000000000000000000000001514752343100155105ustar00rootroot00000000000000PyJavaBridge-2a/examples/command.py000066400000000000000000000030641514752343100175030ustar00rootroot00000000000000from bridge import *

# Test auto-generated usage
@command("Hello world command")
async def helloworld(event: Event):
    event.player.send_message("Hello, World!")

# Test command args
@command("Greet command")
async def greet(event: Event, name: str = None):
    event.player.send_message(f"Hello, {name or event.player.name}!")

# Test raycast / teleport
@command("Teleport to spawn")
async def spawn(event: Event):
    ray:RaycastResult = await raycast('world', (0.5, 320, 0.5), (0, 90), 384, 0.5, False)
    event.player.teleport((0.5, ray.y+0.5, 0.5))

# Test Inventory API
@command("open test gui")
async def gui(event: Event):
    inv = Inventory(3*9, title="Test GUI", contents=[Item('light_gray_stained_glass_pane').set_name(" ") for _ in range(3*9)])

    inv.set_item(9+4, Item('totem_of_undying').set_name("Bing chilling"))

    inv.open(event.player)

# Test Inventory Click event
@event
async def inventory_click(event: Event):
    if event.inventory.title != 'Test GUI':
        return

    event.cancel()

    if event.slot == 9+4:
        event.player.play_sound('item_totem_use')
        event.player.send_message('Bing chilling')
        event.inventory.close()

@event
async def inventory_drag(event: Event):
    if event.inventory.title == 'Test GUI':
        event.cancel()

@command("Open someones inv")
async def invsee(event: Event, p: str):
    if p == event.player.name:
        event.player.send_message("You cannot open your own inventory!")
        event.player.play_sound('block_note_block_bass')
        return

    Player(p).inventory.open(event.player)
PyJavaBridge-2a/examples/index.md000066400000000000000000000001431514752343100171370ustar00rootroot00000000000000
# Examples

This folder contains some examples. They *should* all work on the latest dev version.
PyJavaBridge-2a/examples/spawn_protect.py000066400000000000000000000011501514752343100207470ustar00rootroot00000000000000from bridge import *

@event
async def load(event: Event):
    server.broadcast("server start")

@event
async def block_break(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.player.send_message("You cannot break blocks there!")
        await event.cancel()

@event
async def block_place(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.player.send_message("You cannot place blocks there!")
        await event.cancel()

@event
async def block_explode(event: Event):
    if (abs(event.block.x) + abs(event.block.z)) < 15:
        event.cancel()

PyJavaBridge-2a/examples/tempban.py000066400000000000000000000053701514752343100175150ustar00rootroot00000000000000"""Ban users for customizable amounts of time."""
from humanfriendly import format_timespan
from time import time as time_now
from bridge import *
import re

bans = {}

def parse_time(time:str) -> int:
    if not time:
        raise ValueError('Time string is required')

    units = {
        's': 1,
        'm': 60,
        'h': 3600,
        'd': 86400,
        'w': 604800,
        'mo': 2592000,
        'y': 31536000,
    }

    pattern = re.compile(r'(\d+)(mo|[smhdwy])', re.IGNORECASE)
    total = 0
    time_str = time.strip().lower()
    idx = 0

    for match in pattern.finditer(time_str):
        if match.start() != idx:
            raise ValueError(f"Invalid time format: {time}")

        value = int(match.group(1))
        unit = match.group(2)

        if unit not in units:
            raise ValueError(f"Unknown time unit: {unit}")

        total += value * units[unit]
        idx = match.end()

    if idx != len(time_str):
        raise ValueError(f"Invalid time format: {time}")

    return total

@command('Ban someone for a specified time or permanently')
async def ban(event: Event, user:str, t:str=None, r:str=None):
    global bans

    if not event.player.is_op():
        event.player.send_message('No permission!')
        event.player.play_sound('block_note_block_bass')
        return

    target = Player(user)
    duration = parse_time(t) if t else None
    reason = r or "Ban hammer has spoken!"

    reason_text = f"You have been {"permanently " if not duration else ""}banned{f"\nFor {format_timespan(duration)}" if duration else ""}\nReason: {reason}"

    await target.kick(reason_text)

    bans[target.uuid] = (time_now() + duration if duration else None, reason)

    event.player.send_message(f"{user} has been {"permanently " if not duration else ""}banned {f"for {format_timespan(duration)}" if duration else ""}")

@command('Unban someone')
async def unban(event: Event, user:str):
    global bans

    if not event.player.is_op():
        event.player.send_message('No permission!')
        event.player.play_sound('block_note_block_bass')
        return

    target = Player(user)

    if not target.uuid in bans:
        event.player.send_message("That user is not banned")
        event.player.play_sound('block_note_block_bass')
        return

    bans.pop(target.uuid)

    event.player.send_message(f"{user} has been unbanned.")

@event
async def player_join(event: Event):
    global bans
    uuid = event.player.uuid

    if uuid not in bans:
        return

    time, reason = bans[uuid]
    if time:
        time -= time_now()

    if time and time <= 0:
        bans.pop(uuid)
        return

    event.player.kick(f"You have been {"permanently " if not time else ""}banned{f"\nFor {format_timespan(time)}" if time else ""}\nReason: {reason}")

PyJavaBridge-2a/releases/000077500000000000000000000000001514752343100154755ustar00rootroot00000000000000PyJavaBridge-2a/releases/pyjavabridge-1A.jar000066400000000000000000001343621514752343100211120ustar00rootroot00000000000000PKzg;\	META-INF/PK4U;\META-INF/MANIFEST.MFMLK-.
K-*ϳR03PKng;\com/PKng;\com/pyjavabridge/PKng;\KVB>=)com/pyjavabridge/PyJavaBridgePlugin.class[	|T?e7L$AMIB	@
&	;}<18EVֽ[ڊ@BE-.vZ}o0	~?}{Y_| -Fy:ʧɑh[MK#
%ڂ+f*QL`|1S^yL~'jp ZxM]!Z/IX	C:占B2ti(*bttuhͪY-.Si:`x]{2mILU
ßwN%LgdEfPhXp,nVzd̊<$&2QΠ:M2L:iLW]$`$,"c@{4^eb,]siLD[
M)4.Heꂌ@՚Y`KqzbJ5`a,c"Bf`tA{pTwX(cs95פV
Vև
zfk'.AG-B,
ء2儉XH:=iPN2-*'tzʠyg@/Be|V*Y)zV=GFrN͒TCԫ>S_۳ X+(qЋHj}'uzi0oPp(
:,tΰs}^!ˌz)O2k5E
ƠKMNe=GtJtqѫ}q+Uf퉰f͚.IR|^}	D6
T}_P>ġ˧WT ?:}נ!1Î\j
'j?4GcHth@FOTKn%$g\H!MkiI/
;qK#Ĺuaeq*<-	!2$dl]Q
&P7+פCO"vljf+C$Ɏya!Ou>rȦNɁn	Cf&ո͕n=\3t1x&l@\lY	^B'aQkT}\5xO!KXEi-0>ϡ7tMR50MHy%C|/!vEzXHt=	^;%F|Q5#xZhk?,vŚu+._y]}ӅLSN6ع
nհl.,ϩpP.Cp*_kun6x siqDb<)|yyh6'YBr
_:KǕxJy^ŗ3!PH(;i؀N rxbparYQ7߬!Fb|rѺ2abmHԒB9^Xn4R
;w|Ozi(~XpV)`>di?rV?dF	Nfq
X|F8DZ"?/O}J-8܌
Yp@f&cv3D?!G!3L,/x+lLtS8	Y8
R1>E¡n
[Ʊ{al|D#rF!{
~?
j{E8*=M
y!	qi4jv0Yg~Vg%=<jL_dkK=(Ο5s3OG~	 U`KHdcbT_FeoD VQOm7Qsw_tHۊhTvAN0
u󷁬15{nDQLh)δ>,ʅ2m]١h`JW]ՒՔlLE
z
NS=6}XF-^Ga]Mo5 \7:tM8a$Mfs	/FiR05}<I%1Iꞵ;*ikiiQ-6
A5qiHrr#`k3-9
1kmڐrL4EO
/Dph#17k7P]V8sl>vk+V
/xRb*(V*pk
CNї[
wUkZ%aU'9K6_^oPh*/5rzXlT~^|LU+l$4K6U(]ԗCzPB,/%Y
Lg}fH@;JtLndحcLh3ޤT̮U1In0ZHlihӴn-f3,)Jʕr'5311)S`Gۡ5;
ii;"S?@#Qt?yNG;/ºBVlZC$ґ܉4成[=n]ޭ]pBȘܞ\PagӫK{ʡelXG
Qٸ"[-}p2"UQ06To&ڝ
Ę/RQ()ӵ;v2OH*؝i2FD䕿5%IyM=ShjG=,򇓸zqO,*?j"jH߼F@vnӄih*Gz'Ds q.4=ΣjZ?Þ?ǕI-NrC'/ziǿ{q5jXmV7MUy/qcuV\%ﵪm`#*g*]/uV+i'W2W/O[~=诪Gb3>CS2ZCq&RNkͧh"
Z\L7SdFzo$(]:{K:H7c:=ίN\oqǿC2ҎCKBu^}*B<\ӃGȐK}	7}1>$SCe=ϐ77L`cU/9[g$TlkI:~mbN
N(\V6&R^ݠc4
K!%XANUxD9ӗ~U~VΝzhtW|4LzB^pR-ozƩL;՚ЭĨo[r'>:GOZco;"?	I-*S2Bjfz6_P*Ʋ^̽Ft톚 oE[؞-bb'Nd?_P?V,wuYI4X9BċNWډ.=ɧf'y=0nn	u3U"y-nK9VIJ@**ZNQ:hT_2C\T[PVP%{	Bc)vߕCζI>mJ\5*TϡpxFD8ߦ:Eu~.gybkjtJ4ye^^ϋaY_<	X)T,`>>Ec6濣1r25kn*Z"W=@oe/UW^aSZkzh"~J2K{1E^>w-w0QSyW@+8'9ӘrX#k;QR@XAhΗlyq*[Q)[|	Px_i"NH@7`S&୛&䞧6Lbn~6J/"BW2bBJ	*D	Znjnmi-Hfgd
.s	jѤCܾ*۬oRARwOmW,U7RSF(k&Cyabui],*k%5-Kj2T(P yI;'igr'WA";5lp}S64V* rH1$dhTqQ@@$1xcU6zsz?uP1
l?_W3@9@D
7j*d6wh6H@,H@/<%^ʴ	z߅Q22hTe)_7hz̕7Cs61N䀹k?7=T5ت|wA);ĻI}pw{R~̶U?*O:=d`O8i6e-p
_D|J/Ҿ7PN&j[
y,mw
s\@/i:qєjghU(E9xSQmBc\oѸ"s|dw]p?Q͊p//qI)ɣP犨Kh:{iNқ+ܥPZ@6Y@m\LsjjGNplx}|>>T2=UwG7V͋G6e!σ>pڑƠ9F)x|
QI	t]@5QŚ9ʮqrx`&<2`ܝ2;E6;BL*Mӌ_tWAkO@2%ЮϨG0dW
-!d_y2)#Jl)tei˃ig*է!Y2߿1kV>%SPAMf#mA&f-rԌ5؁usbri5*gjHN=
\:jEbm	28G֩U(j<_&nmnsIۢmS/W
_Kߠ#ÑV]7Pqހ,F\_6 >z3z`ފ"\ou1u	/ݡݥCe
PKng;\
Gcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CommandsFacade.classS]oA=kp[oR1aL*ISt[1(2SYͿdj?e3-/s?f=gn[xGYKXb
99< Ñhv_St$UutTrj;
C6P0,2>ex_[6
.apuqsըvp J/z_/:(i99o
68UgA(g8/vl\wp7a5#"A2tjɷ{i,ը,}E*Eڑ@ɗJMÁ2e?
cyJah/vJu-RʮHa<4Sj3_Fj+z靹e(imVRzkeO$N4R"ny/U_X'h3(k	d@pm>-%[`71w,k
򖏢[Of`'?OH]d*q5;; k'}ouQp.6eP7lmPKng;\_`O3com/pyjavabridge/PyJavaBridgePlugin$EnumValue.classQJBA]c^:AAjFPRT	㨃ȹ~V{7E{NQZ{ZÞSleC<	n!|_<gߴ0+xJ#t;nOڍ5gQpžһ:JoL3UqBθr-4WZ$]jJz8hKV(%c1.Oow,PKE,31,b&.G.+Xp
IDPKng;\ZEcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$PendingEvent.classSn@=8q$K˥Ԉ"P@Ym(RysU:oPE
K33>{س7-/"
Ayʑ?З#wp͐(ЏFFaÐ-B7P2HKvT"^zQLEz_9lTpq&TiሻMyҕek=.BNC.L0lzgkCc!j"eT}YDRSoW\Ur	_w	52l-Hyay?!gXT4rx,˧D
BVOMm+Q2L.y!i=!^2KSHEsJ%QTw;8CaskM:HgtQ'61fX:Cq ;|&Bi-!X`YQ>aj\5lfqǰn-*E@PKng;\z0t7com/pyjavabridge/PyJavaBridgePlugin$ScriptCommand.classVsUݲͦR+$@)(
mBmMC!M.nߊ_/>3ŒËa@QtW/㹻!6-d=ιw$>	dH
c4||\(hNgŎk6oX?clإxț zDcDQtK@]wK@E_0=JxzǢCF[C\ѹ,l84	MW>I觕F4PKng;\pwHS6com/pyjavabridge/PyJavaBridgePlugin$CallableTask.classNPE`Ph%x}N"Sjpl;ܯ
+S̒j:-󷌓j,p]d:B@hj%MEyM>ϫp^pv$R,JeG!zb_=R8%tр9jCR
D#qb8Fs'h0PKng;\Yw,B8com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance.class}|TU{< dj詄H`P8$C83#6[@24m^޻"Ϲd&}W3s=S= /p:H40H[_/V\,Pe
F19t0t(kՑPm1D
C;Cèa]\VU
cfʔWk[H_[` 	$%FCÄk?;PD
^HdBtf`GqxHWPme}8Nr3u^b
݄ГAHHe8X
j#:47Њ`e(a/>}|9h&RhqÆ9`dVk3!
ZaPy	C`(rMC\5p#q%ͼX
HFQѥȑV`pIJU&kS8Vň}4"`O0a"LBW@AW.XdI jp0Ȱ
Dᕁpyry j1HFB1LXJ`b)Ɵ	UU@ :P&z9%dI_Ơ{vqqV?600#q2Rtz8*`~4JBD9qV8BV!~	'T)Jp:?,FWhKѥ"IE
JBe^KLdma]…MHe&,]8e
ѥڲpɬ
>_gN92T?2fUV4fE	&c 6SP89ĕY/	&\ .JL8P	drӳK%JԜ;]
:c5i(f%Ĩg\N4ʼnmטp6\blM/Q:XejsM8BbEp1pu˃Q@+2߂t*$̄˕r,VVՒkRJJME) QנEK
B55I3FB#a	
phDhd	rs#ܤ&BMo%R4pJfpZ,qRt(d0L$n!zk-3~^5M""'є
b5H`V}0i 7	$
j6؎i٪FGL	F`ͨcUá
x
<
&<2T;A5U/2ifr+rBy^`U`t*@藳zhK2n_\\LHg:ʠWshʕ;_7
xilDo3%@$	JˑӊIQج#3XOd򺶮>'_aU{3\/LBRϠ=^,!#}	JR8BqTU<26wEt+in~$In3)?D>V&eͬCZDMnHq°E_ѯ!J3#?i	S-65e`)Wk-W,:kgn-}SFJՑФ
1Y)5	p,]g>ubhE	*r^b%b,RdܳjzTn
Gג `YQ
u/鬿I=}"
2Y6LE8/ey:7Yi-	XRC*`B[8@=lbMYLr@`#qg4iEUZ?u$-"F.[S\%mD]n&QתFEW"2-}APi&+fiZ})%&5Eu3MVFu&)RlSmU;۞$kQ&g8UˈzP:j
߀#Agd3up`&~ fjKʹlN1Y	~)W4v:g['<٘
Y9s'J~V\	;+
,M
V.'x.N(p*dn*"	v.'i+
QfD`+iC\]h/A(pJ]
Q] ;OR+Tm
'4:Ҹ<:S[S hR_n0)&݊GZlݎ}+_0P8E=⩚^MN"]nh/{ӏD	nt0&*iK@ҵG+edPkgk3'bӖ\QWR0caSǏV-NqZ
:c[6m7H'-0Cji.4k699oϊ:U{?\!8YO0rئrT?!7'AoohE5/{dϲ,_ϲU=}6^by5S;D椲Wk:{do	ܾy4]i*$[H`ˮB{*N`a(GZL!C]8	լDL`g;䩩	TkMOUgKF"8BWV(eχ}̾ ͬOSn}zuq8䯪GKDddߓ6փ)+
Ti\֖=th
_[FqPt%@r~3>U?
dX 3H8&\큎:Lu&
batiLTn꼝Js=A陝0D8N@zՑgN&vm!.]ecr^Фe&F2ی0yOޫE9F93Df{rVtJ#[.I܆::@nڕ䫕oijRirE9\tz 'uElT1l7&GZW@N[?l&c9h	fF6X$dL$ʠo+y|\O%ΔKCÔOa_L7[+U&/3gTMqO6g%֯X{y/7'kHvy|'G#W|_HR.f;⚟HL89~_XG?A*M	UayPI3^VM9{j<`.#JBvkyH
4CN'0P+OĥXeSHeyPe֯
M3t~&arV#ېhm&}v2wndzZKH#9PZ_SC*`\0\"N[9V39E%R_fimM/r$¾`#qn4:9״[:[to0l67&DJI48E,#h"i,ZT_Z&"V8۾uaߣ`pQ	Vd]|sbMVY>%u1	hq#ڵ]m`U938	u՚vPM<֝!f|:tMmAnCރwQ
Q՜p 6Smn?.(!/OSj/h	Gdng[	Vi}&;bo7-)j'FK:Wti=+hIG%$]hmOyo7a	YOz=
WMG@}svKIO
N"ߡDE8?+vc
d5MD/-W/<ltTeRٗmvp !	ϾOIRt6*F;W1vSn:*1ų9#l|fo}xﰴ8K&'!B0I[utuZmikxdg[>m_FP7KO'=SOQZ)>"2E:
}bOgJ̐_`lvKJZ	&>4ė,Ҹ_-g#b;i`ӧ)~?;uioڔySJQ'܎8@PJ9Shv
F(~j.=?C{zt?>SNghttk#SHSeHfmT.1PUPI͔1t%_xß~64}ormlgjA@WVZ7QYD!3H#PJ4dW&L\Cvp`J['{7bEg}Fcʾ-T\mUqmeX9M^Br)ADfZS(n1de.)^/t9ؔt;ĺ
#^R50ꠦ,%<":U/gN̰OˣLYD⒒b;*1XPn=zٙh
Sew9)Ō@El[*y)k*A>My,y6ÔA%4#2eMɽB:sL9Wγc&ڑDm]q&ǙB.H@br37WxA'rImظ
ťӦ.F_p
L܌ hE͑}1-8QnmyZH'φ܎e'̛0qvc,*9{GLLla](:Ξ[:xCK)4l!@aE24e!z/rl^Zb.p+U/$/Y6Q4$Zbq^"cE]/	.i]>|ÔoʷQ#N$+p
x4q,,i:xwȚW@^}3n߃t.N 6Ȕhhn]] LQT)ٙ]TR_k
qL‹He'L-Al
ݾ+/AgGZMuf4TTkHLXmȟ
`Tl 6j:_u,7Ek{Zgu&0l]OV2Z&FNj^j\IU-a%6A7VZf",	wr%]t}AxMpL"9՛tE։AVPt*ZUq|]wк0(0!j=M֛z,٭@B.ZS#:z3&6ʠևk
-[#5Zhy*~.'ZD<
~q8n?3X|ga]Եi%-A3]NR{zkʺ"ct<8hB]Z*3wک9$
_kĽgMoWX@zb][戍P%Z=HZIe		cA/C	z*tl
56^Cvr96qAxS	P0ɘÄ1FzԯK|[ܥ
fbR\`}JvC9DW 蚔vN]Zvpeǀ3r`\s.v0Ra54:qnb9 Zu-b([+iY6&crǩ%)G&num6ATw8Mt*k0-ݔ@&p%.jrJlMs˛ᖅ,IR熃d!@O
o,suz;m#^UP`K8"3Bעi_"6ΜC%gCH'UZ	K"y+ĕ||i x*%!:ǀ87R#	Jۨ
,H/z+n
Rc=DfEY1&Do/;ŭ"EKQƁ%-yP۰ZvprP<*:H?]^KY)kt:EX0Ї,o4qLS+wŖ{[ ڕׯ6D#A$n߷,̸扟'j3Zo`/H2ZeS}t1rr5W_vkk2Ӈ_\R@"}C85(Úve߃Y
C[?UO
cRy>\[	.Ti "!mb(D:C{BvBe20ejܯ4tдK=V-)(?P4ŤYhU"v[:YX^Eݜ*WQRrV(KAʎs&ƲC{-g]!jo"X?P{G܁ @*KTxX!|djh;ӴOZ|Gkkhнg8fb(6ZB.HZBY֥ZD[B;SۮHV#v	/zƆeP/._`gBeÆi_:Ԍ؇D}-HfSUG1(&kx8Rkw*z4G&=JfY ٛT}cp]G)96خaz
N/Nx3"B4S_>O,w[ e3x1dLfnnU!@f\<(Wlܼ0873-#r3f(6M
e"hɊر0PV
c<*`*[DzPƎy8
þ,D*E`RDbRDdRDfRDh
g}$\lOQNCn#=&^
2RؒPWV{ktmxx*<*ocX+";`rS´-Pf0c0oVnE1̵16Y^M"ZVPp*8}3ٳbvTȁj–"iHp4[r84Ŭd5Έx0(5eqԁC@{FRA[FmcWK^1tKR"(zV@GAqJ}u3(eY0tW0dm
&ne4ȏ]MTbMkb?aرGvѣ< s *&H/
- Y=8O`΄,:kpdka>;NdA]B8]g`
gKe:Y8A "h(]G1h7
AD^inK
\L7fx %/+v>}?o-Xj:[xk/VTe=ʼ16#7?:7x?7ƺ5Aij$>,صIrҳF=߳2Uʮ^(bעhD~^']
Hv#\eWaٵmHAqH%ӎF=qc2
T]]O]ɼa|w3KYc9XAX$^>/O^k:>}e.|Vtۯ:>k
|lp
iyb2S%c~ʏ(?T~Y/R:0?F=!1Ntbo 5Jo^n^ñ9	FNVlaSc&TXql>K=g5Aܼ XԄ+y'w1~f>Y;dܝu>H	Cr?ց1z{I?wlAAxm9VZm	Dy',f]fqЛ miFr\=JOqD=cqA=%X
X`xf'X}3:+&ێb;Qra8d8xFm"";8}#FnܐC ȝ*cVHv#G$@$D$BBB8Dq"ک%6-8:]k/#&ϋH%^hqȶ1vi#Ms;B7_M$/ѶcnaE2z=26vMoZlYM``|-)uMT^ExE		,R90ً_eX^Uuw7<ކx߅}m2K`6	uD-E)
t$)T+i(vφm4$
v}č9/uv7j*^x $b0Z}BlciAn0e~Kc	tg"Sp;;NXp
3 XLcⶳv)^kgv6b$>IzZ5acؖKta<27c^.o=divoiMjtRZyZ>Owejٗ0ǾWJ`qݷAO{KdJa+v>uW!4׍>ߪNqPmm=1zLa32aELoui@LyW7RI\*ꎻ.JL28Fj۸65xpTouHJ2W@\Οe~FvaEt<2+`a;i	gsh6r	q
S'n~ގyy{i'rx:}l<&.^3Ywc[{yovbދ^hJQ!{L܋MFy!ȴS#ku:hk	ʵ9Jr.W>UwNer){L(ch%kǁ4V
-9a>Ug}S^U6~}݋#{
>/&SUuӈzc_/.TCTd,K4Rgx!yyt^υ09z>nqaNܲJvC,Im'>̲<4ŶHĿ~8j+?	*r&R&蹃G-Ol;i622 ^[yqVӮ|{Z1S)Z>0UdҼEz;0${<}G}f,KA:{t'RA{61?C*9AiH-Ȑ
ːh7eQჼv; CU>b|6MjӊKhuV~<|8#?zПA(΋(>P"~4,`%Ipp2E~,g3>ET9KsY>^l2_Ȏ'b>g-/KxN@A][e,͏b++є¦jRi]6/*-NUf)Q±J YZ[ciKܱ{.u{V:)D['rn'_G_cx_f-CQC$bH E-W6TDmMz:RSYwtXmuze
|m1N#|Tlᛶc|F_Sy\ۺ)V ܞ4,^lAǼ,wnmjZYyKmz\,ƟȔ8%LruVi6A{(0٫h=^-
1Ο5pe#{lۿŰͻ?" R3H?mX
'w@韬whHp4Nk/o4nO_QF@"<b}sLR֜O|'T
v3<*h^D'mo,-"@FcbjmUFcuvdEn5D[OIg	MpBZp1]p*;RL(&MI8
SdZTUf,oxsoeVPs9/FM"q'(	6#[=$x)td8cyXd	a܃/k)dEj鮠
FzrU3Ս0tL+bbyq2FX]/8.˚q%n_GuP76omVkj2.x*ݧ,`=Ѕ̵+'iery1>neŅKE5w!HTC_WH~C	f򫠂_
~~
p:"7 
w	~kog7obyNVbݬ{Y+Fd7	{?>1=#^|wQ>~<Ÿ+~&_ƯgY?%[?Eg/"(寊5.7Mq[;)/:W|({`?r\_Zl_-4V'?5?igm 6M{Wuiwmw0"œ"LazvQgi9Ut\(2<׉.[DW2YDtƣNUK	z+Khj!4yvdGfW/F;hz_	ebVxtAcj,ݴvf'Yf[$6\ƔƷV_J"GZS@Meh[eAֆ^[[-XkNEz #J՘:Ml!1}V"RE0^$1fa0_Ǻj1bK\
H(RԠɸw)ZoSS*]<=h
y_gSb6v"HuT읰txfߦ?~>ꟙK_A]'sLw⎣81	d,@
}4(0RLQ]f,Q,\9s^s3n,0uv1fAErWZ(ҾKvکәKEMnyoMEEj//>ŝHksQW˟<&J>uҦOwih;h9:t;ऻd&}wk_u"t'A#dQj
X*ྪcӀZ蜾&d͙E)G|aKw"˞15@*3B[d?ye̔c̦R(3ź/c2u{Z47my5H/=W]9)t*\z9\u#br4AjiP19na6BL|b_n9ăuZ]ڌ,0Yn%d;SNG&{	
^Ԣ4@Qd\0*.[=+aX'NY
Jqg½x@Ml"nq. ΃7𝸐	qKUK؄ɘڥe!v,v;sYXfeAfvB}z?9²+0Y㪝EeӝGHh}a9{}>W,=Oѭ{k$mr&*p/p\"#MS2
ݙ[{Zo7S,2)RLųRtne	晹wrdRdHq\02(J
|)bф:F#^ɭڰڞ?mJGH^gTELag)kx/gE`r!@	p2Mޠ{#{:vCџr1zkH\uP*AP
pa	n7Ý[yxR4GN^??`1bk/dfI<:Yc6XleEhb["aub'sR\`u|vٓ0]
w:;`CUk"z0EymnŽ5ܮ)We(sǚk՝dAbJuj{X׮õ-h4؞L:zOЉa.W4~ֱ<*r/}daG8}֮O54?Gs5߶iyV4ڸMi˃n"DI"Jڗxk0Xfz*RCk2 *ɡj	PXAњR7"7HneSI1O[5qyBL)Uv*&49#'IL]]"C}4?}6pؽͷX	#IDr6xVN$orv+'rM2=R_,Шt9+H_}fߡ=?9GT?ly=s"OtMhiJN_8bsgz}ϊǹҚ#s#dnD$On2w{qBH#~vmǦ*ȡ)*4G:]HmlFn|9W:ci\O2 b.,B/]w<1(J-niW4ƻӸ1LmQtNf3<8CgD]E9*Eyͮ"4LA\q]U6/Vgl9Y۲;B37&/,/T~O^l>y6ym?ǭѲp\_E@EM
mwAyoL>mݷGiPSX˱L>|<|rIv4A"gQZ[r'Zْ*NCvd4-;NLfɲ3*.p;ex]e|${'7|+i][v6mʗ]Wikw⬁Z	zڧXBTX݅ub=P#ʔz؎/ʽXwklgq8-O>V'a?_Tϒ?.?h|H\q/B	RQvfdkZlC#-=Ns@ΰ^HjUr8H^đrZE{{6
$4snA|jK7ѯmV-
l[yWa|>i)>MÇקO#2eGŭ+jnRcL#uP0پ0zXӁgwhZuޅ$:n5_W^2ŰD6™r=\,kX/o
Yb]6w_Gg-0e$b+L؀VБ*Z@Bi;дͶ=`1j|O5߯4eԷmi9{֥b9#ϧui=J!-C+І
8ݛcZVjHcZQ_NDwAy7{pk`~|=
s
D|\BVOBe:
mG]hPN.84Nbs_%Xitwl]eA>Am)r&>&BkZqmPn}Lu@*Ⱦn+F;Ǿ{WuwC\dBE{ħhل6d=)qGtSy	"[|zpj9->weĝJm0O{['Jۣ=%}M~R=RkhOKU~T?߽7=@ISM{<qUO=>Kd`yGa+N|,>39ـOO1{|&ĩ]}rLPKng;\WJcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EventSubscription.classWYsGFiu`@l#DƘ$+y-/wje	r&ykH!<*/yHR!=-TEU;==ƒ
\>Ik48i	JѾn/?2a6G̜IkL7|"cX&oa^[MG[̜E)ьfm`IWgFbAPjhKדCES~ 
UԠO&F2S*!_˰\AXEV0l{twjm=get"TBs*!L-SLZb=60(;\=87-;MiÉź$`˖oT	)zaC'ьh#JˆR(;.R:4J)
V
Vː@lò
g]=qUc!<
vx1yJ[O9GkMeyPf\0ɑy(R5=
WV-vX32-'ysڗLXmZ0ށ
:U@C,iwZĚ8
Q
"2r3oۄ-(TtEQQыcTRr9TGNȡ€"e`Dd5XCnxKdd /IdDͬs՘A/3%<7Rmbuv~iŽ1M$ꈰaфnꩋ[I-3ن.trgĠ;d
)aq+Îqg7	Fe^3,#GCq6LxRr
h^9h)ը~Έ5ԧٴm\bmBahz0#SŸ)Xbn[>QoQ9昕֣q7Z[֒tQ-&Pݣ/t>;W(
K.<|Sd
GI\ikW]k˪f(|KªT\eH8U.uZL}${p~V@QQL!vB>zѠwAv7(/"DDf&Q]4Enae'l:3v(&7ח"oE۩c]mrk#jiG~jS;7WLb6|K}$V]>Jְm
WMbIk)D8*$-\|F%A-7SRXƳp$VAT=bwċnexD=Re\kxAWe/xxoJ۲=w
4]#c}zW$<$]
&PKng;\P	Fcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ReflectFacade.classS[oAFť h.1&4JfE"anYf>I?eQLjCy"~ht̶gvPm6Mr՟0<;Kﴬwlq'4p#+|TWP|9FjPIO0Ł7ӄ8uf+
4	EW]=6a'RVEa`6IVK32<=
%}{GdK;ط}tP%|0".ey\&b
R!܏3{;xbi"=CnZ[GQ{j!f)!i <Kt֠)+TCȡfў
åydh rkPVwH@
Kʪ'!iO:l(nh_HpH⌄^Dz4gNdֆy1X3pn%+-9S
\/*;PpUo}yRI;S	4`o	y[=Brv^KO`\ua
զ-ѱDWiN;:A%%dO?~.MhEr7\C#/a;z4͐Cfxva2V>VOY"}`cdhqӔ{Dz5Z_6}ʒGfRNȜ:W\	~B|o>sFC<"6Ho1YOȶX%kPKng;\ʹ6Ccom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CancelMode.classTmOP~ѭyL]A"62tӕ(Zu$|'	$B4xn͖=ys_#+#tkۛƖQ*Ϭl?`!VFrRAѩcT^GVmx&b	B\,ԭ2fF/Ztegtp&rtzB
{
Ɠћ)E#BCt:=;;+q?M(*;C0OZ=fAKwJR vP"Ƈ1%7R,D 
J&⊸?͑4z"֤]HZx:YL4eß*qI=HAp%A%%KG蔾!IrᦟIL8	Zݣjh07PKng;\9ZX8com/pyjavabridge/PyJavaBridgePlugin$ObjectRegistry.classT]OA=]X-*EP""Z@qbK$'4O&(mSRlΝ;s;ȩ!kBa`7a0=Ȃe[C8R0UM6}QymPA/4}g1w U*}mVF/[d([5=`PQc/\PCV Cs/KDY*pEVz'-.a׈t|
s2K#f%

#HR6]Qey71`\-fp/3IU-"ۋIQ0.}-] =擅o/I$zZCj!g*ۆ绂ar:D <甄\k~(ܷFBc-õގE0[Q"n7ecSh$wrCVQLߦgʆX5MwMҒAeZ5oթy
^0L\2-oUZMP?bF;Do}cdl#)@x@Q?#c<$VA~f񸁽Oђm,]b_p}V5q&x8DI8	?%3D9FfդQS,aZ264ЁGTR!|lV$3#&A"9*PKng;\python/PKng;\t	.python/bridge.pyiˮ6vB*)Veo6{H"{N;¹zVL4?<Ht=d+i)(!)^fЯիWz+mwl$b
?遙sQ`-Gf
^fkSɟN4Ȳhnl^ǮARh8|axziڐ2ZufY}DgLJP^>d.αDӡ.[=\.Aq;
`C/-,㟯^f*頕"ߓ.{8q$zn?jf)imP(._%Sn_I{Qq}Ls i.#Fk:B^21V]F~Fɇ^+Tx&JN
@xnW	?Jix\eHB^C/&&LzD|;@<"	AbPII4#(K]^S-NѸw(#t0^AChs.em<[yA6[N*Qg`@hi /LI>b`)Ɩ\X+*,<}>ub]sLGl4<6
w"ϧ^eLIq\=@58Ω)bXp33bu&jI0sG
KUN4pTMo$9!i#f--LM8d!c-	޾d~LU+i.UH:6/vVsBE,wB=Ac:SE5|x!cneАQOz"[O!
[\e%xvZ&J5N"t=JYC[Nb\U>fC}Ͼ@y4dH5`,!7i5H/1JHzWo5/Z"n=q'yobapŋڡljv*1#dSA.قdϴgL1K4İD/sV1A?gU2c:e8N'E#eɈC>o#ǤFAѶߟ7'c|hENXIU:R񤵮ݥ4sLO|M~}8	nrFrO>+譐^ 6DF2$#n=iKhRi&U?0rVhCm
LF5~ևYp[4Ӻ[]Pge4lJBS+btl~uƇi#kư{ ٝ&ocO
'a;X瘶2؛:.kEqp_	nؓwa<~4Pf$H`qa2ld7KfIH]Ms
i݆u*PkMyU=4DfO~
	^dM㚗f""NPEMhPͪL.;}BE4^h[Aʂ>WLnSj)YБi8פ!r~;R(='b7^i98ig#7B+os^|v֬;(YiK|PF	>cnTyIԷ*E/M@,pXw{h-fGAf7pwoq1rsƇʓDbv:)&.&rD_"!7J+Y>cw,0
-& H/D)J;G}PKng;\ߞ(python/bridge.py}ksFw
`V?~EYN"8Gov{|1ێ +3+*+3+j]W7IMlMNˇYrzmvYY,+
<_Unۼ*hVY-iTјW43[7ٍjR1zW.۪*]m#yf~ljk"ke^ǦZ^+]~kSw)T6M(uv2eus+بVUfk.YErzWdECy~AxU-y~Zó]i^QUR/[uZZUYaZݺѓiUїŏy>vVﲺ͗4n@2"{Ϫ{>klz/wӪi^VP2SVduKu㴨]]mj4"4i6E]WR8:^0dŸΞu[hDa9v1)$*CrW	A]@.loD7oNA?WvW	~#R.=qxګjeHh,偰NL'EϤ<%tiȎ]t%F^۠|t#YިČn~uTr*QжW9NPMR%LP1M˼晁&N?гSj+og)>k/ mǪ*46ZOy%p?ԟ'!n*q %^S5
gJO/Q%ܟa*M$UI2W{[	}5]+K߰|#M:;M{B@_;׈~NEya:x`]=(DIUu
&l/fo?HY,!\
p0ATGӑ<3_G0w8/X)C,!ᴣi5 #Z4]Ve]U		??K`M[m-Ko`[e<Ѧ0HH6P4&#kuSvz:0a(-&F-PIT1&ǗYe
L/69L~+d7ծl#]8>ɶa-%_o'y0m*ZB=,2kd$:VE?	^J'?wo"uyBKTceG~GG3f=r.jM2Z~.udhj,NeFLFvmJD/{ji
5o|@iPY"cXtJ8םk
F">;KJyIJ	Oڵݿ=/MpAMȰȌYv~zҋ [eL0Ԉgh[U%e{ޫT2ܯv"hږd"55Jj4nu%ԭkHS2}2{FX;3>s/\gUB'DǦf_tOM`	`FVf~۹)9xl)>t:0<5A{=fɃPLXVUKP)@hݕ)WmOHG%fae+Ć,U:Ohz]_بr(_#1Z͂0(%G	fLo7^QW`ļ!a[R0}#؃J6}6!)WT7QYUj0aKȎSDži/M`=YRt6pļ|Tm9obG'PO5uÉ*c`
;qA1Zwc>CџίUZ䛫LLxet
Cța%%0{_i}֫@t4fUk]QLv4ֻH	(D|J{6μLΛ4pvG#B@JՃQ
5``ê7&2hw*)NWz@eD"ϥDX(yF2t( `@'(8˄/&A6d+D*/7m6;?EtLTO%1[C[PSnCvGȦ1!,/:@K?(84+IT@0߿C0NClmȯ(,f8^kM4em#s)?xj>lj{.ДThҚDDHĻ9c`SK\hu6>"vVkU٘	W"{1"ͽ_ԯ`*NU0S,4û
ݙu,)qi1biR@"9BcJrV }
>NtK*ۑxZKq#R+НK&on
L8z==,Cy1DǼG{89L&x{Kg{ofJߒ"<;G/1P<6S-hR%W|2zy};]>$]3QVe7"mpՄO5qXntiw0l!M(}$Vx	%N/JIЮ&@b:G,
k~GW鳶t1LuײCݮ3ƨ˱pl(u~;z}P1B@{2ĘI'HhvI4p<=	6cޫ9ֆ!dDl{ܳ_c,ysѧ
&cD2/D{N  |"R;Y״s/(:Ǹun3nCh.4>YO5W=[A.9d>UjZp
yC _*j%9ZT@=hMWaj]oEW&T7s:pcj|qX-qA SN?&^عoc)FBg7v~W
:w-]QttٷK(sɶtĭyke.Mv=IXOW9,5n7
cBY	?W9dȼzrDƄ3fXOl@_cp#'y}&XswX?OO;N÷Q/᥇>c!ztPHbFZ7)y*,V*փO/ˠɎ4E24vJF!v}/xY+,ZXL}x	s%(jЁI\*\ӉwNKhTNX{|vƈ5Sg؊;/
T_SQfrFZW-@mWDW*J8Ô:x̞h$|w@^XDVki\tsM5|	0$,r_eBdۼ	!3odMhm TwW8KnGSYA-Ϛ)b׊ǝ`TMVSW;^+E%fC6qDŞ*Je,%R>GM\+v|6x_~`'_;A?߂
MĿFV^gɸ=魔U8=XEX#
)ݏ<,/Puآ1Ofh{.PݱT-!j6C;8 \J]{
81׮pW],	HA	{pe.~bHVӖi0L]y(Q=z2YsX(e-Hzl0&'dJD۶F7#z;9Cf	hDSB H
iwǛ-L«6kbęe4t"+*6Dij31_lG_Bg{PpK
GFF
xl}קw4zfn.Kĵat(*Vl'=SlKڥĂW"Yɜjl\UCgDG7HTbiEOdGhZr
~al/*Б~G~BxT^>' D;@(߲D/&"
C@Ϸ^ӣ$-ZN0luVD|FL{3s["W:.	2yn_ιsvio`oWwV|y9_EHcfNoTlb{jr*YN7Ө邨kyVEViUϢqD`x-dQD;-tA>;a؏!4.<2Z;/LP\:{{˷oN_o߼ey/{>uĩӢ)Xqj"1鶀GgoEOoI\y8T&APHg.o3O;Y(32tS=3vv8r8iKYSKu5ZQ?22\ؔ&'J ť<'NwJ
U:ݟw[T2&ӫ%Ib͛mS(7K=qK+&^-ڮktl Yr(.RsCK䭠Q
"BW	t2?ҭCLcnCk\cRdZ
ښ􈨿$}O'd6ԥr<{Ìxי{:Qs00qyD}QftS0q0.vYytsZFqJhc.TL]!|~hEH~CT߅LHq!o`J-nX\p,Ѩ.OğtKdPκg=S_)4淼ӓ)ob{]g?5;,O~An#Uf@wtm,om4Ȫ{=B5n2)+˪2;ϵp-7㽸rk΂=2"AQ-z&$vB?zZ0ֲT:8SI\DLw׌ԊB~Κ⇩s9N	l0q.`Ȩɟi<tR4<ߟ.HH=V0k1uOD3|$C~ 
Ί׉dgL&ڎ":qOA j>C`4|lX>Ngg{F6Eu%NNժfۼ& 5|?H߽}'z'=X['؝?np]A2t	DΤ93BjQP:#ytĢOڔ6[hHf1w6I]}"j91t=%[=LdAGD:egPKng;\s?
plugin.ymleO=0+dl88
bwqxm5|4?޴vwgP?c'dML2*_.Gz&ʰ|P63S69oyb^UFH
W4Xz`!vS<5%SxI*c=y´i
Nw1{`lZֱPKzg;\	AMETA-INF/PK4U;\)META-INF/MANIFEST.MFPKng;\Avcom/PKng;\Acom/pyjavabridge/PKng;\KVB>=)com/pyjavabridge/PyJavaBridgePlugin.classPKng;\
Gcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CommandsFacade.classPKng;\_`O3Xcom/pyjavabridge/PyJavaBridgePlugin$EnumValue.classPKng;\ZE	com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$PendingEvent.classPKng;\z0t7t!com/pyjavabridge/PyJavaBridgePlugin$ScriptCommand.classPKng;\pwHS6='com/pyjavabridge/PyJavaBridgePlugin$CallableTask.classPKng;\Yw,B8m(com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance.classPKng;\WJkcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EventSubscription.classPKng;\P	Frcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ReflectFacade.classPKng;\~
%gCtcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ChatFacade.classPKng;\ʹ6Cwcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CancelMode.classPKng;\9ZX8zcom/pyjavabridge/PyJavaBridgePlugin$ObjectRegistry.classPKng;\A}python/PKng;\t	.}python/bridge.pyiPKng;\jpython/runner.pyPKng;\ߞ((python/bridge.pyPKng;\s?
plugin.ymlPKDZPyJavaBridge-2a/releases/pyjavabridge-1B.jar000066400000000000000000002570271514752343100211170ustar00rootroot00000000000000PKP=\	META-INF/PK4U;\META-INF/MANIFEST.MFMLK-.
K-*ϳR03PKP=\com/PKP=\com/pyjavabridge/PKP=\4ULcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EntityGoneException.classRJ1=kj_ڕۊ+ݧc#ӌL2b?˕LźP0sNɅ2ZȣPw	X9{O*‘T3TwϼCEIr=/iJAK=%]
WnY^	%W*ы#]Q@J
=y$!̵XhpY #Oe6kr0{BNU_*%f߻bX.T~hhhP#tLjeP3/ۯ'^fBJX7XNkVPNcUeB5(o
(PKP=\)|"Jcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$PermissionsFacade.classZ|TՙyB(1@.@Cu&	#tZ֭ZuP]A]i>>-ۭ[sdx{}M~: x%|lM
FFn0͞tov\V}ә
ēM{25Vug2T25,vg[km9s%{\нE@b,RJLb*$ӋR`n6)T6e̡x+Vl3%W1:'t9°	kvHtZi/B^+LH,&N \x0.:Dm۬6:.du)&+m9gvS>Z}DwB5fr8`~
x\r}ݙ`kK9̂}D@Jbg=> [Q<9EWȩkϋm7ZC*DU3V GΚ",LYw5xgaKݩԿUb7>, ]̨)Ya<#?,:IҳnݤJGK+I:'O)?^4 p7ްYA|ħp/3.ښJ%,ݾJ}ӮW-lڽ:YÓ^8!%\!^S$:9F,ϨO|j,:r=VzRfj3W΢W&Gծf12v
'Fr眹3
TNX@tS,xJovq6ubQ4TR1q!9Kj:VO]=ٍ$l.mvޣCETs.}q¶yY3tP9\)Z{:$9,VQbĒN΍AU^U{r)ifoNW۠*f]4(Z5E	mF:1UbmuU3]8@aüRt15MJ	CaeS!oJ!LVL	~'H!BLxw͑~1-$*tC̐b{8ۣW4K;~3Qx&ll&V:J
x;FwVy7.檢q{2dʼt6b.y*{vQ=[9
$^MO/soy~Qxq~!(l)=W>y
ԧ:ix)FQ7Ô=y8iG0KY犋<6{#^%Y=ʴ%aВ"BcF¯`EGh	X[VZ(x/
x
>]u.t]XP)2mxހ\K)
ZTP40ch]޽A9~§^m`R
7hoQ~S>5fcL9$~QÏ*ݕWhͭtwnuN<ƭu#VߦAᗢ kt9w	?uU G]`Q>!@bewwaiX*h+I{UʰSܵ'(Wwp8Mut-t-t,:]v}e%͢7yKWvFg0&g

V˰jTOczqw=`Cw܅q^t76z
zq+BBt;E(oGaj8܌$v>}Q܋xB>Q·pǙ-"/s'֘ne	wt3[j`*[v͖CNG:3yWZPㄭKYA^|QϷR6	i53f<[HЗU65kttayaU^A(,6Ʈwg:U	p?|>N
$Qɧl{4*nr
neNpUƃuJ>p9sZMܓSQq渘X^o==EFr׮rD3jZ
eG_"hQ2aQ.fש2TlU_PKP=\z./h)com/pyjavabridge/PyJavaBridgePlugin.class|	|T9N&kسGq%!h0	HXtHHfDjkkkkUZmŶjjX]mkm]Q~sߛL2	[yﾻ{gw{!E}H[)rFc[j6uoNtuto	Gjwk|3G‰3tiLOw"QubH.UlGu|dΣ|-*id%@6[B5+vɄGrڑpdX(@bl,4Ʒ6|T YlhÔH[(KGhElLSFvthD@wEڶƢšve*)M5}vSmFәЦ-+:B~&δi,dd鵺;^lRʨ)%ªpv&^&m6UI`$*
56@'2H6
w0;/$&ᶚEIb>C)m([#Oi.bvo"g;GiEgt&-d*4#;-57m陼[B:J]rc`#dЯ_'R΢Mh;4p-X8e3mq etE65Q3Ӹ:BÑs:k̘ӭ*XLUjGb	뤪ޔW
WBXs(̲l]q6#!3E1MLS@5}ziӄH(QݙTwD۶ƽH@W`<6Z)D7ucϪf>j'fV0H^ѶH.Fc3pSmi;u ;ݡ!Kj`Gl
`*KV2s;v8Di
шv`MMEˢK }G;N)ޡ7Na.A'Af"vbَ(eI|xݝX}Xʤ5S.F;Bv6]EP(34]iL`kvk^41nuL$	c!;2#mZM簠-71x|2$z{2$/}3;]{M_ 7vX\VINq̳;"aїl2}fX`uDED
~vi9n<{m*3X܄N]!c&fdǀȧt7T/	&K0_hҰo>~&Rz#&
"hی&=ٌ]x>^tb쏾P<ڱKרxXP[m(^FoNҋ_>z;6}=9Hޣaf4
ƍcϖf&]lȵ
dcs#^t XCC
\>O<$/bHHeu6/z'^G/8lx|
yC%xKϱQԨ7uԥ|SrԌnYLQFgd
Oe5kl^kj:^[$ar,3,dv1h8]Y3,?ȼuln}aT[laiu=cfu@%;ŒZ;1p.D13C	D4iHL'7hHd:q8!;;x%NT{L
iK#gHH
Bۆl>q-	m-l\J?B[iN6N{?fjtnq2TC	}X|M4z&uMu6?T£P[Gvi8ԁd2KeC?7X|7񞤲<\ ?;kdtŷ$I'#r&w?gma+_~-R2a
KdGb󝼗iiHEƢp>L,9BS6|b-߼#q2UK.2c{-d)(I|yD*d6Sa:/ҘmX	_jW-~8*CDWxuC2_$sqw	g߁]g?qcw{IIb%17jFڡǖ.sgt'-O`M8#7qF)0#s3"ȜMRe>?B_0v\¾43+9FzemK&&d
Lӆ8}o-~0"ǜ;sRi&,?!dg"gկdSxN؍?,33G,4cq}s +^2qFk+*tZ<$`
P:i[6Bah{Ȅ(
2eQEb[)Mht-qxXŅC򻤐S6V֘m|}GȊQlUyLd?ť*y34;qgRv*P#,5Vj +JP9	DGjZN'X&5Vن܎PdKbTMD5	.޽)kLiCC֔a5EzifӋj:SdyM65VĠ6~&W*U%qVSS!*UmUNHi8m[{jo?gOV5v2c]	IL.|HŲSmuQxhbp_]uXV5hl	%[}ʈJ,!]y(lY'KSF|uR7j؈	$W}U[➈B`{1N)iN:n
r[0(
dQ"wKb%Ұ%@G26b;eE۾䋟FWm5Qn7oUw
4Ks%]W1kA١lu׽s	ՃL ۶v\4Mki
HΛ.qj|V	`4^Hm22>q[r98ԏڏ4!3II8^8Ĺ:/F:v߁HgCn]ٕUOBFs4IDMZK0y}i%ݧ~l	v+R2WS?P?W?JsZ_VY8[uZ76474jXSq%Vc2Fwu29Koo3
&qGcdzzQ^nxط8Ɨ4<^]
	u+y?rU5>Ay+FL,wQKvO4{\4G#@ŹcRi܄yyYR<'{5t5wwn
V)_cM0vsF9sX7~p˘˂fjL
J=4F.(MN9P}=ܛҸw	i˼B(t,޾u۽oH]甆ۚVHb7]a,c0qv~~b/
oH&8@vt_wW	`"$Kykqýlg>%.2ȓGS8LObe~4,\2`)8S
8_:t<%)Zj]!J#<Dzw9WP@)39u|%YxMg}sLO* it"-Ԃ;:ų4$sUJP0	C̘Etay19q>Ƙ9 Yd>ѷ"ipnρґ呦5kOB
fgOwD.@u;D?̮
a(81l{S߅EV"A9nd]$q7Lo6CrI|ȁMh
M*$W]n'R$Vg+FJm滓.@]?l#=}I3	5ۈ9vl*N2-?2;ӌ~dU6~+IBD	v/D[ry3b|{MpN6!e+$%S;ڃ3A-;b0\/ϐK]Pdm>Ed͗dɃԟ's)(l,9F͔8g><X
bK	N1ic@?v L	!ߘEX#-aWvVx]'әf	YwQ7ӒbFtoJEKi@2$?+KRYUE`;(:qP<>:MIHo8>|ߊm)<;Nwwxil`
:Nr+x1O{q4(`>^72Q'y=L33DKb9JS$JKѴ.ܑ9B`C^OZK[0"WS>5@fkׅר/l$_m+|xJkɡBAug&l[ԉ,e6"Q}H2ؒ
W"k&JukeX'wXI
;PJuv1=z&47\P1AI8	v;`I+kRM0ؒ?׿zjA|-%!t
my|i8ÜQy!VUµ%̅4Z'.ksl`{y΁g߶4n|w0ݚApng4Fۻ1IFO3cN$M>OgYaӋs8`oi7'C5-/	\ 4K(nyV1'L*ɿ\j_ߴoigꕧ6202WE"`ˀ{a^2maЬdd3ӧܙ50GFU8>#
$)EM{hdQ8P<;1;{1M6OE.|u9v
0ڇh]Iˁ1:>N;j"}O}t-=Fa/#v.ByK<
O{.}=g4/^ob
}@NQڨ? RPo/m4ybMIfT-hͥR^բZ>֠KtFkzZ}iZvdxNw{Zwnv+]~#m:BA(f:݈kh-]X@93xQ28d9sB@>K-jhE-hYz(F
)0?9=)BnyIm@.={=UC6V8@=*2J#ڪdi?g_zUA{ilG*z Kj}_y/R^~ނ^w-zuyeU[SǗK
g/#+ЂZL4L:^i-Gm]}G!t=Ewo\F~S_&3.AcxUtUx屩Ng/+VPY#<#H1:BEn}uWx7`涼	)zqV-OxTƓiJ.IIϴ4iI|A~+0?4ܺ-
R#Bi$j5:

}61b'}Z{fZtCr{N/_u?p?6Vxzz(zG9ѐo=_04FNK0h
/^L'pYc	0		I-1jeN7Zx6`_Wq|=~6fTrxGs!ʩW/'|>˖ه5%[f
tT)=MFHuK99[̏\QS3D|XQˋO"?5`srG4z6zG|"Qͦb5=j<$<|n>*D3aU+Lny-<~+mu3/2D6z[y3-™	ӷg9B/q^.`cqsXy'EȻ/֗|)0r\WjVr%2}:DJDct6Z}DzzRFoz9>IPT/Q\ߤԪoq=՟GjxM>uI׹jϗ[PRޅVӠ]J3KzX+4Nq&g{ަI!|`>`~&[@za>JgQ;.|rgRjnWjD~o︸Q4^	nUg4WEn{⛓w}jt~)R9"L=f{Rtg9gџJ\#HhmHIQHCZL$ʼn}Fnڀϕ5_R|IY%e͗&k!kAdH>817SWL]%>hm?'t7?t
j;Bi3Vqn
ŹZŏA	-v+0w
H^XޣgUxֵ&m5L o%fԇhdy]^-Rq||pa_ͫX$~O5J^o؋7z߂BxFϙwf&<*pJSPʥfG땏|DQU@U5Rj=&/$L/5stf)j&fa]|Uf5_jmlE&<çiFzNՏo&eLEG[?7rwP51UFv#+C4ρ$ԉp9T8#R7McGwRSK;k1#EtkᭈM}&z[4~J5,_"۩,3U(g}>3FRP:J\҅(%@ɥJ?t聒Cxk'ݬT'pѦ"FaIzG5nt
$Gmm@i_G90@6O%N 9Ol~	$8.`aFx+zd}g6h'KӠXh_h$t?KxOE[V",Ep׆Bj/{ҏU!Yt
GސOYPpp2ma, E\qp39C
r(*eC5gdh[ġ҃ u)L'joՓy#m(C0DcNQcs3ԡ&Mc\M((ԩə7Pb]=Yt}^@̤fBlvJdvXH䏲<$|nB$Yz=k})ӕh5F#}\fsS
ԝ.#!M1z)[o2%<ϰ::0iJdZ9-0-//8_ʸKN\"o2.ZxğN?lFhaQ2mQQ]M5
c IE=bF{
W]L1!lשUB77?i$2N&7(͔0Pv@"ÄW8,9=K
SeQ(	|?.0$896{eZ>.;^%,^z<6O>Ro)=΢|Kbʞ:u{&EC]~eDZ`8B#8eT`K
ZdbeKQF`c-Uު˨F*h8F60n\-^Any4ذ}H*szfڛ8v1S0L$d(]o$CX*0+nidRȚXpwdE=OnO8=W˝P0tBPltOa]L䵫*cj
w@|S*
=}t'u4G3=ΐR懏C%6v`^)%}_2?(bbW1ΉUGk/`RHZn`XMd[_a+@tҶK	kc0K3i[HPKP=\.$Ecom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$PendingEvent.classS]OA=A?EYD0jP"߶ˤl
?D?
35H0N2sf̝;?OP2:ȹ$Q0(]9f|!/+=yEKJP0c.Tԯ:<,A8fȭ{SAA,0
UtlX\:Ee~n4/gvD!Ed/`U,j#,lPKP=\bFbv7com/pyjavabridge/PyJavaBridgePlugin$ScriptCommand.classVsUeMӥ`WʇJIhKAB[PH-&lv@?^|Fg|À>茯>8_s7!6-d=ιw>@2,;˔ݍebQ3sDmdM=İ:ҦXڵu3h
*ڠ2"X"3XeO3yNgm6vjf3M.ſ&׽c*^B`h՝eӤ{o}CurBete
;^6!rCv

kV:AAphaq͡(w-47x,Xfl3S<Ѕv`'1in-*rrk~5x5xo/P\lңb;´:nB"Af1A&[Z~e>°[fحbKy&z,q?^%>.[ί8~B$SBɰj ^WpH8L6K-U6BNǏT3
c . M8J9cU[aތ&̏!YN+xD[HBȰf^A%LḂ1'D?jfp-͹iޡ:o)u)k*,x2twf⌹COdJypka37(?-X=m	|^Xr+Sb`gLhtH+ewR,i9bM{(
ϖ]	'w?5iɳMyFN8ž1t6A]YmV1,NϰK}b[:)C*̰u	2,qm4I+qE‡|(
gIU\kG稖u-;nXc
t'-P.5BNAoy	0Һˉ_u404Ꭰ{k}n)ðmI(a#DDÀ2r|4I'mCȎ|K=Œt-yȒ.T3Gf'01&,4HtƂrC]Sj<,F)jX+
\(rPmA_byVK%rPVm$6诈~_Π5bBz]
վjS=ln!^wi5fGvTwV1Z[9b\,b*zR$z.'MSұ^FÒQYSm*>t_K7t?ItKwϫp^pv$R,JeG!zb_=R8%tр9jCR
D#qb8Fs'h0PKP=\78com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance.class̽	|8;@H8KB(p9
q,dˊ^U*VJ8lZ֪zZm<3^&D}>[;3<33>8l9+eesVpxpb\}#Me#卡Hs,衠'b0
#upPټue~غ<<ܼT6I J	??<G!ǠGA_z97G[PslZ`lŜ`*81kG-p9ƠWU
/G((}[BѦp,%+`&s`(QY#M
S-E0@VZL-TPZCxenX+(=j	57XMQhe0mmnl)Up4|բ`Dwȯ`L4SrRܺ 6tI
a2`|)-#GQ.}JǦ\`NFᦐ<]ȯ(\;uٲP4԰D cg
CUG0z(?T̅yiN%hhb"uպE{>*[r?̂4,^"a	KCA@5ԁS3֍Q4ݨ,_N;pT5b*vjk	ADHW6΋DZUWHMU!tp|>,#Ff!T娎i~X++X	pP;
Y/ܼ,mM
i"uyH=فy	~;cm}HKrAd̆x@W-i2̸VX2FY -ehdM1TN2{m`ǼP!Wp6|	L`va`.O|\\U6蜋2sf5p>1(
Fqbۋ\ M2Im\`#t&+JհAHtyY]U8gA͋u	KsA\z735YL"2lp7+(FVQ"eLiF\k3p
¡]!d9(2 Uzׁ:۱JXuhmnQD-&`CfBq1yf^$-~x~,͡(QomzCA-WlG<;M@%DSv(	-#ɭPq	T#(ۛ*I? x"~
^Zg:NVDg?WzԻC	\u_:+/ʺ:/jQ31`ƴQ}!Oȼe
Zg+}zRW^ዕuD߾o0J#5$ η
Crz&\&M+x' 8zQ8䢰qd` ?)[Z(xB&퇿|ow$E;zⲕV	r
>0TUW1!mfޑQEg֢*4CaC$1fmʴ}_R|Ӳ?Z"onk<٤GdqR)D0lW{
#KY.^.}ftt_S>6TC/^rrg5*B".hma}O]5QR‚\'QX
d[s6~DaW5+vMA7l|O)a׵l;a#+z	v(PX1L@wJh)6ŜEpQC!䲱(&<ë.D5Qlb`cZŔg&EOux
 Iz-dxf˦`q
flx*2yLOڈѨI{H&U2# ?杤XM4ċVwbӪ,Ѩ/D.AbA(v
!q{p9UPҰ#m(j)wZ4M'
*V>w6(ܾ&wGi~`kP,V&:b4]vur޹76+!6t5粳+U1bq֊<ى
Ql-[gXU٨;DWZIOS^cOMUacp!iYU]谋2>;`/X
jkz~az'sdktv&.LmDk]`bvSWI
R8r@+1ln|Wj]îuu]nP=*mvT!IgP{f7Y4z	KVnc#7!O'VkswvbЂ2up'g+MHfDC=Cnټ8Oc¥$fV8*/X/խ=A^-
K|.
a$-.mH=Dl'.n%4I['	BkV(IU.oDqr<@{n̓Y&~5^Z҈K~(m&jtw)=,ia`!In9	pG
%Mkj_uy~(?l)k^d/!#NNt\[hu)ו?TEcta["-fhC7̅5lȅmzo:SL'ZjZBk{\s	gbTg1b3[Qd%^?-eT65L.&Ҳ؟bau3ZkVPj총neٯe.]"
gp?q6KGgVScJ`PmMW@|;NRk}o;@I:ʕ`*8B92Ό99qrG)_ip`t9-{@`j s

4

C&"]5iz!O~eX:h'?vPa4FSʲ#ДOC˃u6!8Z͡Ḣ7hGhol|$*C'=Ds!6Uͨ9mCq%oiDysQ|jiyuhG+~57F`
c͑F%>1+HGO/'N8ҎSxJñ*|

S%TS?cQsJ
bSE*#CH$T|62LK	>'RTy<~2yba9__Q{.J;=}xMr9A=Ee`<t&4Og>ٮi&2ܙ<:	b^2HYU\CeC/dopj7J,D=r@ZNKycӧϜ
Gc>}c=i	i6V]aP^ڤIpڣeي&*P%\f]Es?dZOh3un"D!0Qm۵1}C)u!f?bcT6_e|e-aB]"9N,K>1@Br~s4fBR_`pׅ|N9~yq8&zAFV7SmZ35
~AzbkS9!6LZv'r \tɐl3ZAS~ؘI̱.WN4C2()*:֤r4sGմr4{GC#Biߊ'+(X|
PI!	ŷ6OLUd0%zi;Nw$7ztVuckEA+?"
\ˈ~$F#Wr4ev^4Dd::Zwls*/~UP`Hiz'$+K-5K]PFKL{Jd\_WI
Y)V7Woa=	ii>Ju8ZCioqպH4LAZS5fEq?x֜5vԎhhI2;.	U;q!Ic7Y&E#]SK\op4Fs̀,C$+GLU=__ÿ5e`'$h](r&qWi/ |Myq
;Ok;'j],حqX]k<sEO
HL1zVu]j~Ja;iE06=b#*q@cgfkeXWo%$dS S|SP@!9
3aJ#SҺX؝D	b40*mYS)Q,JF_k,gZJVLk8{vcIcG	<'`mO7`$%	0۱*eA2	JL[kfccPT%bmdb3,Zm(Z8R$#)Pmc%\u	`zCdb(fQB%	}&$8p0/HB)FZvVݜ^a	Ӕ8]a`&&
S3?-&z%̴eJ,'& %Hpf	mu9uH>{q6٬JhA+oY8H"DLMLJ1b/EtJQ|Cb(bBRY+
VJQK]@l$=Bohteɕ->	W͋twe˥ؚ#]iѭ3e,$2TN4_'_+=n&/1&iyMUWS ~A̕ycXx"&R+9|;ہ
I;PP_-Zp
Dy./7n,[eɍooG0ZeZ%&ن?}L}P#(9NUϭ\\Y=v%3/ppti^i65v$f#L`*Æ&GM:^ّy^T)QTƩg*?jw>^	ؕcT9BRW<בJT1W堾
$:ZTǨ@<qrrF-6arGNgp!lMCg
!&gR grwhrd0ИoȖD9ӑUve^	p'3d	P
ɇв	̢Ca
mC}ȥ2X.a{v<[sP-7#y+5_ َ6s!"Zg}zi"FgQw`oIcϵtߕEWItL|5:BEkM~WKނͫHyOczR6x9S|@@܍]̪>FEGe\l*~XOF5.I%
Wvvc޿TbZ
sx	;T}@P'eKl1JF:2wɳv%\
M%BP,ԝ,:ܱL-3#Ѧ`)H}[[`+lZ画V6Zh	޵zc4ڧ<ӮG?=wX%v-
l)@*SLh5*Ic
gt(:Rǂij¹(PYt4N7Ub2D.v'1YiC(ec6HE%}s)7ἷơбl+ɋ7ֵ%U^UHu۵V~q
jRV!$J*AS'{"PqA"\,]0!Vٗ#"fFu_1}zm9Sgwf.R6}PPZ_R5n6.s˔Fҹz~je|ƿT}U*4{pEe&e_C%-+ra ?\oS7(wu06a߬8{s;og	[{Ⱦ^]%oGw)nGҭ;~}#=ߧoU}`rtB'{]!TpO\4yw'~VrmcV֌328̿4@/D]m?&=ŷ{缽K6~ztyQK]k?eL%+"B({S̉GU}Ӻ&ƄL߫ܿe'.?+]"7|~ы0%α_f0RY=݆P~~Eٯڿ5PIIƨE~~ӨJX6)ۥIK%u 5+]'-$GSl:wMH|VcDCe%ixiU'Ƭfn0Ώ&c_=i5?/c=/kFbG5~v3\__Rb
"Y=rbm~YAU>JxawIוֹibN\n
	76c~vc+ǡ
鵟jrt:OC4NWPk(q睞Ew9UUޅrr:S+H7N
arO90yrm`rmҀ7grP+ԐA
vg7;)Pg.hϹם%(X6a3R9t&)R#vD9޶ySƠa̞lYEl]sHJRqB=
Ñ E՛,$k 9|ߎ77h'*XgwTN}金ƙ1
PlǙGgr9ӵҨᖐEr_;33ȻN%N'?e*}
שμ{UX:٥4wQ:^bjBvU[ Ŋ%+t_#NjRʺ[/FwA3t|ץ3)t]q?wʸ)*قi@raM,srV&*3<NIGHw#뙝9މ(FӎpDC$͢ʉQɣDɅ顺fBĈYMvͅ3ֆ[{hQVYOj@AnYp8ss^b!ڹAv)2?@`/P΅E#u-(/yx:4h.\shj5(]urVո0ߨ)vMjX?٪N`gZk!]l٫C+hsg^d!oͽ0U%⤟v]0`38.<;dP%V$\#`|o%2\

ЗS Qno7\L+]Ctw2=\JHsͫQ
uhrТPΩV[1*M>㺇jT\Sgki;/yTir*w>;:ob2(3=;q(?AuֶRqL4Dټ,߯C#8(اEYݭhN5LQݴQQO^^>H\5h\e|E8ݯHR2ܒSڇɴMg3oU;3ݸE陦"4_G;Gl}&S$1Id*gAKJ/
)$Y3MuçŤ&@6#/דi̻4ݝE&Yג`݄>/Nui68OGBF:q\$	0s띹|GLE*O:`xwnk7tgK]ZgLomIU]K~'OډMݰ>Pﺡ6h\&7FJI=XбSٍW34㛟uA7ܰL8Xzb&$;9)WN`Zq)~ͳkÖEG4nt1RF7jKs@"ڈnBlqĵɰŃE-&[*Duxw"TfW%i*YB:n'"$zu&E䋹3O}ٹ/
=\.<1~ETz׵. :PoP3Ūr9؂>`LGh]l_9C
EZsHԠhsJ$):?$?MzLKѦQVo.X>ߍƂu%C
s?"0hz*mJ(
&'ԙL?Prgzf=@]Hݠv3Zb7ׯ/˭ZNzSԯoXvHG1۵n`$=/_;s.6;/>W&>>^Rɦfwr&es+T?&҉=e9Slbgom1Qy1`N鰭$, jJ>t2pxdh}ȄQ(FSX:!7jH$ZŻw*;49CUi.8jcGMb9`|3[`%h7ZzYp[K;
j4RwV[dn+Iw&T0Փ@*&t=qUP 9(?g)Hu0mS86&f.a;]ZL$M/H"ftQJL}&D)!|3}r|(T4|lzp}ӟ֦-@7|2C0wF&Qםܙ?.!(Kr|trp{q/wQ;]KW>hCȸQ&9&:+M'o
ƣX&sV6(Vm"u;ռC&](h4>- MulGŘF>>܏lEUf4ّLx.ND̘Fb4M ^}:m
|'!M
2Иjm:|2;?ȧ<<$a^]zks|;ooWwpUZR,!MRo߽g&IP8WRx^I虩@b!lvH]@2_ftx3R>kK[o_x/-gƥ9=ԤEq'Fd\X&Ϥ`"A3ot|/gp*ҎOz0O:.R&]Eqa
C@p>a=^/ӿ `p||/H{?a.W>[]K;fߋT(1;.$[	 E;=	Nm?>cvm#SEEb;oJøplQ[a6݋";	N|~-~=L߇YvwnXSrovKR}fch$~FC'
<*Tb=٧	(=g>pa:1@LyӺ[F4;7RA
m|"4VIʓ0Fʝp8y;,fjSg[g:6XV佷APUEgAlXSSPp8o;\-wD=mnw>Oc
~J?}6xWlܪfH1Ȝ{0?y	81x`	
_
Zpom6w5u
#Acݣ"COw5ik?q k=qOfĝKc'ËO5O‡5^=_lݘ5}<&v0{;L3sMU櫩y;Y67o966h2EEy$mz!=#&{2MI.2#`03L+pV:_gH =	5v݄sM"$Y`9g ϝ!{%ĝiF#kXJari}Pc'*`?E%u=eNjCJ
^nZi[a
3.~"yΗb?e72ݬ({yv9?WMxN>gw)WLQ1V̟ZX^Tk|>x(?Oswmg~O
 7'@xm学֩xDst=˫׋!v& >;rO3k(o|_on7R=v&×Dp%Id.Xǣ4@<7cVFxMwշ@?e$
̳,i~~Y;w	
[	pr2LBȔA=r3W"0]uZTuUfʼnD~-C>AoFPTDoF~vq4&9:΃z a\D8li(&獢FGQj .nenn|gfX?`A[?CɁ{vH$񣛡7QpmP6Bd'2FDzRBx'AӂȨt!{Oӈ4l硶&ɟ(IKTii-pUh#7I&)Hr6A5J	Fwo	`GKVL
HJ;V(O*&~t~R?5DK>` a`uϴu$/7	ޗ$דI.2.`}_{y~>~59__GOj7]+Wsݣ5ʉݺ공i И^1޷ntuη(lJtBM	+)	%PO'Tp"%tq9xJSstKZs(Cy|o;cQ=;/aYN'MV!pdve0ʵ	YrN!_Gr I&F-1k	B)[DOcx	%SAK;NOZڽOP顱H)oj$DieRFӀ⋲O/5%-VV /?@gԟd[NO1}4yѓP@#qIN┐CrAI)'KRT/NNʘ?)ʼn(AJ`y[UT
}PǿKY-jFB%guMؘL	m~C{J_{M[{ŊpTXi$|ϗі>
&bD
9ʠ|ŭƧp|ӝOW=j;cb7>KlН
.*Ef
.A`rt8=\65R,\{{*m|4t,wg8ZL)vؚ#ބn[{V/Ou8y%vCW>	u|r.#Yq+g~47~~R|>D:GO'z{*~6":nیm|z6
_q#(3OwAooT׸-ϱњj0ױݳVDz;Ӟ
sԕrݨCb,8>|abݞ9pӔov9}Bw.wC Gs߿S_xi{OGkB@"8^*pA Nu/vJJ/$|rG!Gw/4csCS^f~&õe`kǥ4G'y
C+Ի
bhif(u%6>11#V:a#99l~;s
N9PO
*|<,<i2Wpҝ(M4Z0f;HЀ_ป-M!_',
Ct)v8)=;QdcC̣

%\j(au	B2ِWDބ3M޵MW`i:}h G׻wb
7;1EHjq]1`:_Bgdz(cP]g}E==7x蛵Oƈ#zYERlr.A{=tZzcot~RRC6xL+nhTzϘRc[&IL
Akb9B֤]YQ(BQ>#**kXrp[~Bue^Efŋ'C1bv{wsFHi{
bIPM#?!xCO.'6=\4.ד#_O`ui_O'ۭ H{@Dp{!4'hA/qִO1VfL:ZhB;Y[m&aߠOao#]/Ao^Zh=|'[;۴5)-BQ8JVkmPk=ΆsPҘ
suޏOq~F+zF:F`+/@wO
)PĔVoI̪Ӭ)ާٖ'"%[qNKf1`UڏYKA8s8@r̀@5 D>%jk8ml]Epu1.bk#`]s+au65puD+ςh/?HTټp9Lm7BQ'0С{	dst}Sш(na4:?"I%I	^/Zro%#
[ 7) 4!"-7}V#'%UݔTnʯnefP6ƉڒbraIQ1+MjHu8ַXzo#au,z@zεfG(m6Ն.e/p'(hCx>,PE-|iAAs>t'5"0xAkH4?¿,kGNr.rSPa0!Jߒy|'LDNۄhS֍FKm}zd@Yh\6ӡQf
EL3JysX+Y[h&U+꡵
DKôL
.mD4j'fk:6<
Qb:C%p,w.g8'']YןXnt0Y&'W[KpݹC̻DXEb$Yl!+Ӫ@A*ê(mSħ"ħnOňO=/Sp&	xb3a#`Km>	_8ȉә-CkȐ5dQlxmG]lI&_kۯ7Q\9`I2ƞi*8g/0ڪl0:Pڦ
)bq"k2[0̟и`i4hvyn{:s󸑳jt@26C#konƴ3#%/:RKmETgN,7DT[{)}NoYk+wcmW6/@!DH @6w>Bg>PgA~	ٸ\
sυ+<_	7p7_+5_O`>7|oB\L~+ⷳ|)! _UAGwMxNJ( `"NЇC=Hn%X~E9P`tk9:'s	;NHÞy(HƸK^?$(}>3Zw-2{m\w6]υN"BҬwt|%aмdjְZRltf76~²Y(a	t=&a|t]Ыb94(&@Tʩ@45{t2z:nѴ4b|79___=k|}.2Oƭ#mb
aq,*64%XEֱb;j'rg!'#jlÂ%X6O5;pUۉ.$0	BKZWנ7ȼŒ#՚VNރbz]HC4,@|CΆ-XDCYB}Ο/%^'	%?[)9
NaS	{66#la_Ct5a ۇK^)C>4b>4N/1΅Ƌ. 3"z5XF1gğ;P>sŵ?:@7z}懮\dǃֱ|~7Ww>^dmU]mA,ɱ34Ab#Mx2uZVQBcpM	K)![',p5%K%̠|0IRXJhfwRJ3OZTL)-?m7`=O)=:NCH`_h9GK0CHukRq0mޤHSjz*89i99*{Z1KNߙhtI}uQB";l&J45mױnn?g0}~fȵ<\
sLX6?B{"5{f{giHayveY]a:I}\#H'E/obbtC`4+GtC)(ZưiL#Ly-Ng2tMt"'5<,XfyEN8v1anGt~â(~lm%tgCW-V5bpclٯ,~h
),THDX$2UQ-}"BDhjfffhi66l+ښD;4#81/͙ybE换y(6*@S͟毢yTk5LHJDKƊ1ҺXb1ƺS
qNL6bU-η^Z_wb!.sLeGl.ڧ+J{X`OWky:&q}ѾC,+M1خKv{Xj.}b9O+xXTb%&W~0VQ^bOcN<.,'Eh-6bgEGEtբXԈb(ωy1Els1_׊b'//Okkc[RexW2">AC|,{.WrVnɽrsc95 _i@>ѲZ@#vqyƐd.s++t3`ӟO0*ՐkWGBN(s((#fꟛ/x}ǍC\gwaeM*ʼnʼn\ȑv45Y]n}ĭZIbpt}ʾ	,]c?i+{4kkemA!{k)?rnQx:̶'`anO8{dikOP@!M'ɏͼ:mFkYW~xLgh=0HN){*oT(FUHA( =eQ~[ ]3ǒaᄈb-JҜDcQpYk\9ڜ00y/r7HcT0է2Jr{ok8]Hsfna[i=U!anڛeAGafӁޞHsEnDcnI{qȖ^sæm}]j?/|'
G;i|~La:B'>ߧz8tꏯK3^v=ެ#`z#z+o_,4x_g?|f#UU5q{FH8/B,o7jovO{
^ EB:9TZ	Y*ps#n.iݱ}K^pQjg"XCbX$/nE1O$R.j[j
V3p[E*ԣH:*,SLqKB1גtk]x|5n?ZY:v%9m0+{(
k6>QƎh"mDFbofTQʖԔJNWk
x
ŷ'I{bЋT7N׋#@މUh(M#/$8/tv	]ۓL{WANGk@cGV;B)ž
o1:Hi4eqioR؍~JWFm>>Sn3ǝLr唞SJR;ҡjs=Imשo%Qipul*·i~Cvn#1
r'}jW0qYxRƻ&zU.Hm嵐hXn&&.Ma~	qqI
	9$:\uמYjb>%K-3Mk,QBIpNΩ)IXJ=\)~8?uVeܮ$s#?h$Wʜe*Φi%ђ0 6v^<%$jH5!m+5d7hK7J#(=O2.x|ßȦmD2Z]rΒ6IW4Yý2e&YSfë2<8,Y<ePd1ي6,`d[6V.|ف-a
#*;3;(od;"B^){doJϸ^a&4Ar9X-2V9xQ3ސÍO'9Ҵ(3$1crK1r|9ޜ#'
9|RN2w)rTz>Y>')L>gf 7fqdȗ5*61Hnȝb|A\(wr)%q/VWAK,b=
q(|"?4҇k>704Ն~޻B}2P%#6ZZ'F7hZ#D~blJh>6uՒms̳RURunjX["(۝~۞w}kne#\,Phl*?G9v5ekͯKdAKת\ir\eQ.@b]<ɯ0ۍܞmx	,cp?_4*0,s; o}]/@,>I5ҮzİLmA`_0/8(sgAV[f6
̪(puMY9;SNRdyr:6]=GP|e3/X3Xa&Hc)G9cIEv(B1ȒB<{p| d
2{H~4wTS3z慫7O%%H17D=Õ|fB(&{>T[vJ\̣JJ1}RUMؾe']*3͠.4}ǪEDB=pk4.@?#Ro0H5=	
Rɀ@=R;&3h3	n`'s^6JYiQT)Vd(Adԃb'VmTUUۣ]s[viGѶsXfQT"1x)nez~0Á ?kCyKI.|u!J>.EU/#y̒̉q^Q?4A;`C?g07}T;gSow =e1L1(T&tQ$P4P*nRYXe2Q'/
VEXv*ƺՅ:UWWqh'*!S+&:7/@cMӡ
{aӶ!<Q9+`9qYn޻@1vHҊ3@L'r6ۤtOTKa2d8|8Inf\(rp7}7'M:l bMBh!x:`ku0('m??yMl"isWײ˫D9C^y&k^&u A&|$9!䣽hk1%q,/]	)>9(ͪ+/6QAS*:rTOD^p
g>|`:.W5!|gSUeWC}3>Fl$80V/*"P퓩j+FFNo{N?;-h]iĚzl6!i\+ق꡽U(B˫Yf9lmJTj%iLK@AvOĽ`^*"/jjn/c~:F'|qc
teA/*HTYMkMtgFj>|<Z#|XD] 5tijwBU@$$C~#y8vfBKĩFB:qj4tRc*5	0AM$8_MTTF5	ED̈́;,Pj<5>WWWjf&
,W-dՍP-mlҙŰE#p#Ҙ*GJMIjHgHT	~֬EbH1uŹo
kl}*oOTu{>'0YI0Z!
LzHMQ9ccl
	A1w/[όjdcV++
PAZ\ne)>Lx?z˅(<0IOKJc!W;\;^ih~^_'%7 kG{T'%)D854:|?HqHD:UHW#~#pzWkkzU	51\jC
֧s|:<ٌPvOQ$Au% +/ߐ6ץQI\א6Cz9"/iGو	s`0>S 48j#MP6C[KU`U
g)2d|>7wCr[	A_}w(1UcB
\$t_=6>2ʼڃ^VMYylxtrtE:L[b~!!_ޤj8_XAMmHJv@oanuMƼK:!:'S
m3>D/!zQ
]4D;Ed41t	#м(6{tvGg'OX0Dm'(rt;:ya^)4VCQoIꭿ]B_}AjW[$ȐtJ.sʻkHlq"UFXX	tɏ^zA47Cax|c6yMnOPA+>V!>DV#$mS.09LT_
Y`ұ1TA#
Zka<`sZLՈ]_/:#']$=-DK$?^RQoTl,H8?)r9責Y:R{D#'AQ?'OVgk.)KZPSGd5~BTT+ruw}uOVq;P̭C(akɚ9:__IzKĆOTo8q8gM(2Q&uL H%Y18HLCEq*AUdRb	k=م#Ic:baQC!&F6#Ge+P,[TKhHF8sr|~n&V)fOӹARtmսv>-NiE .2yyJ[
)ѸSh?9:U#B쒀wX(U4-9UYHHCFWikg{ոh2HP}w&C3l/RZ8itPN2h4vN&tr1tɆs\d'8M`rNpZN+
T9:C$8䴇9QX:9Y?
wN8z"C'8I_N
1lq.^j,{u
Fct[{؊dUo=]ec-6p6Pl!M--ҏ9W%H>::HE8"l):j%Y+B_p9&}W<la?P*]`mI{^K\a
څ%DL7,;7jJ$t&	UbG#ErrTb!-
7$txrwN|aB8#XXALNeK{^׭)
{ũhfJwfF^2ֿea	$>L`?QĐ;s
p2ы.SYsb
S;@0NvY	qsry/~9J9ʜ0ӝA0!psNsc3	Qs茆_13׈qFǹx.DX3e;YsSYs>Lc%tB6ޙΦ96י9U%ls)ə:sYܹ8k|ASܓP,.s]}&zi%ײ,כfCl/vr<_C	;ȳuWt!dah
ILTv@9kT[=$\ӻ6[}TC?tX/*͜B0EQ[L::jp>V$JbK&ՓXMR!F G4dᘽM^ozk;j-ʑA{?ӯ1Q>MJi)),lҰdoK:NI誤p<#dLat]*N&z8/|[sռ4]3#.MmSkQ?
@r-dǎБ@P
/iK}  Ga+Wx[ЁjW<ݿǺH\ܼU@0Ã2eT5Iljǰ9aO;tWWB~)}\61
?a[=+gn)^`y72A̼A_s97WBc>U0\
WBq|n1½zXaVJs*nr΁f%A͕LXruOڇj}6A}wɶEMH!i(ۖ]0dItÜK-pe=$uVh҉{RFCК,Ĩ7ՎŨJ(NHGJ-hb\sMB͙w@3s6BgsA?si^C0\̫`y
7Ih38I_dojP&	e>@^4C!-T:S,ÐVJ%K5E)"?]측`a'y@, &!%z艇f&H146̆]̼i\䷨<B}-*H
سTK!5߁~*Uer5TSOSggq)Fcx'xyT;M^/.V3Bե2/r?JLWku{.wEݦKRzKݣw]A#QNVj+f3u"|jܙ| M=Zm혾K#@0"ZXvqejoUcr/!6
~|,+W9(X:ʢo[C|&Lw_ܬ޵:W!PKP=\',,A[Jcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EventSubscription.classW[pG=GKN$J"lp^cKVWVbz2;X@H !q_UATAx T$UU(zdeت}so߾Cx)Z%"
^pg3S朙颕?cT-NOqةSzF,ǟ+.D؎x7w+f3g]JM+Lt	߳bvkdV*پbH(N5OY_o2q'$!q0# +$6K ^N\.|	lƕR"
txV-YEwmfeUWc@jѤHFZ\'`XB?7tYܗsb&_LlDz7FѪ
\s	!m`D?HP~0X:j:fd%>!\ݠ]2ٮgk3þX~@
rݕ-jkK`JLU`77I]cV?+}3AV
]k]Tmy|iCIxSOkl;siqoYuȫ>9|[\}T+9oL\`sGRiUrcnk*kﳲ]^䥿*s]Tw!NUʳTe1(p7#ۈ~A4QpWD
qVOo
(0-QfJ!-Yk	iN涧(?Í.p;G5'L
#ЙNEX*#wt[vXWdW<T
rs97Vn@~?DRMF{V@F`:::::\%9F̧R8畩c܁/R/CEQ/}|q0`Hw-c;]mbeh5_˸m0S`v-lX$v/__tG
DC*QC-w")R-gp2lnnRl{^7E0rO1~;-$ٯĜE۱;CZ!n6zvYEp@۫;G\zNXhI@HK*Zj[Xs$*Dy}/RPKP=\v6j/:com/pyjavabridge/PyJavaBridgePlugin$NonLivingSpawner.classP=O0+mSBB,xaTP+RQȭkGS_c|
	~޳}PC8K̒e圯xY*ؤ"r^*RFGr%u:yu)"q
}~;xv"QZcaݥ.?Eh4y	~!݀&XE{Hu
6MM­Jۆ4zPKP=\ߛ	Fcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ReflectFacade.classS[OA^ꖖzW(5Ę1kmt;,CdvO$}Q?e<IKLywΜ/*r.
(2Tw'ގ
G;"0UYcya	swPrq.C8|#Ilź'a
;M&`eOڻ{7rv-)ҏPơU VDuyT矝27bKPt2#Edq!GƼٖsTnC\';-05
M}S*A
J?bX%0gvҋM7N_@TwlA@tܵOzlz"1o8h0,bRBg=!ӳϐaaPZ(THV	;~}܋t;j\匠+d9XLa_\48_gx7pme=Cez@أO\&PKP=\g>)
Bcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$RefFacade.classY	|&`!B@l "@KC2%;KV("^UT^
`ų>ik/&~ٙo}5>,49*<rG`[kPc\>f:P}l#`mm4&!^~pbgT>~
HnHSp5f"!{:!bh(D`Ä=Pgv(j}e5`S̊Q]QWh
fb1*jc24qya"VԬ1bl,+{1y7H¸Y(yp,F=\.&.ǩ8^	(%Lg"Zy˜#9R>ñ(SQ'°kYZpq<8}P&ixq*fΊ!+bZ`!+ఘ!va-FYcE{i^#fsV,S4	8'gSUG$1b+\onAӱT= jLFb#Ptbu&aKVDiˡRq:aha98S^M"kYmA:aA6l4>;׳Q)ֵVQj24|\age5GPp,"xK8O525&,L>5j{q.|
`+e9x44-5qs^%%\i	1$PkVE[0bv+
fuvji(~|,L^m5N+N5WYˁ#F,er-b\ėNf֩hp.CO0'H>5WlĔK=өlsb=g=npH+.F+Wh_a+BQYU\CbF[uU/&:*!L89+oY"JuV7*n԰7xxcؽt3V )>ܢVt2F3fFCFUm%	GP38ަv|sP5drߚdjuo&%+#disd ܥ븛5,tm{9y[%g->mO1#Ķ2PUy|1e|DCewj8/FmyRn*	}kq#YdD^*"xOjƎD2waEV2,K.=+ծ1xW~d`+bv7*}ݠ,=[xRuҫHS͏ɮUƒza=Wy|Z\%?'&='L?
i=՜\jOLe]-KrkZMW|BW1i;v3F;~%Sv+͡"j\&tNJU!J/HHlLq8=Ymn$Vv3\Ҹ\EڮnYsA1q
̢iS
N$n`p,)Hc967,FTi҆-J6b:FiiGd,44'UBF-Y%m*yAWG<O!RgAO5f6霣m*r$֙U;o-.Zh9;$
;o(ws-gZK1ʹ,;fGDaDҾ];ƪ^CFw{PaQ4Z~8$s?pՓipkZ+xV(POxH1!'juY-_AO?/{|+aw*'9"MUG50)'[e'Jɟ~?|WW$hJ܄oxK:ydC!^F\)h\	ŏ9i|C]_W\kroVA_Y.\(
-(T{<ȗ\aV![Y__y$e@a0o;*ۡɓsqsun)M-ٓ|9'žѽUBݸɌϖ:)gNs7uO7tm?*u[*_Uz>tt"_/؋Bpr?m?|SعlBxJ{=IV\6CYlRw<hoc*GH"BhEbqcX:,:pė
/.+
-$Eld	b4I\K:Z&:Wl![DW[h6[iJ;m;-q'#w6veO)(ă\T<,]JH)DR3QNkLNsĕzS
<$] 6=+dmPKP=\(C\Ccom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CancelMode.classTmOP~ѭyL@"62㴼ӕ(:u(I(e
2c4[>>9Ϲw߾
`Y!GVyeneިS
`iTl7yݺoOYm(d
at0üޖdVhF4D䟽ҋƚHӠAI!n*SЩqrj.gMu!qLY)oq'n/.(ЏBmTֶ4kԩcS	l=A	
11k?Зj,KUڑDQF0*v&PgXLrSMS[]ܨfno\YS2=[ti]Ż%o6VM8>e&v5GR*]5k9}~'mYQZóc[xo-b'`a2hE^px]}KlB=!7I ܠaT`,!.	S(Q4B(>ԏ:BӳCS7
ӄBC?oc#})^P@
nJwঘ"Ph[ADL9Rr0ROغXEDlY6◤\އW Pqu/.^}Nu	~&i2S4iu-PKP=\`ܵX8com/pyjavabridge/PyJavaBridgePlugin$ObjectRegistry.classT]OA=Ӗ.,C[T CYEP&
Dv,.xDD4e3mJjMڹssνs|	`!D4!0|dFtN[>Ctvl?N3Ƞk:VyB2oc
@Ü֍SPJi)7j;M淼j7|Aq0T&tO9mؐKy{*qCTz!*1"
(cȖw4#Ip*Ex2dˊ*aBx0rQ|`HRWDnx`F#.q@d˩ҿ]=!E5
0gW<ΰy9=HV\A̽wfFђk}ӳž6|G=i{Yи	
}7TeKT	xen"Tm6|/QVtjfR1I7¨xz`x"wy';L_ztbY@2sP>\`)D!}	ȧ51y,O(ZMd/|W^UM~%x<|A_!bzwuI3لjL`KDH%\K&~8^"§vE"ьlS$0MVer]P@A7PKP=\鲹BFcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$MetricsFacade.classTrE=Zڵȹ$Q.CĶ0QXJ$~FAXZծ_/TU$P#x"eaPA3ݽݧO_4>elG@PC@;V=廼ȕroN@):];HVw[."0k9X>D5028N#Q{*,lfc8!n$'n#Wwvl/.hCx
!ΘG\y a)9H\a3
g5߳e{b8ҳ(7.
Sh&KM_l|)2e
H#0oVukw*y,20ULNn	B9\pu`CtaufNCü>.F
0y;d_J
)UWfm60I[mU>aڎX[5VVl[][=cHn<[diC]/s'\
z:rgOa<@3P2yI5vďL9,#5p|(~qk;*L5:Z|P.?8VC摙2|b]Kْܩ㭼"a)b]tmYQtbW6blxMG3qE/DwXvgsh?m:#`Z'9]VW%"}'Oz .K3̣8WZٟp2-$nEOG^K&̾{RLJD
*2Cѝ׷,e``
{<]8gD$ѷȲ2^<"64LɨpeՑ3to,CmVČJ`g=Õ_0;QB
A~ *Ml{ӝ )G#PKP=\python/PKP=\7w;python/bridge.pyiَ}B觙Eg1nApq.@`KT7Ӕئ?>ś5k @aZQ".LCF3"{\GDS#JgAXMAQf7?Xu޺]k;t)P+~mG&]VQz/V첍^mVT}{ʊtQO+yn.1|=Qm%p4
޶Vw^oEs@z$KХ%4[&DrQwkh~LC#Qf\}]űkRnj);jZ7l5{?Yn_a/t`uhNCv  -;CHDBYq}ЬyT_Rp2EQCl}N1R#HsB+ F_G)
jrT%HyEpJRU;|p/spdVph=V8#:I}…ҩf$mO%}/?	yai<?gZpr9%hX`W_o+hpVVui~w]	@:%Rbv=}結1Gf{q7M,qƸ}citzKYޟ{kUr?9vVOB%ZSy	\JO__ȝ STg$d	T،_;]`fAFi\QfZsL9Z#b yn|:ibV}`\7H(֩'T)JĚBmOQlT!!͇vTZ&e0MBaJۤG"F.k#^+0/wW&sPĨ[-{2SD3ڣFr1UK1U𲊩u'
]nڷ}2<]J	82Y%{Fe#mą-tLGcZ.V/&#A/bo$./J"eek8n۾X]#d`FdG˕_3o]@MחV%E\gހȘlarZV璸(^Q=n>ØQlR7`(Xuj$C.(fƮbN+֩.ZӞUAm.=gB*ڵ%(ú/'tච9ftaՄ.YaHPLmk;SDKE~p+R}ڇD3BErlF~Sp.qss#cYع%Xw:6crYD~j)X:Hg;!XzWHMow&i65~Džֶfd{'2ot?J$74J/N;4@\F6ȥ9PKP=\񁶪python/runner.pyPj0+N6^>	.'-(A6ZVD6=kfwMf0؜!.}9TV]Lqv:hyo\:mО6GƜߤMu?%ˆn=v"/@yOq$W4_iSmG\HޤQ }PKP=\GGP@\python/bridge.py}kwFw
Ќ3{ݻ<Ü+Yu,'Y],D"$~@83@uUuwuuuuW6IyRlU&$y|mv'l_ϊE;I^m[Te~ˬiFQBߎſuɛm	b+mUumP6_򱽨l)/f_.J>62WnW,_4Md~5kWy`/2Wk||^E*7Q}2[߮~"{_z}Vl1ȼIZ4|xz+Ë8jEEoWYEVlVf5dqٮ̓/X6mXOj~*DOi۽.XnI4J^Tu~Ve>Tߜ"W"˫\WoΛFU2;һ<6DǦBZegh_nSMrm]뢽HZhu-B&q>=N9^<~#՞=gJ1B>O_?~_	%eJTKqWG:owu) rB7y{Q-5")fy@#U]C3jx9M]#i =۬EFSwO&c)&Dn妻r	5M?AoWI]<Ԁ8_eSgXwТЄu쮑 W]XIK9#B$3a\eZJ¬eEudnC02Lij@
e6b30GBGR?+
ܫmҞ5de/Nz	Žo_XpVW|=jjmSb$PI[5^S9]Pi?	a:+VJ@X~\B1l7$#! oynQkpv0mo^`EXr
L4$5/򨦛R*
5pCmj,-ڢ]iu^@Y8ED`k0bB&4BR5YBRdСLǨݝ1"CE-r'$rcԓtsI8Ulfb2fZqnS{a3! >ԸXaWA7w-.
њ}9DcMX|6$O
'_d
eJs_6`ݶ&U
^d\иbBJ<_CPm@XզX! lY޴#d5Ǣ4gUhMNЅM,ZGD*:Nڭ-2EۺXtLfމ<0d<ݶ;l`'-zh뼼U,2/XFH'GG5FHIإL~Qe'9+ށ,I#d0=?;˞஝|K=B6O$CfϚEf4ջBs	(XHgo]B6-LcYnHF8|&bbAKs|eR.)"ʕ,fn$˅SK	h"/p|p8q\fqg~?cIWe>⮕c6`,%ۢ3,/iSwa_}4vq?ݕq"y`	:[)N[H#7U|C̅,rA4
Bԙ(lYA60RD1H9ӏ-tgތ+|q~9ĘA`"h.Q͵ w%%O窨s4zc.^#q١es}QJXd*mLZ^JD<lb%2}v$q{Z@XrHXkU".qaVɳXa1I	?"JD
K."=>25Qo!^	kl-YMZ;L\T\άDFj/
`/$l,|ѡY`B?nLbg)2hSӑ0kvk7ZpL^5l$㢼뢕#k7HƂOڇx\(;vP>DE\w<1IZzp:ETNL3QlAB:h]N),#\7<`5k&n#<ƈYݸeU.ߧ^8յ>b8UWve	6\dL'
KVv	N^ҽ}
~f%E$ND磅9%G P[w럿aHycwh2wis
jot~ym`ŹX͖6ծl\RgB	q-rm%zb@v$;f*,+ñutR!2k\_Qt[<8Jf(Di16y簆SR,RZ$PXPA,1IA@C~m@>"{Ze(O,fQ`"kRDQnD_r-eP#[<2wyҪm_u@[onTjan_YG+RO;[<y
w8[ڸy]gu{P:
}d?[YC_* ?UXiWFJjh0][m{d`b{b>;xuU`?*"f{BPi55tN&X%יDVlwyYS>on!8#8@~"ȣfC|"j%f@	فb	șs7s${6t -^X%[LvoA\:VNC侾Rd'0Q'7X)욽Bd|{oH853p@[e,n#mh2ZL.NzOd KDDJvE>~&EQ1aeoڕX!/BD$'z1Dt~҃
ѢSHȃŠc2λȏ
&gJK{Sy͵/fVFXe5*;a()̊–3
83sGFBj|[X+֙&4${]CP֨b
f\s,v{Eu6HŌz-ù`1LTx%/eL7pX䃉TPt
qsXCBqdǃRA x5ٝxM
ډtXhRuxQ]Ig3>0z7H0tI`<xOAԨЀݲVh˼Pޫnm=UJ,My&&:]AO`=bnw	m9LcM6މIzwƉ)"$Qaӧh>fF,,({~0￠ҁYW{\uU02TynƀG]Я7"
I_'{jqafK'_H	y}UTI0j]c6E`[i=N~gV{^#9|%x{=L{Ѿqoo-~ͮ^arrmw/9š%_1sWWa0<0뛃
+tϫҋTn7Gz{0[F_fׇ*I	[kmNs耣Bj#0tYີgKs)=I3ދ{}+~o3;`M5;5CXO_ڲ:*Vɔe!P*XjĽ#K_cAFF/Í7C!b 6ĭUj_ɯW𿯡u{$lEaƗm=vtCu fOw*-27k|#=|	j8:_5g͖Zq;j5E3U2it`B#KX.瀴X)U%lE-,1o4BF5j9ϙ훹XnI_Y}kZ\pMѓG~|bfĺZw).[{sۙuӮ4TIa•@69k#)\=#.Eͧ,koSx_㸌p=v }3	n0c/})zΰpm0)6NZR*[8ibW7%vyV!i8U%BhrhVՙE͎J<.%y^%
ixP+l[sEV(s{mpۤ}H7l?5jS,?QuSߵ^dpsb>>oOb!VjM1ovٙ~6{4{i]/
ų_+M%E-|x&0v[AHLPh ~ξt#|E䢣§ӬLuUY߯j6y/be(¥ag5:˩E30U5m.Gև,i㥠~2z59}SyOR"34:4=q	"oK^vȰ]y	]9<ߡ׍΃,\;Pz
[{q;z5YG,ºH0V!x
&K4dn\%,UJ1i1D٢űF5&#/1q<rQZ@$alw:Wtn5&qkJL	>$~"ƀ-h,g&W5>LrT$2">aKdN]?LHΔg5:*܏u~~

$],3MLʂBPtPo[32h:k'`;0k4l! e~	0<!zmR;99@DnL%u(pq
`H.g8}Ptg_@CEZ.24xLsScu?=	YQ;C;v^s Wށ}¢|!]B@}jQ|#@;YTku%XSw+'?LgP(~7NId禖@df}
}ݣr7b)6#RPxg\$*D2sA{cRExln^枙۟e}0kܗ>lqyd
\
vddHbiO	j4g(SʥіFmi$ޱGQs#aAG'8#Kzƺl(}Y+wDaxIi(Ǜc38.Nlz-_Wu@C𕸐q!l>7v]s<㽎7{xcfҡ}
6.ML|	mr>Yeb7@
xs:pAZ5';u#%}%
ky!ܰv>k^b~ރG$W+eY%u {,)w'yd˾,n'FzZͿ=t>PK3td
p<7uQRG(b7Wm܈B慗i0Feʵ.ݭxX3zLOPWTl/dͯJ@ޢ~;bi۳çYמyDȖݲ~BMY(Xt8z>/"(MV [Q7-ct^}!d7i>4
 n#i‘k/߸^[plYc2/9Giċ]Xcy;jU$X͓-.p*Ugb))
7>ҫ#9m'&E8B4|
+yrĕpH2oŎRJO$]j](v|(٪WڮWAf~GhخQ}[Ί|-鴱ׅfw޽݆9y.Ѩ`[qkG,6ƅ
:ԡb	@اbbY0}t@#J((-#1? IX"
b%q0=i~Sވ۩jAo#;Jl\LɎrаZup5tQR1xjՃ{np`hKѤ]R'|!p@-̲oz,7 "@xxba'܎nvXVpO",YT=%0S?i9cs|VҰM,|2,|[j`U3@zpMHm?jdž&&^JeVmfkh:?\w+켽!;~Jt4Sj.*H'لٖ.N$gb~l|83U|64řC(tWn3^\VSPiMoT:M!d\q-.Mچ-l.ۇM&֡	,5\Cfuҭ8?]i>T͖O'?Q0C#ۅn0Y(€6-PʔCՎv&%dpq#E[3qSBu7$$ԿAE4&txV?L6gj-БxV5ThJARx+^fOB?͌:fn
eHT$&J%˥D:y<|~4
<_d
?UWZ߼;!$0]+#k]8f疵xh%Q
VA>:	`LI.ڎ(fpRҒ~DKF8Xv\-)X2(Oɋ

34̸[vo#3ܮߝHg)kAKTWuDot
bn-j}AʊlvQC+Kj=((ݪUjD F+'^E>r8ޝ`{%<5!\DjndwX+IG{.yY4?B&ZJrxQYCf|[IZniuN?U@&Eҥ6}T(R`4WE+`MOU>`;A)ZQ^X {qȱ	PBB
1e:;=3X",9mX,e[kw` p,!QeF7̇PיWeP8Yk|Е1t:J]T	b#N*R,k0Prρ;$1>'pQ6q;Aɽ9}:J%f{ĥ#Ҕj(02Y
#!5,̇NewfVvO~)	s7Q~K x+j{_Cs93l'_A" AHؿ:z76
iŮ:.avah0GYdR|5C%~	겄#2wːj]4ϜZQ
`hA_nȕ5+24:ZYQyڣ@
,ٯIe/v0'gWdϳ[8X˦T{{pC??rxr5-L{Z->[dˠ_|
.~8l9oZC䉄%H".7RZl{&Aຽ*K@oֺʦOvqIn8[Xqs]>m@Ay!@3(f#T$Y'\2YkW"	/Ä.Zjk.Ej/u?P-.a[`
EմV
 a@e#uUm(vBQ4d;hnWņr&
@WatPcԈj.5GbFåPٙEc/g S1ᶛ8
5ISGu^6$(~ߐ:dmU"LTMv{ak]|g{!@L_¥.!52/ؙ{MHxxv,wW*Y9ZALSQǺ5꿭!e5:yN4!c"#gK>ZY#3@6\T\r-l_Fh3ւ.~?Xo Jf4R™+D
Qw
xim
*وQ3x)S:Y4T*ɠ
,ԾeKvvl6Lʠ^8فhr{u%`<]޴0Gij1Fh*PRo'O='VDPf#;nrTO2w+D
/	Pχ,s8/Nzi%op
r
OFfib.4fRX4nn
*GR1cBɇӄ$F*kJ&!]3AC`q؋N̩E"gd75{>_Pbx"L¢GuG/^H۪%@}\s1st5P!1RGXu^p57O1H
K.B$!7
q} e@|3Ɣ&htڱ8_bWC n@7Z
"C#\pզXwcEUa@EMO{c{R q*h#.\M㤎e@ιg\˹z3TE?-[|EdMM\fo7|Bhnf	d
!)ԻJQ"QI-˝7-v
nck\-g<Γ/MUNͶQ@u2hѮ]=fuXQkOH1hz
{Nc?s"ݡ^>pwQ%0K H% wkd_?޽^7=
6c8]V/Whls.IBpnU	GrY~JNb a麝ckݷq^"LĿ!htDw!-[>e5.s_lo[1&~x~o^?P[UcsLh_*C_c.
X(q7pSsBJ!7*.A9;V;8@jIohKp̯()($mnOHР!H'FѝݛTd^FD&:@;
R6-):샴>}{)dmمyXUY0.lj0f 8лhpc70WOU$@ANno0m+to==FUFm:ve+33ꈂ1e鿱/juQjlpNhT_n?I],Dg!be 2х$.[MlIȦ=̣Y 3UBBؑ	k1Iof7UN#KUWPࢗBS-2!+#搰-C.FjK63]6$̦ї8r8o6wA,('.sgvφ`萠UP+w=]4wW@Hy1P|I	0yx!d|!f%2wKMGZ*Fh'L&X89DY?̬O@Tc M'N{Onp/'WOF;\t_<$EP`RyXNQ(Ю]92`3twnnaeVT!`M"|GT]4l<хO}eSݎ>
-|MTDw6q[)Jه>x[вܑy+ENgjW;A@ATDg*i(hDea@#HeJ~#m`6zДi慡92ӄeb٩gFl*I2X[u##,˙5{PJaXiDaHcC <`
L
!TP@G%L[E}=<83mA:)ÓSx2`$1W%o Ev-`Q[9&SM @l2~XtvA~z.5=	[((rtrmIW@V7Dmu)K!-A
_Vī|^^Xhnpw3
hoplr5rzf("ut5\$'!~'PeVb%Fj6j!A׊OIS56%5geYQL`5i˧fΐ^ib2;UHc3PhAR)
Bcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$RefFacade.classPKP=\`a%gC/com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ChatFacade.classPKP=\(C\Ccom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CancelMode.classPKP=\`ܵX8com/pyjavabridge/PyJavaBridgePlugin$ObjectRegistry.classPKP=\鲹BFcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$MetricsFacade.classPKP=\Apython/PKP=\7w;python/bridge.pyiPKP=\񁶪python/runner.pyPKP=\GGP@\python/bridge.pyPKP=\s?
^Splugin.ymlPK	:TPyJavaBridge-2a/releases/pyjavabridge-1C.jar000066400000000000000000002570271514752343100211200ustar00rootroot00000000000000PKiQ=\	META-INF/PK4U;\META-INF/MANIFEST.MFMLK-.
K-*ϳR03PKiQ=\com/PKiQ=\com/pyjavabridge/PKiQ=\4ULcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EntityGoneException.classRJ1=kj_ڕۊ+ݧc#ӌL2b?˕LźP0sNɅ2ZȣPw	X9{O*‘T3TwϼCEIr=/iJAK=%]
WnY^	%W*ы#]Q@J
=y$!̵XhpY #Oe6kr0{BNU_*%f߻bX.T~hhhP#tLjeP3/ۯ'^fBJX7XNkVPNcUeB5(o
(PKiQ=\)|"Jcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$PermissionsFacade.classZ|TՙyB(1@.@Cu&	#tZ֭ZuP]A]i>>-ۭ[sdx{}M~: x%|lM
FFn0͞tov\V}ә
ēM{25Vug2T25,vg[km9s%{\нE@b,RJLb*$ӋR`n6)T6e̡x+Vl3%W1:'t9°	kvHtZi/B^+LH,&N \x0.:Dm۬6:.du)&+m9gvS>Z}DwB5fr8`~
x\r}ݙ`kK9̂}D@Jbg=> [Q<9EWȩkϋm7ZC*DU3V GΚ",LYw5xgaKݩԿUb7>, ]̨)Ya<#?,:IҳnݤJGK+I:'O)?^4 p7ްYA|ħp/3.ښJ%,ݾJ}ӮW-lڽ:YÓ^8!%\!^S$:9F,ϨO|j,:r=VzRfj3W΢W&Gծf12v
'Fr眹3
TNX@tS,xJovq6ubQ4TR1q!9Kj:VO]=ٍ$l.mvޣCETs.}q¶yY3tP9\)Z{:$9,VQbĒN΍AU^U{r)ifoNW۠*f]4(Z5E	mF:1UbmuU3]8@aüRt15MJ	CaeS!oJ!LVL	~'H!BLxw͑~1-$*tC̐b{8ۣW4K;~3Qx&ll&V:J
x;FwVy7.檢q{2dʼt6b.y*{vQ=[9
$^MO/soy~Qxq~!(l)=W>y
ԧ:ix)FQ7Ô=y8iG0KY犋<6{#^%Y=ʴ%aВ"BcF¯`EGh	X[VZ(x/
x
>]u.t]XP)2mxހ\K)
ZTP40ch]޽A9~§^m`R
7hoQ~S>5fcL9$~QÏ*ݕWhͭtwnuN<ƭu#VߦAᗢ kt9w	?uU G]`Q>!@bewwaiX*h+I{UʰSܵ'(Wwp8Mut-t-t,:]v}e%͢7yKWvFg0&g

V˰jTOczqw=`Cw܅q^t76z
zq+BBt;E(oGaj8܌$v>}Q܋xB>Q·pǙ-"/s'֘ne	wt3[j`*[v͖CNG:3yWZPㄭKYA^|QϷR6	i53f<[HЗU65kttayaU^A(,6Ʈwg:U	p?|>N
$Qɧl{4*nr
neNpUƃuJ>p9sZMܓSQq渘X^o==EFr׮rD3jZ
eG_"hQ2aQ.fש2TlU_PKiQ=\z./h)com/pyjavabridge/PyJavaBridgePlugin.class|	|T9N&kسGq%!h0	HXtHHfDjkkkkUZmŶjjX]mkm]Q~sߛL2	[yﾻ{gw{!E}H[)rFc[j6uoNtuto	Gjwk|3G‰3tiLOw"QubH.UlGu|dΣ|-*id%@6[B5+vɄGrڑpdX(@bl,4Ʒ6|T YlhÔH[(KGhElLSFvthD@wEڶƢšve*)M5}vSmFәЦ-+:B~&δi,dd鵺;^lRʨ)%ªpv&^&m6UI`$*
56@'2H6
w0;/$&ᶚEIb>C)m([#Oi.bvo"g;GiEgt&-d*4#;-57m陼[B:J]rc`#dЯ_'R΢Mh;4p-X8e3mq etE65Q3Ӹ:BÑs:k̘ӭ*XLUjGb	뤪ޔW
WBXs(̲l]q6#!3E1MLS@5}ziӄH(QݙTwD۶ƽH@W`<6Z)D7ucϪf>j'fV0H^ѶH.Fc3pSmi;u ;ݡ!Kj`Gl
`*KV2s;v8Di
шv`MMEˢK }G;N)ޡ7Na.A'Af"vbَ(eI|xݝX}Xʤ5S.F;Bv6]EP(34]iL`kvk^41nuL$	c!;2#mZM簠-71x|2$z{2$/}3;]{M_ 7vX\VINq̳;"aїl2}fX`uDED
~vi9n<{m*3X܄N]!c&fdǀȧt7T/	&K0_hҰo>~&Rz#&
"hی&=ٌ]x>^tb쏾P<ڱKרxXP[m(^FoNҋ_>z;6}=9Hޣaf4
ƍcϖf&]lȵ
dcs#^t XCC
\>O<$/bHHeu6/z'^G/8lx|
yC%xKϱQԨ7uԥ|SrԌnYLQFgd
Oe5kl^kj:^[$ar,3,dv1h8]Y3,?ȼuln}aT[laiu=cfu@%;ŒZ;1p.D13C	D4iHL'7hHd:q8!;;x%NT{L
iK#gHH
Bۆl>q-	m-l\J?B[iN6N{?fjtnq2TC	}X|M4z&uMu6?T£P[Gvi8ԁd2KeC?7X|7񞤲<\ ?;kdtŷ$I'#r&w?gma+_~-R2a
KdGb󝼗iiHEƢp>L,9BS6|b-߼#q2UK.2c{-d)(I|yD*d6Sa:/ҘmX	_jW-~8*CDWxuC2_$sqw	g߁]g?qcw{IIb%17jFڡǖ.sgt'-O`M8#7qF)0#s3"ȜMRe>?B_0v\¾43+9FzemK&&d
Lӆ8}o-~0"ǜ;sRi&,?!dg"gկdSxN؍?,33G,4cq}s +^2qFk+*tZ<$`
P:i[6Bah{Ȅ(
2eQEb[)Mht-qxXŅC򻤐S6V֘m|}GȊQlUyLd?ť*y34;qgRv*P#,5Vj +JP9	DGjZN'X&5Vن܎PdKbTMD5	.޽)kLiCC֔a5EzifӋj:SdyM65VĠ6~&W*U%qVSS!*UmUNHi8m[{jo?gOV5v2c]	IL.|HŲSmuQxhbp_]uXV5hl	%[}ʈJ,!]y(lY'KSF|uR7j؈	$W}U[➈B`{1N)iN:n
r[0(
dQ"wKb%Ұ%@G26b;eE۾䋟FWm5Qn7oUw
4Ks%]W1kA١lu׽s	ՃL ۶v\4Mki
HΛ.qj|V	`4^Hm22>q[r98ԏڏ4!3II8^8Ĺ:/F:v߁HgCn]ٕUOBFs4IDMZK0y}i%ݧ~l	v+R2WS?P?W?JsZ_VY8[uZ76474jXSq%Vc2Fwu29Koo3
&qGcdzzQ^nxط8Ɨ4<^]
	u+y?rU5>Ay+FL,wQKvO4{\4G#@ŹcRi܄yyYR<'{5t5wwn
V)_cM0vsF9sX7~p˘˂fjL
J=4F.(MN9P}=ܛҸw	i˼B(t,޾u۽oH]甆ۚVHb7]a,c0qv~~b/
oH&8@vt_wW	`"$Kykqýlg>%.2ȓGS8LObe~4,\2`)8S
8_:t<%)Zj]!J#<Dzw9WP@)39u|%YxMg}sLO* it"-Ԃ;:ų4$sUJP0	C̘Etay19q>Ƙ9 Yd>ѷ"ipnρґ呦5kOB
fgOwD.@u;D?̮
a(81l{S߅EV"A9nd]$q7Lo6CrI|ȁMh
M*$W]n'R$Vg+FJm滓.@]?l#=}I3	5ۈ9vl*N2-?2;ӌ~dU6~+IBD	v/D[ry3b|{MpN6!e+$%S;ڃ3A-;b0\/ϐK]Pdm>Ed͗dɃԟ's)(l,9F͔8g><X
bK	N1ic@?v L	!ߘEX#-aWvVx]'әf	YwQ7ӒbFtoJEKi@2$?+KRYUE`;(:qP<>:MIHo8>|ߊm)<;Nwwxil`
:Nr+x1O{q4(`>^72Q'y=L33DKb9JS$JKѴ.ܑ9B`C^OZK[0"WS>5@fkׅר/l$_m+|xJkɡBAug&l[ԉ,e6"Q}H2ؒ
W"k&JukeX'wXI
;PJuv1=z&47\P1AI8	v;`I+kRM0ؒ?׿zjA|-%!t
my|i8ÜQy!VUµ%̅4Z'.ksl`{y΁g߶4n|w0ݚApng4Fۻ1IFO3cN$M>OgYaӋs8`oi7'C5-/	\ 4K(nyV1'L*ɿ\j_ߴoigꕧ6202WE"`ˀ{a^2maЬdd3ӧܙ50GFU8>#
$)EM{hdQ8P<;1;{1M6OE.|u9v
0ڇh]Iˁ1:>N;j"}O}t-=Fa/#v.ByK<
O{.}=g4/^ob
}@NQڨ? RPo/m4ybMIfT-hͥR^բZ>֠KtFkzZ}iZvdxNw{Zwnv+]~#m:BA(f:݈kh-]X@93xQ28d9sB@>K-jhE-hYz(F
)0?9=)BnyIm@.={=UC6V8@=*2J#ڪdi?g_zUA{ilG*z Kj}_y/R^~ނ^w-zuyeU[SǗK
g/#+ЂZL4L:^i-Gm]}G!t=Ewo\F~S_&3.AcxUtUx屩Ng/+VPY#<#H1:BEn}uWx7`涼	)zqV-OxTƓiJ.IIϴ4iI|A~+0?4ܺ-
R#Bi$j5:

}61b'}Z{fZtCr{N/_u?p?6Vxzz(zG9ѐo=_04FNK0h
/^L'pYc	0		I-1jeN7Zx6`_Wq|=~6fTrxGs!ʩW/'|>˖ه5%[f
tT)=MFHuK99[̏\QS3D|XQˋO"?5`srG4z6zG|"Qͦb5=j<$<|n>*D3aU+Lny-<~+mu3/2D6z[y3-™	ӷg9B/q^.`cqsXy'EȻ/֗|)0r\WjVr%2}:DJDct6Z}DzzRFoz9>IPT/Q\ߤԪoq=՟GjxM>uI׹jϗ[PRޅVӠ]J3KzX+4Nq&g{ަI!|`>`~&[@za>JgQ;.|rgRjnWjD~o︸Q4^	nUg4WEn{⛓w}jt~)R9"L=f{Rtg9gџJ\#HhmHIQHCZL$ʼn}Fnڀϕ5_R|IY%e͗&k!kAdH>817SWL]%>hm?'t7?t
j;Bi3Vqn
ŹZŏA	-v+0w
H^XޣgUxֵ&m5L o%fԇhdy]^-Rq||pa_ͫX$~O5J^o؋7z߂BxFϙwf&<*pJSPʥfG땏|DQU@U5Rj=&/$L/5stf)j&fa]|Uf5_jmlE&<çiFzNՏo&eLEG[?7rwP51UFv#+C4ρ$ԉp9T8#R7McGwRSK;k1#EtkᭈM}&z[4~J5,_"۩,3U(g}>3FRP:J\҅(%@ɥJ?t聒Cxk'ݬT'pѦ"FaIzG5nt
$Gmm@i_G90@6O%N 9Ol~	$8.`aFx+zd}g6h'KӠXh_h$t?KxOE[V",Ep׆Bj/{ҏU!Yt
GސOYPpp2ma, E\qp39C
r(*eC5gdh[ġ҃ u)L'joՓy#m(C0DcNQcs3ԡ&Mc\M((ԩə7Pb]=Yt}^@̤fBlvJdvXH䏲<$|nB$Yz=k})ӕh5F#}\fsS
ԝ.#!M1z)[o2%<ϰ::0iJdZ9-0-//8_ʸKN\"o2.ZxğN?lFhaQ2mQQ]M5
c IE=bF{
W]L1!lשUB77?i$2N&7(͔0Pv@"ÄW8,9=K
SeQ(	|?.0$896{eZ>.;^%,^z<6O>Ro)=΢|Kbʞ:u{&EC]~eDZ`8B#8eT`K
ZdbeKQF`c-Uު˨F*h8F60n\-^Any4ذ}H*szfڛ8v1S0L$d(]o$CX*0+nidRȚXpwdE=OnO8=W˝P0tBPltOa]L䵫*cj
w@|S*
=}t'u4G3=ΐR懏C%6v`^)%}_2?(bbW1ΉUGk/`RHZn`XMd[_a+@tҶK	kc0K3i[HPKiQ=\.$Ecom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$PendingEvent.classS]OA=A?EYD0jP"߶ˤl
?D?
35H0N2sf̝;?OP2:ȹ$Q0(]9f|!/+=yEKJP0c.Tԯ:<,A8fȭ{SAA,0
UtlX\:Ee~n4/gvD!Ed/`U,j#,lPKiQ=\bFbv7com/pyjavabridge/PyJavaBridgePlugin$ScriptCommand.classVsUeMӥ`WʇJIhKAB[PH-&lv@?^|Fg|À>茯>8_s7!6-d=ιw>@2,;˔ݍebQ3sDmdM=İ:ҦXڵu3h
*ڠ2"X"3XeO3yNgm6vjf3M.ſ&׽c*^B`h՝eӤ{o}CurBete
;^6!rCv

kV:AAphaq͡(w-47x,Xfl3S<Ѕv`'1in-*rrk~5x5xo/P\lңb;´:nB"Af1A&[Z~e>°[fحbKy&z,q?^%>.[ί8~B$SBɰj ^WpH8L6K-U6BNǏT3
c . M8J9cU[aތ&̏!YN+xD[HBȰf^A%LḂ1'D?jfp-͹iޡ:o)u)k*,x2twf⌹COdJypka37(?-X=m	|^Xr+Sb`gLhtH+ewR,i9bM{(
ϖ]	'w?5iɳMyFN8ž1t6A]YmV1,NϰK}b[:)C*̰u	2,qm4I+qE‡|(
gIU\kG稖u-;nXc
t'-P.5BNAoy	0Һˉ_u404Ꭰ{k}n)ðmI(a#DDÀ2r|4I'mCȎ|K=Œt-yȒ.T3Gf'01&,4HtƂrC]Sj<,F)jX+
\(rPmA_byVK%rPVm$6诈~_Π5bBz]
վjS=ln!^wi5fGvTwV1Z[9b\,b*zR$z.'MSұ^FÒQYSm*>t_K7t?ItKwϫp^pv$R,JeG!zb_=R8%tр9jCR
D#qb8Fs'h0PKiQ=\78com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance.class̽	|8;@H8KB(p9
q,dˊ^U*VJ8lZ֪zZm<3^&D}>[;3<33>8l9+eesVpxpb\}#Me#卡Hs,衠'b0
#upPټue~غ<<ܼT6I J	??<G!ǠGA_z97G[PslZ`lŜ`*81kG-p9ƠWU
/G((}[BѦp,%+`&s`(QY#M
S-E0@VZL-TPZCxenX+(=j	57XMQhe0mmnl)Up4|բ`Dwȯ`L4SrRܺ 6tI
a2`|)-#GQ.}JǦ\`NFᦐ<]ȯ(\;uٲP4԰D cg
CUG0z(?T̅yiN%hhb"uպE{>*[r?̂4,^"a	KCA@5ԁS3֍Q4ݨ,_N;pT5b*vjk	ADHW6΋DZUWHMU!tp|>,#Ff!T娎i~X++X	pP;
Y/ܼ,mM
i"uyH=فy	~;cm}HKrAd̆x@W-i2̸VX2FY -ehdM1TN2{m`ǼP!Wp6|	L`va`.O|\\U6蜋2sf5p>1(
Fqbۋ\ M2Im\`#t&+JհAHtyY]U8gA͋u	KsA\z735YL"2lp7+(FVQ"eLiF\k3p
¡]!d9(2 Uzׁ:۱JXuhmnQD-&`CfBq1yf^$-~x~,͡(QomzCA-WlG<;M@%DSv(	-#ɭPq	T#(ۛ*I? x"~
^Zg:NVDg?WzԻC	\u_:+/ʺ:/jQ31`ƴQ}!Oȼe
Zg+}zRW^ዕuD߾o0J#5$ η
Crz&\&M+x' 8zQ8䢰qd` ?)[Z(xB&퇿|ow$E;zⲕV	r
>0TUW1!mfޑQEg֢*4CaC$1fmʴ}_R|Ӳ?Z"onk<٤GdqR)D0lW{
#KY.^.}ftt_S>6TC/^rrg5*B".hma}O]5QR‚\'QX
d[s6~DaW5+vMA7l|O)a׵l;a#+z	v(PX1L@wJh)6ŜEpQC!䲱(&<ë.D5Qlb`cZŔg&EOux
 Iz-dxf˦`q
flx*2yLOڈѨI{H&U2# ?杤XM4ċVwbӪ,Ѩ/D.AbA(v
!q{p9UPҰ#m(j)wZ4M'
*V>w6(ܾ&wGi~`kP,V&:b4]vur޹76+!6t5粳+U1bq֊<ى
Ql-[gXU٨;DWZIOS^cOMUacp!iYU]谋2>;`/X
jkz~az'sdktv&.LmDk]`bvSWI
R8r@+1ln|Wj]îuu]nP=*mvT!IgP{f7Y4z	KVnc#7!O'VkswvbЂ2up'g+MHfDC=Cnټ8Oc¥$fV8*/X/խ=A^-
K|.
a$-.mH=Dl'.n%4I['	BkV(IU.oDqr<@{n̓Y&~5^Z҈K~(m&jtw)=,ia`!In9	pG
%Mkj_uy~(?l)k^d/!#NNt\[hu)ו?TEcta["-fhC7̅5lȅmzo:SL'ZjZBk{\s	gbTg1b3[Qd%^?-eT65L.&Ҳ؟bau3ZkVPj총neٯe.]"
gp?q6KGgVScJ`PmMW@|;NRk}o;@I:ʕ`*8B92Ό99qrG)_ip`t9-{@`j s

4

C&"]5iz!O~eX:h'?vPa4FSʲ#ДOC˃u6!8Z͡Ḣ7hGhol|$*C'=Ds!6Uͨ9mCq%oiDysQ|jiyuhG+~57F`
c͑F%>1+HGO/'N8ҎSxJñ*|

S%TS?cQsJ
bSE*#CH$T|62LK	>'RTy<~2yba9__Q{.J;=}xMr9A=Ee`<t&4Og>ٮi&2ܙ<:	b^2HYU\CeC/dopj7J,D=r@ZNKycӧϜ
Gc>}c=i	i6V]aP^ڤIpڣeي&*P%\f]Es?dZOh3un"D!0Qm۵1}C)u!f?bcT6_e|e-aB]"9N,K>1@Br~s4fBR_`pׅ|N9~yq8&zAFV7SmZ35
~AzbkS9!6LZv'r \tɐl3ZAS~ؘI̱.WN4C2()*:֤r4sGմr4{GC#Biߊ'+(X|
PI!	ŷ6OLUd0%zi;Nw$7ztVuckEA+?"
\ˈ~$F#Wr4ev^4Dd::Zwls*/~UP`Hiz'$+K-5K]PFKL{Jd\_WI
Y)V7Woa=	ii>Ju8ZCioqպH4LAZS5fEq?x֜5vԎhhI2;.	U;q!Ic7Y&E#]SK\op4Fs̀,C$+GLU=__ÿ5e`'$h](r&qWi/ |Myq
;Ok;'j],حqX]k<sEO
HL1zVu]j~Ja;iE06=b#*q@cgfkeXWo%$dS S|SP@!9
3aJ#SҺX؝D	b40*mYS)Q,JF_k,gZJVLk8{vcIcG	<'`mO7`$%	0۱*eA2	JL[kfccPT%bmdb3,Zm(Z8R$#)Pmc%\u	`zCdb(fQB%	}&$8p0/HB)FZvVݜ^a	Ӕ8]a`&&
S3?-&z%̴eJ,'& %Hpf	mu9uH>{q6٬JhA+oY8H"DLMLJ1b/EtJQ|Cb(bBRY+
VJQK]@l$=Bohteɕ->	W͋twe˥ؚ#]iѭ3e,$2TN4_'_+=n&/1&iyMUWS ~A̕ycXx"&R+9|;ہ
I;PP_-Zp
Dy./7n,[eɍooG0ZeZ%&ن?}L}P#(9NUϭ\\Y=v%3/ppti^i65v$f#L`*Æ&GM:^ّy^T)QTƩg*?jw>^	ؕcT9BRW<בJT1W堾
$:ZTǨ@<qrrF-6arGNgp!lMCg
!&gR grwhrd0ИoȖD9ӑUve^	p'3d	P
ɇв	̢Ca
mC}ȥ2X.a{v<[sP-7#y+5_ َ6s!"Zg}zi"FgQw`oIcϵtߕEWItL|5:BEkM~WKނͫHyOczR6x9S|@@܍]̪>FEGe\l*~XOF5.I%
Wvvc޿TbZ
sx	;T}@P'eKl1JF:2wɳv%\
M%BP,ԝ,:ܱL-3#Ѧ`)H}[[`+lZ画V6Zh	޵zc4ڧ<ӮG?=wX%v-
l)@*SLh5*Ic
gt(:Rǂij¹(PYt4N7Ub2D.v'1YiC(ec6HE%}s)7ἷơбl+ɋ7ֵ%U^UHu۵V~q
jRV!$J*AS'{"PqA"\,]0!Vٗ#"fFu_1}zm9Sgwf.R6}PPZ_R5n6.s˔Fҹz~je|ƿT}U*4{pEe&e_C%-+ra ?\oS7(wu06a߬8{s;og	[{Ⱦ^]%oGw)nGҭ;~}#=ߧoU}`rtB'{]!TpO\4yw'~VrmcV֌328̿4@/D]m?&=ŷ{缽K6~ztyQK]k?eL%+"B({S̉GU}Ӻ&ƄL߫ܿe'.?+]"7|~ы0%α_f0RY=݆P~~Eٯڿ5PIIƨE~~ӨJX6)ۥIK%u 5+]'-$GSl:wMH|VcDCe%ixiU'Ƭfn0Ώ&c_=i5?/c=/kFbG5~v3\__Rb
"Y=rbm~YAU>JxawIוֹibN\n
	76c~vc+ǡ
鵟jrt:OC4NWPk(q睞Ew9UUޅrr:S+H7N
arO90yrm`rmҀ7grP+ԐA
vg7;)Pg.hϹם%(X6a3R9t&)R#vD9޶ySƠa̞lYEl]sHJRqB=
Ñ E՛,$k 9|ߎ77h'*XgwTN}金ƙ1
PlǙGgr9ӵҨᖐEr_;33ȻN%N'?e*}
שμ{UX:٥4wQ:^bjBvU[ Ŋ%+t_#NjRʺ[/FwA3t|ץ3)t]q?wʸ)*قi@raM,srV&*3<NIGHw#뙝9މ(FӎpDC$͢ʉQɣDɅ顺fBĈYMvͅ3ֆ[{hQVYOj@AnYp8ss^b!ڹAv)2?@`/P΅E#u-(/yx:4h.\shj5(]urVո0ߨ)vMjX?٪N`gZk!]l٫C+hsg^d!oͽ0U%⤟v]0`38.<;dP%V$\#`|o%2\

ЗS Qno7\L+]Ctw2=\JHsͫQ
uhrТPΩV[1*M>㺇jT\Sgki;/yTir*w>;:ob2(3=;q(?AuֶRqL4Dټ,߯C#8(اEYݭhN5LQݴQQO^^>H\5h\e|E8ݯHR2ܒSڇɴMg3oU;3ݸE陦"4_G;Gl}&S$1Id*gAKJ/
)$Y3MuçŤ&@6#/דi̻4ݝE&Yג`݄>/Nui68OGBF:q\$	0s띹|GLE*O:`xwnk7tgK]ZgLomIU]K~'OډMݰ>Pﺡ6h\&7FJI=XбSٍW34㛟uA7ܰL8Xzb&$;9)WN`Zq)~ͳkÖEG4nt1RF7jKs@"ڈnBlqĵɰŃE-&[*Duxw"TfW%i*YB:n'"$zu&E䋹3O}ٹ/
=\.<1~ETz׵. :PoP3Ūr9؂>`LGh]l_9C
EZsHԠhsJ$):?$?MzLKѦQVo.X>ߍƂu%C
s?"0hz*mJ(
&'ԙL?Prgzf=@]Hݠv3Zb7ׯ/˭ZNzSԯoXvHG1۵n`$=/_;s.6;/>W&>>^Rɦfwr&es+T?&҉=e9Slbgom1Qy1`N鰭$, jJ>t2pxdh}ȄQ(FSX:!7jH$ZŻw*;49CUi.8jcGMb9`|3[`%h7ZzYp[K;
j4RwV[dn+Iw&T0Փ@*&t=qUP 9(?g)Hu0mS86&f.a;]ZL$M/H"ftQJL}&D)!|3}r|(T4|lzp}ӟ֦-@7|2C0wF&Qםܙ?.!(Kr|trp{q/wQ;]KW>hCȸQ&9&:+M'o
ƣX&sV6(Vm"u;ռC&](h4>- MulGŘF>>܏lEUf4ّLx.ND̘Fb4M ^}:m
|'!M
2Иjm:|2;?ȧ<<$a^]zks|;ooWwpUZR,!MRo߽g&IP8WRx^I虩@b!lvH]@2_ftx3R>kK[o_x/-gƥ9=ԤEq'Fd\X&Ϥ`"A3ot|/gp*ҎOz0O:.R&]Eqa
C@p>a=^/ӿ `p||/H{?a.W>[]K;fߋT(1;.$[	 E;=	Nm?>cvm#SEEb;oJøplQ[a6݋";	N|~-~=L߇YvwnXSrovKR}fch$~FC'
<*Tb=٧	(=g>pa:1@LyӺ[F4;7RA
m|"4VIʓ0Fʝp8y;,fjSg[g:6XV佷APUEgAlXSSPp8o;\-wD=mnw>Oc
~J?}6xWlܪfH1Ȝ{0?y	81x`	
_
Zpom6w5u
#Acݣ"COw5ik?q k=qOfĝKc'ËO5O‡5^=_lݘ5}<&v0{;L3sMU櫩y;Y67o966h2EEy$mz!=#&{2MI.2#`03L+pV:_gH =	5v݄sM"$Y`9g ϝ!{%ĝiF#kXJari}Pc'*`?E%u=eNjCJ
^nZi[a
3.~"yΗb?e72ݬ({yv9?WMxN>gw)WLQ1V̟ZX^Tk|>x(?Oswmg~O
 7'@xm学֩xDst=˫׋!v& >;rO3k(o|_on7R=v&×Dp%Id.Xǣ4@<7cVFxMwշ@?e$
̳,i~~Y;w	
[	pr2LBȔA=r3W"0]uZTuUfʼnD~-C>AoFPTDoF~vq4&9:΃z a\D8li(&獢FGQj .nenn|gfX?`A[?CɁ{vH$񣛡7QpmP6Bd'2FDzRBx'AӂȨt!{Oӈ4l硶&ɟ(IKTii-pUh#7I&)Hr6A5J	Fwo	`GKVL
HJ;V(O*&~t~R?5DK>` a`uϴu$/7	ޗ$דI.2.`}_{y~>~59__GOj7]+Wsݣ5ʉݺ공i И^1޷ntuη(lJtBM	+)	%PO'Tp"%tq9xJSstKZs(Cy|o;cQ=;/aYN'MV!pdve0ʵ	YrN!_Gr I&F-1k	B)[DOcx	%SAK;NOZڽOP顱H)oj$DieRFӀ⋲O/5%-VV /?@gԟd[NO1}4yѓP@#qIN┐CrAI)'KRT/NNʘ?)ʼn(AJ`y[UT
}PǿKY-jFB%guMؘL	m~C{J_{M[{ŊpTXi$|ϗі>
&bD
9ʠ|ŭƧp|ӝOW=j;cb7>KlН
.*Ef
.A`rt8=\65R,\{{*m|4t,wg8ZL)vؚ#ބn[{V/Ou8y%vCW>	u|r.#Yq+g~47~~R|>D:GO'z{*~6":nیm|z6
_q#(3OwAooT׸-ϱњj0ױݳVDz;Ӟ
sԕrݨCb,8>|abݞ9pӔov9}Bw.wC Gs߿S_xi{OGkB@"8^*pA Nu/vJJ/$|rG!Gw/4csCS^f~&õe`kǥ4G'y
C+Ի
bhif(u%6>11#V:a#99l~;s
N9PO
*|<,<i2Wpҝ(M4Z0f;HЀ_ป-M!_',
Ct)v8)=;QdcC̣

%\j(au	B2ِWDބ3M޵MW`i:}h G׻wb
7;1EHjq]1`:_Bgdz(cP]g}E==7x蛵Oƈ#zYERlr.A{=tZzcot~RRC6xL+nhTzϘRc[&IL
Akb9B֤]YQ(BQ>#**kXrp[~Bue^Efŋ'C1bv{wsFHi{
bIPM#?!xCO.'6=\4.ד#_O`ui_O'ۭ H{@Dp{!4'hA/qִO1VfL:ZhB;Y[m&aߠOao#]/Ao^Zh=|'[;۴5)-BQ8JVkmPk=ΆsPҘ
suޏOq~F+zF:F`+/@wO
)PĔVoI̪Ӭ)ާٖ'"%[qNKf1`UڏYKA8s8@r̀@5 D>%jk8ml]Epu1.bk#`]s+au65puD+ςh/?HTټp9Lm7BQ'0С{	dst}Sш(na4:?"I%I	^/Zro%#
[ 7) 4!"-7}V#'%UݔTnʯnefP6ƉڒbraIQ1+MjHu8ַXzo#au,z@zεfG(m6Ն.e/p'(hCx>,PE-|iAAs>t'5"0xAkH4?¿,kGNr.rSPa0!Jߒy|'LDNۄhS֍FKm}zd@Yh\6ӡQf
EL3JysX+Y[h&U+꡵
DKôL
.mD4j'fk:6<
Qb:C%p,w.g8'']YןXnt0Y&'W[KpݹC̻DXEb$Yl!+Ӫ@A*ê(mSħ"ħnOňO=/Sp&	xb3a#`Km>	_8ȉә-CkȐ5dQlxmG]lI&_kۯ7Q\9`I2ƞi*8g/0ڪl0:Pڦ
)bq"k2[0̟и`i4hvyn{:s󸑳jt@26C#konƴ3#%/:RKmETgN,7DT[{)}NoYk+wcmW6/@!DH @6w>Bg>PgA~	ٸ\
sυ+<_	7p7_+5_O`>7|oB\L~+ⷳ|)! _UAGwMxNJ( `"NЇC=Hn%X~E9P`tk9:'s	;NHÞy(HƸK^?$(}>3Zw-2{m\w6]υN"BҬwt|%aмdjְZRltf76~²Y(a	t=&a|t]Ыb94(&@Tʩ@45{t2z:nѴ4b|79___=k|}.2Oƭ#mb
aq,*64%XEֱb;j'rg!'#jlÂ%X6O5;pUۉ.$0	BKZWנ7ȼŒ#՚VNރbz]HC4,@|CΆ-XDCYB}Ο/%^'	%?[)9
NaS	{66#la_Ct5a ۇK^)C>4b>4N/1΅Ƌ. 3"z5XF1gğ;P>sŵ?:@7z}懮\dǃֱ|~7Ww>^dmU]mA,ɱ34Ab#Mx2uZVQBcpM	K)![',p5%K%̠|0IRXJhfwRJ3OZTL)-?m7`=O)=:NCH`_h9GK0CHukRq0mޤHSjz*89i99*{Z1KNߙhtI}uQB";l&J45mױnn?g0}~fȵ<\
sLX6?B{"5{f{giHayveY]a:I}\#H'E/obbtC`4+GtC)(ZưiL#Ly-Ng2tMt"'5<,XfyEN8v1anGt~â(~lm%tgCW-V5bpclٯ,~h
),THDX$2UQ-}"BDhjfffhi66l+ښD;4#81/͙ybE换y(6*@S͟毢yTk5LHJDKƊ1ҺXb1ƺS
qNL6bU-η^Z_wb!.sLeGl.ڧ+J{X`OWky:&q}ѾC,+M1خKv{Xj.}b9O+xXTb%&W~0VQ^bOcN<.,'Eh-6bgEGEtբXԈb(ωy1Els1_׊b'//Okkc[RexW2">AC|,{.WrVnɽrsc95 _i@>ѲZ@#vqyƐd.s++t3`ӟO0*ՐkWGBN(s((#fꟛ/x}ǍC\gwaeM*ʼnʼn\ȑv45Y]n}ĭZIbpt}ʾ	,]c?i+{4kkemA!{k)?rnQx:̶'`anO8{dikOP@!M'ɏͼ:mFkYW~xLgh=0HN){*oT(FUHA( =eQ~[ ]3ǒaᄈb-JҜDcQpYk\9ڜ00y/r7HcT0է2Jr{ok8]Hsfna[i=U!anڛeAGafӁޞHsEnDcnI{qȖ^sæm}]j?/|'
G;i|~La:B'>ߧz8tꏯK3^v=ެ#`z#z+o_,4x_g?|f#UU5q{FH8/B,o7jovO{
^ EB:9TZ	Y*ps#n.iݱ}K^pQjg"XCbX$/nE1O$R.j[j
V3p[E*ԣH:*,SLqKB1גtk]x|5n?ZY:v%9m0+{(
k6>QƎh"mDFbofTQʖԔJNWk
x
ŷ'I{bЋT7N׋#@މUh(M#/$8/tv	]ۓL{WANGk@cGV;B)ž
o1:Hi4eqioR؍~JWFm>>Sn3ǝLr唞SJR;ҡjs=Imשo%Qipul*·i~Cvn#1
r'}jW0qYxRƻ&zU.Hm嵐hXn&&.Ma~	qqI
	9$:\uמYjb>%K-3Mk,QBIpNΩ)IXJ=\)~8?uVeܮ$s#?h$Wʜe*Φi%ђ0 6v^<%$jH5!m+5d7hK7J#(=O2.x|ßȦmD2Z]rΒ6IW4Yý2e&YSfë2<8,Y<ePd1ي6,`d[6V.|ف-a
#*;3;(od;"B^){doJϸ^a&4Ar9X-2V9xQ3ސÍO'9Ҵ(3$1crK1r|9ޜ#'
9|RN2w)rTz>Y>')L>gf 7fqdȗ5*61Hnȝb|A\(wr)%q/VWAK,b=
q(|"?4҇k>704Ն~޻B}2P%#6ZZ'F7hZ#D~blJh>6uՒms̳RURunjX["(۝~۞w}kne#\,Phl*?G9v5ekͯKdAKת\ir\eQ.@b]<ɯ0ۍܞmx	,cp?_4*0,s; o}]/@,>I5ҮzİLmA`_0/8(sgAV[f6
̪(puMY9;SNRdyr:6]=GP|e3/X3Xa&Hc)G9cIEv(B1ȒB<{p| d
2{H~4wTS3z慫7O%%H17D=Õ|fB(&{>T[vJ\̣JJ1}RUMؾe']*3͠.4}ǪEDB=pk4.@?#Ro0H5=	
Rɀ@=R;&3h3	n`'s^6JYiQT)Vd(Adԃb'VmTUUۣ]s[viGѶsXfQT"1x)nez~0Á ?kCyKI.|u!J>.EU/#y̒̉q^Q?4A;`C?g07}T;gSow =e1L1(T&tQ$P4P*nRYXe2Q'/
VEXv*ƺՅ:UWWqh'*!S+&:7/@cMӡ
{aӶ!<Q9+`9qYn޻@1vHҊ3@L'r6ۤtOTKa2d8|8Inf\(rp7}7'M:l bMBh!x:`ku0('m??yMl"isWײ˫D9C^y&k^&u A&|$9!䣽hk1%q,/]	)>9(ͪ+/6QAS*:rTOD^p
g>|`:.W5!|gSUeWC}3>Fl$80V/*"P퓩j+FFNo{N?;-h]iĚzl6!i\+ق꡽U(B˫Yf9lmJTj%iLK@AvOĽ`^*"/jjn/c~:F'|qc
teA/*HTYMkMtgFj>|<Z#|XD] 5tijwBU@$$C~#y8vfBKĩFB:qj4tRc*5	0AM$8_MTTF5	ED̈́;,Pj<5>WWWjf&
,W-dՍP-mlҙŰE#p#Ҙ*GJMIjHgHT	~֬EbH1uŹo
kl}*oOTu{>'0YI0Z!
LzHMQ9ccl
	A1w/[όjdcV++
PAZ\ne)>Lx?z˅(<0IOKJc!W;\;^ih~^_'%7 kG{T'%)D854:|?HqHD:UHW#~#pzWkkzU	51\jC
֧s|:<ٌPvOQ$Au% +/ߐ6ץQI\א6Cz9"/iGو	s`0>S 48j#MP6C[KU`U
g)2d|>7wCr[	A_}w(1UcB
\$t_=6>2ʼڃ^VMYylxtrtE:L[b~!!_ޤj8_XAMmHJv@oanuMƼK:!:'S
m3>D/!zQ
]4D;Ed41t	#м(6{tvGg'OX0Dm'(rt;:ya^)4VCQoIꭿ]B_}AjW[$ȐtJ.sʻkHlq"UFXX	tɏ^zA47Cax|c6yMnOPA+>V!>DV#$mS.09LT_
Y`ұ1TA#
Zka<`sZLՈ]_/:#']$=-DK$?^RQoTl,H8?)r9責Y:R{D#'AQ?'OVgk.)KZPSGd5~BTT+ruw}uOVq;P̭C(akɚ9:__IzKĆOTo8q8gM(2Q&uL H%Y18HLCEq*AUdRb	k=م#Ic:baQC!&F6#Ge+P,[TKhHF8sr|~n&V)fOӹARtmսv>-NiE .2yyJ[
)ѸSh?9:U#B쒀wX(U4-9UYHHCFWikg{ոh2HP}w&C3l/RZ8itPN2h4vN&tr1tɆs\d'8M`rNpZN+
T9:C$8䴇9QX:9Y?
wN8z"C'8I_N
1lq.^j,{u
Fct[{؊dUo=]ec-6p6Pl!M--ҏ9W%H>::HE8"l):j%Y+B_p9&}W<la?P*]`mI{^K\a
څ%DL7,;7jJ$t&	UbG#ErrTb!-
7$txrwN|aB8#XXALNeK{^׭)
{ũhfJwfF^2ֿea	$>L`?QĐ;s
p2ы.SYsb
S;@0NvY	qsry/~9J9ʜ0ӝA0!psNsc3	Qs茆_13׈qFǹx.DX3e;YsSYs>Lc%tB6ޙΦ96י9U%ls)ə:sYܹ8k|ASܓP,.s]}&zi%ײ,כfCl/vr<_C	;ȳuWt!dah
ILTv@9kT[=$\ӻ6[}TC?tX/*͜B0EQ[L::jp>V$JbK&ՓXMR!F G4dᘽM^ozk;j-ʑA{?ӯ1Q>MJi)),lҰdoK:NI誤p<#dLat]*N&z8/|[sռ4]3#.MmSkQ?
@r-dǎБ@P
/iK}  Ga+Wx[ЁjW<ݿǺH\ܼU@0Ã2eT5Iljǰ9aO;tWWB~)}\61
?a[=+gn)^`y72A̼A_s97WBc>U0\
WBq|n1½zXaVJs*nr΁f%A͕LXruOڇj}6A}wɶEMH!i(ۖ]0dItÜK-pe=$uVh҉{RFCК,Ĩ7ՎŨJ(NHGJ-hb\sMB͙w@3s6BgsA?si^C0\̫`y
7Ih38I_dojP&	e>@^4C!-T:S,ÐVJ%K5E)"?]측`a'y@, &!%z艇f&H146̆]̼i\䷨<B}-*H
سTK!5߁~*Uer5TSOSggq)Fcx'xyT;M^/.V3Bե2/r?JLWku{.wEݦKRzKݣw]A#QNVj+f3u"|jܙ| M=Zm혾K#@0"ZXvqejoUcr/!6
~|,+W9(X:ʢo[C|&Lw_ܬ޵:W!PKiQ=\',,A[Jcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EventSubscription.classW[pG=GKN$J"lp^cKVWVbz2;X@H !q_UATAx T$UU(zdeت}so߾Cx)Z%"
^pg3S朙颕?cT-NOqةSzF,ǟ+.D؎x7w+f3g]JM+Lt	߳bvkdV*پbH(N5OY_o2q'$!q0# +$6K ^N\.|	lƕR"
txV-YEwmfeUWc@jѤHFZ\'`XB?7tYܗsb&_LlDz7FѪ
\s	!m`D?HP~0X:j:fd%>!\ݠ]2ٮgk3þX~@
rݕ-jkK`JLU`77I]cV?+}3AV
]k]Tmy|iCIxSOkl;siqoYuȫ>9|[\}T+9oL\`sGRiUrcnk*kﳲ]^䥿*s]Tw!NUʳTe1(p7#ۈ~A4QpWD
qVOo
(0-QfJ!-Yk	iN涧(?Í.p;G5'L
#ЙNEX*#wt[vXWdW<T
rs97Vn@~?DRMF{V@F`:::::\%9F̧R8畩c܁/R/CEQ/}|q0`Hw-c;]mbeh5_˸m0S`v-lX$v/__tG
DC*QC-w")R-gp2lnnRl{^7E0rO1~;-$ٯĜE۱;CZ!n6zvYEp@۫;G\zNXhI@HK*Zj[Xs$*Dy}/RPKiQ=\v6j/:com/pyjavabridge/PyJavaBridgePlugin$NonLivingSpawner.classP=O0+mSBB,xaTP+RQȭkGS_c|
	~޳}PC8K̒e圯xY*ؤ"r^*RFGr%u:yu)"q
}~;xv"QZcaݥ.?Eh4y	~!݀&XE{Hu
6MM­Jۆ4zPKiQ=\ߛ	Fcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ReflectFacade.classS[OA^ꖖzW(5Ę1kmt;,CdvO$}Q?e<IKLywΜ/*r.
(2Tw'ގ
G;"0UYcya	swPrq.C8|#Ilź'a
;M&`eOڻ{7rv-)ҏPơU VDuyT矝27bKPt2#Edq!GƼٖsTnC\';-05
M}S*A
J?bX%0gvҋM7N_@TwlA@tܵOzlz"1o8h0,bRBg=!ӳϐaaPZ(THV	;~}܋t;j\匠+d9XLa_\48_gx7pme=Cez@أO\&PKiQ=\g>)
Bcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$RefFacade.classY	|&`!B@l "@KC2%;KV("^UT^
`ų>ik/&~ٙo}5>,49*<rG`[kPc\>f:P}l#`mm4&!^~pbgT>~
HnHSp5f"!{:!bh(D`Ä=Pgv(j}e5`S̊Q]QWh
fb1*jc24qya"VԬ1bl,+{1y7H¸Y(yp,F=\.&.ǩ8^	(%Lg"Zy˜#9R>ñ(SQ'°kYZpq<8}P&ixq*fΊ!+bZ`!+ఘ!va-FYcE{i^#fsV,S4	8'gSUG$1b+\onAӱT= jLFb#Ptbu&aKVDiˡRq:aha98S^M"kYmA:aA6l4>;׳Q)ֵVQj24|\age5GPp,"xK8O525&,L>5j{q.|
`+e9x44-5qs^%%\i	1$PkVE[0bv+
fuvji(~|,L^m5N+N5WYˁ#F,er-b\ėNf֩hp.CO0'H>5WlĔK=өlsb=g=npH+.F+Wh_a+BQYU\CbF[uU/&:*!L89+oY"JuV7*n԰7xxcؽt3V )>ܢVt2F3fFCFUm%	GP38ަv|sP5drߚdjuo&%+#disd ܥ븛5,tm{9y[%g->mO1#Ķ2PUy|1e|DCewj8/FmyRn*	}kq#YdD^*"xOjƎD2waEV2,K.=+ծ1xW~d`+bv7*}ݠ,=[xRuҫHS͏ɮUƒza=Wy|Z\%?'&='L?
i=՜\jOLe]-KrkZMW|BW1i;v3F;~%Sv+͡"j\&tNJU!J/HHlLq8=Ymn$Vv3\Ҹ\EڮnYsA1q
̢iS
N$n`p,)Hc967,FTi҆-J6b:FiiGd,44'UBF-Y%m*yAWG<O!RgAO5f6霣m*r$֙U;o-.Zh9;$
;o(ws-gZK1ʹ,;fGDaDҾ];ƪ^CFw{PaQ4Z~8$s?pՓipkZ+xV(POxH1!'juY-_AO?/{|+aw*'9"MUG50)'[e'Jɟ~?|WW$hJ܄oxK:ydC!^F\)h\	ŏ9i|C]_W\kroVA_Y.\(
-(T{<ȗ\aV![Y__y$e@a0o;*ۡɓsqsun)M-ٓ|9'žѽUBݸɌϖ:)gNs7uO7tm?*u[*_Uz>tt"_/؋Bpr?m?|SعlBxJ{=IV\6CYlRw<hoc*GH"BhEbqcX:,:pė
/.+
-$Eld	b4I\K:Z&:Wl![DW[h6[iJ;m;-q'#w6veO)(ă\T<,]JH)DR3QNkLNsĕzS
<$] 6=+dmPKiQ=\(C\Ccom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CancelMode.classTmOP~ѭyL@"62㴼ӕ(:u(I(e
2c4[>>9Ϲw߾
`Y!GVyeneިS
`iTl7yݺoOYm(d
at0üޖdVhF4D䟽ҋƚHӠAI!n*SЩqrj.gMu!qLY)oq'n/.(ЏBmTֶ4kԩcS	l=A	
11k?Зj,KUڑDQF0*v&PgXLrSMS[]ܨfno\YS2=[ti]Ż%o6VM8>e&v5GR*]5k9}~'mYQZóc[xo-b'`a2hE^px]}KlB=!7I ܠaT`,!.	S(Q4B(>ԏ:BӳCS7
ӄBC?oc#})^P@
nJwঘ"Ph[ADL9Rr0ROغXEDlY6◤\އW Pqu/.^}Nu	~&i2S4iu-PKiQ=\`ܵX8com/pyjavabridge/PyJavaBridgePlugin$ObjectRegistry.classT]OA=Ӗ.,C[T CYEP&
Dv,.xDD4e3mJjMڹssνs|	`!D4!0|dFtN[>Ctvl?N3Ƞk:VyB2oc
@Ü֍SPJi)7j;M淼j7|Aq0T&tO9mؐKy{*qCTz!*1"
(cȖw4#Ip*Ex2dˊ*aBx0rQ|`HRWDnx`F#.q@d˩ҿ]=!E5
0gW<ΰy9=HV\A̽wfFђk}ӳž6|G=i{Yи	
}7TeKT	xen"Tm6|/QVtjfR1I7¨xz`x"wy';L_ztbY@2sP>\`)D!}	ȧ51y,O(ZMd/|W^UM~%x<|A_!bzwuI3لjL`KDH%\K&~8^"§vE"ьlS$0MVer]P@A7PKiQ=\鲹BFcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$MetricsFacade.classTrE=Zڵȹ$Q.CĶ0QXJ$~FAXZծ_/TU$P#x"eaPA3ݽݧO_4>elG@PC@;V=廼ȕroN@):];HVw[."0k9X>D5028N#Q{*,lfc8!n$'n#Wwvl/.hCx
!ΘG\y a)9H\a3
g5߳e{b8ҳ(7.
Sh&KM_l|)2e
H#0oVukw*y,20ULNn	B9\pu`CtaufNCü>.F
0y;d_J
)UWfm60I[mU>aڎX[5VVl[][=cHn<[diC]/s'\
z:rgOa<@3P2yI5vďL9,#5p|(~qk;*L5:Z|P.?8VC摙2|b]Kْܩ㭼"a)b]tmYQtbW6blxMG3qE/DwXvgsh?m:#`Z'9]VW%"}'Oz .K3̣8WZٟp2-$nEOG^K&̾{RLJD
*2Cѝ׷,e``
{<]8gD$ѷȲ2^<"64LɨpeՑ3to,CmVČJ`g=Õ_0;QB
A~ *Ml{ӝ )G#PKiQ=\python/PKiQ=\7w;python/bridge.pyiَ}B觙Eg1nApq.@`KT7Ӕئ?>ś5k @aZQ".LCF3"{\GDS#JgAXMAQf7?Xu޺]k;t)P+~mG&]VQz/V첍^mVT}{ʊtQO+yn.1|=Qm%p4
޶Vw^oEs@z$KХ%4[&DrQwkh~LC#Qf\}]űkRnj);jZ7l5{?Yn_a/t`uhNCv  -;CHDBYq}ЬyT_Rp2EQCl}N1R#HsB+ F_G)
jrT%HyEpJRU;|p/spdVph=V8#:I}…ҩf$mO%}/?	yai<?gZpr9%hX`W_o+hpVVui~w]	@:%Rbv=}結1Gf{q7M,qƸ}citzKYޟ{kUr?9vVOB%ZSy	\JO__ȝ STg$d	T،_;]`fAFi\QfZsL9Z#b yn|:ibV}`\7H(֩'T)JĚBmOQlT!!͇vTZ&e0MBaJۤG"F.k#^+0/wW&sPĨ[-{2SD3ڣFr1UK1U𲊩u'
]nڷ}2<]J	82Y%{Fe#mą-tLGcZ.V/&#A/bo$./J"eek8n۾X]#d`FdG˕_3o]@MחV%E\gހȘlarZV璸(^Q=n>ØQlR7`(Xuj$C.(fƮbN+֩.ZӞUAm.=gB*ڵ%(ú/'tච9ftaՄ.YaHPLmk;SDKE~p+R}ڇD3BErlF~Sp.qss#cYع%Xw:6crYD~j)X:Hg;!XzWHMow&i65~Džֶfd{'2ot?J$74J/N;4@\F6ȥ9PKiQ=\񁶪python/runner.pyPj0+N6^>	.'-(A6ZVD6=kfwMf0؜!.}9TV]Lqv:hyo\:mО6GƜߤMu?%ˆn=v"/@yOq$W4_iSmG\HޤQ }PKiQ=\GGP@\python/bridge.py}kwFw
Ќ3{ݻ<Ü+Yu,'Y],D"$~@83@uUuwuuuuW6IyRlU&$y|mv'l_ϊE;I^m[Te~ˬiFQBߎſuɛm	b+mUumP6_򱽨l)/f_.J>62WnW,_4Md~5kWy`/2Wk||^E*7Q}2[߮~"{_z}Vl1ȼIZ4|xz+Ë8jEEoWYEVlVf5dqٮ̓/X6mXOj~*DOi۽.XnI4J^Tu~Ve>Tߜ"W"˫\WoΛFU2;һ<6DǦBZegh_nSMrm]뢽HZhu-B&q>=N9^<~#՞=gJ1B>O_?~_	%eJTKqWG:owu) rB7y{Q-5")fy@#U]C3jx9M]#i =۬EFSwO&c)&Dn妻r	5M?AoWI]<Ԁ8_eSgXwТЄu쮑 W]XIK9#B$3a\eZJ¬eEudnC02Lij@
e6b30GBGR?+
ܫmҞ5de/Nz	Žo_XpVW|=jjmSb$PI[5^S9]Pi?	a:+VJ@X~\B1l7$#! oynQkpv0mo^`EXr
L4$5/򨦛R*
5pCmj,-ڢ]iu^@Y8ED`k0bB&4BR5YBRdСLǨݝ1"CE-r'$rcԓtsI8Ulfb2fZqnS{a3! >ԸXaWA7w-.
њ}9DcMX|6$O
'_d
eJs_6`ݶ&U
^d\иbBJ<_CPm@XզX! lY޴#d5Ǣ4gUhMNЅM,ZGD*:Nڭ-2EۺXtLfމ<0d<ݶ;l`'-zh뼼U,2/XFH'GG5FHIإL~Qe'9+ށ,I#d0=?;˞஝|K=B6O$CfϚEf4ջBs	(XHgo]B6-LcYnHF8|&bbAKs|eR.)"ʕ,fn$˅SK	h"/p|p8q\fqg~?cIWe>⮕c6`,%ۢ3,/iSwa_}4vq?ݕq"y`	:[)N[H#7U|C̅,rA4
Bԙ(lYA60RD1H9ӏ-tgތ+|q~9ĘA`"h.Q͵ w%%O窨s4zc.^#q١es}QJXd*mLZ^JD<lb%2}v$q{Z@XrHXkU".qaVɳXa1I	?"JD
K."=>25Qo!^	kl-YMZ;L\T\άDFj/
`/$l,|ѡY`B?nLbg)2hSӑ0kvk7ZpL^5l$㢼뢕#k7HƂOڇx\(;vP>DE\w<1IZzp:ETNL3QlAB:h]N),#\7<`5k&n#<ƈYݸeU.ߧ^8յ>b8UWve	6\dL'
KVv	N^ҽ}
~f%E$ND磅9%G P[w럿aHycwh2wis
jot~ym`ŹX͖6ծl\RgB	q-rm%zb@v$;f*,+ñutR!2k\_Qt[<8Jf(Di16y簆SR,RZ$PXPA,1IA@C~m@>"{Ze(O,fQ`"kRDQnD_r-eP#[<2wyҪm_u@[onTjan_YG+RO;[<y
w8[ڸy]gu{P:
}d?[YC_* ?UXiWFJjh0][m{d`b{b>;xuU`?*"f{BPi55tN&X%יDVlwyYS>on!8#8@~"ȣfC|"j%f@	فb	șs7s${6t -^X%[LvoA\:VNC侾Rd'0Q'7X)욽Bd|{oH853p@[e,n#mh2ZL.NzOd KDDJvE>~&EQ1aeoڕX!/BD$'z1Dt~҃
ѢSHȃŠc2λȏ
&gJK{Sy͵/fVFXe5*;a()̊–3
83sGFBj|[X+֙&4${]CP֨b
f\s,v{Eu6HŌz-ù`1LTx%/eL7pX䃉TPt
qsXCBqdǃRA x5ٝxM
ډtXhRuxQ]Ig3>0z7H0tI`<xOAԨЀݲVh˼Pޫnm=UJ,My&&:]AO`=bnw	m9LcM6މIzwƉ)"$Qaӧh>fF,,({~0￠ҁYW{\uU02TynƀG]Я7"
I_'{jqafK'_H	y}UTI0j]c6E`[i=N~gV{^#9|%x{=L{Ѿqoo-~ͮ^arrmw/9š%_1sWWa0<0뛃
+tϫҋTn7Gz{0[F_fׇ*I	[kmNs耣Bj#0tYີgKs)=I3ދ{}+~o3;`M5;5CXO_ڲ:*Vɔe!P*XjĽ#K_cAFF/Í7C!b 6ĭUj_ɯW𿯡u{$lEaƗm=vtCu fOw*-27k|#=|	j8:_5g͖Zq;j5E3U2it`B#KX.瀴X)U%lE-,1o4BF5j9ϙ훹XnI_Y}kZ\pMѓG~|bfĺZw).[{sۙuӮ4TIa•@69k#)\=#.Eͧ,koSx_㸌p=v }3	n0c/})zΰpm0)6NZR*[8ibW7%vyV!i8U%BhrhVՙE͎J<.%y^%
ixP+l[sEV(s{mpۤ}H7l?5jS,?QuSߵ^dpsb>>oOb!VjM1ovٙ~6{4{i]/
ų_+M%E-|x&0v[AHLPh ~ξt#|E䢣§ӬLuUY߯j6y/be(¥ag5:˩E30U5m.Gև,i㥠~2z59}SyOR"34:4=q	"oK^vȰ]y	]9<ߡ׍΃,\;Pz
[{q;z5YG,ºH0V!x
&K4dn\%,UJ1i1D٢űF5&#/1q<rQZ@$alw:Wtn5&qkJL	>$~"ƀ-h,g&W5>LrT$2">aKdN]?LHΔg5:*܏u~~

$],3MLʂBPtPo[32h:k'`;0k4l! e~	0<!zmR;99@DnL%u(pq
`H.g8}Ptg_@CEZ.24xLsScu?=	YQ;C;v^s Wށ}¢|!]B@}jQ|#@;YTku%XSw+'?LgP(~7NId禖@df}
}ݣr7b)6#RPxg\$*D2sA{cRExln^枙۟e}0kܗ>lqyd
\
vddHbiO	j4g(SʥіFmi$ޱGQs#aAG'8#Kzƺl(}Y+wDaxIi(Ǜc38.Nlz-_Wu@C𕸐q!l>7v]s<㽎7{xcfҡ}
6.ML|	mr>Yeb7@
xs:pAZ5';u#%}%
ky!ܰv>k^b~ރG$W+eY%u {,)w'yd˾,n'FzZͿ=t>PK3td
p<7uQRG(b7Wm܈B慗i0Feʵ.ݭxX3zLOPWTl/dͯJ@ޢ~;bi۳çYמyDȖݲ~BMY(Xt8z>/"(MV [Q7-ct^}!d7i>4
 n#i‘k/߸^[plYc2/9Giċ]Xcy;jU$X͓-.p*Ugb))
7>ҫ#9m'&E8B4|
+yrĕpH2oŎRJO$]j](v|(٪WڮWAf~GhخQ}[Ί|-鴱ׅfw޽݆9y.Ѩ`[qkG,6ƅ
:ԡb	@اbbY0}t@#J((-#1? IX"
b%q0=i~Sވ۩jAo#;Jl\LɎrаZup5tQR1xjՃ{np`hKѤ]R'|!p@-̲oz,7 "@xxba'܎nvXVpO",YT=%0S?i9cs|VҰM,|2,|[j`U3@zpMHm?jdž&&^JeVmfkh:?\w+켽!;~Jt4Sj.*H'لٖ.N$gb~l|83U|64řC(tWn3^\VSPiMoT:M!d\q-.Mچ-l.ۇM&֡	,5\Cfuҭ8?]i>T͖O'?Q0C#ۅn0Y(€6-PʔCՎv&%dpq#E[3qSBu7$$ԿAE4&txV?L6gj-БxV5ThJARx+^fOB?͌:fn
eHT$&J%˥D:y<|~4
<_d
?UWZ߼;!$0]+#k]8f疵xh%Q
VA>:	`LI.ڎ(fpRҒ~DKF8Xv\-)X2(Oɋ

34̸[vo#3ܮߝHg)kAKTWuDot
bn-j}AʊlvQC+Kj=((ݪUjD F+'^E>r8ޝ`{%<5!\DjndwX+IG{.yY4?B&ZJrxQYCf|[IZniuN?U@&Eҥ6}T(R`4WE+`MOU>`;A)ZQ^X {qȱ	PBB
1e:;=3X",9mX,e[kw` p,!QeF7̇PיWeP8Yk|Е1t:J]T	b#N*R,k0Prρ;$1>'pQ6q;Aɽ9}:J%f{ĥ#Ҕj(02Y
#!5,̇NewfVvO~)	s7Q~K x+j{_Cs93l'_A" AHؿ:z76
iŮ:.avah0GYdR|5C%~	겄#2wːj]4ϜZQ
`hA_nȕ5+24:ZYQyڣ@
,ٯIe/v0'gWdϳ[8X˦T{{pC??rxr5-L{Z->[dˠ_|
.~8l9oZC䉄%H".7RZl{&Aຽ*K@oֺʦOvqIn8[Xqs]>m@Ay!@3(f#T$Y'\2YkW"	/Ä.Zjk.Ej/u?P-.a[`
EմV
 a@e#uUm(vBQ4d;hnWņr&
@WatPcԈj.5GbFåPٙEc/g S1ᶛ8
5ISGu^6$(~ߐ:dmU"LTMv{ak]|g{!@L_¥.!52/ؙ{MHxxv,wW*Y9ZALSQǺ5꿭!e5:yN4!c"#gK>ZY#3@6\T\r-l_Fh3ւ.~?Xo Jf4R™+D
Qw
xim
*وQ3x)S:Y4T*ɠ
,ԾeKvvl6Lʠ^8فhr{u%`<]޴0Gij1Fh*PRo'O='VDPf#;nrTO2w+D
/	Pχ,s8/Nzi%op
r
OFfib.4fRX4nn
*GR1cBɇӄ$F*kJ&!]3AC`q؋N̩E"gd75{>_Pbx"L¢GuG/^H۪%@}\s1st5P!1RGXu^p57O1H
K.B$!7
q} e@|3Ɣ&htڱ8_bWC n@7Z
"C#\pզXwcEUa@EMO{c{R q*h#.\M㤎e@ιg\˹z3TE?-[|EdMM\fo7|Bhnf	d
!)ԻJQ"QI-˝7-v
nck\-g<Γ/MUNͶQ@u2hѮ]=fuXQkOH1hz
{Nc?s"ݡ^>pwQ%0K H% wkd_?޽^7=
6c8]V/Whls.IBpnU	GrY~JNb a麝ckݷq^"LĿ!htDw!-[>e5.s_lo[1&~x~o^?P[UcsLh_*C_c.
X(q7pSsBJ!7*.A9;V;8@jIohKp̯()($mnOHР!H'FѝݛTd^FD&:@;
R6-):샴>}{)dmمyXUY0.lj0f 8лhpc70WOU$@ANno0m+to==FUFm:ve+33ꈂ1e鿱/juQjlpNhT_n?I],Dg!be 2х$.[MlIȦ=̣Y 3UBBؑ	k1Iof7UN#KUWPࢗBS-2!+#搰-C.FjK63]6$̦ї8r8o6wA,('.sgvφ`萠UP+w=]4wW@Hy1P|I	0yx!d|!f%2wKMGZ*Fh'L&X89DY?̬O@Tc M'N{Onp/'WOF;\t_<$EP`RyXNQ(Ю]92`3twnnaeVT!`M"|GT]4l<хO}eSݎ>
-|MTDw6q[)Jه>x[вܑy+ENgjW;A@ATDg*i(hDea@#HeJ~#m`6zДi慡92ӄeb٩gFl*I2X[u##,˙5{PJaXiDaHcC <`
L
!TP@G%L[E}=<83mA:)ÓSx2`$1W%o Ev-`Q[9&SM @l2~XtvA~z.5=	[((rtrmIW@V7Dmu)K!-A
_Vī|^^Xhnpw3
hoplr5rzf("ut5\$'!~'PeVb%Fj6j!A׊OIS56%5geYQL`5i˧fΐ^ib2;UHc3PhAR)
Bcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$RefFacade.classPKiQ=\`a%gC/com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ChatFacade.classPKiQ=\(C\Ccom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CancelMode.classPKiQ=\`ܵX8com/pyjavabridge/PyJavaBridgePlugin$ObjectRegistry.classPKiQ=\鲹BFcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$MetricsFacade.classPKiQ=\Apython/PKiQ=\7w;python/bridge.pyiPKiQ=\񁶪python/runner.pyPKiQ=\GGP@\python/bridge.pyPKiQ=\s?
^Splugin.ymlPK	:TPyJavaBridge-2a/releases/pyjavabridge-1D.jar000066400000000000000000002627361514752343100211240ustar00rootroot00000000000000PKA\	META-INF/PK4U;\META-INF/MANIFEST.MFMLK-.
K-*ϳR03PKA\com/PKA\com/pyjavabridge/PKA\VITLcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EntityGoneException.classR]KA=ךQZ>$j%d>6z
zkPd
s;g.׷gAB,8;~k.WNjփ-fFz!q*4
~3oh|Bm{l\}9qDm$r;w.IWiÕ--22O}55`t,k>vI<#ˀ1s+5C?uk*Nh,Cj}[e^^59j}M/~ǐ*%˵B]1d.,`145H
#Rt
։YH#@9z#f0P'T"$;PKA\t"Jcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$PermissionsFacade.classZ|\Uyݙɹi:mNKB))䝖HRi"lR&C'3q +(-[ tkh[*V]]tEW.+t;73~̽~|o>%+!x5# /524r5lxӮoxƾHfV/VK3x*YcY1@vsz#CLsGrs,m܆n\&cJ:Vo"f|jVֈa5LLVbv[iR0N&Dr瞸3
DR, z(etxEEz0pF&e&Xs`$eSX
񁤕ͥc(uP,d9g8KeyY3tZ'l{:$9Dף%yY,7UyUɗ)if_NWې*iR
kbxqMuc=fʄ5oz9x†yfQ7rؚnԴmVJAW,4"(pi;f˪ iT`4w”BO&?͑i1=,"b!fJ1K=|ҩ&3Q`Md}O25ԖPmT*OnӕV"Ҹ#t"[E^_:LR~
1m00D_eO.ʢgc>Ǜ QQ~ī)\6p} <8 ^WR.+~S
ԧ:v7|.nƪq[؃
0[	Ts9^<[}Q-!(7!,7cRn96.^^?_y|?ژ	1sc!jOJw%(Lyv:~ANIڸc.bJ݉ kt9w	tɻ
B>`E`y7()c3>Q@Kڥ/kZ*hψ^y!*"( r-
HQ񗣓Fupq-Ek>o	}۩33Q/4Zڋν9.5j*M/b86w55*8X|B3Id-PL>xDIԣch1v Z7tT7x֐wvcZ>{'sl[߰g.U5([
S]MjuՍȍHU&.7z7(距KyMG:SP/R$ZSXszeN{虏Af{H[撶RN:1uFlO
xkV'HfO;^ۡO;7*W6)WP%a	:..`|Vv)e*VxDHtL'XYjծ<Gx
mKa>=X?U)٥~)b
@4;V#j(vJ"j"U{1
-IՃ?!>>5d
3ihk@9Or-(߆)y/?ZC$p1?O
y5AC>u?66WHXyVxsU*TtAAtt4>,DZPF9^msf5|&%_ݔdE&l3J~O(."+ĈMT;d5YA,&Im&W~=sʂ__b|+-+X%0,O#W5O8ܤywi	flcflÓb;\vtRoW:BAr)=Rz~'sSo|J(HNS8nAP1p'cP[`>8?etE~~ypF7"t1;>9צ<`VQiOcq؇T~c[B]=ΥY$OlECb>bB~TDhx_އypOFV=5x>
̙(3+1ۜyTPc6
j7<j{l3bY:A*,VEcWXT"^@IR,1[ljs;-a}Yj'k]p׺ර.rU`5$3}&q5qO£~qk`yz``/ܵ-VM>,oC *aQ&l:EO$f8KT#PKA\۟./h)com/pyjavabridge/PyJavaBridgePlugin.class|	|T9N&kXJW*C2@2g& vQkk֪hK[ZB@Ŷօ.jҪ(d&w]=ܳ;y}|y>R-ؔCL뻶l	';ۻ6#՛[ՋXjr#)LlE^rӧ+nnFZbP$Q]*6#[BmgvB>HQ>43MmvTwn cᶍe#9`8|S,t 1U6}9`q>*t,i$bG`5i/a['0C	&q4ޢ	6MIL#{{FCp4" #bHP2͂9e}6MLv[h}ƥX]4C2Zn
n
I[MeTΔayu/JnMCS0jc%;BZt,SYVJюpk|$BC1͢N`֗'4j0oh+F7T}dz㣹tEt*c*4#ۃKo陼CZJ]r``=dBЯO'"NӝĦhӼ4p͉X8qΚ~3mv tE
65RӘ:BÑ-s:k̘ӭ*_奥LUl7$2NlY+Uu|{gH̦fZdmƚ@azeg#JH~y1	,:i|rfKEBA3[-Kq/e3<ΡukSghv`Y޲CGm=`FIë!hlYF.a6mvdk+d$taY
MQ, Z}D,`
i((7]:͍YMxkF77Z	+xxڜ>`}gUم0m.x%tiP=G"y$txFX^	.c27ϣy80_N°AcFe@wgOx%<93@3o
ƛB'ZFLyOELu&뻂nQLxӜz7L.\oJEE^6WIeN+<"Y6óK{8\^	0JH(^>YBD(nجX-x56Y>cgq0r8?YklnG tpa[akJ怚$Kl=4\MU5)2`&r|nbP}`?~[ڪL8j^SR3mUNi8{jjo?gENV5v2ecq߂	IL,xHٚluxhbpYVR5#ʜ :Opɰ7]V$fnCjy
OR-IYpY6WkBXp/it(llor1VvjipzRIn^.V9mB뼮`{_JnClբV;4xz7]_AGW:[Ηjuhv'nSARjS3Txz6̯[WwV}`p7lF[mR_3Vĝin[E$V.Ԥ~:3bm8*
mm]6ɤ5d!^uE:.ꒃ,"'no-f
zG,d˖NՅ¹dlu1vSIO6cdD}FRɹ~*ne\,'W|F9+mE#*PGtt1T՗ԗ/
TUO{F~*WuzK`&?Poc#&t^uSB+䫦=)ڣ5scS.ّj3SҾu<_,|-96cjQ2Dnf:J~cd,Dm|VwȊ
?o"#nګ\f&
Js^uǬe}C^A\&xVn3l9rѤ6I i:oDkDžf
}zHA*Djv3RJPj?$%x	P$ib|.|r#yw]GgbW=M$Kb458Dvk,lR'KOV?U?l	m7WFdrɧQ?WJsZ_PW8[7555/_YnɲuV2Fwu2%7y8ģDSV[~/~Ys[MVRFs%O7^ qG2?Ro>ڏ	z?A'vlDEJٺ6SނtuSt7@~oN4{6^^zjԙk@yrjʔ)3O-{QGexYXhc|!n"{꠭>TNs [>`4ٚ`b7vk06Ajtiαt-~X7&{6#m;Fp"gc,	m[H#HW[«iDzٺX+Ak3_ң-=1G\[.^>qjS瞆TN$-QO2è;%z
\0%2OɆ 634[O30]{tc],&t3~ե p@ۺB3.>]gZGc2!aH0<Ο%;y}"=.W}V14MnŽ?o4PXѺMzP_aِ>ZIxh2rZ\W=W®G
ətn_?E{ٳ
5e::ևb˃/Ѿ2;J9ZHl
#>Q	W];ԀeeA3c_5z&yqtdVq^
Pr\#W%g(AMYi;Oڄfu!D:uihwoߺ7.{UmO|`1Ӯ0iݸb;\vvfia}7$KYˍErT;7
ｫV[0\^3yBUSyqG"yKR&FMhd1T2.@0ѤÜ)/X:-}xq
Α``SԎe~tS
*(uv晜:r,g<{3n9MÇs]Y:
ЖKjm`BiYlq*%WDUs_Af̢E򰼘KSF8hc̜V	
P2q\	G
4LKU87GwUpHcGt	'2}Pbl;O"tb׹SrkTL+76wNo&7X
!$>|X4֊&^X]˫N7˓GH)#yF#6vIzخ_UڑA$zmĜN9:Bwx#٤Mu ̏V b<h4Q
v:|Pnx|O3M8"r.a+Q^Ot"(-IDړCjJrx
e5z=EPkͭ\)N#VQw
K+l _m"r<%5ֿPg:{3WCDIr"fQ۽H2czؒ
S"k&JukeX'wXI5PnOu뷗1=T1M1hn&bvP5p,^S]nm) H՝<^mj5q4<#tA%l^Q/H0'~$[B%5'vI硳s{jFyޞubU	הi-OY9fat~^`l"8;!(?@Dߑl5u9ܔOkFtu~)c55bf:?">?Y(];i22']ry8^/$1*Shj3ڗX9iJ} %eErG1x寊=>r1r%v%{"e=H>Q?HE(F1Ccކix<*ʇ=H32ų{N 
繘&宧JFRNL]vP-zHhy?UTMsj<vS]MN 
T__CgX˿ƒ_,/bnly')w[/5[<#O\3Z{((uRJR?.
V3,|;
Oc\ܒ(hnO5x)
:r{}H2`FL[(4YEw
U9B/ɸUB$%0Iʢ@tN(zn)"x^@v	y؟π.^F>Og,t}k^^Ot{<"Н<œ.{8gӽuS_H5z-o9r:}JA*X6t|Z7@&sPoDk.j	^Z'0Z,.כmOkњU ˺XsuðBUmb-t%F`5SzX(EkʁS	%˙%3J:udY:nQE,kQED4bNɑѹ(_,Aw	M#[ڄ7\K7vW˻Tv7P`/u+j?l
M`GzUUB)MORY+L}uӯz};vT<>z|KZ ʪn7_H6/<:?zӣ4CӉGm1']DςL3E1zr6}>n<]ct%9.ҟ@I
:-آ׊@)-~@hk`lye<P^.dˣ*x/Fa
cULy=\%{}|rt[*ǧE4/rvؐSar7˱D sa?Ne%jYH_-.wwKJݒ2#Z=)"8.N)iz-OEenɑMx9{LM9ݼאhP@r$.yAg%;).kIɰT1"}1ZNfrHQ_[6,^O+ɮW8B=|N8U=_w^&3aP~.Q<*8@'X:rW
2kH%+ʬa(gy"7J+ds?8wqΖL3x
4iHIϔ4iN|A~+ܞc=OMKy.e'??cusj/7f/!G*Yjԗn=

}0}@1>H-}H-:`!8
=/˟G_*<|-e|c`H7a
'ҥoZ*:F%pz`<[bʬS/.K}'jmb?-;ťlMtS-Ox?|ti-7ókS~/t#H^Rzݽrjrz~xQ3D=|@Q˫O"?5`s=z7)N^~A=uqNdG#>yu+F|Uxu^]XӅn5v
vaS(,,v
xMܧ&Si5
JQ7̊}
}[ӣbR='BlE+^yEb^cm9_B/n|x Yi/FXIU
,ءZ:φ_G\A&Bnx},}%$ZB7k>nIOy<NkEoV`x>k~XBOr_-|1Or_^
ʕx^Wƾlj\:|x-=tVOѵ:}=k7g5!y&|@^>p	xW$_?_%(A65TO|̱)4oMn}E
I܋'w&?i~S4UIc꒖TRW}iסC}ք0 Qp	nʠp;^|-/Q_JMx;U2ltyh%Fn}r5F˒% 9TkR*rt{hS3g"m^Xg_{aPsq_߀{Ffz/	`o,oQKWsK4[ UW1̄K+ݨ>^q
 S"U_A{ߡ.?t<~;4c+8;lZŏA	/яV-B;GnaEƽ꫊(Rϴ8}~Pωx^"n]KVӁV2nKu?"Gۧ^O
>pQd:
ǍP&*MW9sTGG
ʦ&5֨BڤF'.UEe5FwXԉ=JSU5sUOW|3T%UgjnWGsT@8@oxnd4Ă'
33t:͘BR~\?a厔ܡ`}bˌ?4FVJiN)3pDi{FR^SH';c1Btk͈M#&z_4~Z?oarړ[,3U(e=^3J*VP:ft!&JIIzgz#f*Z!xI7k0}%kI}+gHG}TU٭T:ۭSEyO
N4
/ÊtaO Bgp'PZDuybgP@5Rjºq&RhZIgtZehq:^8?j%jBZl."?a}%TYX)w`>(c<,C"o8SRWdjcW")MXUY'06Pa;
"S~i?CY?Imys"1-Yb2%q2ؔLB,"zX!.K][^UQfҌ&}٤&JdIf=)^/Л\{(c2RLLaNy/g>x8ROtaEn]ǟ8@_wYquiȻv''I1tEIr_^?i?MJyctOyG)%$=8뗈^@"UЯ{W^(S\G#/VvC+o T&<ig*ГtGտsIP!*Yehz
xYd-pц}>S.+$PrP2Gwi'M^jjcvI-U{t=GǏfu	Ezo$}}AN$Żޔuu>6`ia74mTOє7&ߛĉ4]MLFZUܺ__M{M3?-~O?ԇ<[(j1Փ3O?bHH{0&ysygyVL<yzK)
y
y΂vvsޡtrkx,us5HЩwXspuWA5p\l	uK㩩fly~PKA\<Fcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$RaycastFacade.classX{xS}4I4mhRZ@,3o*
evirh=͉	s)T69-S&^N]|;Iڴieyz}Ǟp=>pb
$dڦlWئM-
eF3Б@VL͈9 ˘bstCc[ŻUSuT\Bm)C1MFBCPCCm+Qܩ!-AfF6w[@+-JɨL1LXm)$ԈeXH쭖1Kh,nEvŽ9K[ZKQ#a0:GAOikI2ɈP
׮j]av㔂A7VX`3$snrgk*f$L^h5)\)! c!>Mo0#nL(a21es,sڶmȘAMt2*W⬙+t#ܕdƞ7jIeԡ5iULM%4KT2u:kjq"jl6Z]%\/c0UC2V	faX7b c5֐X7^ДYhnR"TgNy:͢wmdf %hh2ڝ،6	2>/I1b*ES_—M#v&TF?!#,mJR`2ic܀feH
]ErUݥZ@z5(t:V+hwBGqÉL)l3CFCAn+Gj5J)+*QuOQ,7|_'3{^;n|R`Ɂ]NJY,nw.2Ww0ruZkf8*Fw +:ZS
4H
hSZ&MXX	+IA	+b:_oCT4+^ҨԵ5QAoU3LըV\&)n⬚W_TJM5"JBVM5Av;iK//yP=#UEћ;  	6\#LIl|KCVyQCw+;BZ:84[躧ixNf/b>f%LgЪ\	R”{6_m)M!
4vheM0:2wMkttTN>fոK1Bc7-kƊ.	hbLetS	w	Ϗ(qA‹dv-rL%Ț'YKtwD1j?ykotDXmDH+JVISkGGS03IVNkqL0Kxˉ=x[I0Lw2NXxğ掞Ŷ]jrt)[ѲrrUg6M["i4T<8elxqiS_]zf	)J^;/}sᓖJb/y,qײaѢ5~DPKA\"{vv7com/pyjavabridge/PyJavaBridgePlugin$ScriptCommand.classVsUeMӥ`WʇJIhKAB[PH-*nKdw7ʇ3>3ŒËa@QtW/㹛Zdss~ܻ?~p aYE|]eʅƲVX62`XNӦXڵu3h
*ڠ2 X"3XeO3yNgm6vjf3N.ƿ&׽c*^@`h՝eӤ{Oaow3}CurBete
;^6!rCv

ZAAph~q͡(w-47x,XflG3x
E6xNbhStTlF7p["cfj(d-
^$ؤGVi-Gu٤E/G`Lt3
#R}uae5W6DS.&MýxO~L|l#'_QH'alOOo~pBmZl4JJ%LMfA]
A*qr 2lm°MΙCfV*7$ؑa՜ ЃJQc*~Ẍ!Z"qs?JCtT1#RZט^]+'Ui*JQ+eR-N$sf\hwT3^AiI{O0WVXM*3Ch\|8'W&SVsZֵlam!B6ӝBԤB9WJm!@$4H.'~av;ٯMc-E-
ˢfS]@fK =h$;4E"~-2lKR-R),B5sovy3lzBDg!o,HyBPWլ>
5,t>~9(\/4+%~DXlx1(GXzBWD/he{Pv1!=jOM.6
4f{C۪HxDD{۫T1.e1y`KozR$z$R	%=R).`T%eܐsHtHtHo3!"o{46ȞFE%ydoR4>J!ߣwlZ_1:>Y]S@p/ѿk$uVӳƏhPKA\pwHS6com/pyjavabridge/PyJavaBridgePlugin$CallableTask.classNPE`Ph%x}N"Sjpl;ܯ
+S̒j:-󷌓j,p]d:B@hj%MEyM>ϫp^pv$R,JeG!zb_=R8%tр9jCR
D#qb8Fs'h0PKA\>mJ-8com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance.class̽|\8>[{{wk[\re˲X4,qaY'N6!`HLͦLBqL	HPBM(!@Lw;$|$ֽevvvvvfvv3?ly*Ax 582;)2\nZZ6gI$hS4yQ,I" TiAX
Z
UM$"M\
xp5pJ,1bde%/r\Tklĵ9<7ܤf%%:B 2(Rpn<]EPR/'#$Z
.g]
Q`QfXp7J}D`K]#qz
o~HðTM!بalFo%"GD#V:hIƦQ?UV
G<
vn?1
6Z2g:NVD;аzԷS	\V<=xVsCsq:ի1mNt{^SE
2/hxVə#g޸ET%
qrbbo,NIu݃WkO7#Ҝ4 οjx
^Gr\6eL75 w]p=(׉IQ؜q`>`PM-I<
c|qʨU
lpHgGiU~Y8 8oi9z:TUu*BvD5
w]k
/]}ZVA9xʛӒL7it81cT,!;}RasK2ꫬ.2jbᆪhS#+֛Xf}Y>v2̥qVVd09炘)V?c4MYKϊ%,aŹb%`62dl=i46L=i
pS!E$[#A6X͊^
}"
h6F&d:h	dl4Db^G"VJQl/8B5l_	j]#FŦEOue Iz*C<ӪaX(Bk\]C	niC0)4bu4*R^cQ*idؑIyGjVEyA7
jdT䩄-ټ*
V[!G5;и3vn5q(Xӑ6wfu7#o5[1w6h6wOi~-,NJuj3enS66i#6TCqSdd~y8>Y G#OvaC,"84;Zc"Q#>Fsj4~N6QMHCK#bk"㫱钸yLY-2bs=vf3TGZÉUacM+u\\jFEn>e?D1
m*?֦Zd=vfWTEJ,!?kHRԞ$``ffapnhs3?v-^؍$xӅ**R[iAك:8IS	DAc%<يг55C+	Yݚ푟ͯ4A,^D>cFazf幺P"u0*FMCx.DmlEԪ-qj<
WOb/ff/PSBbh8f
V쯨Fq	$qMx]7t|,y=%r7nT9Rgf_iߓ0eʫ䃆3F-v7])w=H
(-f=u{~`;Qn?iv8ڔ/Fl,uhn$̖dK<9GKu.4]([VKx=\Z,Gڕ.qĬk)2+pk PNZ$<X߇]vL
e=zMJvY4CB#6oC<>TadnǟPGn@/™Xm=KG3b>_8vh$/u1_j

|spk$sݴm2PS=~?!9 mTmx=C3 yFσy{lXwg4?ÛȝB΅O>s&輎|HUMv(1(	hjYaH+ogU_&CTPJ9Kw^v j_uFOhKyN*P#0=QN;5Y}C9sa(~5G*H]q
]oV;F66r{&X}DmNokȆ:~_tAD#"DjTde~?1z
N8gIW@SzhgѲ"ܔ8
H4Ro%%YMͷiƊd+1#?#]`L+r$C[o4`BqN	й&<ş4nJV4$yNO2-d${i8rϖa_i82]?F^aYg|M>_O$7)Ĝ
IyNK3j'cu
p)I-!K|*_530s㱥6'EUzLd7Qp˩hqBo{7zBS`qكKۇv.QFU Y@9Mb`ͱ=qõ8h8{6K#IZTS-/j9hoPw-曨,فU){!V8FZm6eHqm2ۯ-ĉAY;ieZLdHpnK2	`z`$b(P
-D)aHgpEj'[iE':Xufm$D[X)VY9G;TUSF
ԟhq:gjq1Y,E:Oh|@1oq<n'~4H>3uJJF+oI4H
b-~&~ngR.}9[SAD˱!I
]U6o(LF|jF\g@
-wl7h\4=ݤ4}QBX3BR[mri,﬉PONW>|O}`Υ;j'<߹7hu-UpK"!g9ɪc5-,a"oȇluPǧzA>ufB<"FZlyU51	׃h_gb'r_#`r*kb\iG;~(j=b{9n,@A*iʧG㩀Aٓ6Y4isrѲh_SxZ@{J8"Wa9 u3\EtpMR#qΡix?Z^Tu!wxOo՞*F+rCIܒp=d!SOĿN"#	-+RnZ_
h]ZN(qmZ,ZKtHQz7&2qE)R/IN燗8@^}I,n5ѻ[I@r0B$7+b+#\I.GGQF
JHc:\eHK-{Y
hNGC$\-hG;)$)&h |͗
Iq̅t@Cz,f}lXn""rмhw~v,Er3$2T6n_'\r䅱9$&TUt%;Yx9h".5S^e''i9YzbW{0iۆf}y	S|kϙz@(χr
}[3fWz+W5D.\kkQ1)@e9+S]WU𺚹g̫Ӽ:d!H\.հ?0ɃTɴ.׻r@vfn4Ufh9SSrU^Dz'%+͒dTy$/lNL(9sQˊG(:Yd
ձGxmAX.YkU푆N:r'epnlM[Nׇ"AHfEX˟IMv~PSdU11+_=2_K}	Z^)B5m~3l3򊀼F^k3i99ס6+%|f&j&< o7_LŒry4洓n7mvSʄGܝnmV0IK˻M{
{%CVD;)=RxMli|ˌ~j|RO̳AUյD
^I?ʗڰƐ/]/4|5Y|Mɠd**h%4w
湎P~Ba{t/ȿ-6+ZO-?ʂJi7qK]	ȧlzfW
9so_t:e۷穽Z~)H[ͫHu7+pwAO&pN	2(G2`SW;LI#HY˜vBNYڕ˝N%ZNoqt"Ir23_n~M	MNr Aاgk+g.6UN~9X%V(2cҎ1T0==5࣍q&P;ilŢ3I;MPvqgo9kH9;Liw쯝QÔr)5wFbBIr$gؑʩ ݧÖS0} fhg&aࠉ[=sv*Y_@[IvG*9UlϩbKѮ*0(ݏm\9J;cYe,:BcEhg,1NmƼm:s'n̙3ͯM	!c5+v3g$itBksXs͏_;y9Q;a1	sAKG5ip(/pLAMX'J۪x2ZAryΊlKN#k啕!UNLRNvV:/-`E{dPV.&$B|sv~n+w!F1[;gjqsVGa;/P9Hn-gI
t@z=lMGtiɈu5jAljzrPEVF&n*vuK-:{2JSq􇟃n\E=.;#Q'puu=fWu
.jy*A?20(v{8"PFv΅
PjvsG‰)2hw`*@:Pg42XPwcҙ'c'-hNdW\V+ОES(\,61ZZ6Q~W"KsKK\Y}o}7J[sMoBwp^m
7W`>m=KF3PbuJ?^#
י(]a3> rW*~rEArZdK{&vj&ZkHswvtPIMbl$7jY攏qRNw_iS>Xs:e0=>Mgm}z=NMyschJd~Z/XfǰͮO5i`8C+^?r^gB
$tMH:Ȯ`z7BQ̼-ҽI0^klThf5*(oX
ȼQ5a7u7ktEdv1q+
~vwJmx8qQ-H['x]pgWVUU}/Q [Y1\Jtxf;|=K=nQ!tĊ400
y=:]yMtonȹnwء^=adO EFžluzڛCט{q:~1{:QnU$Z^̞wJ]T-	XYsoF5'J,PT.=rʫ^GF1i&΢x[H.pCG^T{'yV,3nJ;NšXK	$BI{1:Js:V_>2shfԨ)S{x`g7Rruh@|<
ČAjshv\b￞C{_z_.Qp<6һ*d%tq7\`S]!?h+\)@qnSUN?|F90T8\)"q6͞
i*W&YTXmRJS^ON1CUM~zP婾ת@Kt9WBzB}8玭
:zRP",7芪܊G.i5n4Ȓ T
jkoѷId
TZ4Wfr}uq4fCPu*4NYnNW?<5-"kg=P׮fR'csÉp#m8CJ{Dj5*:kT̜U0w5rf(8*Wu	̭ղ	ṇvΌਘse,
O̮͕ɌCZcD,r=]Sun38O_M]KΤݸƢʥNS=/A5?jVQu6ӷvyS D^HVhդbM-=R)32P.舸hڪPEűxrP\sfWNJrYt|^VsJj
vOWv#%[>J*:-hof{~
se?*ky`kSe7vV(Km/[,4mrVo-ǣQ(ˢ~C엉_/C]V2>sVN>qf0_Ȝ2-02XM!Yt|2g-{n?xȠfpD*	2kRGNIsOz:y2?ZO6>̽nsfqbA=9|Z"8$?::nLtPw#HP"V*8HOEL?9)ч3
kМK~
9L?2Kq'Y ]9 Mj]i.aφus
4F+S5IS+}
yhtURFƽÕ[O_ؙC#UsV	?Gr]c#g5sEz^#f/nZ$ѣ9ٛɐiOC_
]UzGxkTz&I3ͥ1=zVuy!J{:Q#J6y퍰(gp77?._JHk'HIZu?~EN;abi=5:"zSoxMN"=ٗJ#+up1xܕ
5Y
t8Òg))T#b:%l
2Eq{ynލLzלtM*m
fe=R{W:MtًM{'SW7X%a~%YiEb@_Ǩ$;)tިatYmxr-
ӅDS^S9h^΅D2	E!#eCڕ]T˨p׻à5`}.՜yj_Qw-
sDS՝V\W!#׫7hSiN^=Ы>S:oG!G$[Տ&}vu7USZ Cʳ?uJ7t]b;}b~TU`x'9Yj%:>_!!ZM
eI2҇VLѤL`$}po6d9n1DWZews\*]$`u,FuЎœ]Ff؛ˣt'.LeDJufG7ъKqia+̡# SV)U[\\qWBG:a_t𮢅t=4|TO"Vzi:]B:i'"dN j/{'9EzxG.|bWzwۣa&%h,ф}&2RKL0*G}wr Hu0wMrDM1I_q(M:W6foC$`h2{$֒MZEnl`Ex̕Y{;33BŘU9j/|b̺EcanJ8NZߗ/t=E{On=/@rp3" HDD:_s4=j#OyJh"uJ̌2~L)Kۺ69:NpeME٘
JJ풾/	{^aðC|8ӣ$FH7TGH1d튗gtj"9aj8SOt._Jf3/̘cst
{~eoӢ]^!<U/گz^737FKwe~S?j .̐gir 8sM4i)	:
;mbҰs1>y?jA7E [[fcjv^&RX:H#{X,J}ٿ(^~w,;V,mŚ&ISX}cA2pU7zg6Z8p
<Қe-ɆتROOYPTkjBJETivP`*T!gu`V?1@%t}qUTB|0Vdf]+*HMO86q<%h4,
"|	/t`]஼]*%.XKjR,aR#_M
5:pg`mhPA0gM
r{>I>ƠO>nˆ`s7)Ev6≝#"^Ty6W"Q:#t>(*T8pRp*THpL*8hQHS6
EPm/Χ![tmX浙h/DOŖ4wcU8t:ŷ|$yjhbF,P_ʈ'ꖤ:D
j۳Ldu#	
J!69i	LmRoilx2~wHkGElFc\ ^pn+pϬ[:q	jR=e,uK2bgW;t}T.Ϟȸ!~D@tObYo*T+Q{#^([ 
 })o9d~
L\	t,|/q܄a`~
0?56
e0	х{$S s+ﲒJWp5c>o|`P0|^+7
0=DlҒ`rɄ
oI8PnK

p)Hw俀>jįZAz8UN8|0{XX[fƁ'	nh,yѐP¥>*W03m;xr-Hq/6TgZ׶m]&?WSA5|"4N*DpxȍpLncg_7
N`IkAW<
 U%[*m6Y\|=
.xr{BGz"2*` o|#p(-Hp 7XJ].6<)3=)gKAc7Ek`ORX^nDւWW<&i>
	-w0?	cѮ>B ^We{c
eA6o_2XNS޵;?GOAOkFãaiO?xAx
B6OB~&x
HDpd΂,`,`"qx	0+p"uho]8g\7)~~~9zKԥbeP~BTei`Ҍ٧[Y^
nZz} {#w#|`޷
0Υ=
UYj;z%Xڝokax-*)`E69XM=`F3߳Is0O?A)gp2C+Hp!.ô0o YN۪.G.u
7gPoa8/m8`6Ē!47lD͞Pml=-R]_@Gpa[.T	LyF_La<_M}utwygקy%&@Q0:{L~酴L78ocO||P}!P22-M30mV	CػS$wp.~P(7
X]S*jF%U?XԱE˜PSQ"Z1:xk:k!rq-%ޢa%b	,Kt.jD#bkq2lqX/X	oSC.j
B5́:|r(7?A/u̖vz_V7RMh*2`a;ªS=5(V hrI-k!]u)Jg2ڸ$OCrř(}ݹY݂p~+6VLyl@)Cyjm
dx^GCch
 ,eR힦Tdui^A50T\u(Ϯ
P+n[qn	==IBIv?I/H8C$đ0HS}2IC;y``T}Cy
)9`R9u4ӳ5e8
T4"1k)yDED-'.ҪmS|e*O\HXn)ZZ[`DMqPi?J-n:OB>m椛>4#(-SܭBw9:9%w3?uőT:R1D^t,=OD ^~F)T/e oaՅRl'qTs
m|vP8Y4QZ;AaO>:u@=FS˗DkB"4[`e:UnlqO7VKJIe40OB^Kj+>ClRh`hVJo/д 2jSEK(^_ya{oz2`
C;F:Na 5Ҵ">MD)lơD*=cQ+
W5m[+^+
M6nFC3+\!tKJ?4vm/ID0]0:܎íD#?Y?ţODx"dq7ś0EPBr?&ߞSֈ{λF9m
wVkOGwʪrhCc*{o0$\!)g0$Pi0$4p%:j)aIVp%2	:Q2>TE)&0ʧ/?`tcyQ%gL8{r2i,&le]Q΍)Yr^!_mr I&.Lw4=U)$xD©`NHv'#'D2XW
C	5LtRZF3⋲!H/5a%-V/Vۡ0CIs:vn<;vtp8PRdEKt''Be,"<H*9`FBi;Tj7	ա6LOlLSi{ޤYz\ ε}l16[Ƣ,?_ .lW)E%68+_.>qgR m$[O	Q^^eV)q]rpC7͔r!-hW-
)_oT*qQR#{=v=V;/jv--r܅[瞏lG0(s#:tEJ1blǿO	{4ߞIy"^ċp#U8W
z:oz7xHw9b}ǬH(ͦ9[*`qX|ͮ߱{MdIƹ||txte*{	.$Y ~b @D*NE9\\*Gurx@8/Jr//>r鶿#Ų\Vȃ3y܊o˩%9C,_J<'g;#eS"8ʹ4y3OsjesD1Ii9gds<$ΣyG68r
FX62-݅dV&ݸlqϕ+*y{<}@>,3MlEyW>8Dfˍhgȭ#c+Umr{>T`|6|.|g 8dvpo^@4Ap0x8W//	_)W~ag|qr7
	'Bqz&9}B{9_h?q%qʭrsV;{tBpnpFqFsF:	nw\t	~<m@L[Jc}ZGi7]X{t1({Խ?i~.(ԋozk`>{Eqx|.<(O!KݧŶ
u?{8z0b
\1T}z=-Q0@Hmr7;\ZmV[0Qm<sԯ#{}@xhugG?Y1쇒[aQ@7ljjH68BmTSep+`z{G>}E<eG3okD/Ϡ=ʓ(Q/Q7`ړPa{RzV=4~*őHzWP 
qapzӂC`)
T"C`p%'#:8ӎ%gyee
,YM<*Bihq9Q(t*b;tbW
CAzC	8V

+)
=r~?Н-L0)t#/~Hx4ΏApz[kC޴\.H^G{z@X4;>>11NXLF[70f +<KFx|7,a!60M_jzxv0{v6Mm[TϤRk[GHL7Yv7/LaŲ	.t5LD<	Ed(qJgorK"y/PvW@Lx{ܖ77y(Fvo\m`_?SOĿ^Xck 8q	o!Ξ&b|+\;7SgCfm4|~!
͈GUNp21hv0;ldrC`O0שET8˙w:3ag&v`S:sDg.;ҙ95dgapiM㼨>ǧپ%!?9p"h6`Ѭ$	fxRHL5+
#9D2C܉poDp8p/Mk٠	fy]!nnrr&9=
AּX\rBѮIIBAٳp͒[	B"<-oGןz
%on⥟/ʞ}rJr{al'4g8sǩxAs"N0ui,a~rV4J'8q	qZXYpNa?wZ5OحnLvsk0P'G&Rzbp%\!bIPeL C!ZxL.'fr)4.2+cYL`%!uiަ'b fH{@DEpLSn=wG(~TzߥujeOy{(]j)5o'f%_dJD;u`RQ׿q~?\/ߥ8tF&(Hp0H\B!\#D۹>8(HJPDp=GberF,z!{B+siƒa'`M@צf՗4
כķ4
Qz(K;iw.,[
rY
RpNOm?\"0c@(
K5pڣLXsF@ùF:x8Թ878Ź.rnq߹wOAZҐnKrib[F	7!;(gӼ}.owG
/Yd9 Ap	
$QCe.<ÉψL3+W3o-}4=Ua)rPCh9!D0ֱH۠I6s5l$000i'	$sd&s#␉i+LqjŒGrE!n'Gq-0ɶzHC="׃`q,Hj$p
TUzuj?CW,UjK!OH+\F؛XZ~IAqC6e7^OAVE6.˭sdIRFBe4O}މr=X/;pPۥ%r8
C"S> r=s(=23QE>r+qF&DVcI.Uh3Q|YgЉ}8K=x,G$.dʩO;:ٔӔ&!Eq]tZ,(NppǝN'\aӅaȧn{dJEoObQ}jGB.?
uh߄8`F;>,-X7t|0BGR!wLg{,KC;
J!q!`vnH4e~C-{259i3SЈFغ$ϧN.:c]6,e)p-*DTluV|)/zjYނ'2}m8Ǟgy{'ٗszmoIG{#
U8ͤP}N2^3P}2pi^b?ۜR]3ܷK]3ߟ]z`Nh4S;) G{W;ࢽΘng\\De0p3AΥR:S)8uS2יY02=\xsns,Y*g̿ϰH^Svd$Mspk!ۨp9~:<&hoN[
8AC)J";Z2?s39,Y5{)@r(~5ڊ,dE@/}E0ZԂRKE]q8BDGD>saw)t
/ecJ	Stef6D뵃kjÕ\G)S8GH{I`W'S6gX?фȸ!≔tpd;S΍C$rbN+zrk3:&cI"KޚQXZ;+	|{,RTTJ:(ZҢ!8ZSpΆ|	&0P5mB`a׉bX&(Y28
GJY۬mcvZAO]׌lcbD(6L6Cz]lXM}!`dڎy1fޛVv F
?F;q&
ILt}m
j]awnz	Ox>$3rʽrD.ڔsrg]U{rPι\U!ܖ->b> aĢ(pǐ8Qd#QBXxMt 8lNO}">
@|t.%p8a0A|E\E)l`8*&b2|$'b"q13rgd#>C dQ5
ŗf?`۩NyM7	jkjȧ<)E|ÙI^Y6	)8769q:DC;3X9E[=:<%}*eIH2@"%1&и3KYcڳ&w	Y-$i9:UyJޤ1sgp2#LŏxWʝ(&^R/FyHn(!1b+Y*h-Z\b)pYsč0_W[jq;$]bwƒ.xL
*P_5X^+cu,[BX7SkUBKO
w66<]af4Ѵ"NSt2}
U!V60bh5s/'Kqpkj4yo>
6ҙ}M?jL%AYx>p <n%'bmxa^'Əy5lO=+)K6&^KY/|QT=#>7ڇ!ۑ@T+w"Vܰ`^zL\E0V$iiS@Nn;3^ɋujcq/ؐ0/L"?)fYڬ	;vσ!Gb(l+qf'#,VKXmQΚ=,隋,)d~6H<.ϲ196I].^`ċF2MlM`J:tsՆ־ǘt!Ldf&tvpj+v
JpDZk
Ѥm`짛CҮu8ߤ|w*4f_ex)KfvH nД-纈'y0O|rR^%/PZs3OGqU{W7<;@B|mGI|'Hd>
CoDC(_5O'ȶbH⤶-̺28XX҆`ojAG0Z%ZOIȑ:y
_*(GRT*(ϯe~ǫngK{ԉ!h"	(IxСMP$┰F&
I	)I(a%43	Cs;(l߲ڼTD)-|jVSJ՚RjRJ'nH~<¨@!"WX워O3Qyjv'#AΑp伖4yrx+cEZ Ì0+:mr֜ٹRԠ59ќ2b*)%s4́BQ
]Nw}ab,7ɬ>^4|}-9dHybI}~AGɈàv"sT^3b^)E&t)D#~){횥dGwn\w2٤adҥ-䱮&"/I텢!ӍQguim[KEu5XK6PZ5ǔ^~Mv/K'*s{bYGqAl:Vʜz
VglK26:
43636mDLYՍ_{F̾ٮ6}|yl },Nс<(@2Rs'|<RL~QU:!e}-"%A%9TӸ^(4nQӦM=-i
N;-70S!gweP,yEpH kNZs>|a(y45BSp|υgm:3dK5Q
؆eaş_UagkqxL$eϭ[iHarseH$vx荇<]rDэ"0	EGdhqaCnanfQC~ChɠIE䤂_3e7 b9U$7.[&e09>O/Z#2cAGfw+,1EΝg˥b[fޑYGe
+WXj.2&kY%)ZdCkldmrz^6g2n$%[ڹ](d;,sVEv{ʮX͞*{ڗ^<^$7~9~Bwseb'ϳSr#NyL:m8XNpK1Rg̐SErs!g:Y:yl'N\$rɫ<[.:^G^R.M1r/3|(W[jRZ\n ]>ߒ#"K>*b11@>.&mjSDL< śB#I2"Ӳ|F6ʸ<$[e;,/eY"_y|MΑG"V%w2%c<&O|/T~kZ~:oU7@.
Z+W;e:z^rέRD:*A\Z![9B
_ѭQ*<[W1;p}C.60ηυRçg[ˠ	b޻V9xZ?AV_	m0߆BɲwC?ܞmqf_OXR݆wں(gFftͼu;|#gC=Ss3>s^}C|M4P!K~Gf޻|k x@a9ſ#rE)Bba(KL>Ca{K(OڌHYb
k]F\;0QUr?Z*!VM}e˟GHY)3B'e
n1G`.r%#.\5"X>_jB;!Ҳ~,~}gy6BR͌\>M
e_|:7
v_dO@>Y0Wn6ا~rk0
Ҝ|}ҮY>	-
K0H
N?z%J"bɚI+OyA!ߺj=M^ƪ=;V/03⧠#Y|>&88Uo%#aiZNx~¤9#d2Oj)F&Nf^j_[~!DŽ̉JwM)JkcE,
FF5nOMaȢ,eO$S!7n\%Ζu^n˥ݒq-	P9L;RΨeu૆Ē,vX$m˴H!G;,oρ>k)pM&C
A,o𧌁*2>LZA=2\$ӮP}d3MҟJj(4jk?ZV
v%OXqH<ŷu롴;IktƧ=nFD9r0LyRS)LrQ_(/˝])1rǍ-PICP1*&l^S-{*4*U<{^VeB&o^#1|
$zT"+q˅=/c)a_j>ͅ
kEiF;1,PwTT4-W[3t/lQwb@#&#x*\b%za<˪9cLGpȀD	
.xVU|2kxSS)^*>^\8QξjDz$E[yLPy\~Enp.BfCcU&tT\CU!UQlUpjZ5.Tg˪9bp\YJZ%ڰ-KvHu`TacT1:E]ueUUd{T/Q}ؗ/;XR
 *:!V5[ke]F[RkgVE֣jGMQXGԥjbs5Վ줚fwWaj}eQe
{c?عk**I@ܹs=tOռs>s#4@a^K_0GiyПh|TVߡ B펓o0.Yuf67l
}NXx"8kԉl<	#P"k˜f1ߐ/21WűxJ%cdEOooMMv$imASNzc{}V1XJ3&E=ϧcu!>2*&9~?8碔<!q^J/`8Q)(7G!ȭl#+R8
!|_wɀudӌ
Mtd\PW@S]mtp]u}FR•ܨς[t[aN>@r@`';Kbtov:뾬`*5 _&^Ym6A^iiqE+BK "<	=<0޾U:*M*X΂z֝k:FF0HFrNAk]+ə!F쓐ӽ)X^ϣcd P/A})zZ@qaq.
Jz!aǧt̽Z("əa2MVi߆Un{W8<I2Mɯ)~4%.3JJLZ̙n"~"Ϣ)14UJv@5P#	GB}>G!]R5z<&zE_)}I`fzғX)1,
*"Pr+v]Bb_ޛ@K+_q'ɫJl9gc'dL>)&H1U	=]b-{o a3\\$mO'B\eSږֶdk[U'd9ofQAf'%d@܈W)o3Aςwr^MXJNnqy7Uf%;ŭH3Y@49ʋ{ŤҨ.tYŝxTEbYBĩ5P85Zˡ	
x=p^3"B/yA_n	ܮJ}po'-pHw1Kb\ͤ^
HeMXO,0m:̀]I`T+aC71tiC
>b1[,,V <C+ް&F@؋!=s=nq.䄀۰3[m'$pv%Y>f~s1
Qzbg8Y
i}&q9!(Xcj
ۇKtU^5&6Xߋ a}@?CBo.prbă$ɝasS
dS&u3ί6^gWs6?p`{GsAxO#T~V&
( ]":Ǒ?sfHw""ޅ45u9\+k$T}Stڀ	eH:|[@Cu8O5< :p:E6Ais|~ms:mڕs8E_ğ+|L8Jw7ؾ!NJ8i|{ڌ8X
θ#BT㔇<(Q#&	~Z@!H?~
5YfoZKȺWXZg2=t Kwb$fݡK٤~6Z4CFj̍Q=|ŪTs-i{x>N
-"ltKF1ܟ,eXo*NjOk}M֪J}:op6.Lļ)}\> :':ܧ';ZgCؙ!Jiȳ!"vXuP4RVe>m^eӍ"f͸y(Gǰ۪.18!/	֟Bc??nTs
KAC㱎N^mPпJlAp!I[َFvlbgcLK$Wx~zDD1Gc|$wyPJyb%xɫi+6/ۂ8	eA%Gu<17@/}=]?(sU:LB_e͔'KK6=_y֖Dd..Y/.ِn2Embdʗaڏ鋫xlR'vts/jmK6ln	a35wKZğVp}Kn,^0k̀0愞V!=)~O؎4YgY93?ѳgHv}!ɯſ/|
F1E.Z%])OBo8d@z-eg%:87&=r1鑥|;:c1,uoӇnQ;;&Xq
gGp3Q:&3y$k(d67K\b1Y58[
WLt0=w?%F|BE.MB)y!NRVuSd;|ڌBF>X5/]%\'x.*ҼV޼~˘z
Xp		+y5?+j@a0c*"5G9E9M_d;8qj^;"DNbb^CKa;.sw*.7u4˝{9<΄m,(wx֝y;ww1Nϫra,׽KX{.eMXKw+vod]ݛ8f6ٽvoesw9]w;ك],*\荒^p|
 MKhg0lJ8?Y搣\VA-ŊayCW~jVsK硸iҙy乥h+󍧈l܆!`"XS|=cXyS/$O&^EXf`!	wIᜂ<2l~i	Igm	2Y'It;_H]Kū5}
:U=}*AJqU#+̔A8m/Un\!6BwtpCTW?# t?ݒq4t\#tT_ET& p
jk=<=D6w6\_DU($c'@?WǿqrA%lviT4r*ip G䌔؉E쨃4PΡ1qaDV,l/FW2WGe<\^7RUћGoDˣ|4g#`[!}Fo6DLqwl{`$,sJ)XӰ}s5pSv5ܦB!qΜП.+M%Kaw+۔p\dYrg4+7;Y@-EAX_lc0^ᯠ{|񷉑}4&'1(WHH
7<3nWu_2/C
4t@#`364BZ@hMzZ:̥eJbQΓrQzx^Lƍ6ّ(扃r:h8 WAkz坤b2y7":llw]x8:	-gkyIʖלd|@uIa4s?)08'/a
<yo%;𯬆dqKu164dҐͦ8[즐b7Blu(=
-+"^oY]eF GD:‹XH8yf{aپ"|׼:ù}+c$.+7{G1b?m-O{G1(dl-p”74[WI5R<P$tr}֯퓔ۑW\uznM)Jɲ2*A¼5;9aV64-TT6
ՁF<zՇӶ2ti[rZ+m5I,dgfWSǪ)ԡg_?dпa0T955
9P;b&
%aX5C`|M@XsD<9 j
ee#.BLpuX26[|?MˠzQҲXYwVͅCCEAQ~
U&NTm>^k"]&|LQӱ:$K]UYj
uBgcu]f/3LhbbDo>N`J+$!c,$zxg4~g0ӶU8uy0ZzBP/8'€P?cB`Bhp`

81Ġ.R>c3;EYF|(#.l 'R=yRh,>-Ua(
d輌+[miT̤Q#I;I}_IR!'"V7*[T|̠*{nins\W(\;)IwRhS2/++4-I)8fɹվJn<hz"*~O\]e8ׇV=hez^-Q@px-Dm[SŅH1%y9"\@(t"Rojd߅sX!RCC8
͸*EMn
CCЊ3*+w{fc`7.u#^^cG(	y;&jA#Jq;X*(Q#j>܈7b1_盡=y5nF5_i0:12>E_ܫ&IfuS%&dr@vxDar᭰&l?m=lm[k8/z#ewS,(Ο3u<*ԦM_]	2]QIОn(%O)U|e38D}aKJw%q|Hrc|g3Ms.a(:H#sJM
Bh^ROk 
MW@^hÞ1Ol $CXNNJuIZ@m-z~G	4˝Q1fV{.,c-̯ϼX"~M3m@?H=񫌃f촶2œO_lˣ1q~[‰Ch' T'@\FAƪ>Q"/=y[Y}v7_]e~9,!YV:MgeQ@Vm(vpXm} $&  	?BiG]v]hc˘m|0!kQ~\UR_S,Twա\WJ,Runc\zg!}j~ro&O0H;iT3/)^d?_M	+e6k+V274y.݃KPJ>q|n@حg[e
xPoCVvZݢQw3\Nb|^.OdyKWwVgX &y{(tzDw{.DPKA\#Һ[Jcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EventSubscription.classW[wUNdrMڒM[K/R)V(Ni:M:&
(xûx}U\PwKLҦ-kfΞsgN
	nx$͉hvz\T>ҢGK|d);I-3`>KZzMG7t{í[-gβshF5RAҍTl;r|KpN4%ƵP2_*ըa	L3#|)+P
@ǵQ/ш&m.C̤&B$ܣ՛Yh)cc_-iah%kTk)X
6%6-D<(@O$-qJEtZN,bشelf
VeXЉ "UFډ.P
4AڧjJ#4G EU32a;%"$K7-ݞmx_gam|iXb]2kA5Ka\kyr(Ua_c#a}ϰlC1,<tf2jNtIq=UݡlRZjk I8,R藑3y"8F%%#p/Zh+Ix!R6
FG4=Sٌ9TDLOiN?!Dn3,ТdGzPELϯ=/ibpwuDX\7DBNͤR-:N	d
)n/aDń@‰2&
Ρ8Lg*	L9	tiyJY5}=f-DXQI"Zag1#V.% DG\+LY-!?wbnY_]Q	<|~P숔:QÆvg't>z0ݶH	_ќZr1.=JK)0h此֫x7;;H}GFui9RNΥ~P4ެ>'>>gX`ݘ4Z4.FkjC:_$sqLo|O<ޠs[GLfPyġuveٵIn@·t/JQZ/ÍZ~n-S0.JE?]$*IVuv즘:y*@Q!+	}2ހ
)$-ƥZ%$*4AtZvd7ia\Fc1)mTFn6_!ocUn)G"u#pba&	rAeJ
ae8JsQgEw;v(QpKEK̇`i^|t}i"M`נy#y?\IKBm3.}Aƒ.9wQȕIzA&8DX9ƻhªOBmZ!a~\@H$xs|i,6UZ>.SP8]7'y61<3ͦX́͠wKb5R´<3;xv"QZcaݥ.?Eh4y	~!݀&XE{Hu
6MM­Jۆ4zPKA\9	Fcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ReflectFacade.classS[kA\&=T7 Rl6#yl)2;+O$}R|3bIv|30`.  "Cu툫~+P\J5E%2TûOg;}>+-Uis	Kx۷PHȔAR5M #>j/=$!ߍ-AŗJX|F\KfG37QmMr518Oﴬ-avɀk*?86U0|ĞJe^ɿ0š7&N4{]mJ8ՁI;'f1,EbƉq`X>,Mj	zcg!Ҽ<$Qbzvhi}/]$3vrW2`1}r.rO~:M"mywp/˻O=L.cd#}2&PKA\͸
Bcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$RefFacade.classYxd̓%!ȋ$A"H dK6;qwK[RĶVjJmXlZm~ا"ܙn	#w={,Ͻ{isi
TCl:6u`KXֵB`yhG-=l]j_7-!}pN{WT^@npk`麍FgAk!r	䣀jC!¦MMV$nL
Ugo5֐h"p@U6U熟]F䪰nxQ"#qVI.U`Cz|xE=Nh#UVˌzY,b,c7;8–a
t\lX"um?ө`"&hc'K\2&G'{Ut	\d	#lc굃{?>C$bBF\*n"HEMNV6q!3섪7	jBñ2T|P2P,w+>67͐m0X KK(gD7+h1F$Hs#D?PS1J.sA)ސ侴#Ihպ76LVnsZe"#ךL?ra.>/~NrTŠŧ_x@0]GX2"fL&b'" gU^_V?؋G8Mň%0tߦ2C2qsM.|%Kfq<'*=&{4,1;u!Y
s]Yb6Ś78LѹbS>-pFO1Wdo/ԗ.-׉^)N>?&RVzSv\KoqjdVjtɦ01[9nOF\>$Y?^n'rnrA_LnaqהM4[ú;sf3:vsbp#6}镜J94mm٘O9'۹ -!82S\CYEйLp:aU5߇_(NH
8#^uʺP_Q8DLpyKіf݊2rA16s
pSq0<%K	=l-I*|O=QF
R=<{('s)w)h*)l|hS2qTa;iTPJ޴>-yL~F8\4]t2^T.5P:uzUc[e4ұk#j-4S<ӴVDQn*fIEDԖ437w8͵shXJ1yA.:VrhYi:RFY2]#^6劆pA٬ɖ/O?_g%z	0qH'U0fpQ&G[e

O<><
{U=~R-[R?ox#e8Ů+||YZ5zRi=K(y=)<ʲG/peKxg~cll?8pr4YU`x7~11c;ks#,IT|5zЃsQR5i9Q׍1Z!ժv!W&D1]תR"B[sn5!,h&@*I	V̱r)Kčp\
=\Yq:6{sQ]z
WgCM=K3Y{".ǨNG	R3UԫDoƞ$uTL
.S)w?Tliɽ'Pz[U>åH'>,:Jniѓɟ*yNNgO m&Ty4W`'痗"-!W\єRʓ-4ahSzЗ({zڛ:avOj7
h.CdxtaV6Oi\#}`#dhd/"D)}$5cuBގ[G̥>MЧOӸ{Zcu'%6=dmPKA\~Ccom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CancelMode.classTmOP~ѭyL@"62㴼ӕ(:u$|OC eGVT,['8Xuq+aZu'^Wpa=PGMi?)7(5@KGo'1J+#"Է54Plg??Ek툅4E_JT 26>().!FP2Si&B2](Fdd0,o
i %9\ރKKWߡS}M?4)
p	㴺C{Ԗ~nPKA\'X8com/pyjavabridge/PyJavaBridgePlugin$ObjectRegistry.classT]OA=Ӗ.,C[T CYEDBCM"v;.xDD41Q?26%}&ܹs9޹?XB^Fa	]2{fvE[+pcΛ-2SM	Af8.=-4Ws}WpzHP0m8Umw_\\3,u˯D5gQc+QCNCs-Kx2qATz!*7!\")eύW#I*[py2d\Ũ1pa
-fHb[D!aRMԖ.ͮOds⿷k]= [E5
wгaVl]0z9hX$H)sqWj/Ec֦bpFmFaD\n`;Yи	2uӍ7TeCTޚ	jvS"T<	OQRm-VԏXkaP<=0vSy';L_ztY@2si=ߊawl+"7q|J=ӸE	ZGd1ƫA J'H1#ꯀfդ,QC(aQZ54,ӁGL1!mV$w@G6)b0M,cd:%{PKA\K:BFcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$MetricsFacade.classTKsEFkG$!I5bQm53|WV-RRlxuN*yr*:V«&B}0mr)sЁȍ㼆7
$b7LH]൚5;MݓMC*XZx]fj
\\pe\aCaEfNCޒν@
0yc_H
d1Ǡ۞)lUWjU60N[nU>dZXᔹVlUyc;ԻƀxW҆~Vo
W8wtƒ͞jyXfdmh/aWFbw2.Ppo0
pɪB9614f0qoRsbŒl	Kljmg;#k:moA׏ t̓}}tG߀A4#ןp]/zN%eHnDI.18vwbN&Vvf`<|Skɣ8	|d?}+(&%sg_0fO4``<ØM({D$ѳȲ2$B|4ɨp
EՑ>^!Ti/"f:u0z3]=!.|A?A=2zl:{#)C]PKA\python/PKA\M@<python/bridge.pyiێ}B]lE^ @,a1hYSCR3A>wR,ٳ
t/~#vimwZohKx(5O?%a77EBw?UXwMk7t`S)iS4!_Ns"beV[uߖ]o#$L0MqS	=ƯG"kp~j*Lo]}Q2hX0t?Uv{,jN
lmO9n7-ezpGi
MV	::Ph}4D)0{6]վRկi
t5d5[.KY	`($(?C-t܅#t~Nٲ~1r	cuIf3Rgf7m4Lɫ&Hu9FBQCb,1JX9ّ\⧣ZwM確.qʡ`^s2J	Z{Pe&6%B~q(G,KHz.N9 V4ci.ЛjH;B>F}_7J}kION`a	4
z!4v>9]81+	y~
GAx	q:+?+Ou]Q{{
~x5>'Ir(E.)e6mdxի5=e}e£bT͹
wZ^1ӡRȏ=Gu-ن4[,0qָ}cL
"ju?ibWt?Sרa5$ݬB('\qZ
v7r/7C;Ha9urF
*\,L1L(ů=>ZfE #%,id0F,m}ζ((,}̮5iVP3o}Wu؞sxޙ{qKe	jQZޥ2l42Dx@:/
I8)9,l	S6gNOw%a߁s\{匈&$Νj&뻅HVIm	Њu@xU'	2;ٸJ9
{Ld: ުhiٹ6v:6;zG{ܲ
B=S@}:PՙkܳNLIOy[0KhɄ2&GEaq-Zh$!;I᭕܏v[-s99;c8M)C9ͅ1z!U5
<!
G(G4Py*=sf&gKEIG5Tڱ7_ԹrrQfH"m='rHK/U:>7EOPPj5URbŹVsbZO^$6')imN8$DRU)7v{@]Z(a"4l 8~uOG"ÄF.ػ0)5yP¨[-{eng$ky{EVr)5U	K1MU2dM'

}n:}2o'煁{t@pC/}fF]+.Q<LjsgH.eI5a]cK$7-R^(_%{oUj&	GJ8U)a2IsJzxn%kGҝSd/Q=]	"rB;\纝B"6:1J?G3T.}Z..S	2.Ni;)켎+[ԙobu`i<~6NwsN[ϏIt!
fqY «t͊jn:-jUY/ٜoflw8:3/(ѤFbtLFU3OALތG1 R2uBϯ=qIq=/&nO=?Eam[FǪ y]~qquثu刣rljt1R.iK-f}k u&vjC`>N
acč
@nl7ݽu~m+mGGHdOߘ~
IoL*\%CwRvh,}яmK{PKA\񁶪python/runner.pyPj0+N6^>	.'-(A6ZVD6=kfwMf0؜!.}9TV]Lqv:hyo\:mО6GƜߤMu?%ˆn=v"/@yOq$W4_iSmG\HޤQ }PKA\2o9@^python/bridge.py}kwFw
Ќ3{ݻ<Ü+Yu,'Y],D"$~@83@uUuwuuUuw6IyRlU&$y|mv'l_ϊE;I^m[Te~ˬiFQBߎſuɛm	b+mUumP6_򱽨l)/f_.J>62WnW,_4Md~5kWy`/2Wk||^E*7Q}2[߮~"{_z}Vl1ȼIZ4|xz+Ë8jEEoWYEVlVf5dqٮ̓/X6mXOj~*DOi۽.XnI4J^Tu~Ve>Tߜ"W"˫\WoΛFU2;һ<6DǦBZegh_nSMrm]뢽HZhu-B&q>=N9^<~#՞=gJ1B>O_?~_	%eJTKqWG:owu) rB7y{Q-5")fy@#U]C3jx9M]#i =۬EFSwO&c)&Dn妻r	5M?AoWI]<Ԁ8_eSgXwhQch:vHTj._n?*K.rc<'v'VEe]&ZkcɞJ#sG!y8R*1!UBs7	',h|
s\>!
E3Ian8t؛ŒtW2Nԩ[MӐ1Z\51&Z䋦YNXJ㣩I	O5Fp@2 PO3"'ιAu-exJV9;6Cؒ@uh% W+<&4BR5\YBRdСLǨݝ1"CE-r'$rcԓtsI8Ulfb2[a3܌ȰɩYj܊Q ;V0h>&Dd,>R$Ipc{/2%9Q/]VsEn[SIઆ@{OvqA![h\1!%MQ?e6 XjS,z,oڇJtI{G{bZcQ`)*4E&pu'
&_BEt"'VLQnz.ٶw!$L6OaN${}I:/DKC("B:5~jVb8$@T`vIJw n҈1م31Ds6g	ډ3*is@?dy]dfſ@^*,4Џ1ȎtڴiarDu4ġ66q,Z+k"`VxNf'*W1(BN,%-ī%[9CC ƅsqqhi%dN؁%]Vr?<#ۀtpEf9X/8hSwa_}4q?ݕq"6y`	:[)Ns_$opP*dh!L1˫\
B5­P3'5D`>
̦Tb$wL3Wtis6gQE.̛C	K	Dh	Nٺvn,E\rWZ"jz:G7yr v+-Ey(]bM^rֵ1y&7/'2}v$q{Z@XrHXkU".qaVɽXa1 H	?"'"%
B뚨N5{,"YU&.o.e~gV~"B#L2{9-hB/:4LŒIЏ;<La M@d9t$pL^{]qQ^uJZ9	q`8|>Ľ/`Z7^MI[{
vlx4$YjQ9	3ϸ6GɎu6pֺDy]X6-S[tly5k&n#ƈYݸ7몈E&'& |#f'L2<%cHq^]rOGIgf+Prb)GP4`16y\saĔ937	2\}TKwҹQ9Їo8qá<1Ϭ=2'lQ`"kRDQnD_
-eP#[<2wEҪmW\u@[onT^ZtAcnH\U@-ă<+nq	m<̮:(`tgmk߬/CWIVV4+]@Lu74H	ݭB=ar0u=1`:|*0J=!:c~o(zTzh	6|J*R	(wGCOܣ
0g
0UA	wN飉uٵ0qZ th'Ȓy
?Lw[t;7rqY#C㺸`mmls*uc,E{]}y-ݸL?_&lXm{|>bjwxtj7n{(7JDEbL!yn/dtX|c`;$^w)ݗ',]0Yb_CdD@TDթZ'VCB3fNMuc=;uz.Pt(χ?М%cMǬ'H4xLoLԺ)첧f`]s,MR=k0ʶhh%WmZ_%+/䯳!ϕ<@
 #ԥ$.+9mUbpQWekWT뫜7j|>L(~]m	0!rW$^2cB%qF|V@*
Y{#@g8LL
:-sf!*7μ'ϧgˢ~s,3B:'8_V6H5ս}Ēk@	فbș}7s${6׷ ([TU,Jo%[LVoAtV9=,z`Kɓч1ur3OnO J-Mg}&OCCĩɞ)F:X懡bF0#/<b2wq{MDaM$&R2%+4CC
1|l-s{Ӯ M
L,'C"&8Ytwhԓdl)pPWHD!=蠰-T7Da
	g1h۽<]tG	&gJKGSy͵/fVFXe5*;a()̊–3
83sGFB퉣j|[xz=HJ!t:CP֨b
f\s,vӯ,
-2OE[sc,Jd_͙.o;éڡ؍..:ƑJaQdwLv4j'j1;LߋbI&9DV$ў4t.#U$=PTQ.FBVZa-wmTB
\/{
uTy(ah4Ѿ_癘t;=%lp;*m}0Nha>^0ڄnXwa"2M6}fcftˆnA{؀E~nvٕggQu=ԺjP3G0+VV4|8@f5m} 1B
?GL:o9^~\K֓>`>5Mfer"r~UDxp+D@,3\D.
;Yy^N-)ns?̴>gQhN/ы6ߌN3`̋}ѡYOPKCKhXE
͍H<^o`
pMh֑#R/
5$ t)ٍ\T#J	7#>9uDZ)Q(CEqa1Q	x;y8O㌉xH^(D-m?0Ji?:Xr6n׸4%C	o?Ac@Wu|3+tǏްLrT$2">aKdN]?LHΔg5:*܏u~~

$],3MLʂBPtPo[32h:k'`;0k4lG"A)oaayCB^W;99@DF8KPH?ӑ~%|pBM5
ijȴ3M1$PgE)P8ZW{Hž)\"ʰ-,Z*%gη=YSuLvZWkQGzDtͷ~X?a?@9wzLl%;7N9a`֧7=p#h1"1->pUIbB!3g6ƙ)Uͭ3ssa1tf@'cq-.PK=td
p<7uQRG(b6nDW!u6L{Qro;z@d*yFw+7r2g6Y{~৾2fb)pֵg!l߰vmn#fz+%v:v=sw"Pb.O1oF߄?/4-#[4{`ݤ
LPW(P@zUvH|&Wڷ-.`_ٲd^,sh\y+;*`thFdvP]%VPl<6&G;'O!hz>O^xnn),̛GgGJO$]jC(vb(٪WnTAfqGhخQ}[Ί|-鴱ׅfw޽F9y.Ѩ`[qkG,6ƅۍ
:4b	@8bbY0}@9#J(T(-#1? IX"
b%q0=i~Sш[j)@kl#+Jl^\LɎ
аZup5tQR1xjՃ{np`hKѤ]R'|!p@-̲ozYo@Dj
p1N찖RERY{Ja~ȯӆsR:5a]3XdY4Lj`U3@zpMHm?jdž&&U/2+6a_*`2W݊;o/{T͖O'?Q0C#ۅn0Y(€6-PʔCՁv&%dpq#E[3qSBuuKCP3ó:80[8ڜOGCGY4SYjd9n(Ki4x̛)>	Zo43fp\plaRívbQuty$*r&J%˥D:yl<|~4
<_d
?UWZ߼;!$0]+<֐pm-k"VK64Xa&1'jD1ʗ,[Tdˎ뛻!eK|s0#E
34pϸ[vo#3ܮߝH{)kA4JTWuDot
bn-j}AʊlvQC+Kj((ݪUjD F?V3N}p;J`yj3B`5ȼ++I[{.yY4?B&ZJrsM!}d-Q-7YLJ" )K^׺D:%usC]T`|yVp:%
rw9:XФ倇~1кSuX+pW.c_h{9cm-߁I4χF91j0B]g^!M>L@dAF+	b#5uv+M;GUY`0UwHc5|N:4lH㨏wV;̓{k'srtKO8gVG񄐴Țl
(a|kiTvK/I	8X0|f&leW䇛0w3d"nWȘyV5̬?:<(P$53	W@G7F!m[uί0L_4sL,{2)u-ȡ|?
ɂHɄ
uYJːg%fir94kSKgD5c95"Wj#kBW$.eh8uB&ﷵ0E,G*;Y_b>^`NS9^ϮbW#!xgQZG;`/R	̪b+ݛiab"h@d"[u\-, uY]eE#jv O$$(@ʠq®X֢g34QdWYBF}T6}Ltù@s	+(JăPGʜK`	L2ya1!`CdnCA7$i:	ZI
h}d0^j7z}Z\r~7&
]鋪iٕV
 a@e#uUm(vBQ4d;hnWņr&
@WatPcԈj.5ń;A9LO>K3_DKG>Fbm7''j<	 ]C7|lHP	`ߐ:dmU"LTMv{ak]|g{!@L_¥.!:kd^3#Veߑ^1۪{5So`_f*hE1ME֨#/=u	}8]r~wgTt%QUpB|}XF8`=~t;*Hq{)SKh-P	g#F5*LIx@^4gP\PL|2C|& %yF<e%
U
m6M
IuRB.|H!8a!xD6zjDZ[\gm'#H34PB~3u[g)r,ZShvWTIr#b1uI	!i
V5	YԐfyƮ!0C`ꍅ8EF`zT"33ћƏ=HkpZǰ
ʻMF6ϑU*lE^\˙bxK{|
`
o<L_&_`u@(ɍǕΝoLSXF{>g18n@L~~Ei`)j	P-8>fͥH7ZOb߽j\X~4	^+{#p2>4U.+[Cf&	U>cӆ?)"W~?,y^2/gôi{?5FUF-:Ve+33j1e鿱/juQjlOhTH/LT:.Ya~s˕$]Yh<'뽤փ IABtppf0"] ks렵X||(i٠js0su{d#d\,L!fP%2wagF8x&kyWJtR,mtf'i*~]^Wߌg0`unLfFzO*owv_<$P&`]y;!tKvFO9Ю]9`3};RFqHt|h+Q?6߄D=
e!%Bj&OtSn8yuGe1ĬG96. >.`

PW_iQ0S#@'44lMNGi(:1@,}Cb]K_KQU<|C'*:ԡ)ye&bX|)N7FS\^	ay^K96?Nj(K2ں`7 e|b$FB2mmu'@Qc(9j_zu߿V۳b
|~i|}?kz+=k0]4^o$'hl7#Oșb@`f2b3n.0*,i,#5SS"ߟs05)ROB/4Q#oRt$5appMm
Qy#8X6#(_;FcFFqBOnV=(h>=g(#""SB9(eQ	VQ_O`vplUmŕ'Ռ2ׂs>~WEZ9=%E䅢`,yf7o38>OL)3""F=bm32DK%Z1|:hJ6cގw[8{) a\?/W	
N
})%K<ȞV
$@GSѲUIHkP^758 |~f\uO=uWh*ڕUg31m&~Q5a|gp5W<xllpDPɣ5DHHO{QWm&2	tﾀugȣ-ViCXU1CYĪ>2W?=ı.}>ך6yA(9f5f -gjX~6"~]OMgSUSRa̼-Q|/$dV25#Y^t&/20FӃ`x#4x>l/+B9,Jܙ0j7}o^?~yI
.x)ٷa22	d&Egj'<DR]CݓZ}8nL1B+N)'jOL&duAVYB;9`ذP,lexu/kZG$,p	o@S}c#|8dhl%vӻ?&Tmh?Rc]~>2!ьL*cPWX.Fi]X$zQaHW4f3̐ւZht<`yj9h.ΩZ"T7G7Z'Kind]>‹0@snG~5
bC?(Z:V?ˤ54Q%%)xcTEf?oa`HcWI+3h'gv.h8==In+qhCn"WQM].ړ_
Os?xZJ	Fh7}FMڀ;מ5),6nܴRJ⊁٩GAXW;Jӹ,1A9N<=BSLCҢW$\긿U~c?r
(ae(uuU@Jɫ"×sުV;-`LjL!ʻL^uqsVbN	@>TXOE孍=G^V-yWd8ZcnqVU:8^VÙ|om`;<-0\Lշ
ilaF!-vVK-t#"ia;oOx8q,T41P4)a:Ǩ}9"No@XqX
u'ةa#Aі}v;ʦZMvk68qsHyeZH10q,v_Wtfp.89%:'7cN:a"
,qf7ʽYVs6L*zƞL9?N*/WL# JN:K0pOayʬ]J)x΍'PrxD< <y\	Vџq§{>pu3/,
otgQ
7Z6[|[ݝFzbqd
Ĺdt]gƷp]:ڹjY\wX峛sr-^`džmƽJchȉ8:5)֞
ݛƌ
lÎZKkšgUIx%b?Z"/4{wx=ܼK5]k%`$p-G&'cPmJ-8Xcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance.classPKA\#Һ[Jcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$EventSubscription.classPKA\v6j/:com/pyjavabridge/PyJavaBridgePlugin$NonLivingSpawner.classPKA\9	F}com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ReflectFacade.classPKA\͸
Bcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$RefFacade.classPKA\A-p)gC6com/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$ChatFacade.classPKA\~Ccom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$CancelMode.classPKA\'X8com/pyjavabridge/PyJavaBridgePlugin$ObjectRegistry.classPKA\K:BFcom/pyjavabridge/PyJavaBridgePlugin$BridgeInstance$MetricsFacade.classPKA\Apython/PKA\M@<"
python/bridge.pyiPKA\񁶪3python/runner.pyPKA\2o9@^Ppython/bridge.pyPKA\s?
%[plugin.ymlPK	\PyJavaBridge-2a/releases/pyjavabridge-2A.jar000066400000000000000000006436421514752343100211210ustar00rootroot00000000000000PKLY\	META-INF/PK4U;\META-INF/MANIFEST.MFMLK-.
K-*ϳR03PKIY\com/PKKY\com/pyjavabridge/PKKY\3	($com/pyjavabridge/ScriptCommand.classXitƖ4<`0 X/`!MR`
`bR`,
FKЦ[5mCBBli}O%Gz89ޛI&?y}{wϽ84MWe(WDHA=>Ӎ'~=yO
ftVPS8qKϤ]cfҭ
BEDC%4K?=Jcf݂ɹz&i(X&Y>v"Bl
UIA$k8f.gMPZ\S0+mK*hMϻt	>
!Q{nnfkX
}FI>H*bFb/,ed8Ab*iX4UJN'M1[Xbz4(X2x+Yi
&
kwG7D[lkX'3=tBe/W/0+&ʈ(ݡN6s@bg@p5̙ Y>T0]3 OomF-}aȿ`al'+U$4B)$m1vӰ1YFҍKqB߉*h^K	9&(ݔLD"3ְRPNSd==ǩa֓I#+!
#Hi:
]E$hQ
Cܞ|&#s@D93sO0U'+͘.#p2Ygݯ!s_BLs^CҜv>3X>`f̵cs{ioC
_+Ov2霝E
H6'#Z[)cJP+vV觢Vq4܇7=E8n-ԥTmTfV	!;-}pxY6&e3D8whx'$$LŸ''']	۱Rb{4Rs*r7j\[5ڻm+a*!F3cX"Q|>0M
Vj;=ǘ	I|7]ږXX?NB?*>s	1][ؽ10@>EQ/luLr/U/hx_Dˤ
̥LV"Gf^]jխ|'"WImM+%3U(=bƎ&S*a[ɇ,Ũ-i/:4Gd?!',g#?/.WOQ1~b(I\SF2Rbg{H$"RJ	\~ȋ"#fAS"n30e睤nJNS8fvsgwnʅK|mvJy7OƱ;%+vzX\ctnƬ'[
;v=6qHͿcSG'M
cf>ÏgIvX+vj܊m%cƽbtpWѦ[VDۑɰMS7+_*,|cy,HC~kTVw|V66]Ҹ)S-P~,
-".r4Lġ}w]̄&iԼ@jI.u7|`㓘u*$'koKf\fȬ,垺TI¸zC8g1{mj@CXa(CK(, ܢFզ!4EET]3(D#EjhxڢEշEa^}riNOs'I
Vч,F#VbkmD>7VNт~J.!Tp|B 9%cR&GO$WpqYxAޅo\KoI}^c/"NEHm>j͗:Maۆ#=M½W|=8£E%Mŷ}I-CHɥ*u*.sa>8]#)UQTFiޑG1FsmaXeY23}KU>MWp|
V
*ކvwM2	R=T!>DžX;O{'ω@48s ލEC%I}hk7?rr:DG
`c$IyJ@b5rnZ!A~@BuQhy
ᇒƏHϾ'WѮcK
g	*ksɗ~O_/j(+"?PKKY\A>'com/pyjavabridge/BridgeSerializer.class}|TU9ޙf楐wR	$ 	% ,8$DLLAu`G%Z1$bk/k/
"|eLBۏ53{n;s}SP>i^CC5V.GN?Aff-	>BRʯVV	O_õʊSõfmxME]}s:7WT:C-p
yD AT#k"5|E3łTMlXSA#:2,z6_s()WWo[;7T4~B_Y aOTVҔ+"u	k#Uap6Lf<b=Ȃ0Wa;4DY12\EӧpFX0F!G4}-
Әc d҆UZrAVT1 Wtj$RUضŋK0oYaH%Z|J?G>bI̚q"ܼBϯԄkI*GevZb)AJۤ0C~S,($uD֑q	7݂PL+XV#Jm
$ԙPb,f4vE݌*+L(Մ
	5[p4ʠaJCUazUSɀQn?,,#XގWsHIX8%
h~rnCzUBf'@$YQ;Zk`~S(@`5b6D*#28hIF34JhgP	j$biSZHfG:7pr^t>\Mo׶āSTNt($kCuSL΂Y$Qq5\v>s|.$`X3b.a8PeCU2.+`w6(k	*j2mނ
{\q-1&2+W
UWY6bp[;cWR]^yV3Jb`ht;jlkK0.j¶cf"Šp{iHU
U篪˟ʟ&܏	Ax7p2mCh[vnhr#nAK€I:bF)*OӰӀgd϶5GVUcdy&Ori	/RB'3^Epyd=Z^xG{,&El-Y3Ѐ2bk+Cµx!Q*~؂OS|'5K;Z
I+|IdAz]c;W|YSGԄo*+•u&|GtxSÿEyF擦D2'Gj+~?MmGLK
f{$rn<-`f{4l%
*RkDZP=Dׇ+kD8Za*a#lŀE%x%
sq8\v1ML"J*)jo.aq1
䏟LC*\Q6&2l`Ys1ފƬgb ^W6&$k	y8¡8JW5kaB.%h/Zn8fZúMjb"pH5	ghdגpfUuyxF!3cISbGroch5B(WfF*~29	ahWB&~l~b"U4u~LNUEPlQ)NE.Y8VQn?7\b綋UQu~0sygd#^QWCśWBY WmVʹp~=+nUOm+YC+QմHUMpcR_Maӯ^2
"Yy2lu9U!X8EPg[ea۹rE
$;V>F2jnҸ)$&]9=T2|@nSka^
@4Xi/OuyBa2?E=^s7Wx&9ի;ρƚ1Ws\lt.Xqfadwjm:˘_BV_hWYxut;,Vx-IjUEZz	1~iaXf1]˨#~?[٦InD1]maOQc7Mx7CcOήc7E',|'^).rtNyXQ^i|N|g-|'+D-T#1!NL5bA&"dQc'N)d 5LțW8
ֱ׊/k᎟(8ߴ-|/\P.bS]0P[w-|ߧHQ횶A,]|Q<
P<`s!>$&g{,:Ż2϶ث4N貁Aى[D;W.	 K¿kͮ[}kw[l\T-
Ur;L#nD=k?v¢ػc^2ٛ{)+cTE@
9r@~]/BHۥcH[XyoPe]
0-~rCBd(ZZQJu!mF[_gP
ap4h$mS	g!z!C|2"l{q%iY"h#&yCYQϥ
n%ꔦ
_[QUQ_>u-1D}ն|E)b!FZb0[l9el݊"y\A:ac;cX[@x4aC,q([/f[p;`CoI`Qh6EmU.ԓGZbni8alfi8kTKLm=,dtQlL5W=	̲lCSOsRVxW'_v6ΖxxnODE9Su%$ѵHD
xʕ:]ȳ4q8^>m:aYb(iTEMwmPbST>7\ʼnlu*,qȜd/BuaWZJ35)"Oo$jaW!)%;ו2EM{{$xm5)b~q8gXLqV{bwE{!kq0A^ИtneexMU׭98at\*w97y;aOaK-mSe
K\)"5w[oXZfk,qml':SIz,`A7a/3?eF7
:L
N%K8\fkSTH;ZHmUݖGlk3;tkHGdx	,BbP1nb-$Ϛb+5#BSlc6h&J}BEOS<
=yʶ|1}Os"މT;ßijkΊU8k!v?rRj/v k,axMn7,xC4+@([u01wz>KIK{RQx,[a{kAfƝGI֒YsN:$ĸ2w.	#_$봄пOB~P)na;Ӽ;KCSR*!VY>eMQ ǎ̠,AG.6):g,o{,ͳpѼlY7vD#]&ڰ
$RX8KR1`

Wdǒ^i89P_˔ikC)	WSD/}ojѺPY|vxCv>(l^2qh;M?oQɼҕ3gL[r3:h{(@&GRt9n) \^h>]AKeB*e՜xI XRb

  C,9TkmsUՅlvLD,|ӈ!GXr[YKfTIfY2[Mӳ.З~)G[2߉l	L9֒!LU[+tvd=Ja,9^NNWdƂ,WE%so]m`ߝDKN☟bӗqONӚse_N
9Òv	;'(TOv]/DK,9KΦ88Z\9גrH~46JV\`Ʌ󯨶oif%j_\!Nv
Ku89אǷ4'B4`ɐ\EJVI/Srn|9+ܔHu+*q\_<ђ$y"$uuk9Ǝ':giWUd	ء!)=-Q9xMє[l,^K5'!zEk&9"gXLIAi?hՔX\B5J)LC^,l O]<0[y'y	]I%.WJz_x):g'U34-	kK(o\cկiΙ}2	r%o|WL,y@(f,vs'Dv[L_y)I~l&IPGQo\=}4UgŸdTͰ̾?*TC|J,Cބ6Whwrv|8ސ?rOݵ1ZE8V݂$n3q{L8EۓKrnʧHօ7N>Ҕ.vyK wٙy
CD/RC0ږ@тA.j$,ueTfOdOd7-Vd0ٝ|ǒb_Whтh%'PuyS.l?}⣃u^2~ʮg:tu|zK>ܒ_/i*Eӧ,]q{bq6NTV9׭+2PoMu>Tvlm"UOl*F8zE;>ptM>1K-j0'4H[>ЌńC9^
{0#{؊Qʾ]{ąYt)Jׅ
:@r&O{vGV	59!C sDO>}	]m:upC;J;'/@{{s	eQNYq"}v.tBG,{@)L$_6GujN.x1a;8 7 y=
/!1l?Xwwc1<:l=ne=wA=LVkf7w'C]׹#fr9Ivⅰl܈`aS[dxO%+(fT`"-A7&T?Dz]wO/;_GŷG!uulի]ҤTVikn$$wﯨ
}hN,t~o;{/N,ODj\|2LMf?jT%(S?)`'tY_8SOﵢv=³:Z
)#
SB%ܸ"g7X a薜g s#৯F6ǩrv01@U!ypX3L*F24;ӤӚF+KkQübQ3,dhY)
	d>*Ak)U6bBlW#P	zZF;oPpwra6/B6åM^•64z͑Kq@46TdnzCjj4&˓r{'a<ƀ(ڷ6"jm;Z)u3<>nRb?ɏoۏﻍI]T@OG$/~qu1_4B~Ѷ¿t\_"z˗Kn?\
w,
O
N JT'Mn~M.-u؁wbZ(Ӄg06zrqp38\Kw#cbNt-Ǵʱth#4388tjba,[moux.L$>,or̔qJ#z1S$85H0遊3ъs\-x45cf,=+DGqu1|ùĆ>3k,m:Oh[ڠ*ϐi\ǓX6)Q8uWzV!muDsc	q~!.b%mZu9?_|
?_gK>?7=Ϸ4p
w=&]JY^1¸aal9![0w0^zMdnBbQx
K0RnT|_cL"1X`,ݠx[GUO
$4J@E.Ll0Vg,a!X2Sp,`%N^P}`55M!p"	pTb*:8	ϧwЀ`=>'N`~w$X{LaY"犑p8.".2Q
i3=r^!h;`x	n-;U&Sv9N9K6ӡI^Mp
|`%g
c*U!lWТVAjLxB]O;<^P]jH6%O
x"xͳ-O9\
z{	_x*7
x?";~?{O_-}y_^޼ a2i>c
h0$&X)F98bxd$*
}Ce*A%Rdk% zr,߂N?V I6'n"NQi/^^At*6QvG7T\e%NmxcqO0L
P]F{r{ıш)j5V#,2*D<]
AݧF%^RT&xC`>0PDL-*Wȍ:Tm.V yrq핋ԧj4c]syp`SPzs3{ɵ?z;'6e!T0ƀ
{= 1Ҝak.fp}
E
8w?dLGd~=W
cTwRt8R@QPf
L(2QЎ9Aj*'i?T r#~@?'X^la˗Fn*آ=nAnrm߷#
WȁŰh=I@28FPá$GA	fsjYudeo`؎tv,`B5IH
Ƶh0Eˎе,c~Hr8<;Dg*yaf$}AQd'E@iH^N3HO3BܝK.F~
ޝVs	e.5ǎ37{Pq59}j#ZxmrA{ܫÇ4/F	
!`,*,)fls'dck	!)ڊ\	8˰~\)a	UdHͨU;ڭ
hlwW>ڡ蘮^u5M=]=MoQщd''C.ӠN8bhM$˥p9·+p!܂>%2.p9|+P1HNjq`ɥ_p-.
<r1/j|:܌1<
Z/vB*
>5E6$8UM#{x$KY^z1`/V3+S0Xvn:inwmU"
?z1GgZʧ\z&Qj7B}
j!@L[lHN#T͏F>sf14	|q(P٤;bR44MQt.͢HNKhs䦊yr.K(ѐd]bqM?*/U,PCw/pw+4/;Y%7tqAj|9?ܔvaX%w§J^Xy9
WҶt
k0
F(›hkj0n$gfږn!Gv8ȅ
p3mKMp?}	_̿DAQ)g:6Sn[aHP|GAAvy~<PB*ybSmg'Ic+72'F>L>Ȥ)$p >IiCI=DsQ"=4[֖iyB7/g+CN3sE"%g*j9kV?{y
=^~~e^܋OF2᧩]1_x.E7΢o=K2"Ne	.+]:aE:eȧMEśL/s{!%vq0v7˦FB=lA8iX$v
_Oo|~q&|M|	)R|
kob>M=\Ү)>a/h٩Hw/TJ1v4B;caqE"-ȨK]˷%$=g b6HԻdiDQ6j p4DȄD*liI5}+Ǖ1IH*2)=o"H6Ա'	
TpD>vڨl괊dm&$66VS$$$/y>0D$BH"Zd鲀VEkj(r1FKQRNj65ARhM9	dnNNcqALn=_ږp}"|~Zƶ倘0Cy}_(~mGjN-}c=![C]v;eJMښ=&ǓMxi݊1pW0A
8ˀd0`рL`0/Yɐ4dRn4!5$'YΐV
	&yK!9 9Xf	Z;CL5ڌKO3 ̓'ɤ&N<?7REbQn
IV^ʛQ1,H텫
FCu
IV&Պv]^!b(~+	%FC"S"7N"1Z̤bX/'YfqxCLob^L'[4CzL%2Y!+<-|PErX**Bq1?CF8\(5抯cFX+aT[ď6xEb| _o>co’$[JsC,sL2dym^-{dsǾYǑל,8u/rpH»)_	
PķRWR-‹X-*%ǿT{b=Lۊ+!n+6CV|	*VϜ% C'>,y)\S)xW2ዷq*!S1CHLE{Vў=jja0@PlݳOv>Sz4ӳ?$P?*-Rk6
Gm=8TU`xJp:L'p)^+5xtXתu
T oR͌O(Us~.,RUܟ<H{;h4S8(vj:\;\5o
%CD/yci`C)gpPG
u3:wLh^"uhCh$G%Ng![T5g`y1)tm^'^Ql†}0b쇈>dK,=¿tSbA^H;@ZthzoN#Zo
o
&\9v-o/wlH/:M\q6zs)i)y>Ag:}>H#Lp(nmy.}Ep\}
:=gsrRr73ә	1"Uו7j@R
Bfi^Զz#NęX"*ZM<1rdr/W٪ u"d*8\V$Z@xP
<$ρy~^yZrLWpy5fpX"oٲ[q
ZyV;4	ϑwr3^-Zy/ tѶ:Dt[juKB:E$Iɾ^h]8Nc1]Hx
g}.RK4]@.)J6Ȧ6
-:OkK#4X]R"k6UvvDe
{0gאٺw*wynZShK\bwK҈'FĕП	NHHwRhIR%7~R@zwܜVy+n}Z}a:
.9Z_a%[괭r[}̷҂flu}AY>)^yR?8p/T??,wS}.M"1^L1ȏH?$)ȋ_t/J~WP&-!+pm$?Gտӿ[HKCUF[+t|hpra9sm08ǐ[
s2mu,ǣ4Db]46z$[+rAsEs_1yv.KfT-'u*NN|}z@됔zxRwjC;˾퐾۠W|E~8qOt;猧]9*\`qohtΫz
vm˃.*H	a{!=M3iG)8EW}Sh*B y#B"0@I*SpJHJxhT}!T?\
AB
CjQ8\eiY<3-w8WwE%^9Q=2?c
YdrAY!_U
.2OF5{coDvD#e1&*=	JRNUrAm{>	-Sц0\|9MW|u(mgN!^Mu6Ъ&HxAMXgֵX>>Xkkvi:XY6~nw[QfVL[JgbQ,{@|ܦ|ѹM"**w_S*?wB\r
~*$1ODKWHC*(HW`C\V1.!_/SDUoéծKh#*HҾ[_vVu~Ue7ЪdK2{(ʦg-ZHKXDKXk|d@@0Yo8Cзρ߅ΉF6l55YԥuT[rN;@ІCA˜n[S+[գLw[Tzp[|Z>?ӟ/5CvOl{SEM?%>PO PKKY\A=#N)com/pyjavabridge/PyJavaBridgePlugin.class|	|T9M&GIX&$!Vj	$!@<``2g&@\poV[[.6UZkڽ}oU}}odBh?o뼻{k?MD+|0cQ3͊v߻7
Ejk^"2&$/S@'Bh?#թfK(}dQ@d4"4;[7 HvB=*In;7tASu˙[o$sYpq05b2&P$F8@\aJZeaoo0\P`#jPdW}eK*u;,}@&h-]T>07n'(1".pSijCGp¶ܜX2a4Bjhg75p (t֮	mkaF3'Dt}0iJr]s;1W+f&3%ⅴ͢r9B
y9x<@L4/*	[2Q~E;f/PnبݸmE֖3u3Z%b
x)sʽE,R
lp,z*s,v^7t4Bo}H@g}JݥLhc:tIYt=RFҍ+vgkݎ=$3OZ/xE7Mn'#eU搏n7tEoۘuXPdgir.poMni]n/F|t;aѝv8SYEΣ1$$Ӣw	=qdtȤ{,]e(*y{n?,VTdxrƅOAbKE}t? S}h3ڹg1=K}!}>h҇,z>;u&$vkOn{usCw\67YX }+wC=LZXkcϔLVGAsآG%lODfll
IX4$Cd[p!a[t>KJ蜖0;4=aғ}`bUڇM9NZ=Y Px} -9@_zEpZF/!&7*̛#==F	$d}CfqwFX-^!
Cߵ{}AVmKdC<yEZZ#1P$lAQŵ1'%SI?K1pJA.8=їG?,|17~n1[L33g,[}E?A>vFc®.,!/$_-,Om^[a?zQǼP\fsыym&%:wX\[\Plv'I#иe퍛;"noY\\*Q0ڊ䟉f lq-/4<ޔ@A4n|~@QCt>^XN&\O|jD\7v=C'n?я/${3FB{ccx`8,t2Vye%:gx#WXM8p8i\\ōڱ!0ym2"XkI|/t:f,QY/xJ[GMǿ3P9;
xo6-#
WC.cZ{ŜvK&xPhB!y]NϕȪmF>U%Tlq&Y~B/Iu%߇h*-efu˱IfGlT
Y0)Mkd6nqBr;b`Ow0hŢh\\YkJ"='PR󬸩7*P\/q+[>:D[i x:O
%+wS}[:e_後3Ft]oMĹBiG`*,-M&8Ufo@,+xӮH4f1OToX[-"ћB؝^>5ܠ	{aOZ/Pw0hi(1Vn{>m跛D*rx^H:'7xa25ƽP\!F{yQΕve2y[xe;Ҽ1&</G
r\a:\!H19iKx1\"pE,.w0܂;]gP0jł-\1EuP
b33I 'IrW7nojkolkohlܾnCCLdI?ş5i?'~i(yXb~)zB[tB*R?R3

OT.T/DfkX^@#QC
se	M,=""
)(yPmr:nTc(U9-#I,Za>gTFtyy.썋G6ٕ>A[
_Z+~IE4Q*+)в#.L?3J{w0W>|CƎ5Mo8ߞ;'(]i⁊usmm*ٳ+WyuJ#x^[

=ٔ,䔥H1&Ejq&9X;\e`ju<ʳT([=;CZ@p;b>qZM9+e	#uzDDt6Ty$&.RK>`im*ER5RƶOMWgjVȅw+>l7ap"zg/WL5RsQIQFޯ5ݎI5szSo@^^
UiTImH/58ֱk{뺆5]𘹨HoR/,Tl.]qeGc!mQYjZM&L#&X#%:D'iJU瓑G?:ȥH-Kod#UdDRomjiijo\=ʼn
T0*cylcP55ZkN
1I.nQҗljR-jl!W.Iե qL\ޓ`6JD>Im6U/j\zKkP\_>uT-^!-Q1͙/;,-%!-ь-SЙI;!=e2o8K'Lm{,uȄ7DEW.:
I{hW$(D
7+Ks]˲zOPtA\^[;![H#
uc!j'[tI*8y4$r[&̞`"rP\na|+{ݙսw	,FpX0r"=q
%y+6E:NyG_B,}}v7&/o2Qפnq9s!r(dE
NHk5'S4I+RE=mD*ww-}I_z82MZDrUZy5e=1_} %!م>f[d)IƈϷҍީŖNuC8#2W$?f3Ft$P^EBS\v(Rʵ5WbVUȪw4+]ogs@'7{|d9;B0T(ۅKsF+ebeT?QF2>c?CA?>['ڝ#	)96r1\sɼs`ܑKdݠDguO&21".9e#c{%6VvHt?$Pe8Ryq	[eH$yi@|a.jsI#	Y.Kk|qZ:Ƽownc^Ns*y-M;rN/^e?Os"iס=FzU4'bV;;i|͹Ry$kLf:g0ь䒺r.y4~(|qNH"U{eL0
B̖9aj'`ex5@wJwr]J省rb8Pb/2LC]3|0Z*Q#`2nݩT1V=)Th&^
??g'i$Yǘ(L8SK0}y'!_RdrX
Bԍhq{!;a0{f%4[AQWq0H`2啽BE&=2S
=L
_;ޫ0|[9N? 'ӯRV8Z:W4HemZّ-qIptj(58A S;ݨmX߾\R{}iɝ+}RUbGC>B&h/rGgJJqzI={kҿ0b&ސscOH:nAomU-E2K2WTE8SO*ӷ
@_.hPT5̆r$"RepBc`<hn&"sOH`A%tݰ` gZ:DI]hJp>cm*ѧv+4Ť_JqOpJ8>%\0A?@!h}Xh
HFjT(Oty:RR^XU"MxRZH|σx~4MP
iIUPuQork@0dPKl&aF
YUCW]Aq\1x^]VO<ڽ'®\k&C|S<iB5NO9]_֓3`)Yx
&aĉN癔j= 
gP2ī5]-'vbSm٪ܪmlOY*F@7	^@|xaURâY 9$<.)JJXk⏿$׊") */D}Q=cX㜋ėaFz%_(ˍ'yI*w"ϣ'xSWҰ/?o83rx"M-߂gjh|\SԜ˟=m.oNtil; %Dy\N!
s30i{92ìL9;r|r+|<;HtU@W=DʡDn|*}L&WU|**kzEcQ)qo9D1~:gV%6D~D"9ͣ.|ˁAq=ƏgɎ FAHtr~;)\W/8I!!7
8+ɭSLM wY)R=3G9C$}MJWP>&q#̈́k/|	j6jm
i;&dwfAF2KHoM?#M/r^=<üV#Q
1WCin&wUF|aANnZ^YLKrȷz<ä_}G}WIE{ZOj>~CiXRJ^!ZyK|[:t3?e]JO<چMLmU5CMT[oT]ށ;XD}㟇;	69R* 9LRNwc`ˑr-҈),RG}K}ɘj6	#5sVqukh
fїV)h#>*	9~gJj\6Aw)j5,wpTʩ]k	JOk5,LyVԧ4I9FqөЗ_z%I^t`'\$OrD	Ճ9Lkj:35/g0=kB,IVM46Dq`F<8Vy{akwm)6@J柮iY5tPKKY\"Z.com/pyjavabridge/event/EventSubscription.classX	x\Uo23o2yYڤm'
څ&m!e
X^&k&7/)Bq nU) 
iHQPT6Pp}EVLifTO%wϹ垗^>|219j# Psz~õ;&JxM+בvҳ@`%7ִ0/ˆx_heJ$RY-7]Mk'Z:nWSG_OTdk;
gELZj7DXV(?)"e:1I HF;# JdS$\.SIӋu3$VꘊmsO	
	:p$J9~Kl\,jsL:L1!kIyXga9:bao׭mY@DJ訕b̪تQͺڊyydjٲKHeNI^Tp\m3q23'xst,""<z0F,/63avY;&J'1<4khѱ̘_ĵgJCkrܝV#&HiP{R
t,
3rLt-WCKö,5(^))ܭㅰjXc-^sRKU}f<+
3(ȗ[[4	9=}XSz:fBzp9Ťϛ s3Kul=
'3Ͷ͙p/&ӨRcZFRc2nXncrk#zHܒo+bR/ʡ	p\|`zew8np.2n3cqmD-0-Y1rxrtv/iLI퍥6ma\cɢ-f$1XW扦SSt^1e
6]gZ P&H!of\DSR)+avĭU+0%<ƨuKt:fn!%1rwф}vrC؍ ɫz,nGJe9OeZ؃;7)/@[$:n^)NRYfM^WCRsI>M)5yw:>yݚdN05N|dP')D0NqNAIJޥ;5|BYj0܍hG~v

@)/}0JStm}uII#En朄cΙ=5c?>/]=UȣV`6h
:`1hƬUʜ4mV.gLY^ә*}mr/Ɇ:~_OP %P DyUoGZQ	." 0'ؑ:=VSr'U51٠2{G=122Җ?7RsZ/clʈ#[K]ag`H&
]`NwZGêanÐa,O0IL5	FJx+2&&fLa_V!Co-!?µ/p^^yj^I9E=
O>5׿ȷQ"H]}C//qT0B
 ;;|Tfq]'$;`9{
_OͤZ~5:
sR(@~*$nRR"S4R4#R7H8(>h
ĴH/W319T[X\XG"ŕz(:0XimO9h'\\;վhhhhhhh9{yt<ýE<
roN7OƷCsܣgzyηw\Pn
5f4:T%?@)qfpY:ھwPFPu"5qq|jڨ͊=OIGahKϲALHN"=1.ª)la\?Bh=WGhy09jFcа8]CͱKcq2#VB_Bw4T4f͸&
{
ko֮}ǟ|xpo}Fހ+QF%3[u9
܉:C1=
R-a#H3Te}3{gA@ލp&(
?9^pVƏ(Ce
q0+c}]G!^FO(k.DI]?у5b0,)\M#弄./
Cy|D!|l?E*fiHX3	O	&H_P3~e|?4@v+ΠY!,E'n@^Sf^rZGG*,E{nÌC7C3)8hušYUMx"̼:zFpi4zy6J/g|]_\S52Y+fX3{rl-~22	c;
1TG6(H#/OH^5eQ\PKKY\com/pyjavabridge/facade/PKIY\(com/pyjavabridge/facade/ChatFacade.classRN1=!K-P	B*"UZAٻ1IFS>;)~Ϝ9-/
QLbYH3=9e(\CjbayDd<v#ʙ-iF0Vk_1\"*",ca;w/Q\tF2C#?,o	a(:OQyV
S#B}_b5Zuzlp91ZtR1^{照#R\bT'T#yLئ#ڥJrmO9IXF,35`؉/]wdA_"M–T6X*~v\l5
`P|K'NQ_X`	1I?LvW>]a/
8v({1{v[>{PKIY\d:	@+com/pyjavabridge/facade/RaycastFacade.classWytTWɐ7<y		1ȄgKJ}y$L慙7`ݪŊ..ZTZ%к6(VZjUjU?Nﾙ$~v]x#_^b
`Tuu3¶@J3fګ5m
<V+ؙ1`mӊyEUL	iZ:xʽM&
GT

Bفx4R
k$Y.qE&-i`/xUYW&5b]vw7"a![bԘzlPpH[q:b偦AdLdo!n+r҃0N<8Ltnn=82wxpA%LBwSpi=5bRD,ld~DGd&m8c|2L¹S&TS'(۴oޫK
P)|05#u^Ci{7c]Lg懭`߀쌛.#HzĐvso2cdoߩ;9/S'ڦMyN#vɺ^tMC;$4_IP#qbEQnNd֦{&>XW4?MubM2۫k}Iם4ch21E#y{."0ZD"Nͮ8{l2`O~빞*~oD6wUp?I`N<%xp)D	?^JтUkD7֊~^܃q?B6shQ\xP)^M!(6"%T(g$_dԇ1|T0ZCV2f[6%#׀cђ1bnAIvn2/Ree(X%2fs}󲲲.#䬼{;WB?{c\O:^ge	!R E+8,*=!KOHĄ(c)!%1er-2~EL}!1M>N!LƬ~PKKY\Y$'com/pyjavabridge/facade/RefFacade.classX	|fg;9X`8pi.\ 
Db9װ!G VZk[zZm`+Vi={Gnn7}M|cJ\SV@GH{e#,4#f|@^Uuk(PS*05du{%Ӷn!3W^3S?M)(F;=U̓ǣfwq3l6cvj	Qy
^a׈^ѻJQ`a)Bn$p=bEF=FrDn7#%	Mʞb
ioG04->Tbi*c@	,*P{
'͈U.8w5_6n8*RQ'#0>jĬpߥ6&̶ki80?76-kPP'PuM<7+|W莛V$=MEysi4Zd;iSFy#S]#U}8CRA.pIg@`TIm)X(0%:;xа-t|G8eZ"a3b؉\*0!4c2lEbT
xFPR
eEg
fXYr(fU)XK;1w
7x[
uʧTFvS\VZAFRWqZ-&c|0WY6iMآb
L˔A*|P P^\
i:edmSB#C5XThȶH;wU6ҵt}Szl21	:&a&(>$YcXQDZUC]ooF|\M*n-?LjwXm|RUu]z5S֭أO^|ei$B
uzNiU:+>S2ȾGI7V"ww
;!En͡g%>⳸Ѹ)3vk%ϩ5cuR99S>lTYl
ztVU|	SNra
Qk-,+9
d'B\v#V|xs58GWFmXב08mV{9+܍~L&1ipԦ;a2dg>P7ly&b1>dKYXyDzR`/.%1SQL);cl/XoGx"J;ksĝ0iȽZFnT'U=gph=l#1gș2úd9i95	UG4b_<Qf8U=hX8}nwʞFtpݶl#yErRY΢$28TSF{DURpB3lOcћ;̘5YI9:암*O^ʴ
nIk-CR6!1|>\Փ\٫4<õz
r99om)q-%ܾ?06}YIL)5BI.(j7,a~XԒ`$8<α9>k#hW4 (t%i>KFd@_dM½ՒLS✽gdo)R+R9ReMI6чݒ  ?w@$5`9|Q͝w$$Y˵H8[Ew^xD|iB>TkPzA'z_
W+|I?
mq
ZiwF9
ICI "M2_Y]h2ߜzOb,ѭ.],ErviO׫j5$/
B}VtxkŇWľ7>6Jy2>ኸvvmg0iLSo5XZl`v4l\q0>R%bG=^D^Y^,%X*(20w2y9^d_ec^\7ns]
\l~}߶*
[RjTd?Kg*[fPKIY\7	dp+com/pyjavabridge/facade/ReflectFacade.classQN@=#-~FFĮ
Y5a?bҕƅGD"n}{Ν{g?>\4L$=]^̐,@Dд;23z!	:;6HR,YZlwoNt|3*qe ~KDsCMIOA#~4ѹP|<&ay a0p2P=k(hR

xY|{,٤X'yMBZ|Ejj^zZ=!L*"ab.CPKIY\d?
,com/pyjavabridge/facade/ParticleFacade.classW[p[]ǒ|-[8~%lJB`'Ԏq℗,+,Y8Zڴ!R<tG送ta~0G~ιq:OtgQ
Tͅ΅zdwtz.	%cN2T&;rB\,(N/93hw!KJ.O'pPMdh>"P3|}\&5PnԸP:\D:ӿqrP)`SwnA8t'zP"3хH2wh1Ibd9@[,m
C3ć)DĹHKY?|+C+7h(ɰb3|s9hWi*`(rtӀ߅.tle$eJgp{=.b?Zpt
T.v[dnF[\AO2l:t>y=F6888ߠvY,2@ʱ#.ܡ³©jӅo[6TGZVϫU*Hz0ZN :)=(4-Z.1=v!ClH%P29OGR:ñdt$3Nh¡d(Svўe:r4~(h8z]InKMϭo<
GBB@	-k]5-n>xϭ/ƬTqV
F_%;cq2"L$.ΞFrhNsb.(Ki[2"Kc"*8©l$Î;z:r׳gJ	#0Jɨl.´?aOX	T":ϑ^_'E҅/zOY֔eMYiR/Ulv|tCVl㩅L8r8tQSErnZ%ءo18ބx]wWh>>]V0ucݿ1*Fh;QEytP1Zb{k	xի0W9H۴Mt&P#&q{h
Z;wT3|6EΞ%E6\u-$cg0
ݎ#GҊV|%ӳ]ta};U&~#h'+#l҈OQ6òI6ël	8dtǟXUkmfc]2[/^9	|e7U6~ktڷ.y0ta3cL&oBfЉ	dL
_"&³qJ4ZF'24Z$rjtBD=@hZj5zaz$^eM"U9e@cKY_xfk\lT
oCe8شKNEԸ4g&=)0I-L`jwb
HݤMx"~}Xew]{b|E5qnGOa8r@!*
f&U
&գ&qV磈`$`e|Hˋ웦芞oq=_ȭ˚DR 6؈b#z-=eG؈F4~F$I#%*j4R!NjyttUnԬ+GJ>GRs_w58tMɥ;,Au"W1lfB5lXT-mnմvkZw!%fwrK0 5=r+3@Mʎ^]].Z[8hU֋0+v(3w,[
S!>=v
R_ppgem+kٕkem1s~yeU:Pmx|dO'dlɿ3w	$O&D;#3?ʞ#kvyãuivQdkG(4@?GQh Rh):==5df`lk66v|˜+PKKY\ao*com/pyjavabridge/facade/RegionFacade.classYmx\U^'339L6i-5_4aJRD4Ԅ-iz2s9ɜ03	I{Q
򭶴 PQQg^1OOś}NN>:vY{^{w{{"j?y29*%DڜQ;hD^F"G]}Lnʍ@sp:ՂՌLj`/'႞iaHQG~YuP(ܵBNlLAB7E$X=[dXSYD/2_MI&m@7׉J)'Z$Z0Qg&
-t&^jZ#Q堚ڍlB-)H-%bu;m9F<kF-xZOHiy#3aLY=/2ea/ءGtP-M^t-
eԄʎʢfI]QJe]qq?(“	Mpnz/"]+ܪGB\A%
	.خSn#WS(K3I瘛3sLi24]Fv6pb/-,
<4$
[6*j2,3an{{ή;$v`|2ۍ$^.=]?<اv}AjFBVaÆ>["ˊFAmDϴn$XaXJ&]5V,]#VVKXgO<@4I#| X31bAuh(3vCj,'`+1rhh/nH&c8ȋyQ8AfmYgz^.D/lfk?g.Pq>Z0>+8PJ"móRzJ۸OeWNM+ed2Ɲʡ+j\NelRޥ+R])MHq`m%-/YGZ`QM$HÕѲ*!C$%4wF(ʷKU^_`g1Kh|@h1Il8F!_ȩCZ!e$nD
fѵRkM'zw4-"-gGfD;
/9xbM#dF˯2Ж4+
)~K[ES.OjϨ.yOGsUT8KpPITE{$/d\Qމf%K^ y2%PtHg
>+Gq4#9ʎSx[q򡭼7HU,&' q^\,|UPV>N!mD]2Kt7GeXZYSA?A(EZEռmTjQ`UnIDUiUI§QRtiƻ!Vzֵ1G˅7W3YsRLfAΧ9c5fXejj	7s&4LOGMIH!}
SH[J4IAd݈p,w.UʨIYz܃tr7|gY"ָx'ޭq?s27L5d
&e~oY@C
i`C#2@ς1+;MmY'%pz?l:V(uϸqQ9QyQQR!}KH BntpA¢^$_^aH>ظ(#*$Q`^jв`3%¾(z;j`JQ*̉d~慫)z OїY@R.yPJ(g2Fz-ABOU!;t
>9LpH	jzvJ}JS#38&h/qt*tVoJ/bz^
.
>*òUT#9:pHr
MuӄW2`2NdYہ,|nt?sֵbbAVMd<@UyC\1$pIU
C|0t#^ŪhhZ&&&MTA:!0)Ɩӈ$x8G?G{p*<>r8}dP@EA~}o7h?mZȑS;,\A&nm4Mh4miFӴi@ӴWHW
!pÞ^cg
`\O\cU;yj<9jSH!\5"3z0Ǜs\/țmqTn"9\pDf8HAq‹/W$DE7nPKKY\N<+com/pyjavabridge/facade/MetricsFacade.classTRA=L2I@31b"N V(,u5	Ct2C{č**>@Ïp%nBDt{N_"^ƦRN[lY?e,gUW (#
@\*[YcԒc[ꂈRpsVz"9DY<6Pp
vN˸hsbbL'mڛxN#"Kt'9d%fꋄ^0u6kƖnUz
:+._Epi)ЅM\\BHʸ 
@X[Xq9ؠ!3t
f.F\hF%Bp]ƨ	l'M7!UicO\5u$YdFOPu/O]J[̘!YjkҪ2\k'=N;5^R'rJpu\VPؕک5|Ҩ9dVd8M,WtG*V+P)iCUtٵ%<gEzz取V>Zp-PCmg)`6xy!CQA5Ċ8hA.7<ބE|
G|nO_C@2z᧱$t L2Ns^:D=Q9]HZj yi_?'x2hdXv<"cLI; .cx_/BrPTC6	nO`w㓘Qw
DPKKY\"/com/pyjavabridge/facade/PermissionsFacade.classZx\e~IN)b"ThҖ60MENtdfK
"(Q#poH׭]^u˲wv}9sf2i>O{}w}O>	S,
?uF,iFb;5T"qw
.8e&䦁lbhČ
Ɛ5c\.N.V+ԓIF)Yz'..WuHKt,DҌ37|N`a\['F#=D`$'QKx:;(&1J'bIcvK峉HGc8M2Q,vGT⺂=$ihtykWaX)W.
5Fd.;vmksWb#3Jjgb@mrd
y{s GqR5%Dd[֢AG#b̻ioFnIzV	,'rs,=nuEdӱg3ɭYU`j2FgCC>ICx9XħkYuiv9Od\[wjMԠiA䗜%#ݬKc ijl1S٬1!;sL<@U	%JT}^go—4<8TV&Bhi,{FǣwTNQƢz즲<+xV*T&@{=oX}ai[kW5{`,oy3:ج#)#_Ȳq+ke^/tU܊q7qߜx"e21_<=h$wلn/{lP /嚘?,=]=j0#3-ى& )euIR/F.;k؃[CʩJ`Mʴ4YmzlX[DNQ>lل%7sD`-u	8*-B鈕[|B!1T1T#ݷReduIEjvHA5.Ik[_iU6[^'!cMYY'甯x~i鑠҅yqBFW?ۤ
BC2/XpBT~J.j|Z5!aM躨V X\AE?v'?coϹb{v#54skh!S]my-'8f#cZN$/U|=(%Uo<F2ȟM m,ޏ9ʟ|懡55	Ajih-ljnY1EM6Bm
45?Ӂ֋I&_땦e!|S
Njs,+~kh?	=;U?AOf;}?$,9=
gHg{ZL+E^w9hX,se\smP<*OE8iT"3lYfyy3iaG rO}ʩJyGێ, ?/\d[+sE:TK莣VÆ.%~-6;"_(:B:^9Ro:#?:,}nz0D<&4EJJq8xmbB2#,A'ëY")#4'+ 78Do"7TD ^Uluk޶>m=ޖ>sclc}ɷOv7]b+yt!
Vd^,E6E	uow0Ʉ	߃HUٍV$r=lnT@Е2,*tj6k؝J`3Uh)Sώc=?Hp#SV'ȭN["FN^B$°C|zioXY-|7b@4v	p߮E5CxjȊxF90~#⃚h|QZciN,wl=Xo	8`G(%Ј*$%oü,Ow9$1,E:$yf],$E28q=bK}!E!вe$KU8Xd5/ɴ|Sk"$L2E.$_|pM_I,ZfrWwj`Ht%if"v-g]rM3>$?~JIfŏ]M Xg~?={Q2[sXl@bebfK;aWQbO؇SWAW=G;@jqS=xn>	N&7Ci9{])RjԾ*G*g.86=J-N0C<5y$cУ,Ȫt.P)S<2/*΢:C2쁠UboZU؇ڨ)hG9G`
zwsE+fJMQu(zuQ-3WMp8\Џϲ?b~p|y*o KdYKBw⿆smX֎~fD5js!';Yy>2]k,[,Xx_ɑ)feq	"7З283F{y>Y4²>KAԌnvfVPÄaq|ROpxҙkU6[Y6.u66YL%L^7HNy uK
Dnk6oz0:b
rÎSa'5y!yZ AxGxE@,Tӿu"" PKKY\s+Y'com/pyjavabridge/BridgeInstance$1.classU]OA=S
+`A  UR][("L*i;lݝⳉ( (ؤ{g{3wg4ZBf0UxyޕŒnfAyM0U)8Gt
jD;Li\;	lR*\+:q@!t1SnYztԴּZJ{3NU-mkWa5qGFdkkR[bR7kes*fh-	]s2JKQOIqdh'%UB@\WVn
01CǶRH1Wu*T.(g;"#=-/U,g%r(CJ,Uyy<]w?;~2HSB:,wyYhRF0n
6Zc%ƷԧYuN*cY'1TNRy659QYvnAI{`g|)fUv!
3%N
zP
`NĭӉ٠\@_PKKY\ޫ|`6&com/pyjavabridge/EventDispatcher.classZ	xT~I&I EJe1ANhXT:$0230.uv֨u5uC%Եj7ZsL&b=;|ۗs=`9&<r'qNhg6ծzݒ
Gy>x3᷐KPkRímvv4(%[qnt-^ӵ/^Ph#"I;Ӌ怅bpq}.9+~δpga$5'h|
0H[Qɏ dbfc~`y`z6ئmˎ{_7l5D-;V%v0>$]ERpf[GY;dK:oQ\
]N2嘯9L-v_gk
2apnn⣂}Y"\fc9Y"?'L|§~QhQFv"m*,h^+UzUgV&%	mh(/X4.Qs^\β--΄^e_Pp2ذ4뭴눉	
BۘH
#^윹y,۽J:UȀI-;\&ԛ{1FUFmʍw>qCK00`PtR$ٵᤲ9T1X^@һJk}>&396֑*^eI/mt9]#jl۝d~~m5Z֫0g=RWްKA Gğ-eW8SCIX6?tZ9|pt-w/Ee+_&	&޷p8TF86n7#pB[

LD*FT'XɒRlWQ-GrMɳTgN7*N|U'WMv{iwnń\J)#,)v4YQlcG^76.o^ܰzբfqyI\XR*hWHT(X[5HڭS_XSYrOZbJ+{IyrhBSf%*IL\Eή¦*;d=R@?b;%Rn
wȰwjڤFuVPrNR֥ZrU'8z#VhI2ЮoX2ǔ-zu$fYGDj]^YK	xgTm͖
@wF:(YhJ%$Cֆ;%ֽgvސ)*RK	BJ)UCػBVZҨʴV
[CVdʒղFGtaɸ>夭ʝZN;hcMgq:a3KyaF$afYj!}1gxA~9S2lKG+D+cɕrw9_%DĶ;ky+4-[!^`;_L%7~$ە[dLUk6Ԑ-EnuSl$P'H

6ÒMvr{'A(3"f>x|Ô,[I`+VêL/eLyВ=Q3{ܹג}i:d1yk[؎P [̡T}<{8tϡvKaNuT{/8meNõVeq6Id)߳#nWI3Uq*߅RGjZb(R>^M,s:,Df8$ǽhKSnЕNDB~x۩X._8`RʔW-$Kw-YMɌV~g-y]_Xm3SΐA}L-<
1NPW!RwInW=U>CՑBPj?}UCܸri	]|5Nq2/SZF*	7)12N53a@j5<)-|P{{6
Ma	؎Ύ#&U&#[1x|=Eo4Lc%%T̒C3K7%pˣQ;S;a,BgG7hd^Ϧptg1&@ꏕ8
?+bh?yc1.G2\aIb5RRYfeTʠgJ+{(_;_&(c
sV!ev]_}Lԋ)
=RG\=Rt[r׏&*r}՜}՚q/&	LLEyM`J~TWbZ5&5$qx@k*i*m2@Dz}Q"I$)3YӋn̨zQ\毪*Ҵd7+

nt.|buIoV*U|܏l
CӪG'Qm3QYl
d[Ƿz98Xgc1l,AKj-E+j-sk42-Ԓ2]'Q{FdG<)C7*(T܇Q1'ּ7b\
HA;=tW
.Pn̦/.zzq>|	|V}>%E\GH򯺀R[\m).'K݈<{ra{@r{:3h>z6 Fn^_Dyi|Q|ڹB1hd뤡aGs\	(OR܀xOE|
Ƨ>C_ղ9VMʮ<.q-c>O@oXLoDޡ[vQ`S{dQR'=s(A67uF=/aHOӳy͞Yޠ!A%x5Rd24>g n>QF>|;U0:ޫh7=1SjlɧP#VWȮu03P2RL_MJm
1wzh_gx'koAb^Yf{LA7܅sx'm\(	|aoBߧSbi)3a>LijR|_لJ+~$Q<'yI:O$OVLe/~1RNnR`>}v0?
ϔtWQž
.%N(z"-)Zl:?
{	PmC>E}[Wr4T=NnnrCM˼g
ĉ+w~޵*ڔO:cq
SFVG!FeC|JQp:]QPvb,1Z'Qz(4jiȱϷ1Uyek5mUG
FZ0
Eis~pc39ȂbKc;f|Ed4]9r%0+MJIz'cݶGbڀ;${ȩ49hbOB,HC(ǀ-Y̦hMC::TƁj*`E6Q_۰,{#Z;
_?KUSÝhI0@_HXWZNF,Y]7.
db5bNPT6,`868Te ">eq$LJse<w+f`PZă+0(9q汵!V=4 bAbɚ
ϲ@,lA'gh\\BuAaNZ=paNJ[H8AvN
F@$Y
 IV8QfO{iC8>IhCp|=td;BSrr1}A1DD_`hsQ[]	728I
\W2Rrym󻖕'3*Mp5~
ԎnzaRr]|w퉟qqfQw=D݌ª4`ՂvLXӝH:CH͠n?^QU%؞K
AZ
Br
G.iX"+,Qԇ`
BW{	Cۖ-<僇T	m؋:a	۪m b6ra f&1xY,^C:l7Đuũ0I?!M'lN2Ptzn9ӡ|4ϰUYHLp`u2oHDTCL4	}/ʀ-͠g[ռ`hi]xR߇ւ{\(j¡YpB)%G.}Μ6t~B+ruX8[U $@MD‘k3&^_RKƀC	1gzer\{PTF4\mP"c&KA	6t+j!Н2l$jv#bFce1":dׂe \Xr+CiyL_X֮_%'k-NeYXl npmcz*u#ؑbAF*h51kPǭhclSbD3,n'-t{D>Ϫ- !V&
mֳڬ9C[QMl6VX`aճ8=FW{r!G:>EQh'rEGYclBƗq
lX;FFk0+'y<Y;A׿y[ORM~hohLQYbvҤSj<%4KD͊S
]iMm3QZT#w/9SԳN%FFF
C#?vMulXzF&45*VIjT@%k?6@M&vnح6vکk/(e~9ɻw@MTlm}f^ocvn~Z{P$06=DgԮj2d끕
ڨvH
I=0zd4 2_	WQ4=e?>z22$&eѴL,<{Q
R^m=ZygeoW-gPȇ#!8T3mQײ.b7i[BVL7c}	덺m%6/!߄PM!bZ
Syqu8?AiWr|PͿŎi(f:د
V:74.T}Ke>l"M[쇸&]BZ째&'Hbٯ_YUn
hFǬj X*GEK;Ғ
92+r64iڅ:&ō8(\;*KʺĕMTH;,PkJiOnvijdX<3n?T؋f8k^FD6fZg^m>u
|j[<U;&͔vj۪MJ6V#GXHChhQ*ϵxϷ	Ѳ0Ie@/T|pfQiRȄL>їi->+nJc;+`j2fx80L&?VYDjKCjP	sٶZKI>ZMx	h+NۆxSH.SPiOf,A&Sކf.%(NT^g|g,pMո-y䧱7Ąf݆jRE)]OɈAf\6\|O)]GU[<@']FsxF'R
켖di%J-rW-G-
{	rDZZNk~JPUfWV&3ZWn.7i]6	5D14TY<2ķa3Y@˭Zr}a+ rOp9?G
2&UۄqD*7_ZIF*Zc,WR~s^4DW~]oJvzfS$VKlru|3Tֈff2J,\*%0nz~oMfC;u9ݭd$r-~mѬ19jةvŤhnlSC]6̽Ww.#D9RE$XWbG6XW10xw}ۭMhyCݒ@m=|O
7QBl?3%qnn9.}O򧐓ș#Fcn"[WTş%En;?t/Xs1bni8l?b5p,VX\M7UE*ܳĔ3&Tn}ƐP'"y%bx*K)[*:'|~`TRqaw}q2Ȳ2 =cv/^(?k<5xAiI-*kk*18Z9Vu
KdD_1сXi<[7\*2Q"cpc7Zؚ䶂ΑA~<2+BAg22;?d0:rۮFDY;Pͳ4ff!c dhrCB6jSH~C-;''C&D"v^0ѭ	:]nOi)f!-2Q]Zs4yvnG<\Sd5bp nw2 KEˠrå)#Rf䀋,Sd[`;׏'cZfq-NP-r,1T"xPٞ1*"bۨkWTIT־n5157QxgN6SMhrՇ#1CԸ'Z6XK.1e%	4QGI7Qaqkka47D:U%ϧ,1Y-:|RI8թOGj"J-1MLG#UW'ڏR3DS8qriYbw<.qzCW&jd8D8t'E ̵H:چ* 8015\[ħxO90dzG_XK{^0:TqB9Jbe}[yjCYT%%Egulm	jT|{?^J2B>F؄Ud	Ia_QG$ea%TF5%"d-L)rݺhܢkEI#S,铩z4
#؆dgK$IZ$aH4QCf&(*P==ze7Kv=pvicb̐Y%{/ȕa7&fJ3XR…̶9 q"evtpx[ wd^nũr<GZrOv)
"PRDSC-KNvWoGy0P\h԰?"")GyAӃtk
hKhOVGXK2Y97XK
YD,K9<'ɉ$'J*icW밸Э6-MY/Qe]~i/Ćh,\7#\;SΦ0$hv"B@]ĀFݒ;Hu(ӒVj#
ǒ{#Gpm2Ry;qN-'ɮJ%(JݹA'䓆|؁9	'n4)ѸL_	ڗi|.O&?הhR-|{.K]#4-ϼ&_7Dox PppԺQq6(& fn2g;?WM?͒pΐ&GX\-@B}O/63g[e$ѩvי
T=C0ÑݧK97។/*bc5UCmn\5-;\ٿ;<;weP'3l5yͲi(|'Cl_ă
UHvńJA)KخZ,<[h54I7\Q"7h%O)eZZ
.@GPPѬ4,SRbQRj]Kt}sU=':&uV9IAz6tg[ô9]кYZw-o⮙ghY	>peCU>zcOrStSǛZ6t۟1t¸
R
IKM-GZbS
cSWT]SF16k-(m-}6QS\S;:="^Gjc,X'̦,1bdEh
k,82S_"1C(G ~J,m6ɆMԣ[(Q)	6/=h=Ҧke]N@.SQ+HY@]6|֦S
=U`FB:6O;QQEhh.9"NS''[)tt2B㦣1-mVe_cq<7'=2i2sҖ!
[[VwKڊv$Cpe bt">4A7a\hQkEQmBΘ|B'5VZ,Vk`j!mjg &jąVM0렷Z@&J]`ij)Qnʎ.E6sh%χvv{`r%~tOSՆKЮkhMG+ubik7آd93Iz!na5h7Ydcנji>MeRv!ZcjwyَbH;gkN_b8vSp)pԾSu⋴loەS1&SX.uuڨO/ބkT(sJ_|X=>å#m'-)c3A9I%
%IppvŁʨ!/h0jgC(_dh/[+ګ-/Q)颺T_iįWQY:`h\y[!5!d޹\igXڻ{jwM	RszY)Xڇq6.3cKDT[ٝ5pM[O>׾0/-?۱I*pF|O\Q:>`s
,k巶s{eq3Xڷ5I
V#:.Ґt5ڄyJ*J'0ysYFdj?!5%T3srSEMB~\N3&گᄒʉF8:ә
]X$%2h,Pg{8MLD1*Sх{jna%T3]RfX`M3p3\(,Zaz7Cn=.yE;)z/ռҊ9s'-\> 5aTدLg3#K
}>Y`}O2Z<}&"hL}ٸPKpaN6]FĒ;H6ʛ0>=b&h	0u%t6{9>ǩ`"5DBĊ7l'Z|>yrĹ*qX	NH	6]^jӈәEe}H|Sʾn
g鳆5aO(Mj賑7Ç$8פiI>~3	hI"bi/؟4Ur{niK$a0Ups(E BZ;{&_V'茌U;b0ul*|!i+\(;ťd]ú{yNNگv.1c-/B'a]_SpbAE Y\`'HfKlJ;~=>Iu\jݟSawG^CHfDR(G1*>oݑbSrطDQ۩ASv)lxvu7^E|\XyELGW<(87=1aW
UwzFywJ{hIѦ
c$`hC+
ʗٙR^C!Q8@.'T8$`tvjfHTmZHeptդ㣉h>k>O_krd(FQLN+Һ'?%W;Z$5DQ/_BJqu06{d$QukiW
:Rcp:j0GP*
kG=:bp[".q2	/&HĽt(~G^WsAjzi
,3D+3,~2$R!_NbNE8N~؄b1jQЎgI_E-nѽGBtkǟ׵(isO&ʝc6פEkV倥($(mNNFNzM3[A6xdRu9e.}pQ(r.GV:Zʇw*`3=o&DGyb	I#2
.nyi?%`3ZNv>7Y>O%álE4͘Tcׁnv=x,Mc=L1#!08	:
gt66hP	tU1Uq6]7EHTɵv.8w8%Jb>En(BUi>MP_wu:HOq;FC]qf:	G"YF	+xk` s{Ǫtۨ	iHX'i=];Sr1Mu6;M>殪8T`يg8864Aʞ4
dN&d3G3j'tFnҍ3[͙
91#1c=elQv]h#q)ZdWz2#|#Iz'S&HB]"y,Nvkp8B(So!g[pU)!,gHqϸѸ0n[[d_.,S~Tq4jShoSoݐC[3D3Qrϸø0KVm?0Euߣ!Ge-r ZGt
>s0H@z(0R@Ƞ3>|WEpz߳A/87(.D|?_y\4,a9
Vb%0Q=Kaz^WfآyOc'}_=gUczX'&᳄F*C	}VVGO™`)R@g~N`{RvɬЫ9ٯ99ld&sw@&1yј8Lcr&rNf퀊0/`,͒;,m~v턥; yu v|?}~V{L"Uo'\.M?k1}|;L߁v];]^xv&,:0iz!@,
\J+0 %.e;x\x%!k_JKo(4A@|{X]zi,.k/҉1hQ?W)RJpOa]m
@*d"Zox jsݲۣ닉gnSumӭUl0fsY\?3/ѫ4l)Ic4P74^в5IG#b^	آnWsRD<-A:SST++w&xa|!3oww$b|ß=9 -3yo4U_$aCP=w'3v0_vkb!,iH#p7ÒېuގDzֹk̨݅n$ݏ7i`5X§J
ĉ_M6vt;^FdG蹝M8&ӣ++kb[){މQ-jb9%g
py\yʟ'R8)<~	p6ʊs5IBU6{H=/G8:+Z+ЗIj#~_`:ns(!S4obU.`G{ha`Կ-ov'`0Y1z7wt	==s6l9*]ml'.vm<^lb!N=Ķ6nb;6,բ0{p^CBc,Ld4^HkX7yv9u{>q#&6KsϫHo"#}'vқسp\Y/SWAe65bDvUdR"||tfY?e4v&OG^LГ_w?ߔOOyE=ez66E]=d!ߑ9~Yg8zuOdB<_
=a&|z#'qv?r_QͅC$NagULǹp;῎Y*u;ϻYOMgv?K9`Oօ=2K,׃y#|~ʲԞ\p|0H@Ȕ5vmtv6FFAv$zD=ǰ&
XBG_nc\_a&{\>W@PzBKR5݀x㘇Զ~(D"vyuA?}rz\T){qJD<{f:RA|,hboܧ5	H};Dse>7t;z|U6Q`%]zI~莟
|n{w%|cˡ#~ȢuBW1ޯw%oi:7}A|z_h\|XOOW
&aƧ*(]@ReLO.OaFn^}^!Y?3g\?WύyMFXK7Jz~׈9>l.3Ȧf4@6+pdui6z6pzϡg_yE&޳r6M6	O?Vzְ	 ܀G{0Y.{WXnFx#xJmðw]`Mp$dkFNד~?JQnI2@"M>x&NaPT}%.l56C)G#T`v,JEnZB|nz;a?4<a /ӟ=q }{~&"PÝMɣ/v
O'}#AK
Mw,En0$6	qg/>d8eN[k
f*okz5qJD^9;N (2L` DiW$iܚ/%KA:|9]nħM;E'z$k,0Z	QKXla*Qh>\S*hV|[=]_KgvEoJW+mTx9v1n?~gN#wL.hU_Y^p|U[ӑ=tdB3r9x졯_otvJ
_D|p;
?p5oid/}@rP6:t][ZPLv}78VʷmlE27fN"=lo4we9iإmnFq^e#z@lB\5E*Q
=؍[v;\;]kd[DxȼC2/	P_4-ZAʯ80;t'+R:TSCVj.fY^W;X}i;^P'S׊t*e&.YcZ?Rha~=%;sUd/+Yzw\/wh̀?Yn[jYfsퟰin-?vhA+t.
G`<7{pmq?G\=K6A{?š^4@Mq=dO}
D|ŞC3y4^BseuϬ{
%V߄2ya>I"ZaOtwZ_	HI%	#G-WMԃp$ @5V2!%PudC8Ydg$o=sT`y{8M'4J"oro:{휫|]?xg,n5b8e.S*ǹJcUJd$*SG+SFD7]/=̩yѻy궬%c}}py~gB԰COL{F{=.s\Js\%J*4uʮʮv8K&hǣ%ӏJПkLWl=E<jȳ5G+wpJF8BU:Vl"TqYzboyM"Z)
󕁧YZ^)FYCbf蟥byt·&QRBopk[˦lT6DJ]ЛmLRfWiNy[>+|f|;D8)XdkXcScIsjFwQC' Y*Z	ܚ)B62z(k@c,]eٲm
!MbZ5[=߂

Hs`IP"P

EEm)m7}So餾Ezd!EQ	S1u~ARA
Sajjۉ-lwlnbCO䗂JX`nX~+tٵ.r6r#s<7JNCBOlu"_w5?	]ڍlB8y8o+Wevh{3Ɲ]~ЇGTFۛ}0]P듕11fb${f{@{W4|n{UTg?G.}N<^,/-0T%Sh8&YL)1jӭۖfq7:!fP3u{a<P!y68?p]uXHx"V^UDxWa;<{cDbEStc1C>1M6\ߊD%&\߯p!yE؉0Kv[/@ewm>#!>B!QO|dOІuqwQ>]?9C&rt[[`khIQΐ8ţ|M? O<
!hn-_
		8Bb<S9NϠPO(_$
b-,i{8gCH]ԑ;Q菖}a
Y\Pg+\mIf>E#$9C+sɓ"9vyD~XES;7G^|v޵3
Պ\)Fkp	e2Ζ2F3*qN'QT2N	*cI)tf0HeP=anڽ`#uP(ag/F|8[x
vYYLG\nj8rJZcCQe]YMvKřa4`[R%K'i"4)7F%R %{͕*eO?)2v*Jڻ,kB;H]Y2G]GQf2)r&<'"Y2#7Oy4I9Ly17qDr r!V"c7n=,4Cy^>He}+:_Egn4)yOх]`эXѓOY|W|˯?[!1(rb(ߡ!(GQhQ$ƈX1+v]*L	YObSJ˻`OԷ(	OC
DFTnA&?
EJ],IK?X/WXS0eor 1ɕR4A8rP+,"YץK3!By;l}Ht7Fg=YSWE"X+0`e
J3w#LB
?>s?"PgsO|Q$M䵩{<>*a
>/[5^
29nF2M26R4qFQFʨ)c9eȩY*ܤQakhʙ	h0sjA9'9r"eMW1
\yXg*^-:Qcb9_%WzID.OX_'8SY8Gd@grq>qX..Qq8M\)6u=>UۡTEnpgL鯡Ia:H>*z&2ͨcbJ@buPDyIp\	KMo9?Lo{0cِlCH&URoWAoPkȅK1X;ȵ.w0'dߖ4E[]`Od
,VI!'9=ƘV=֪Ѷ"B|i3v˿r,M19ytF5Խmv-GA_^F/1Keq~<^oҾ,=rX%XYSŢ*$*N!˽{{h=)?JUf>|Y;?vʯvXE	(E(B
nzzu]ЙHw߻䏻4X{aT?I>Y<CpxiMɆ]Rf=ȹaWXxM}
xsq@Q8ƱpҲTXi~2}O:ydST*?BF%cLhߧNpRC@<J1cK-C'HJ8nSHqx,Ɣ;1bwww]AڑӞ=C8@2NO'CԐ*?Ln?@
Bnp6rITrlkҠISȏݴ۠jpfLJ;v̀JqJL_A֙v%YFLߪUm>|l?mdzR_CzϷ!G
S8bo2
U9#cK0]ī0_`xoj{x[Q"TuW✿#KP~9B_KCpN,r]nx&cNj7śV{.迡0`(s
􁔄2rrhZYeZ![hUI, ZEQѶcW%Fk$癩G~wtr;}t`}0*V'y}ǝ/N||~UU4Ei I_cyNi}z_b}z_B}dkCl݉ֆ:1ن91٦x.ڡ,Hb'* k|Fd%qm#]7[6{?>7BO|)o6Y{#mlY;	OYEl#d㢪Nr]wyB;t!@EY'Sۛ-"/ k6/o6jFV6OP^]=2`呎\dFf7iǔ)eWKl`6[_ߤM h]6PҺ#L,E&MnJIo3Ob*Z92Y6Kxӎ'z64N(QE:m]o D626vzQ&mN0 22Mڢ"L'ƭfE9{@>zU,|x
Eoѓ;U]$_%?.#:?QƉ_Z=G2/6H
.&l>Hy]	Lx%{»/{÷ݟuH9-1V,qr&Ƞ qC8ASYgs*U	Y;/2؃h7^RFub%ɎvښӑH@&H9I\)H.8^V
˻CVRվmL;YhȌC62lVà.h{6iuߚ/Ѿ*+pKOl-BgY
ir:e+gE8y󦟧A'#^gi)'o7D xsKxd)vHs\_O,^
<]wDp)q[fcvUq4}
yt\C"ȑP
(`\
25i"X*U:اKu)FbXRqUh0AWT
AHSQڽZz'@TlOwM\(OScviR2ڜlpPVYkp[!l.p\
dujo,ZS91K!G"9No*P"}Dp>fGX3'/f%4qI^nkGORr̓si.`EU\^R\SF'3gft.p)CIF"Zx2ZyR=Y%_s:oJ
>m#8f"GC\|"Eo6i[DX5RFT'hЧB}]]mS6cPꖽvn^mFW;Tɋxzzed)‘7j:#/h9-G{
ޕN*t=Fo`hdK(+|{ 
BHlvb%
	atAʨҎvjkRm}VGHX
hk[ojJL9?-Lr߻{s=;?$J~Dj
)	]^'~	P;0Fr'=2&%S/{v<"A'Q;GlN[<#*{}'~RZ|j-?@-o?q);ɵGW`Pp\l\ò9v} tcp<HE~p[x&q~lz7~e
F;%/'aF|3輻mcٜÌ	󤻢u%̯1!C9|Avy^a"҃_NVѼ	/?Bsz"r=Wv$'ddx]c#ټCHxV_ 3Vc&*S?
^<
O;iKl4/4
a7)Tr6MERѢTtWkLHީo^/'! vy]
L›D܄;IlJ=I>LOV21G[փpnCG
i13fL
M/2Q\kbx&3{i}0'cG*%A~l8iZ;X$z&/T;c7F,N3Hv&ZsV,]1]Uo%m΃e-daI?!AԿZCt
){Җ479F_߲\.z-0>[a	-_I:rDxx%uӷ;o+ڞfs͚ƛ;?ݜ	3j$jhC5S)36
j,?p0	}IΙZ!
B3\zslzp6;ejz5x;e0d
N$@ԃ6Y0,!3F041&cg9nC,a13ͺ/tH0N9J#ZJ{tTG ,m%x[kGpһj[s4h#i3T\vx*λ778}[.fRRZsx䠡yT`p[R#H
c2Ixz0u
z*ڙP~@g
*_bQFes+Ēxb'
O<'	_A^&i8"4pSw~܀;qWpD,(HLP@Va6TV8R5.W`JwɰYM;TܥNm*
ws5	vjP1UVSwj*R‹j:Lץ$I3m4sANg̫o|J6}BCRVam?$6I
p=T46jeI{-fm3 FGGⵐ,vnN%p;A	Fuq?qz$`&Yno>J/'hŏ_A֔c|{CATaQz|O[g86,b]aQur's=J@t^i.291f/^ƭsֹɤS+6_ZEƂUE-!=|4
`6|⛰߂N|VXU e"L/
ur	ޤnEGT!I'(DqJPp4^G/:KE#	
7۳2lF%fUY-fg$a	rޭ=>{?PKKY\com/pyjavabridge/util/PKIY\*|/com/pyjavabridge/util/EntityGoneException.classJ@iZ-(͛`R^+o%$%و},OgWAA0?,
Ez"82).V[1WKKFgNo֤pa]`*YsVӢPIkL̲+PnLշ2+Y&\/1wODjYx/3ֹ$7ĩk"^;//WV!8 {띛ÖF߳v|PKIY\}Q0M	(com/pyjavabridge/util/DebugManager.class]SUB*چ6Um%B$dI=aDBgtZx~Q@ ^dg~3GBhB@CPG3Z"{|KǟfDV2!gM
]RU"w
i!C!]Ct2\9JZt:-ؖi|%rd0[>%Iba߆.D5tYԔN6ryiD_&AϩZׄ6 C~+s9Je:㚲kEJ4cTZ)a:J8c7HhHasiQ`|9t1
:&1= *n/vmwg]7:NxKxRG-;TECC[^H|RԢ:aJCv"JuO}$ʼ(rːZ9riif>1qV@Cai; fu+!3L&7bz%޼@p1ӄP\׃aa1bGp&culjؤpq)m7_i5'ɰ]zn@
Z샽d0g؇D<@08%#F}Ko>\B=? 2ys!E}>67`Z؄pEX*R\YM-Z6E&e傂
֕D-8j.yA]ǣ8"U9#
6EV\vB%#*mP5әEg3Nv36Nn^1&ș
\ĥqj/kZin#19נ4R]LI(jJVF#q56/>B5:3h>-(S8B$QdT^zAiqye5^EhyVRNKZJ0eEL1ёFCNc4bqjGixR/MtSѠt	SQg`SRW<H">;ʢi.$2*uHq@eՈKjx(5
/E
DP"b]JC\@RqZ2e:KB[8)3H>Od4a`[@[Aԁṁ(){zQ,*&rAQǜ2QR:%Qy‰
Eڣ^-:m5hd <Ő֦5}LF[d֠PvCwdS=dٲR)NJL a
))uT6ҍtAJgb`<mHۥ`@@ r)[I	"AB`,BT2{η>ӽ}(F@1%,EߠAYl1"pvh#;C/‡G xpMӆP;!zԠqO[$2"~̌&ӞKAY#@b_/AOLFԵ(ʶξM{lnzٲ=óxؚ|؏mɇ{Y&׸+IM/$7[=^fЋ]j(+h gn7A7}Sh(\jKlgAߑVGZAXz7vm\/sw@K
rGX
E=S~F?[hDuaҠ_ѯ=Y$['codQZI=.,2ID5?1"l_joޑUԗZa?;nKOe22	ׅ]Vse@8&LkOO+Tt=,@
5T,vȒPgW8؈G..uva/ڍX
G1.[if^F#zdžٜd@~iJ2ёJWIy糏)4VDvv,]j͏3[Mmkz&OXOZ_fO6x\>u@w88к#펴y:O3x:6Dݎzъ)p8LOgT>)qBaEkq9r7I[h$KW?LbT#DX:&T	,.x]ZB#		HRDԹΕV{mq(BK#sCdjru^0R2ۣNQ"(Bx$X`EMP' X"D,x>_ .d,
-Iy^ƕNE_|!/gV4q5#6,&+y97)Yae*$^%s/ܼFjf*H(%yvI
drDhk
^'tV[-:x=fpۇ:6Kr]:eaCRSCIq3j$18]VqCEWsJ 6naapHbVކm_XfT1Ո2[qQ?_NjYYH+eN:_VS)RDT.rRfqUnʋO;їS=+
6NX=Q쪕K,YJv;a5pFu6s.Jnt@ORY=BC0!
.@W.i#`l-
0y5K6a'&py&1A'ne:D*rN"ma|D65!s]U}Pt~$Q[h\Ú"D::N)3ў3+<cM,9{RC2|
I}_2L ReRmUrhЍ܌*?BYmH=MZ`jt/*Jz[`w
=l3?i(ג̥][[enܰvyCâ:/dyXyq9e`ꗐj4YN b`*V5z	hRMHbph8Kz{ydgݒΙFC5Uid6g\y;ԛv_
(XB$ǩXp/7ĩ-i%}J{Ey),<;1cK1"T(ꡗhGd=5,ZvYâQ=ː*3:f婘s5^/jmAyUd
BBq٠#>>ڑΌW'a%JXEu*[*oZq3J<
}S2+=Qz4)0w8uX1+!MG0=s{^5H=w7vh\:6nJ6'Nu$bp?$s7ԍ.IB2x-p2c"֋Ի/1SɑvkE
L8
Yzԫ7* ynW˕o0fK'ìH>etoT8^.-8iz&u7I8hƙo2YI?Jl8V5`eBJlvZKC,RUI@;D,eY{3d[KK,R%P#C`yhnZMQ
}V/)	B+v!\rY}| k/x/;8KY\dM\@ȡI\$Ij`:3]jt4gee#8t!|k.Mz_TT4t, R!̥"a~/bkW2že wA:#[.zQ*L:-V0tFNO^QWۧGRyQlȂ#ZP\B**ȪZ2FF[=(^{1v,zq;=C}.]BOjMhW^m=m}Mv'k^:}W}UH$stD{^~@/i?ڛ}m,WS5g}9^wn8Sgy7EE;YgQ=rCr+D%p#Ki|^̹ $.=r4;B
!>:h<$y}PMT/#Lv4BD9I4x
dz*>Lq$9)x
f
z'	iSRm8WeK.h"^YrK.)|%bؚ-K.-Vlv`Sb6dE@^h
lHi˯W
R\)Hq ŕW
R\)Hq ŕW
ŕ,$ҮD:TXl1a\ԒojwTKV],w|cu^j9րsX}ujsvFgT,t"Đ,Y/c̠ZQ([չ瀮euhvQ[RK`uK־Zz&=&KuY9Ck^/70ciqKţKW|CqprũZjqjũZjqjZj?jN[Qyqx?v(tꯒi'G@2q)L@2q)L@!P!S& ҏ%{?+I'q	̊Gೀ9EG}F8B=TPqzjS|ZOG,{EfaU]czTYhzd6|7,4Ѽ
ܦieY6ZDê44tO$;a7$zk
]гl=[cu=4z?w#uH;EYyu#o
xEͪՕɮYl]Sm4tʍtS6eON[YbL#{Ymjj?YYo2A+.z8'Itq;1^nf[1G÷lށ	'9qT}BuGz1eߍN҂9~nK4bw
r^

r8LU@hd'DLѨTq1ӔeoKD1X\*VR/%Fz\uJ4NrAي8Er#GIx=
ؗO-6k|*mv
Mi#Q{dd
CtS WHL*,$$G-2"8dz,BKٓrBgO'm/Ӹʹ*ZgP;n[{az}Q}4ARGR<"V∸LiWN*~|$-VC)&HCvǘN	M۩\4cCOØW|H-47#/`h~)=!X)Xp
W2RAiT&T$/LFļ(?U5u*tGBW/m8J
TDu"tہm
Š{3tݲTH|>bK^JM|!xut55}/񥴓WГ|=ǫop}_Ulh
k^i5#\t5Tr5Z+=GUፔռ7T
܇A{JXM)JYOc4	Ύ|J`N1wZ2dD!a+oBc6GPT(4T!90®C
qʯL¡.B\v-r,s®A5l,]b2tųK\O񽄟Qx ɩRD;jdRHVTU	Ct(qMb*2ƃNUdLNREFF{^,6t-˜,*foN"l:@?Qc^.ONU!^oc,43 oS/Otk@^k/@7&8Dm#+oWBb{: ;SHCY[+?V	'?Kr)}wwA.GƬDИIqc!pZ-6pѰ=jdx%s.&ÖJ4,@aRVJVV?uN|/;oM>C..{~cIЙeϒqo}W%o/Wy
q^pK6ހ1T!ht6N|!)eAS/{4GRs8P.1W'Q%㻅Ʈ׉OqfyqK=߭>?>?>⯄ /œ&nw)ϊd?PKIY\R'u,com/pyjavabridge/util/NonLivingSpawner.classuPN1
ICHA?t }rr'/pFQ;$ݙ~|(CpJBebmĭ^k[jbgS0V\
At,D.:'<NɠE
:tb_9'&d#lVb̵^T&:GZ65b;mJ476!20Yw(= b/PKIY\Y/K(com/pyjavabridge/util/CallableTask.class]MJA_QqpY1 5m:vzLOЫ*څkS}ԣ_8..l2%oBL77=^y+NaQKv;8VK6wn@1(
R!͠IY}isr:s-NAev|8z`ob
VdTO`&Nߤ+,@\V4.9IԶ1EXl`R,TL:,ZgU|5N2Bp9-ۣ4%
5X)Xz3Nt5ֶNfب9VHVPޭ7jNE6@kPo`:$l/ٕHy&ES罽T&/`]Q&DO^
WBlt7'6h~	z^6)4.p-9:W'Ղqz);V\c`B)OdehN؂h:֔K{5#؅ZZRVr{1taS=`~bO$"Z
*uo$3cD1>Ca?:.=)X<qeoħ^oa4
o›iAsi~\xySQ.nP5~|-L|ݎezs03Я7T#]
aiA0bMb
hvد]er]2Wh8fn.FfmfzҖC19nk8}vAke331xw&hqw*,fKN|{q%ך|}Qx!Lv_Jv&}e`ˊg;`)1DhZ&\&m*K5)TO'S
Ѩ2Ĭ.[L4%^-
+ e
I[>_O£x9uycKZbN; L[M-ǰGteWPz
Ic*V6F^5[8F
)ʹ3x
K_d,{>Q[{ξ\Ky"+9[wko(|*4d{Mv3IGx[TXhMeۧW]S>~P2tr:ru](v¡9H	!SH~MEyu?SQ,gmc_*
ǓTb	_&W[g^lzMgR/h7"(	iУ̟qOӆDj2%zJMHe$bTp=K*T,[rf\ڶpy[;Zn1UZf:gL8u2n7lac_JƄ՞천fFHumNJ'KkЫ&O?4NDkEEgi9}
H{1.a8M♺fB&F1iM?{ՠyЀ55`y?-8+q
VFDE9=܌MM9͋İ

N3&sN(7j,M0moe]mH&ljݠ}&pnR&PfY[&MI1 Ӑ]l>d7kN	:9y@ޠukZm{ )Q{kENw0	Q9mHM"V
w&	_e7z6/32Bb@Tl9KZy|[#™ق!uq(8|F}so,HH-+^{UqؚӈA0>h,o_{u\4^zuE]C8åSУ+`l#~(QCk	@k!``@2IlQFp[7Hx!-|PY{o(U씿b5)U|Zl-UUeU*`PU5''w@C4?6ĨYLk|TG12'G6O`a3/޷x"a󥾋O2>bvKQeXZq9.&lj4!aԡ<9ɓ}W>l&|
F#$q5ۊ/|D5.anـق=RVكvه}b:饋!Y&
~xdF%Ge,g߅gd\0N%R'qIՒ@eZcc
GQxr%-%yz#KXRQ	AͥZ#8*d<mQװ,`Uo2qVC?o?%NBY-l oջ-}#A'8?NQ`F>T,[/pP?GF5aL	hŷY#m_7!Jng5#bՇ·Gz(~ؾ)b?=UH&~bѩ`guvx#)@=1<")D=uΖ(QٗP>;!<Ȓ|>!A-,ǖTY<ЩwX0c02k>|nud`1,X\l22olë?t{102񿌿p+N"NєGlluutoeSޔS0kɾ~V,>DUr}YN`Gb>e:0*f#}?чݞٍ5?!*Hc\J惺'Z`dȬbUk/b,A;U`^$V~}!F"܅=oc{U26~?LcOЖeQG(vlbQKB6SHbcSs
_EVPMҏptiW.;H
mmy>"x{x0}c`-#oizX8#:K̲!Y~c
ډ]-4;c*3iz'|4{p	(8-s+]Z)(D/54$sw!(
+TK^0S<${>>f#aߖLo#e]w;P{dCD^O&4`C<`_bdO8yOͰn	'm?i2p<*cA\)61
+G}?7pouEfzRY)р
-+'_A=!wK?PKKY\python/PKKY\4iapython/bridge.pyikܶŸ[)WR~0Wvٓ
%;7%g;) p8/\rڮXY=5dSЋsR׻}xE uz&X/!գGtUÚ1%um\*/8i?rVW˜nSߠnh`UtɭgM2e;$9K-UPWEJ+*IXВk~~0҆4 ~kuYf3/IyZԓ`lo`.-)UHDd7y+ G*`%?ѕW`IIf";闫$%m
A"%n(2(7UEPI*XCK(|tAVU鮭pWo.Os!6i[̷NpJt=2+'4?Walo֒6-`č,i
PqtEXqRy@mZV%]{Uv‰"CH9ihAQr녎d|g!AK~CglCIn(Qo)11ftR@*g&
Kk#|<]DI%{ywEN
"=ހ{
%!ںI(C2*'ܰASRoɥ%s7K%f(JȌ-NnjvMsγڎ	GD"m%%k.zkڤ;Ҝ6((HV-)y[5%sf+Jlybf涥B*@juxj|:n8Ȟ:5c&Ύdu
b<֑V ޓI_"71r]F籭iuJX/D9DERk$_]l/hHc5bΈa,V(c"ӈ"91"aσtWyRf9K.+鼰S@//hJF:'}'FjS될X<ǹcwA!=4x%g\r&W#5M53ܽ!nZAɣmQ$q~U6uESfX~l@אr)[JyY+4ٺ4XmӨmptVm
R* 6ذm~ZK{PݱfimIQwP9+>Kݫ^+:l*{E5ڌ(3ryD!R3`8gTc}*ĻTtiOWǫ|J/LʪӏΜla|l7B_Dxⷉ!%}pR{~LAi6gXV4UgxgylB5>`&K.Qvx¼_n7ph3&D&/sB֟rY|D7c펏7#E]㫷\[P~xՋ}LKcˆ]b;ٷFxË%	G1g>قZmRkX=F:W86q{D]h$߿}%I6Ϙ}O;q	=AkDNtF\xPBfs [ߔ*>5)dDnvɥ}1#$~\FG'׃E'$wןi:$Bn=NxvpN'7W3Ih6g8Uwff\w0^PNb2Q톗Ӆ#K81j	&$BGGli5A/YN8=(XwJjiNE(!"EbAUkq

]~fIbzuЋd(6s6m̤%9ﰍ<	"mJwatY;!M'ƆAP=9U7"'hyl`թUXfmѝ?ݓ`,|v؏\@r|,immPˍڑ}PJA6eo|S#O_ZRlG;:Įp2VB@3|Rw&4d3ٙ;*or!fWy9ՕՉT>()ֳ'B^պo@NvaR֡KCޛ4I}=핹
O:*3F<5Xy{e^oDLjMXi\zIKv/>PI&˹*Յ>4US5Mp+u|4UŪh3|2h"=hmB^Lll`%PKKY\񁶪python/runner.pyPj0+N6^>	.'-(A6ZVD6=kfwMf0؜!.}9TV]Lqv:hyo\:mО6GƜߤMu?%ˆn=v"/@yOq$W4_iSmG\HޤQ }PKKY\ħuuJpython/bridge.pyvG
STAXR/ciJmNk;l[.
]U 	jx_{n,gJ28G"P9/e$M)$((]:bU=x0GzWj;ӼN(z.y>Gы_CEEӴ,"X#U~w٫tUt1|EPPeyV>/,A3ĪZgZLjgUL/3ˍ-7VlϪXe&eZ_C90HU
#'*G[U66zza>#A??7yS|H ^AO 0'EeV|1DƣC?Q*HN  aNJjWχh>I-MtQh}#hR1TO.Ĭ:/@!X 5˫z.+R*Eݩ[
{Z244M+Is;ׄK9͵M^}>/>Zde7t/U<&]@qz	o
]ĩdxrbH~I.↖ޘc	FӘZnO0TjbTm
 551Fb_G0B,lQ5o0e^9Z8/[q2݆Qĉ/\4nA_^~
@3>z-[j0/e<4;F ^u%bha9<(9N64bp]NA
<!ĪJ팄%-y?݆dk\M\Q:\$L%R1~
h!Z/`11Xxrb(ɻQ{@c$=JbBI)hVj501{CUa1i9Y~%RƬE#YU"3,u!CP,4gl?2n#MSרҢjiK>-d-rijd鄅/{fldR}!AXQ%)m=Aړ
qb:H IQS(=]i跠#]exBǴ
lT8 ^ܑleR9Mh1VC{^FK)IG+O|Y(\!r4(DM{BQM>S>+X5(I ܗgTbnbU{
̖L]N	#geЭ&
%ﱀR	"ͫ
gMQdTM6bIK0ӈûM}iŪ*A@lA7[Ehp@l2ZX-rre1k*XUH5n]݂x'оӞXenRT`t	ٲؚ{Vj3).(p$6[Y&ek䬨,-/^H`fJ7hj^x&ip7kF4/%鵳njq.$6zt$X?l-~$vP bTa)'%=0лc)Xb&ЄY+Yj팖PU,x* 0`8g0+8OGh0:nA3
s3Q$C&vLbѵ	<@Ze*R09Rtʼn=+ڷ)DcL
!cE+*jwΨVQX7((eq2vҋaLz]WT
[xE**5H]V8rXo
bNU3޼JfY(ȦB:hk"vnZ
[+@ҳڳ#ls;yA^ү+N]j*Rsq7%52_hW"U~%nOKH ;4RpHЦ=DMzTW)tnu]j]MT\1{$}ҳX8D\_^ޤ|js2點"y3w_L=ԼvS$=շ쀑}jkRǸi
EV\1z^7VgҚWpWV+(tDԎd@ޞ.ނ!g<¿ɲyp8'4NŒy00MTa't^!N!~T
>Xy,tlrzl
)
iZ?{LNt,v<Ք^^wzD{P)iS\n$@~T{(bM\ϝӭEsW<@k)נ'8vGxӌ}5lqDE N*^Q':Z\jK0EeVrft4(]
2Q/u}4v^˝}2L']UX|pQ^"q3ЮѺpx%rgѡY`m`᳊R:
Y<+=ƒhmZ
482
G57`S6inXu1q_h	~XEXX>TGIk@Ck2éyd ߷Uwp/MQ "`2(9EF&6Un%bәzK\Bk<\or^rt٢OchG: L/^z0Dfc0.>t@IYC_v* ?VnX{n''_Mndeg|[&v1 pvhVԨ<,+jGZlw- ç^PT}!-=;PP.FvC#|@pH*<,aRDWb427<?YZtan^ٮ0ID$X$Qh&ǺeD5.wخ5 ЧPkRY\K0_qLe,rYbٙnx$@M-=y\/eja1+)0MN3:=KUrhc$izF'"kK0ٷT!.iEMCHTȵBF6ly
2l.HM<vQ҇!&%};Ol1I8/c$3i@`l)v>$,WۺV0hQ_Nb>QKuQ:!$=JabC϶5~@ۼ3fTԾ_!_oâq	cN[G5}vOP-m:Tg	Uv,}kZ]g[82hbUi6mUw5Zmmn	ܿ^W_K!:73G?1/;.żg 桺?Ft. -a\s<%O=L#H: xS` G*A1oҬZlع6" ux24fd#}j%yV2jZ=|`J}7OiԮ>sZWV_ive"Z,鵏tu.twK3R66-0~3opx.YVjnϊ@_Bf/񊺉C%^q]5i.U-%}Ah{T~Uek48s2&45H܀#Sr_2v;[	N?ݜKr)Nrc9k(F?L)G1?.2-V5e=`rZߺF$Q%Չl=2{[bZS@'>Ē3@| dv/'jߟ*?;~<9IN	)P0$y`
:B>yR%PN7o[.W!/"\ɑ`d&",CU"Bv}	QͻH3.jmYNQ>؟>:w15(hF,np,~&IDמbF< h/“_''ȸNbہg'NON6͓8d_+CM ;ƤmG!{&؁WW+pl")cJVgmA%D&CݗH4GQP'bAǝN|yI{)pƩSN>py:=cK+>r6tZhtdtRȎos-{Qc$_C$ڢXGb158G}u~SFY8:jw9pB܎){^ZqHXD}ZW~^#;zu\oy!'懟=
owxEcz; |XIv܎󼺉<.u:QDfmX<4xW/{Z݈\ڊߥf!\7tQig3rINI5EYG
Bۺ%IAg7(M7Vݪʷˌ9VbK7X9&տ6im1Rh~淴^-\nZ_e/
7#QeeF>+;_cFFnD
O7P
Eck?B+~dFN1cF@HX,Λ&3r酖',
[`=#xOޓ۾.`*D\eʢ#cI8x[-薡˜gabqZm=s'|
,b _f׼|_.VZ-tP2t)E	5%|	%@E`S:_D_IhTq#a:]G8
:,:Atoɢ
YZ
Ğ8=DE3s(%_Cu΅bw12J4 vLE:[E]zכTc16_36)v%ڦkH+nk3
e %؂Z\a^UTW<&kF$&RւыQK*ARUEFE3N>5QL Ǡ^.dxo$cYJ_h0bie"@e~L&{y{OWLU
M]O1Q-_׌UDk3ühkdP4_~L=!$490g ?¼4gܚy?sR U8hk8iG~<\%݉U|ICڗ05hoS"EHrSPft!d!:
C
@IyT
ԈɄIe_쭃bat
2w6i4jJ].IoݬuT,f]ok4ۘ(O66I1˴ib/&
c;K!w8&>Lv&,dd!й܇.4tE3|nQ%;+6ާ5DqlGT3?(FNˆCύSrpR!MXk%^Vu-׍)T	"")۳sίC"sE]=o`Ԥ)"#/ّ8Śarwg݇8'|3ms/ϧ@3#Χ*[	嫪yo-
{CfHzEȕr4uٮjcy?bvZ7}U;wc1}~60RX_'[P˱5,6c{2y	D)zޏNC3U9ݽ|Sm"Q>?SYiޅmsVPZL5g͌&15v=IMO_$V%}lȘn=arM+ߥwɍ2ֆX:O˙aڼ݋\:h)+f"g'lSgI=}\1z}Hlм}cnfs_8ad6ŅRB- 
h
	*.(
T=t^ZդuK3=<ՏρxZ+ƴ̘@Ӻ@="ߞ+ӄWP	;
,@cZ0+Q405N
9Kg)4.}ןK$&yMXџ¨ۇ
zwwc~|u5TE);6:
Y[r:f*p9m0lfRlny^lԯvkp	h-WN{J0ʟJ!5dsz'!R,㝷^1]}_!V.}N>}%"w!G|9Eq
*i}\qRŠ:Ao؛^XcV|ftpk7}o4JcvÒ$h:&*:}4\e}3|(҇# \B0?iMԕL!"nTr%dqP뇣蚖
aP<1~,r:NDdGCMuo-="$ԁF*5AhTezi2t3*+|د.$Xus}]0ZQZ4-g
ozógb(U]{"ZbwJD<÷qa-/Y,%[`$ByGخpT}7o:AW:jZlWmX\wx#v]'1joZEҞ0m[pJ#]6RbNBR!5Wf2dcijK"#h*Jf[,~OPD湞L
$BK+NP#
j!*5Pd{8Mm2l@R'MŵJh価O<˄UNz7ip,'?R{6<)<%QuQZ0yu΢<m./z";fjpxO\bޟG
GU&&o܀QMf^B
UrL/?8A| `ZcҺ ڣjW;(ʸ[GNz7F	[ƥ3QZBXrr?1}UC\SO*v&-]i4!z"h4Qo5c°p喙ț~FG e	@8F*ǽV@tJyǤ}/"aTɄ$,1K@AWzF4\l翩"֮0Hvv{`P{ԡ孳.]JWLasf)o'DLs;TACNK>Mɥ*RZpPP*{]LNИo1A/cܗ~ $Ȧr6MA,!ad&@Zrr:(@펼KBӻ
Bwjo F
pm]R+
CjIvUʠiץ6do͜ISU+yn1O!5Y@)b.NЪwqY W"tq"
՚S}g]
9Ch{p_J#\iX;ϊR$*Sx^,OĚZy	YT+(I0TB{AqsZP+od*:wr<-HYhowUvU
E2]Yt2dH?i@ʮu`/degb0.ʺ
,44S	J
˖EXaWf
K?ӫ4{z}E%Y%)Ц2;75f0$e/Z	v8[]%9
qz|ow~
]b)Q:}mj6̈́Nb
HcS0]5	8ŸŔ#ԑnӡ̀$@Qe}Lnw`
jP6+*W|}:î̆WfUYb?nb'BY'L8o;E%|NĄMy0!,J#+A%0jDXH_M,n,HXa9eK[I
ǒ4tJqIëݔx^NhxnjnU-JRG-u.4A|))eLB
ʞD%.mIp
-rO[}#^#4Ss}ʉz2‰+Z"c+drhGl h$xdsgd-u;I	}X}	]%$F
I\1hܙı]P[#j`EUJf'Rʹa>ي:2.Ѕ9]ٳ"ZN.RW^X3ޠʅh<|޿\.[
x{KXhmMd3aakΙ4dqoZl`ŗasML7^7	qx
<4vE?]2xP
~J9X$ԟȉEU;Ž;+3)XȯU
gKIt*v6s]`W1[z/{G,+zf^gym3Vc.
E=7&yǍffʇ3av	Ʃ$XW飵C9êO,chC~WHbpLFh;ЈnER['HȶEV.78'h4ǧPEnq "پPagIA$1-e[[ꓛKtJ']u	6cѣʺ=okX&RjD,b[dw 3quU.|[F(\)
Yli
n_VpƎbSϊkwlfJȸQ#x顆'9__TT	g"Qu[J?T

j>`^e;Y1h]7.%P魪5+}W'uu-ӤCxA>7{»4٬qFq:ݱ#Yۖ~fom53'IN06mN[&	LUu
PyShQvys
7[91-ɻ|HO68غ@::yZTf4`ݺ^~
XLX	)H.ԋDD_u|MhH3R,d6@ssxJګη\#߲b-&b#	3NF/?Fg0M/ݬtDm茢w04L14:t
Gd[.Euu$۷p{{1*+ =`^
Xi^.ɔʐ*e%3S&d妊M[d䘋jti{TEW% V%w;#dhHc敂GDP2T)U4$T&:$
Ih#Vv/6nd
nc*;Ww=oA"Ktv +nQ.3P	,z%oլN۩ OMŬLF^u@:1}`T(*t=
o
T7Sf!!TuA{g:l{ʾO	x e
oĈ\3ϵH(b7F-"q3X'J|_}m>o,m;ׅ%(odzGw$q_SY*+	3I#E;"}Pr4Ok#6lԞAjK٭8u<'$Ѿ"AiF\bR*ѽlbyY"Cr?uujpshL'D`zG-iޞ&75qBT?˭Lsq՗yjDpn;I2.r\2<9-g;H|z"(JIgѷG&9gY*7.EB8NRY䫬y4ɒi'q6Լm$pNfˊ+=qAg
 O$QwHWA*6e}F4.uE~>[8e2x?`A(`Dԅƈ9`rۣc܈y(ӻnw?%=0[/8zEE1tSbjY_
8ќՁMV!|,x_gro[j50o2>=xkSsMk|,s"7P
\!jSf~
MD*qx}=ÐOCێ@p`<>#v٧{Q=iFq6ddղh`Q{rĽDAşIua,69Af^YW$@NXjlcRe=6,HY"dUU钯x#v/WJAMmzD*lNo2~\<Z{
h1dE8ԙȵz@u:b9MVb]|t`T_%(榴+M+)<".ie|PDYByi`)8ϕ&+0Sz#ItfV{/lN1,_pV42IJǬ>`C拟~b)\->Ũ}xJ1]O?Yv׾6.BXZ㪙s30
;k6`Ĕٍn	c/+BdUP뷹1,l?]Dz%M^ǻWG_sd/4nL_qx؋wRŞ=d9Ph>gc@v[UJ脄:ߕw Y<[('ݬJC7T"(-DGgo޼sr	~Ya(tU>u٣N)C̒ءJfyibcR҇ݭHA@]!fz#B)hwaa&D1p9~[GrBMp]&|kDՋїo8nJ2w4$䊔X6"c
~;=pݺPZ@˲74PA8KWo$9~+,NΎw(UnFT}8
ϙ`Ҧ,1%3WUUPA]͉yiӳϰn}919y]+bެPX2'W^3
)]#ƞJvėȡmj\ªw`PU8slSO"X&(;+$TIب'gn8zKYO#^dfZUsߴЋŝ*>\#r.

[d;lU}+ATPQ+
S0ńǾVi̖ijx=B˖ċUܺm`S/c5_֢m5SW(VVm[NfR~tzyx{䏘>n"]hVO6Kgߙ;㝍xϙ(;ߣ
r4kfVx
mFxMKQ4~&.tLƣ|YQ28B4
NMKlGR.d+TRuAjӊ\FbMo)5Vf}"ʑ(n][k(cf3v~,4n5{Bʫ,{8Tn*UӜt 
m3*lE
+l-tQfUHV՞t!r-_$
"m]nj:ՐRlkF? 
(mSjVdYfRa
(R+v
i v^aySeJO<ŎZ|܏{(yg:qKZY|XWt&pAb*%+@7]7
̢;$T0}1mкTWv#/{ҚV$O]Q]z@&l yGY̹ٔPqO]tJq!gv
E/	ooСgv*EUg*[8òSH4~Lo!SRjKL0~&үتY>0O/;>mcN51O)oJX>fZ^)e955o;İ5z̚D=2+\S^7?vy eQM쏇/^;+]7Τv:E5WeQfYsdBd`c$(Bd"h@O[1[D!O5RNy*ƎLhp;%gY@f0'J}5LcCrQ}oaZ	|̴}HB֗<X:4^2x@9Kf	{_	XHh='0MI`oM;k\@R_9υu-&f"*P^P9=zYA"VqK[(x9Ws&%yBᥰ/O\Dz()f$A~3fw&ZjFhha6`FWVCtt!h,)VQN5H:ȨՋIZB7#Ѕˍ+2]V.O`pX떆/Fݵ=T
F%nk5J艅Qx~t݌1`Ю	QgH]F|}C^n0)` 
PM2E±y-T)?=n
:ٽ0x/ljy>9zw2dsb>"C0j!딴W[[*
vd(-(G(W{<^8qkYFhwho*(hB-h\6|]_p8U>^e:Ѿ\S<]sެ@i>j|_FSr%|/}O&E^hnML{8{#g&/`7GMKa@01~~9~m(FLGG6bF\4kϼ<ƜdaAcS.D[qB<;YA$gztrnNGⅰ-.quǭ6-PRLW_EO0ԃszg?o؟k
l{*ɮ@l?Ik1G~	_.^CQm=1/ǿ
08bZ<
k@BG`x%vi؏
,tT`n}5fk)1xFH_>`їz"z Uٓߛ]&G[Qj7ǹlӞk8CG৏ >pIm)j
U
@JBuL3`mAp4OshNA[5~.ln$I#__vy4}ު G2
1̆.&JQs?w4ȋW̉]h끉|pԱjhS!:Y9
ZRہ&QN$iONg;{zIoդ4V)Qa5 o
:<;2%WLo`glBr[ܶܭ.wkm-Gcb{(K'3x0e[~@ε-oZnp#ѱ6RnT\ZE֡fV k-%eOF;>vUMzwqӰcC.NL0bėEg[AiǮ=cԃr
2Aɽn]n:S/=C$~6:t&3`\mltO/ݩeXBX䮩&Z0'Exb
<]qrvx myZPg(@#`]
9Eib#r?te’b1yltdO̥0U%mac{^LȤ~%l]L~??!UUhn;j_X+&5yPM34f%3ǒ`EJ+F3_M!S"WݖӖ(-nWb&MXhwbH%IvJD8XJu?+
5r<\O0!ͮP+	Bi/OYE%&O.dbMƸu"O:f+:T/A()IxHd5:aS!Xf;m
Jo>@󐗇Y'=x7M1Kt@(4L-tjD42qU/&˃JdIq}\[%k)nfez3h7@M#?̕?4y嬧s~(*ʒ@G@O2!f:$wGD ]•NluQ
(7G2HR={YgG`Bje+AFq*zO`ξ(3>
Ḃ@{n9P|yYj(tGjcu 
ts.UwG$N.|yr&Rjuk?MxMfv3Êd#1DX 
FY6E_vGrQS`3yPdJXȨUdlϡ@59Aխjz,ǙGCRt+m0<0@XRD'yV,N]#Id9:Wf1U.4y# ȄD&D{$Ce&;oQ^wUqzAHש^jLT8o@?23lpܺi36{eTCOŰ.0K>=/ˇ&@9XsnjCH>\l}qN%+]Op`L*ن$:]ɟH2MY8#N0cWnPבzgdXCw^qW2#Wn𐫍7Pfy1/q9VZ:k̔
jx`Q|lMMaLr=mi!ZSxYTf{DB't4IgXm	
^WC
3l4˟(0r訬(g˼x?_GA@SP Q"M7(2[rA|mHM_bQIG̺ 3
9aʒܮ$_IM	HKМe9r.-nv)D
sb&0ި.xU*}훬2tO&$oƻ)1>2~t	?3
W`vF9A_adԆO2r&92l.!ߋ㖒@3GidV@6݃$e`e¨bOd1,B۩ZSDz%DuN&dX[cd~y,w :ފ/B)a߁cс||
A$\dP9 xv@%LI>?#qbRb3EjZ,)bd)#U59>oE0L$n$1=jt#LY5/Ql		!e!aHJxy^
Xt.1t#Y嘶Y:7hR%Au7~u"yŏm13<%-Љp6[B]K߸ Ġ{B~Z2
2Sd9Σ*c=^_/AؘFp M8Mr@DSlRĜ6!j4]S5QftBo}ߡz0~8£?4wCm-i1ÆJJi%8v橠;w\ȩw_v>GL.q<t١/1!W䇥fvo'=c(U%^ѡgYNB:(/UV{&UEHVЙ2:pd4Z`k֣!pHs_(z"4ktr$l2UOƨx\2&qN_@Eɰ0AUM~8DGevGoG kOܠVP3?,zMϟ
e8S;(4MAHXWy碤[DW߾^ G:mT8y5괺l֊!HfTkOQTS%L^
k7o"fK錢y~BL9<Q,߁e@svp=Z	QI&OiA&rXI>ͪB/",#(YL*z|(PEt[?i0;C-TX7a^`*r>7r8	ũ[(T:|ސ_̫A4T
o
7Yϧ.||'Q⊮ûSz81cݩ3hI.I-i
[䗰S|aDE"ϘcT-5~e6SmWC)}1W|iOM-<'BY;k
hnQwt%8)
v_iK'wErZ{e[H˨t_X9_!kSP(,"j}w-m0_2 X{aȆCA$E>}[ۡ^\(Jd"%"n8p+Jj
9fQ!ݷSpH&
vZMRyN^n9K)Zl
9Yi.KїRsq
nwW`@7[UuTq2CE|s>+i{|m]	ԍ3lt
ur9/TI9WF/[٦2nAmj<WF\/
~@v&`_39,魉5nJX61~Q7d^4Axam֘T^΀ٴ%-NddٵкT'9f`3uEILrI\,r9EUtX;oֹ=GW7$y1c9-d8N\v<]@t^͙`Hp
H)N&RXiRXnTI車PKKY\python/__pycache__/PKKY\x18.0ٌ)python/__pycache__/bridge.cpython-314.pycxu(@	)R	)Je[EezIE
	(yrṛ
	դ5Ӥ
Ӧ7mR`Bm6}eGs9O`AR">ݝ9sΙ3sfl,c_
=/,׌C/ϐ;?3ug-qK
[pqa[vΉvs㹇yq'㎸z;{ۑE")$^x)^ex-"^xW*^וx]_yuϩ`xG.>=^wdB/"b/!R/#r _IU俒Wj&_K_Gȿ=7HM俉Lo%mB$]俛dk{0}ޝN2 zwM'C֩uG[7
Ǵ$@ozVw=p'\#C^kSFL[6`$;J`TXŽ		a'	wF/B&:h3B	J݌Gw
݂P@W6Э U7lCh'A[(VE5:vG݉tth=;M`u:܇mAGh/ӽu/Bh.h BzB@uy!@7 Ѝ:	tڊP@7vmC9mA!t@p!ݪAyݦEmA!4LՖ8AۡyݩDh@w#t@A*hL}qVK#"]Ra!Q_}'LĞ4JnYr?ޟĿA_84se<-a68IЙRI0I%54$B_^Gx;QN̙fRWwr}R}@t?R'o8O'AS^	r2ޟ?C?+7>_'Io0-"Qq?6GWGy{-azؙ`ìbjIR]rOh9LmʏōlDq<In_d4??;kk(OZb!xNt	]~1i
cqܠ?;BCaP
. ]F0>zѿ_	11<EE!Byh4>4ahɸ|>qys9ǪwֶMKnec~(Q-Lo
AF4:{ђE(opxp(v0Lkn_xCOw$k$R)6*kVhul
2$.\)Z,"
J#jW㵀	J̉+@qxd^)o	ZɱD,.KՐPbqM)=R{Mǔ])DLV(sF[mj#?cI
Bچv7b=\
WC.DѠ ViLX##䅱Nn}}d>ny,>%9N-5KiȤ#WCC+<)A.SJESHb.ᮑ5XM(D܎c9?LQI{L/
 q%#P|P4"	(퓶*{}•M+tI[wT!"scx4৯.$m#G"֨8I'CaBI	"mhdy_Ḁ\5t"]	BbI[GtTlC#Hڻ[hX눏,yP`8Lj?d^G *
}QLZ;`2%B2#H.E$ Jtv1zt.1(!M1@4:|#Ã]0}PZdBaoSe,-gƭ%n9§֤vpE1*UȦؐ
zadGd/ɫ|wVW%wsֵoQ
C[IHcؓ>`B?vBԡ	Ey0)Lyأ j̳^6yam='[*&s:$Ge2YܫW&:	cxHro{{mWtA{8%G`L-G-XQMVc Y"(4btUKcsP1({7ΑړP鰡jN>9g
gbDi^rϻ_xyIERc+Ci%*:XƠyN_U|5o/^,N\!&/u4ס͟3ǻH>X\>3$FGF=F_şC]($s;Ow8j~NqFFPm#<UX9^tedF֞NÊH0%i	~X&za"}qQZ$*cE"@hxPd=p(3XDsMGzJrpq{
bcIN$kLae%]
{j߱P>̧hʉqDO:NMz6󞖶bŊb"j:j1l(A܋{: W!q0kFf*V˭r4q%G|ͯ!e[0iI/fmL-GJj\aܝƭM$MŖV/TB|Ҟm"ܵ8#o!ot	4Z8`SZ3~Τ0Ѓu]|9]\LrDbp*'=9-mT*&!!ɀW%+Zx
u	%An|Y3ъSgvfڹɋӝ83;6pN'RtXC6ìh#"SfYR=WR;SR;c_^UZ%uRp IK6Q2*Fo5753EJt闏ko>SF9;303adݲY_KFdfXѱ((;Qr0zv?/?0&1'j\,3¤,ѣE(ٟ0oLET۵oz_J|f?#KO$D)>&{AQMǐQ^?S~>FkzfRh0H{RD3ddztPzzw8œp?O\"%rUn([My^0a|%ʌ`&]~AbmbAbぉd^RMXz^f%p7nI䪻^9ޚi
oPJj!U[FEV;L.8pFp<@S>Q٥9XYN\Tb撶*Vڪ'LeIL$UY֞oJP'thw1woS-"_iտ(0tyRcBV*1rF+2AIp /7DPlxHaBLׅuF&0yQ2<~	^-fkt=hU3au5*67]sU3UG:zKgu~[jIkլ+B(sqțj_Z\rrѻJ'{ExUM㨐,6\z:qL"L 0Ty&{°tu)	ʓa\|Q{
UR*,_:Yg",[Nr3-Y&{vj&ij
e:vz6%zL
[b+=zQOg~Tz",ˮOѽ(tG+K@܈q2_ML
WYc}6*C'O`VVVN!);D#})&\y'4mu6c	|_M N:h"t2k?5.XTWFZtmKD:$%s9??ÞRP'L+ra1&BAHXLE!4_
&]/NBvo0o	` Hq!HVJyDҡ|0f¥^_$%ց偗|%[/;%O'"Sꃳ67͔l&JImhN%͒ykV*j)٣m1P?Wbm^`q@nD]Ӌ5	LFB ZA\+"#<2%NuBt/	M=NhBK3`.)c	HHr01W|
f'_m08{f5UUf5Zq/:NJQ譢ܸD'}'+LR{MI:C73kȪbլi`%G˳!kSQmew\tfifd\1俤DGd+~<6Iq&CEAd'CƘvɼIRAtAYT҅6tC!*ϗX
1@(]m6|.[cBc<1STRm7eWOu9pYZ9><[yg,^-UH\'ݥduýfW]VKpC;w`U$F$án'B<	7v.n
Yr$hyBrpjre#Uzy!XYe`	2լ.
ZnǦvj24]`5{n!r`\v
9BB>/!=gwqwoӭn~eٞiR֫VLWm"\i~NIs3o>jq.0e nsRCB)CoT{~&ZH>.	Gg\ eU±͹θNvϺ*~_4pz;
W>MrБ|,_k%/fn^"637]`
`3<7gL)H窩&qj@뙿NyDWj\9Ӝo-(EQj8i
rҌQv\:u-n"
_MӦtV]YvqEл"z2)JJkr)򼪷聺Z(H4YMSZpNWC-B
dhv
d-&Ph(Jn˗ [@.5$pz20]˫*utIEK$e*.A)-]/?]Mͤɗ	v	.CbF}f^l.
5Q_ìd<6"s&&mQWX3C(wG*bz\;3$oe:uxC]F.UD3:Azס@]3̭-i	4`5 o@j>SM85@?f{ز\Kq#O%[,
T0QJ4=DKNYHq+n-YE	{iص=dY[0aEgXK5AS.;L6PPoSS'%⿛
pcRDZnGBJ2Y{l(m2%n;II%$͌u5礼:Stq`-~B@M
,!'ނ৬2[K
JqMXM,b;*L#kռm̈[x{
wVXlrXluFXUX
0
۠6ٳCl`eeL}ljjP
O
Ua^a?TU?
*4EYUSM̮h{wH>t\߳<3SfHTp*lM$~N	DJ^04q	Wf%~
5Pz#_gaJά*~=I+38uN~*	ΕôռqrZ5yfkH|.)qNY~&Lk$iuix.#IHҚy֥y#x"Ik&itiً\|♊6{;t$ީ Gu$ޥ"n]|7?!S}ȸ~~7c؞Yb(Pɛr,!CYŦN>Tk
1ZpHѓմV|`+mFj#q'8|	랃m\*%tϰHbCCGZſjbKk|m*oX|j0}a+2,7a-<j~Cy3l?yusε7k'yj7<.AIy>--
+k?{'+7_qܬѧX.R^u
՜7;߲אgnn~ėNQ-Vl)3._Y²sf
=\ԙYa@
=D3[{Jbȍs3_Zs>_Ryd|uDdWu_IҖfg|=Zn3SAlel*~ڮI\g~&a|XaO.k-	kލ[:U*Zw2T6?v$fЊȻ5s:yqtS"Ay7/X:,>y#B2,P˟\&8_Pq11[9 FQn;4äS
Bc= Dݦ%&HNt:K
6,:lB5f})iK=ʼYƵ2pW$־JktieiB:T0:/nQmKP<
[4Ǽɜs$ȐM!r*?VDW$9Ls4Ѓ2\F2lwYU*\E<~<.Ѣznb!ـ}4Y$#W4d0tA;ytq؈ԽͽD3f	dlʄRQ/[d5@f)s)g}?K.6p	+ϘVWX@W_y{&+Q݅ߍ<]gsZbsaJ)5ӈ$PHg,O&KuM#VFsKA튚PUh ,˴* $OhqzpXuCG\J
cT:thBꤙ#drr:jC1c$=e1q4]wH%tjjvzn;Zק=]Ntc(FkObs-E.+Ԑ*H3޽*(eHkVG"E!y=L:(!v(:G$:+
3
7
<(
0vwJ(VƉS4cEC\d,vYS-:tƨ艡%=.6/Eы4J:1tl߶9U4su)Jg8#q;pkf5NG]/,kA1"̲fZ
E)W<6yvӹ<-Kl%q5sMTWҚ`QR5Vv_+!Jw.˦`=ҪN̰`In.^OUOKY1vꀛON︾	7?&9{ojތ5C~q4
fpəAА/g5UL^ky}O^V.bH3Y+lAxy/nuZ;
}$	q"5!ETHNAVScӥ	{$GrK͐YU	6˫o w0í4BbD
|РӽGfA"՞e'jAF$FT/
.x-1v
Nק+=r	'9|s\hj4t!i

bjqYB;&H0s.Sex(Q	\jwnqO]IeɅﴹOt+I RJp$hՌ' 3mp.+z()~>:Taߗ~ቃ?ϞHn|PqbxJH
{]jqp2=MK"->ڧ` ܇	tCmzqRoh;mc[:*T6-J?o'lS4|pM/ACDJtI¢EcT`}Nd^ҫ?*hNZKfl3XHekڭNbŚ1A'T|B쌲@A6+7+!%1sm$nYFy6π@Kv';N`d>a&A}P%8́fѡh@G?a6hĬl-˪e1+9hP9&rEޟ6z}zWM,iɾg/nJCj2od\J,OJ6uglHK>n1s8t0C?LyFM@XT:Z5Y@-ef*OgUz1'94ũʗ;
QB[@m_+	t!kH9F@YIǕP\0\9yFbV^CQ<@b
).V.j@jeQfGїڒSwp+{RkRNB_8{UkIPWm/NOCKrT!oX'*/v>WLYO4-y3GZu-G<]/\+G%ea8>W6w@~TkrppL~ǧ/|Şn{_>y˾ĺ)לtڻu_nK7<֩GݳgR|يT6#Ezs\:Zbփ^΅2#8GŠ/Z5܄p @_i1J선?B Bp=aM|_`7C7!m~<5-!#W?Bpw x`WA%dJ4yk2Lw ~%oJ1x;z~k;$wmzR`:m:m7$4gi5
>av)VuJ4Յg;m;.G:<xU{EӢֿne#̗$4fzB~IM@loxl^Qz[-.`iפšTX
kavcK}'Rv4w\[qK$C**
_{ÀPΜj7/0\(| S?z?pdo}dw⮼2{K9&^cI#
NjEâH<>gf})GC>ڇOgI#GJ>HZ8)̓*A|?VM6<9汏ěu5$jvO~H|/^Ovn9}r|=x?L?HIo"[Iwh~HKIo~Ϗ|k3<m%҉++ƣR\K<\dwx)l^1-}@#<&;³)lzGx6}$}a3Sd<(2ˊςy8'2̉N@ԥT4
GBTE
HO'|5={?TTw
X,n]ApmMPHF̿Zt4S8.2A/t-ig^UkexȐF`(B ţGC> ygVNW+ͧızh06MLN>NBG7װSQ(u(7!x\LJ`xfRX>S30uȂ⦳8퀽Z9D(WPWFP֙)|{'}زȕ!DOt󵶱8{Xu_<ۣO4666y;/5yB@'8JcOh;{4QKyPzF/B8~^z-@;z,4͒&K=}f
C.UQ&(b^duVdt*=_EcoDC
+{nl!\'t/X&{P`8L0WCY74m
Ֆv,Q+˰Ndֲ=/Ee̋}Plӆ'ignuGNށGh;b<{vA'mf*+5:ލ%mH\/J2롽:E\N؉[x~^&0 ߌ5e)QMoE*W,'`{ԮlT:KnsJ9Th*\^#˻&%[4RّiTSD1]m
M925Ɂ{ؙEA
5mQN3Tkw⫀}]-یm.^P\A}*0]bDkd؆ʚEt[Ԁ?>0Ҍ*(=(x،xV}F

-рF+k#ʋ b\XͰ	>i(ev@QyҚ1cGf7O!	8L%đO_跧.fSO.'8,F1*[P~֧dL4HwɄ%L_Q7Q,G4|$U-Y_'2B1e&#O}b~x..F+YHpCZ%-~/7xɓw9(xYE76SQp\؟{\h3!r1$F#%,RKqD994cwbϢzH:qhJ£X([+9HB=[F0l[xu^iyoI1tYӺ$V͜ߞǵ:^>赧8_]ہQB#vQ8Tg\@r+~pyլ @`ZиDMu-8K#	^R+ܜfE\ELEWW
{]>|Su:2wnC|45i7\p.$KC("kn3L~*4ǵs9o(BnjhX" Pȳp^'6zL)
.aCyM8F۪j]4ތ*sz8NrL`X	,Oon
a[(&&
?rn8=<}B RCh!JHL>ΣKo^L3'<ʴS.i4G>MNIȖed+'9mi.
aWޔK5v~-R;gf}L:u:hLfϝ.&EfbRbbS121y҃'Ă:E!d~)tƣjdQ^8m}D@8ND
\'b:^wD˟&Z/ZE뒾hLP2xDɢ
2TrgGddH`I92 +' hT#o!2(k5t9o8o[Y|zyLDskb' nڹs@bC}eRoǤG*0gfAI8̞"CO.JF٧O(Ќa\CԷ6lt6=@H5c~
?iKKy^&" pk^Ȃtq_YX<'㲾"+86 }ey\mi;ho@S,ARցH!v܂,8S8,rY
MI[,CHs1~tKsm?C8Np \9
O״yCܟj²ťpfCh[k1dۭAMY%m$Z
.C/'sW49h.Q^ke>?(vdG%'.Rl81xqVŒNz0(BrmÖn:էOp58CV,KpoovH=1/HD5Y$c28Ƚ4r:}^W/\|J#GX.=ϖ0'ǟ,JnnqisM`&LjySӯ
LbJ=熈0F`tip73{<ޛU,Z['TR5-,\uJEY1GLgC#q4àR":2;ixmFg@[N0N<}{,<@2I>mw)
qOrzxP]p#ɒO"q9$6K>D
[y'xks.#,}h#{3aFn"pSznz=hrrJ,-!gRY푅\?x9Rײe[Rd&gԙ؀j/$RlGEk!40]܊y@9YЊN%2Ka3H(^/5T(OM
F6y#'w]o0M<12O
DGQlTbx*x$a\$҂\D<m
BE\'۸GH\ĎAE"s
ːE >J$HB^mUVFꞇ.S7*K'ڞ_cljWi3F~[
RG\GLGOywɜs(q?5<̉
ӊ_gE	\%\cx<>kOrq%(	:'~]AVx,Uh5E]ϩ
Dʏ=*"RF~ÐLn[w[+3Gr氘r]VC9CyzԧL \*&gRz<>S=çs˩åJcMӊn]sX%9giu&ҽ.=_t=,Kw8Mqbν{ODy}t{sC7w_ص-xVv= gRcו=3?Yr+T\C7YqGM$O|ckcG3$J\_QZ1mFQM5Ѵ.]Nqwr޼W|WM}yׅkyp^Zw9Sɴ/%M"}qJ\KꙊ:_Jm?&?
S•`fHTm-*3&Ѫ?/UR)Tl2~Xޅ	3q,tި^_C>6:b]17]OɱO;v~ σxL
lF|GCfvNWۮmqwRg|(Bۃq'~!x_Y~By_sP<p8,DA`rAPAUA	d>A%1~xdG
<
"VN5~B$6НG_\`!<Īvt\ƮLS4/~2FgilU	ۍ̘;2C=
܊1ag6;.ؒ
=s
);U
0)[ܟTrYN,pۇs%rx|)a	pDP=9xC*g"=gt%,VGZUu),o

¬WXu.m0^;0@G}\le7rc9V1mf8K}+uNin!]ڈלo+R",Q-̆>n=QE#sc>1/_5rrꈿ
oD7\f\g]wb+-PܪWw@-X
bVOO'״l!%f|ᖋHUYc}T)C&2fڵeTIӫ;iF:T=sFz
#P$Ќi4p
/Shrhr_ȯ*&,U;5c
|μPYE u0o㝼x7jΫ3G&	w*xAnj	G,$3Df-(̍(I:-_手bf#you? W7(PDZ)A/IXI?Zh;VҙIMI4T⦍3NA6DMݿNNK5N;{}}HIoﾇ{=sϪoI7xfEUV"8xY(O
ϖs?ɢ3c]YJ"T	R&[)d:n=S*uTNbdJ%9La4ͣE]&K+Y0=EmV&fuZδvJb2x(  x)/568
1Q40)'40Y.5	I`_2|ljnknNo/tN"E/mzqtWkf5%'Ux}ׄu{/{%
ZJcÑ}{e/Y[_ʾrpVƯeZwym_`=2w<29ǍLsw^%x	ܽCD9ܼWO^? KԿf|8xHFuoǿx``.KTvU8*tZQJ6,l".^2&;ZMb"So`gTT*%@ZM}We飫cIKWk'nMx4I`Ci#an+	UAhO#ϓN1"Hfs$ф-g]\L\x'tBYJIfo*TNfOt_%I~ts\o	(^Fb'HVئ/E\╦M+-+0wM+=(h4I4!"2UvjƷ2q):,X1T/+~2e|jW=gZ;[zó~3pgfvzz3Ե=
ƞDS4n⟴$S٧_l=d:2]1;4t8	-$VcJ=k<:~1@ٜ(0ayM
v~㙵&yJ`h(FNhJifE/BgrH`O &O
9a+dv%
T[#02#:*A+M?
̂2Jڇ٨_qoTV=+L%4B/}”_".yVӤ5<[GKi/t,tX|ǧX{hxLqLu27fP3aP1cw7DRcprV|߈f63E`2ij G p.fjQ@71+L(4lM؀JMi@K699>y ]F7,0y`97#y
zŃ:̬b/|)Caҳ	UElN`)Opz
^L8>KKؾ:d^
,>AjH"`_Na~E^~{MP`$aG^n|?ؖa{nЋņz>G\EQfCI3gXDU[<&[Vh
$ JUOh@18]s'V^Vz	
/En
\V+zRi7XG<<[(2?Ц@ېu4xth

J7Ʒ':5e`*N3K-
lTV/hZX.:,RU3Rc,/Ƀ%j4)+tTRdr/)Wj
P̢4nhQSdžKRq	z,)N͍*N(2Egqh4;Pr|P8G+JGt*HGtJg1p'ߜѶ뤛ݐ~Ko%9(XZTmQTꛥOW]e{y'huF'Ȅm`.[4P&K;;,(Cyi12ĸ]m]nK'CCIr51C"CYXh lY6(8O%b,nd-x?2AӵP}m7K$ڛ$?O<m~!ra+UU^ÀD--PkfqNJV!sEjږ.ltWo&j"OTJMr)aT,=jN)TWe'dc5
	Pyx>#jAV䓑(\&oX̨5Tp1,*	G
AOT95TG4ɎA3iUymULw3\gyNc$&ccǪ0qsCVRx}؋Q0mʼnQ0FcA7@8e0{ȨozyoegS#+l,nۂB߀G]"5I3aj}kyy2YF%+h
*C-]yP݉7OȎN7O>%WZ!e}?@Kn꬯ԭeC{INZ¿|\P=F3%^y,ʟzLn$m+m6bB
]6&r14Hk~W
fiX|,x5}5UF8Uře^@2`^o4\k83߬}>S?8g^=!Ruό|Ĵcõ[qŋ.ƚEI[zZS[ZB@-)GnL  \M&
BAVn4CNg=S::ׯQ-
Xf99LyMט|c2y]#KfNj`b{t'-ۤЅK{?mTUm!+a_.y,Kt;T1dr<\egD#FF(]}4i9twz6gusa	`6hK20dZv\qZ~dCzGgWm^X3j]!\ʓgτ\VB^_o
MF9O<{fAԖ^(p
3INWgd^_OͬYzܻ.M"9#R]7qHĵʡˇ-sk%6ݲpy^<::ov]:tДeVÜdҹr?zn20bpA״OIHᒐS/KzZ<,y(DWbG00}TCT$f+ݾ#`, 36k2ΠS}~Β/0DC/T vD	lP.C_65nU
0a{e\`nƳ-;{y^l`pr9wh|T+$4EˌnrH:]5@Sx++l%nH]r0Fc:Ste!ǺpNS֔px?E4I/3GNK$NK&ഒFJM44OɽG/sZݘ|ېb8^F~>tN;#q@s
.Ȃuڠ?[I;xy]`,i+R%LMNWe
rA%e_RdHYM'n1􉈷phfdt|v-KF#ۓׅRa0jyvu-0]|Nx&Ny9	C	&	3)A$QN
)i|\kF]ޑ?8814n׋/22sPa
C*hl6<2;SF{V9LU)A
j$
UDRØtYÈk^AA,Ylx񽘩?3d]~yݗwOoldE;˲NJ`,
j&jBi>naćL$cSXKLHji4bE:;zAr
j顁4c
[H$ƨ,6'|eQa>f'2pYPu7Co8ܷR`ra<}A׻d*:"\ݲňNJ@J(k,؉jCi`0Daܕ`;%fɶܝ`t)a6,y%`Q$Y"@l]IbYfD
%a` ~!ݫ
 K)))ÒBR]v́*	쨃cG{h9v@i]4f&9W9Pn.-7BNaZ&fR36߆T-8mBa c?.IͰ1x%E!#s7R4'Ψpj"Cjf_d/iGF%&%RTB)AeMñAnnYlns컧w5#G6m\ؾ)d޴\L
tG|
xEp8jH8ӎ{z&Ap"xn-fqj܍75u*e(+dqQ\n8QlKcG?0rꃟG.u3"Eh]"
ĤG3IyvUM(<8}}9Jc9%svt>zz\
yɱ/0^|ߋo78ZwwwXhYf#FOr
1T^@n0,x^kViyO'tq_yZ Vu/VL{K[(s$Cr)U 2%q:=AGJimU dn4*UՆ肌 
ҩz?-aP^_2_R3\YRIuB1}fbbDue96.
,Ў[QSgN-/P8~@S1@4q(&NÄURG
\C(j?S>QĖ-,`IHаD8ǐpQxȯcU99rTG"Dp;Hz:jDŽD Ya4T	h>6?	A,홋τʛ
!P%P+k3`f<"G\"
}7(7""95)+nt=4uy?J10T蜳ճ(*vb߽ Dj6pׄ,1eFA.|e\(rUBA	~'APQLޚb[r>RhI\5<":ۜFAgόO&va5SVdO
/_P[q4>Pb٢H}%sr9v)	%5:FLUcԔ{d|䧽4y𾫗(DŽ`&W'[WD*Os2gc2E_Ó.P"NjM!W-7T7MƔnJdK˻ﻃ^+=;I+
].6jYÊ~MЄ#sCuehy_
,|W^n蕲AqqRjmGͨdj"AQqF@gAD;H򝓒A@^3me@`t/256$VG?eҳ%(N?A*k$.));C#5XFFxYzNzN? Kr_/9W
KFsTKwi*92e}ro%jd`a#ᮑUTPbr
jvwPe6wE0]Ij~)}CclбU#'.GА/88p?f?pY,m缧G|۶Y>OZ:3;v|]e{zd'pvtbECqH][l;"<><
y!oF_Wyor8XWdk lT061IHf"x1qy݆ciӉYyͅjdt`Ea:O	;@Y.;(2%
K>~=,}͊gig3I$at]+v+8"sf&GzD{ƨI05PBʞ2zd{<
vPѬ{QKYzmE^Y?W TAw6nZ}Z}|9W{u.>?RTlFdUY[,G%6N呦f8F\IqZdm#Gj\qԐb;8568mk&wi'%k3^:wJjtKuFY0wREׄ†?mLlبd?=/e9SMϝaLXSds
M8	"}@EcczqK̶Ksќ襪bDܮ%$iIVfɢ^0١14MLO^٠e$rj!5jr=+dv	(:|V1kP6u"8>c@21rNj~h/	~hE%X(DXazF3_0ϙ/4̕4K\sTL=!-U]ޘM\Ҕ@07'9@ǫaa~͠&2U,ؙ%W_Q3{r8)4?j:O֦xOd`Ir#g|<9%UUJUlj5+pՐeK)ehJ
|F
rTW.n3Qe%e=eSn%*hXI C
4$З$et.0WcY&I*-ҖyItjTmuiүCddG1&uFɮgtǙbuZR&GeUQBO^&8\Խ):yK,C;֢S,ըI2ZtS˲b1p/.~\Ndes	S5ϯY(dM߬iݲPF͎oo?>ҿBZ'IM[^;дF=Nu?r%Tˏ<=S=3kC+
Sd[+#εo\-yjyhhړ<3<3Tu`p%(lq]}waZL;%͡x7frŏ_+;/8CG*Ǯ>F՞kᵇuI
:ԽvS22^3\-i\V8H+0	OI<ЧE.:X.֞is/C$Ƨ]DYVڔdzh+>N/"e!CpWyyT֭u1-YlPbtAff 0AF0,L^2)ƛ,bG`w2VU
ay	8;2B
|^G9#)O]+gpdyq'?M`)aX,9͔]OJ:	ZVS{Dөv='
VA5&5R		,&~vKLP!Q )jǼC=AFƺf1@9F(^s9o6wxӜ~4g.}x^/Ypnsn;wkXb3K'(}@<89$DX}]=*[0SƩ['o8QR
~刨H		Vkt"58Ό	{}=Q)_@@|1_5-
5rT<@:1pIq	cr5@`rRro&o)=-BJR+)J٤HH
DJ3Ii4VTu(3hgdYHa螀k
B=*Ĭ0
Q+Vw@jLm1AMzhX j>dk,zLK*&#l9d-(rN;Z{Nsoq>Axݣ핮y-~">={)e]UhQ5vVE둘xH=^2::t!c㣀FߢE"?{pJ7~1jw6EH.Μ51a`(9c:?ORXB A("J;B9vA!*hnJBaCq@p]хoP8$\_ڇMvP9ݧn
7tҍW?HFlFX}M`.)DZWNWG60mT9hMcX"=)a|^׹bk9B|S).8ĄAÉ(+|&$DB>ń)!.%ˁ57ϕݾ:n.{`^f5YiG"%/uLx"YDvOwBIŞHf>l^J7gL KbA.Pdڣ16ކ%;'Eңre!'q2bcjIX&ܿݪFo'h͡b%Jonjӿ7qԠVxW]9Bզ}cȼqp*>P-RxwT.`
`_SeV4C-)ot߷LB+G/>u3wZ_PBqo<}:ᑴK`o5۴L/WX8
 ӆ^<ͤ-${Ƽ+S΀UnQn |5aXg:7^{Q8>?5iŅVV;0뜬p+E4nߏ
(i2|zT񩫟So>v_Pw?3
~9dnNrx6Vm"A ܻ(6W׏c+I%:_~{8aF3yhuv:-{Y{}縟pt$b9C%q#H|c^*$mzlTE*kʚ?4:|FyҰPcZ8C}6j&D	ҽiBPmA!?{ V+?z{}B!|{uS]G3$@H%QTИȓ/($ߖew9&MjGϝ`qKg\W
%k%IXH5kG+ޣZRUCOuQ	-bÍ!_V9
:4xE"Y4]?F!NF'ܻ`aYZPat쉅6o<.=<.fOL#VvX9{(dl/"B@0*ȎφPD*{ei_
ga`!'jU
|A~Cvhl{}v!q/vϲtT[u\خ
4@	@Qrb!C/gR0dpR>x50D&)-jr%
Z#ʘzwZȈs *QgІdi<iV>1Y}Y5G5?d2KҔ#M\YSXAIZ.e(N{kF4oyL3Z;6FWbk9
t,a@ݢ=L	Յ_+
bu6Nge5f~;*ط˗?E}~Qa\mYuU}"C,M9h}Gvz;[w#aGNUtZLmuʷl"S3X p!3
	d Hb3J¥e>ϹP&#k;24'Yd0z5#x>)~*#
նt/EҮ%`JY(chaYZcrژ193`VLl&g`(iM	.~	=|dWc>%Iv\pVDn%#y*X"ȣ')ע7	X91)TL5X"	CcwnRhQ $UPwBg>:
}7$eTw\Rue~FڨDU%4Yu&/UMU9w(:{bI#	6}})h?5t=|N#%(LQD1b@Dā($fsτs]bv@l8qfFBF\F}6X8mBWL#9np̻o븒#V2&
d|QJT|*0,+hQE8B+:`\rPZY?ORPZ:ɠMuED)C_L^hAy&dQv% Jv9]lV/vxeC("0,6ү|,R1
=
##X=J4KT
|?eRS#`R:¤DŽBfhDZxheS|)sorInOUg)Ik\v Rh?եj,3wCiVssߩO	;iWH/jQrSѡƉdkN)aN(d-fvi10ZWj.yI"(ߑm‹O=xnp(!8?i:lrrTcUvAdS'hՇސb
.xn7>h4ޫvvD%#qH)D6+Ln+#EB*H%2ࡘ	Aso	w}(CP4u:yOLwIaYG@j
9]#J~krFM{eэe|lr沫B'L{b^ܐȖ5AӚXShASp	](ltRH+jg1	%Bh<ЄZ8fsKcJ鶮lX2ݐrBK1h'=ϫjchHnvmڛ`n_1{?I'Cl)Snf1πբLӰ/B0藂Tr~FL}U*VZV̓Òxĉ#0N2?QLD|,]!HAo+r#sN:77E
#{휽vF
׮HE
7HΤLIPHDme0 ;M6U4`@G3xهo,&/MPU&_DH
+՟0.vF
elx$^%wQ([}Jk	"2Qs̅cHz,,TZv\$7%Ç6§6UC_bC>^:4FR	:K菀P*,0}>8O

(>b4 @A&$AU6lpw	/bØ@sKb߃XEYN*z0C9*TOeU$W$E()h<r'|1#K*|%
䙃3ӚDhL0qWE?H@"QaAmY
w,sxCl(c@(R]%J̖!Kl	e̽gBayJ&,e"| Ęp*V%p\
K@=6=ٴZx4ڗ{sA&pY"K<2
l!Bz%WS/;jjbI*kazK͝pCܘE#L(lzmiG9dລ7*=ۆ4ALؔO1es SfHK˱~YFi~(VHrZU@nO{A_a˔QHEf,6w::U]4t5[M*UM;2ܧx=>t8'çF3+08rN0*C}TCzJh>Gm	dJ}!Qh溦6nڼedoovx\a _:;%^}@vE斣HzЇQjm{ZܤU{hcj)5!an;kk	֛sӏ̚APnu8S
m.-+̕_޺Pajüycdu/$_,xͳg6܆)לds@8|[#Xq'4
L* ".&D0s$XZ{4lQq-ytG2b;_&u,'[>rҀu1}uKȺQ]O$oU̡hڑ{hoZε架N_$_UCs	*%ɴ)EL9>ɊgL_/X{3{U|˵Yv;[	glʓVFr|dډ6Y~yBN\NL`vm[Smp}[|^5f~GCMöVV?sI`pzX
ä1JNZ!+ubj:o,kDT8U3c1WJ-$׃OLnJ7hТ֞ɘ|'#SmL	Rq͙!5֋wE9st缹>AT.X[vl5"-9A0Bv~3Ũ"iڸ-إBl=ғTpڝ(~WcW<6uxJ9\׸Uh9W9nE^ɬ5jThvT]`0l.jͺ'/3&:&a`@ntdT1QK'C:cT',@e1H߱.تlUӇmM	m+֩PfNNWku|%cv~k`gfjY?QX,[CUdMN(E'?^/j`v~X3̥sҩO=]sJy[ ﰀO[˕wjXȡ	aK1Qz]ȉ2/ثU&Vsb%-Nw Ӑ	q1MeJ.J\9ŅC*Ҽ8l7k+'a7E$>@Ē8$`0e&aH;rP2ǸzD9^:HhM|o[e:krT֔9o9KY00}Zw,tfAT»ZOre/~܆_hYW1z%4IE6-4R-}g '=|.jtDt2MPpeд E9͠x;V0J٨4w-P!]@ᝠnRz0on6Jc;"BbԛcSUc_
?WV@hn7=[qRGâ9
ZkL)WImiŵ]] .)p
t
kf€NRsb;l*2w#ԶF6AT\:F2=-q|?UsysMĚsZ_Ȯˮ\Ȯˮg/Cso5@R-&kZ?l2jV%䀸x"Z:h-P܇lrűƒTIG۬57Q
Jv77ʮY<{{X/[ly8B呒|!.TA@4"rr%4۽\
1\w99ݕ
iƒ"w-b<-qד5X@uE̽\7u{}TS~0=pApk8c5H#jՃ٢)7˔bq
Îp'0!G jiw-8%l`j#
֘VX$վ~Bڌ$㫤n2eO5s?V_֜^lWKթ6<7>)@6AqGw%+QܭRܕC$3R{*6VUW-`z6nQ۪8w\7#׷fqgZ%NwT[+H]5Z5\%?]Wʑ0"ltٓNM4$D=rӲ}Σ
;ޱ`9tj1)L_ر󰱠!qk9X	4DM^`Ʃghdd<Ǔ=6k4cw{s(YסU|,݃@4
$ԡђwd818E}3{~#<3|p!siYUްUNoxm+l[R/5rbطEg5x/@ѭ,l9Ќ{S]
Q+A`ps:x>̌p%Ǵ{os7H+Ļy8/x&'rsHa5@aZzBm
I5+/{4dҺ;ͣo404B e/\c'$(;@9nq9``ɴtF_Wcap^5Ջu =Sp(N!A]33C^vyᓡSC8I>-9k}Zy
m1_yt{ T
jZ^m;rjN^11yn	w>
p*n.I+H4j	Ѕm#i:&cÌ#bGXQoǞ2"DӁquS=PkoEy7GmV*~2RdY8T$㎽ޡ!!cnpX>2KRGt!X,aКC ЧQba-!u_**P/qHZd
Y$#q1c\1g967-̙\+xW-MuZL>G[G(='NosS	FyqP~/sKҿ#n6 =9Vok	5:=>ŷYa"sFqA5,kIFhG'A͛@l?uC1]#>gT-H[ylOUeuR{k6jzlbOhk~NC<HGmb}35BvJW@G;՜"jp?JѼ8BK-N'5ڪ9ys]\τ%wrBs.Z3aT_J>8!ٲ'El[dVpmw]v}m6r3U6W4CetٲoXK#Փafw[v}yof|]?y";_3}pњk̘5/RV7ш5{޺*R^3=g&Lri<̙ف=.-=/XW!RŖ`s9[i޶Qgzζz̼u3t?SՈ|F-pݴM+B_+ޯ?wˊ6eUfmn|˕G)Y,V7[&[jB6.dEpAr
مgHI|Zڣ}Do%Y>]|!5.ߊHeZBp!RqH]Bۋ/DjԤ쉡,]>gR_h1-u?#pD0ap8UgSr\Ao*_JbA`K$7텟rBq➩ms_kE%E;ȬK.n`v!RzſYKpqQ4G+.aRP	J1HNӏ]팅6osKZuGdQ]:Uz0ҧ"(bHK,,0,éiS0pf#,JppU`L+0S<5z<}`|aR9$ĦX,$	`GNoK~moRW2*oJR(c}׼:ްF9҂X(#A0E*F5ydI|'%c?.p	-9[Ż:V%dC}x$\)K
ZK#z,`[v)wA- hF|xdqX;ȿÜHItpv\-BkPs.Mr3x8,"I%$*ҽKK}nݖ^hYi jqJ6Wyn8.I%D*J֠XX;\Nv*k C-G]o}d3>;C^iwM4x>Jäڸj yB4P0^_W8|C	2'XPU!{BrIڹ	3ZTeL"TW@)pm\돆|$/g1c
apB	ӏK'e炽a_5im
nC(i\/3-k4{oiVui`'_<E @ OQ$(R(R2H-IHE@8jR@\A\\ÍRӍ0I#I#!z{{r۟z~ovi/ݙٙٙ{2gTae[vXظoV2|<Ĺ'-#{XRx}-!ue@VI'x)Rz☞<96r/+9qgXL_%|,?8;B&	PpN
b@+HХa`F8z^aqkZϑ%UB3c3FM2
ʂ|Bɜ-/WcqO[tZ&Bϱt>A
FkiIJ?/8qI!:#i|QiXY]Saq-MD]2x/Q9p3efJ-r-%s{o
dm ژJ,DMafG6q3[a,'Qbh!+O_hAoe>'1,k}c8(8*GĽ%mx^A~A l#B|*&V_,[>/zdXPT"@hut0{|َ:`-wA]wLyؖ!R\kӞh]fp>.lJ5_YQSy^='IX7SRgO25
0¸OZ
PQ嘒e6~wvͨPS>f}uQ.峜gNǢ.S9㷛X禨ibS08T֕oECta_l%yTV3W1]E3XDNƟ!rҔ|po}ˠ}"S_tn5Z9_k|zZF5Awa)_?3xpx.'U(2>F5\3wg&0ēʅ&u2ZocBDQ^zJ>99A[G15m7x>~2bvb$3N7>jYOL286}<&rDxB1ǰsLQJ*1bg蘛6^k0#?w2oj7˂2A͢܈4Y!SG!޴,0ira|V(wvOw40W̫mܥ<,׀^}3
Ϯ!?P!l-(?*hJEsu,R,jZJovzwDkE3ᢖhÆHCgΟ
;q08]WD-ů+^UjzRӤMD74
6]KerS(s@dFrk

h[=hnEu|h,ńmYB#*/ʋⰪ^WTUwDU]CwT>~d 6;K}~M,FE?s|%_5+\mܕF̀M}t3],򍐿oK{D[$λ"1n-~N'8^󠲉{,އI=N}U}~ 1uĔy.~QqJіfwQ2a\	G5$	@=#_UV|)wU+g)CL.l_[ܫ))bTŵS.'*CbQyc.e8:
1r9wCtJ	2ܻ|CÆ<2Tx@Eû9C`vD_ԗ~m
mYߋ?no=qj
YW^,,=72U^Ri=)-feS7o({B[BY[vZSD].-H[++#_BzɽuWrGcM]㢮1j0{O]<m6MW1qcc
0jhSk$*S#券W%KCDS)oo\̗JG6+dhsGAM7{CG%w4_z($rpZA_TDKsQmDK/]|R{]rQX֔ﱏ2l	p.Pש Ċd1I\˲~4YSfh%!{Λ	Ŕ==y2;ay9`蚗'P)1:1>`bGM趵L@U͊A#]YUڥtXo%Ķ+`iPG̸,[aW8B0f8D{ZČj(QM@WSixƎC᥌S\T2-i&eB;_K<(X+t%e)}FzמҙMKRO^gWU-C]Κ*TSPs*Qd
I
y)[aqJŠmu	zEg9R%if?ךT8kYY~Pkvg{fkvgkvp7V`ʚTfʚ]
jpŪi <9dSƤdqX}EEQ+;q%:#hMySq
v-ArC1uߘ(qȁʨ7в&?`]5n4:`HvI4pEtL\R3SCh}7 Rrܼ9xTtHHi*/!JWt5rzX4V]!c[H׎9鲠XD۲@ͽ[jO#7Gt:DPGt5>//	K|G͗/6W!#=^*(=G-=֔&#"nIo
-lX(dw@pYFsvQrkD]n%b!fԴڰ.z_g{KuYC;"#ґC#Aψgo
^ɒ
HܰhnV5|ܪog/tt%7D
8OO<
?Zio/'*dP5\_6,40d`T}6P86>5.xJ3_>6~rߦy@;GE487JzcX_&O~%40gྶt{]ߘQ&H-vѭjGiTِnmB6PwY:Hk:
mrFmvWv4Qw6 ek_-({SJk	:J!밠_QC)
n_]ddhj7cHcDCΚW)'NHV/&$eDȭ
ot*)dU%-Ԟ(8J:J#Kbf6$"V։J"KVK+plޚ1՜lQ/a&2g**X%+i%}䅓`VŝK/n/b`1SW%ť`[
!*`dæ
Ԙ|ָ.5L
KjgGD_%Y	phL'U)ՂwoJ}ϠLRʪޡ$S Ua3Sa%
ȤW>oMͺ>ĸN\8g!eMFÊ{?3`$e{+W콢t=w"KkUCu~K#eGQeYXc݄#L6<윘9.ї33cV!0Hr 
$K( Îd6z!
s̴R@ĒAqoEY1vMVƯDaz_q^9Q-*ˢj7|ˋ|'~%7k߬.8r''NFnכ{ػ0xon=0[T|=HAkuacg]_677?pPO]_K>'-|v;Pm^=x-wM"*eᢲbus]wC
oX㎾-qP!ڐXO8x[r#:XX7FOǥ\T`][[miS}@tϑLwILbGBY@"(_Gib6{rܹoqmɿ20V
(N3'>!T9>S5RȨ0M6RNp""|1ua>n7WL$1
Hb
^PE˪gJoX{DLHp-R=x׃GG~(ƍڸ
"<=/cүЋ\eʡ67.d7R0$;6IΘ{xrjgpeG֠/āl5hlN%Wnx~qI?0Lnw!(ID9 t
'|>k·%Nxlb~=qN֐+0V(p-t}౾q2;h#wkS%s1B~;Xmo!XmOc(v
ljn
~NYUż+`'#NK,qDC؏2q.]W.W]G
%9)	"\..okڄe9-}DT(bC\>{EuYԔ{5rNT4ϗLmkjuO#	!O}R@5,Hv?vrqBi"nnB;&egR++,ီA@e\/B+ќ&+~+DtNݏndr )M!)&1$zR/,SB?ə.hz?oQW<0AlMڄXmȁO/A
8/-	dt#e$
Qnr˒{@}H%}TrCfVM162{UeAaWwg[85bYo9h8&Z3ee)qg RȴLlej6a39RZUԒʂD|$1f:o4A16vH:!]\gyrTW¸QD Ɔk?$vH 9PM1={rf3vL^/H͐![s!G3/>y!W_-@jń<37De+2E/fޯF|TGȴ̲`f_ɬ[ss/]Y_]oQ<,x},6FAu<\TW.^GmQP[Emݝmբj){wwD[])^l<.p/,pk
CBR!	+wD;?y(ڼ'Iq-T^X=C&[)Q'kA.*lљY@.KytiC*8`SʸYOB1xcn`6l9qblvc
pqmq=8qrgͱ*
ToP
Or[8\Gze	Qf&].e7ڦϴr_\NqR!Qn!O
jsI2pm𓓓	<	n⇟D_#*tuVY[Ʀϲt;''Of7NC;z>6]t29xc;267Ußx~frb]x1'14e&>4zge5b@+qjq@|
SrMP_oE}}]KC]U[e|,zvRoo^j1SM9i996>>vL"dly99Aћm)lLL2MSbгY du=ܷMh8[D;D!
SVj@0 51`;R
E0Y5@*Ʊ94uCOJ-Ν|G7t9yD2K%s%=aY%GdAY)F{X7ΚKˈ]_xFGGiR!`Ӕ>	"4d>Pp@fG%Qc2O;cQ'ٿY$yY%}}-]iHaEڪb~oOA|;qт?
pvQ!!c0E<`C;(nhS";1|!L@dJJÇLz'	*&FVrM%h)mh؄B>*Uzӑ& H
_L?$͟Ar	=:,6|&nr@fغ^JˌK{ʮŬ+#
]HC?Ұoa߲@9H-(	g6#EsKGL2<ʮkDcd0Ȭ r/$jkɘ4E]o=ȳEAb1ď2;3kk(w3+oDnlAՈҒ:ѭ	"TV	<eQvj*͝J;1RA>SY,|"D)"!_sH!6	-AWırʴS#ǎjiM5c&֤.+Uk>NEMTf"XjX_
1%@Nl"iacv	ej{u|R5j@FNO{+}էMr|(	Yn_!&91KMQqzISbPסF`	TP	ŔN1Q"`˝u@߱gxoL
pog4}KRt{mS5]*s]Ip1Ԥ{b
ӷ2N8>=?;uzbJP9?ALN_x:&Fw0q=pM#'5}5ۜ
]P(f2sƀ(3Z\eE3zs=K_ih=GOmwUzF+e`ve$=рV:"%QUF2ǯDUAsU4ZO$*9_էSJhv{Sn7I5
:h/ԁwNz5/\3%A\ZKLɎY9G?HTa)N)G)x
#*F?+B>+fDX:}?TLYu]CJˏ	V{]cMGcMƊƚMmWkQ~}94ޠiG)*(Lc|
=Ris1{bEFZk$-9ߍ!:8Ψ=dp?38{0ѢY	E_o$Mx=+}o{[]c](.[ǀǦs!FZJJAkт/&vOMTcQCpL@@ȃOƦb“w\Īw]h-0
O;GOT;
L;pd==y7ob5yAQ1>JT,b̜ʙj08U:4Hz|2SƒJPM=m2NМ~\z*&qMe)&1Zb!ur¡tdU%ʧ'I٤(5bHv]fە"'mIɀvHiG'H8퐬iЀ#H(ʦQlu!%RV<[%!hv](0"FX"Ip)\Hْ<ޗj-͘u
mL֬:	3$Lm.'h䬊ϵ%|K|bΎSʍ!sWU$5-,5YH6޳	_>.
9r{fƣo٩?gg0aΓSg)U]\!r[}.hʕ&۴IXII3aS)ɪMW"5ܚHnS0)nk=Պk#uŢ"j(h
>7;mZ5=%]gŭs;+=Q[VҳPMCTg"[
t.rH8,_ubџZt!a#1Nok@R.DA<%Bex
ڇOwfMhllHރ.G;F)3hk"fkUCְIyʬgMfǖxREMj*N"&O*bOm%F>#*UMM͖ó'6cd>i;֨4Ʒ,
cRZ/Ůw!-ppm8ĺ]oĵ)7&wh O<8a
:cT3*Hv9[/vpas]1Uxwskkiȣfoݗw{7\~<0n@NK#[),mާ}O:^R]PyWٕ9~pXSH_rkÚ|UvY|Y={tU?o/oWP	d	Ǹ	
X=Z8Fl[Ń &%DžŴAT_Iݪ㡀heЋPwjiSZbJ9`	1F2$E>m*mJ9aHW:/C.J͕ăEs{Hܡ):W8+ Z\{s 
g\ւ<ꁌb@\kjg=|hWpkCe]-{JIRHD4Q˜6],>.E.K%{fI-Zqb=DgYrsM唂9S@qcꙠt(bM%1p\sNghe;v9kw3jv]kwoc vE#%`'Q|eWwujRBYqJ\ ]PC)vrof ԊQw=QX8w`w[p//]LhL>N];kͦ\$`:OOSºG`_CXvq;3.bb|m#P뗌-{y
"f'%ߨ
{>S:Wr=L^;Q.kˆ4Y#꠩[?_m(:7Z,z255T"Tb5Mnϵiھ3+J5-PVGbcj+K^/{_*l\U
m-NB߽b*z;sq\4WR%=b;\d2_]^t/ekt辽=dv
(L&Us|@{GBso	j~fەboM*4p7!ZzevL{fo˽/1TeGٗv_ubXԖ-`myh^!-
|-#F
n::<zBRfO~λ2}ηgC٭h!߁p:E?({l$hhJ	|K8`!&B?׌ҟF%N?Ot[]sQNiNKZQi(|Nxu4(
LsEJl?8yDP`?y~Ŏ2?-
tm?^AT1'b|҈.hZuN<}>`ѿPBBa\n-FO}.YcY-<e=K2G0U
UCͣ׏Lz_XX[|ऀF~฀ytUySߑ%zJì[$;k9ph'X8f`PX<%$T2 1%`lxiቧ}.z,!C3֧
!ìٸbj!o_oc	JsBV|UuQs͗7S~{فկVG
ݡvO/DU).†*|1o^4o^ji[hC9MKe~pnke{C-annǏh#+NT
J%ðCIܴtϭ)y-
?*;?BDB>	|XX/
{wM6MlZY
W#}"rc1fVZpLuqS(hӟv:cQ0v010㷱wL$opqxUs{0BITY{ʊe1]e)dθ,P뗕S0J\:iZVCNCdeע%U5&:3	+lj$00/نu*1D'nذ77asK	\#m[+/*^ye\n`vX	$&r!O0.'Ǩh(m/0PQl	7T,vHYx0w%Kdz
AD!oJ'FVY"(35KRK+
kZDښ%,^fqjű6[.5fi1~gGiqVD	A?9+A	gMv"$gČؘ]x!F+nNLbDf`XcN	BL.;~0ď[7,4+)sd7֠:E`^5}=H>8H
:ŭԌiHxjSq0
!q !
ƒֺ	P4E@ЮYgHH!0
#>svnLr9=tQsF*6+4FHQ(exJ"EiRVΥP5ΉxɕkbonDZ(-ê>+_w|w׷'ߞY~yPj\o~卖oy{BOZ~#9=m>./+
ꊢj#:SiL$*J
K*M@[R'/o~HUlP+!K>"4s˅,UI`ХW#Ei6kBƗ&|GCꈶ>?/]s%vRvuW9RM{\d^8=;3XRPh)]wKCeKڬOB*ŻZW=2$DX`'Ih+d~|GJC@ٟ6="OvwE$J/j*"hZJ=wd~|#jEuߧ+ON%`7)ߑqVh`xi-Oj|mS]&'	:+s"HD30rM9H'LbvY}{,n.H<'}gONX(mY#ˬhbf|<&{h3M8)
vI(T!ۼ=53	Ԩ}v;YoP$.l|͘|lb|{;qvtr?J?ko&0+WN6'sdTѽz`4J{ijO^1|LQ+j=/m5+^TO#2
_9gƁYqwM!,Ïw_kh-*\ݧ5+Ny|aI51T`834wJ1@`J@$(u5rTz*\Ir`I$qJ蹊$]sS)Ë,nĈ7e	qe[160I>pVs@kXsά2ްKspSј\LL`Ӱzw7Z?.^sݴeӗ.iN15~wܸhn/iW:}Z$K%㡌9ʌ-QU7y7+飯	MGBUkK_oS=Ҵ^R{/u~"b2:LZܟfb_{s, a字P*Ƙ*1q<# m.%CmX߅Fs{N+w	z_J!1*LL-wpYD%0%ao,Y9D">&qON;',ոj` 
3?79\%rXc[z]erP^<Sc|ı;X	ޠ໇=j$R(_<D_)? LVZ*rBs~يrRf	EAew4,ZTBy>"=-/lAOu.6[7*z*?_#i\H$p1lV/Tv,VvD3L"o*Q(euҵ:jF̋m/<+y_Z*\)_?3ՒʿِyG+/*JyM*Τ0&+>֩Ѓz]$@`HeY~
ҙTT0\B,0|,-AIv$qJfgL1}Vך`K$__$N9 zQyYXPaW(8ˣ()E2^]6a/6VޮZSСV
۽Kag}ˮGPb;q3~·V%7T2gCQ`9B&R(OvX)S)
ghֵV\kLWk}&KdJ_TI&:I&-wڵ)SMI``>&}YZ/L׳v%+qΗf15y4ao/CfsKaRjF9NǤCU61Ɛo֌uk1ش0?)\QtآMPIy.SB>aMIkjtII1{]$߳$C=CD$1#EufK"	c3CyP2T̩Y9S/=5j43"(lgn&d&Rڅ4(|e	9N+GJۃmms"=G=G#P򊹞Zy6.WFd(#\/IfoȺ#jl}rQSz/qYաZ0z{I!:Eً[|׎Ovbp鶥̅oP<]ђ
7X==k[|Ne.xK^|=1^hEw˃20x}OW5FAC4bh\44FQLPͯQBE^[Tqe7ޱjx`CmkX5"5Ӷ=#Sâa=Ҿ7ؾ7o0Ҿ}4/gr"9
PN료9-~wϟphew7w|ݻglBM}wyʞ{FάM8Qߣ*Pv[XVhuÄ7 %^2*$;GIE$Ao{>cch~7H&0[V0^jOՈ}3fB"$9$ZH!!q$B9X'¸ /c p4FVȭ1YW,%1r[U:&!X]*KNɣ	)s=#~#`_&ښGPVs_FhcpJ׬g…mRa$ ~D?"NJuÿPu;Y!ӒFXu;z^"WsʇN܉366wo	`@4ll[&;1'4vg+N-V2D-zm;vMf*Ealӝݝ(sޓ#q?f={=sDu/3d֙$Zl/$5R1=}1v&(0Q*~qIǿ/nZ{_}
	 2iӎfB_Ew=t>0=f
&&#'Y9coE+\zǧgw:;2èn9U@贷րR}jsYJ9}錾td2N='gܪ[4ěO<0m󪦿ȫv=2佣}S;-^|>ww_zpvˡ-šOc3K~eӜlFQ]uզyEL7ܲLZ
#J37 E(åm"MyPhՠ	DˣEUE9c耷sPET*I+d/;
|}цsp7mYa2œ,\9Izs6LNX6ɹN]MVdel	9uh(>NlRy5Kf@;Z";~b1md61rQ	I.
q"O	_婛/Kit$F; Kofֳ[(COw4u75ێX[{O؎Bޝ!9?nCBBJe.^PaK
woX`|!%An>]CkRwNS!Y/d=a;RFuHA%g#d
?chKKdž	|]w^L8n姅WcȐSft6kdti^ͭzTm+l)`h_{go
N^ͬpi3nL>Ȩv)'O{+cđUc	2]
S]Sݷaq_hJPN	ݣωKl֝tLb^5Lb||5Hzɸd\װE'0$H?WE8bI1@+D9hi0EQb^&f?hZOSܯKϡXm,UPscHd؞XUu''ͭ?ۺ,c2GLz{f@ZK>4f益	?F1˂[?8vba74Z2eP25-e
Yˤ-
b6{AH-T vQGD`dmD@	)v9nNw@ޔ_@:.qKIi	Q0(9$Hi%mHsڰKsܪOj?#AfuxL90Vj+DqJ1)oFWTP~F
Y<6l4T~&~XO5wC̸#
C~bh;k2ϺG?kKފrKNcl4iDv0~]]*u:iMPcZ`IݛEO;W`pJ|Wn2oVK7@=W5Oxkylt4`pP{G|Kۖ.NWz͉k미 qx!kLx7]|2ƕYMYT1-a5jtiVþ*bAoDLbbjxZLc$SPd-&&c'&pKi+ꞯ3~%}
Rv؀8&J%y)ԛvw]t`v[y7]
W'UtKܾt+Z1(oV
3RE=)_orMo1>y_{z?],ozQ7
Hȗi0]=+&67M
/onWMFH2([a#{dd6H}#奶
V^]ё↛N/lPFea4[)	Ah
r\`6\
F"on6
/R^tV*zP.mH:NIb0
thAi.v3(8#4Lx}K^ـT)E|f;ԓ^t~㕩}Ɵe:W4S4I}荽ZtV29.wkO]O2>&mN(/SLyY"Lo-V=(%<'Я!UGl z/-@Q
k8M5m1d}.0'"\,&d"[hu`l5!L*vx>#wD!a4hcu^[*5ܼ|Gz%旜ukz0ʪؕdՓDRaRHy)l	R'6#ڀXڛkJ6?oZ
fJ,,!/Nn6yUI.u}C##~Ozf$=կ/+W7$ڀuphH&;/Dm&rG0X}6CaɉbOsqp5|xP!PE7u֘Kx;F2h/nD$mn#		M=GGxQ0ԅd-іŬ֐)ߠp`X$IRPN-LO0#{D]0US	w[%L8ap?$F9mm~2~˙(m̢D%S.gje2g&VUɌ˙RYZ*[V+dYtJ%#剖r$҈<%"HJ0`!',[qЅ74Ӏ:%'#a|)[ӓ=
2ksz"'3MSu%+%_8lDDS:\i`M#ѿcguʕ`MP˴B΋0QF(!en{kܻ%\PVnT!9Iv.^HmJNLs`6M[ϛ0tķZ9cPZ.͉'l]!s´*0\P)ˤiGOv7;ݍ~5~AeJB!?
xh7?|0rmӾ
#߫41^(U;!X8xMMD!
|}iph	Hst:{tOjϡw<~~0^H>=`s09XB^pG?9H:Pt̽;~CQ@#pĻ:={@+Vp&=0#:V!:&w
@'^<Y<}F :P!HkP?~.:CA?HѿC㱨xfPЎZ9k#c4>}}HN8:0>l?Zů)]}N隐L)s"Wr?eR/%?TaVO̟%Ȋ,gnH&,hHKYJX0`jFk22MXX
,g`L6feadi\L#|F.BbJ+
X9X#KW
n
޶jj1Z(e7`u=5@Z#` m?`"sĭ^ԊxiG0A@"~@%#މ?8zDFqO!E
O"MSz
ӟbkQY֫+!*% S8\fY%p'n$0D#&)v%DCxh	4X$GCJٞ]o/9
rXNgɎEem#ٺ#DIvDDÄF0FNK(nEa <"d;N4"`I3bSV* r% $g)!,)
"EBA.#Rd-2#X%9e bdʠAD@4\&,
5AD˒j7>TQAA4	)h8<*\76q
E#%ed;dA)%h@?@Eh|"bJAHQ
LHDXy,ZXL`9!
s aRL^tIwwKA%.#Dr0s:ai,8*Ia!3$!Ke(Y|_aB#ˈXF<2_Hd*WOY+jUgl
-ҋHҖiHRN
I_2+HRd,K,\F2HH"pE).=!("tkyL'^3a
MTp[ox"E/:BPKKY\?
plugin.ymleO=0+j88
bwqxm5|4?4Ukq;ӨC9ǃ!PjQz64R&3A}|[$7qΊ4nXlP` _;i=ƆGS氞5(ಛ+<*4)d)Mo(T3iӿ8^PKLY\	AMETA-INF/PK4U;\)META-INF/MANIFEST.MFPKIY\Avcom/PKKY\Acom/pyjavabridge/PKKY\3	($com/pyjavabridge/ScriptCommand.classPKKY\A>'@
com/pyjavabridge/BridgeSerializer.classPKKY\A=#N)Hcom/pyjavabridge/PyJavaBridgePlugin.classPKKY\A%lcom/pyjavabridge/event/PKIY\m]Y)\lcom/pyjavabridge/event/PendingEvent.classPKIY\KKoPe'ncom/pyjavabridge/event/CancelMode.classPKKY\"Z. qcom/pyjavabridge/event/EventSubscription.classPKKY\A|com/pyjavabridge/facade/PKIY\(|com/pyjavabridge/facade/ChatFacade.classPKIY\d:	@+~com/pyjavabridge/facade/RaycastFacade.classPKKY\#j&K,fcom/pyjavabridge/facade/CommandsFacade.classPKKY\Y$'Xcom/pyjavabridge/facade/RefFacade.classPKIY\7	dp+com/pyjavabridge/facade/ReflectFacade.classPKIY\d?
,ncom/pyjavabridge/facade/ParticleFacade.classPKKY\ao*com/pyjavabridge/facade/RegionFacade.classPKKY\N<+com/pyjavabridge/facade/MetricsFacade.classPKKY\"/3com/pyjavabridge/facade/PermissionsFacade.classPKKY\s+Y'Vcom/pyjavabridge/BridgeInstance$1.classPKKY\ޫ|`6&com/pyjavabridge/EventDispatcher.classPKKY\8bF^%jcom/pyjavabridge/BridgeInstance.classPKKY\Ap@com/pyjavabridge/util/PKIY\*|/@com/pyjavabridge/util/EntityGoneException.classPKIY\}Q0M	(Acom/pyjavabridge/util/DebugManager.classPKIY\u&%Fcom/pyjavabridge/util/EnumValue.classPKKY\#O),Hcom/pyjavabridge/util/EntitySpawner.classPKIY\R'u,skcom/pyjavabridge/util/NonLivingSpawner.classPKIY\Y/K(lcom/pyjavabridge/util/CallableTask.classPKKY\
.mcom/pyjavabridge/util/PlayerUuidResolver.classPKKY\*	*{com/pyjavabridge/util/ObjectRegistry.classPKKY\A_python/PKKY\4iapython/bridge.pyiPKKY\񁶪upython/runner.pyPKKY\ħuuJpython/bridge.pyPKKY\AG	python/__pycache__/PKKY\x18.0ٌ)z	python/__pycache__/bridge.cpython-314.pycPKKY\?
W:plugin.ymlPK(([1;PyJavaBridge-2a/releases/pyjavabridge-dev.jar000066400000000000000000006436421514752343100214350ustar00rootroot00000000000000PKKY\	META-INF/PK4U;\META-INF/MANIFEST.MFMLK-.
K-*ϳR03PKIY\com/PKKY\com/pyjavabridge/PKKY\3	($com/pyjavabridge/ScriptCommand.classXitƖ4<`0 X/`!MR`
`bR`,
FKЦ[5mCBBli}O%Gz89ޛI&?y}{wϽ84MWe(WDHA=>Ӎ'~=yO
ftVPS8qKϤ]cfҭ
BEDC%4K?=Jcf݂ɹz&i(X&Y>v"Bl
UIA$k8f.gMPZ\S0+mK*hMϻt	>
!Q{nnfkX
}FI>H*bFb/,ed8Ab*iX4UJN'M1[Xbz4(X2x+Yi
&
kwG7D[lkX'3=tBe/W/0+&ʈ(ݡN6s@bg@p5̙ Y>T0]3 OomF-}aȿ`al'+U$4B)$m1vӰ1YFҍKqB߉*h^K	9&(ݔLD"3ְRPNSd==ǩa֓I#+!
#Hi:
]E$hQ
Cܞ|&#s@D93sO0U'+͘.#p2Ygݯ!s_BLs^CҜv>3X>`f̵cs{ioC
_+Ov2霝E
H6'#Z[)cJP+vV觢Vq4܇7=E8n-ԥTmTfV	!;-}pxY6&e3D8whx'$$LŸ''']	۱Rb{4Rs*r7j\[5ڻm+a*!F3cX"Q|>0M
Vj;=ǘ	I|7]ږXX?NB?*>s	1][ؽ10@>EQ/luLr/U/hx_Dˤ
̥LV"Gf^]jխ|'"WImM+%3U(=bƎ&S*a[ɇ,Ũ-i/:4Gd?!',g#?/.WOQ1~b(I\SF2Rbg{H$"RJ	\~ȋ"#fAS"n30e睤nJNS8fvsgwnʅK|mvJy7OƱ;%+vzX\ctnƬ'[
;v=6qHͿcSG'M
cf>ÏgIvX+vj܊m%cƽbtpWѦ[VDۑɰMS7+_*,|cy,HC~kTVw|V66]Ҹ)S-P~,
-".r4Lġ}w]̄&iԼ@jI.u7|`㓘u*$'koKf\fȬ,垺TI¸zC8g1{mj@CXa(CK(, ܢFզ!4EET]3(D#EjhxڢEշEa^}riNOs'I
Vч,F#VbkmD>7VNт~J.!Tp|B 9%cR&GO$WpqYxAޅo\KoI}^c/"NEHm>j͗:Maۆ#=M½W|=8£E%Mŷ}I-CHɥ*u*.sa>8]#)UQTFiޑG1FsmaXeY23}KU>MWp|
V
*ކvwM2	R=T!>DžX;O{'ω@48s ލEC%I}hk7?rr:DG
`c$IyJ@b5rnZ!A~@BuQhy
ᇒƏHϾ'WѮcK
g	*ksɗ~O_/j(+"?PKKY\A>'com/pyjavabridge/BridgeSerializer.class}|TU9ޙf楐wR	$ 	% ,8$DLLAu`G%Z1$bk/k/
"|eLBۏ53{n;s}SP>i^CC5V.GN?Aff-	>BRʯVV	O_õʊSõfmxME]}s:7WT:C-p
yD AT#k"5|E3łTMlXSA#:2,z6_s()WWo[;7T4~B_Y aOTVҔ+"u	k#Uap6Lf<b=Ȃ0Wa;4DY12\EӧpFX0F!G4}-
Әc d҆UZrAVT1 Wtj$RUضŋK0oYaH%Z|J?G>bI̚q"ܼBϯԄkI*GevZb)AJۤ0C~S,($uD֑q	7݂PL+XV#Jm
$ԙPb,f4vE݌*+L(Մ
	5[p4ʠaJCUazUSɀQn?,,#XގWsHIX8%
h~rnCzUBf'@$YQ;Zk`~S(@`5b6D*#28hIF34JhgP	j$biSZHfG:7pr^t>\Mo׶āSTNt($kCuSL΂Y$Qq5\v>s|.$`X3b.a8PeCU2.+`w6(k	*j2mނ
{\q-1&2+W
UWY6bp[;cWR]^yV3Jb`ht;jlkK0.j¶cf"Šp{iHU
U篪˟ʟ&܏	Ax7p2mCh[vnhr#nAK€I:bF)*OӰӀgd϶5GVUcdy&Ori	/RB'3^Epyd=Z^xG{,&El-Y3Ѐ2bk+Cµx!Q*~؂OS|'5K;Z
I+|IdAz]c;W|YSGԄo*+•u&|GtxSÿEyF擦D2'Gj+~?MmGLK
f{$rn<-`f{4l%
*RkDZP=Dׇ+kD8Za*a#lŀE%x%
sq8\v1ML"J*)jo.aq1
䏟LC*\Q6&2l`Ys1ފƬgb ^W6&$k	y8¡8JW5kaB.%h/Zn8fZúMjb"pH5	ghdגpfUuyxF!3cISbGroch5B(WfF*~29	ahWB&~l~b"U4u~LNUEPlQ)NE.Y8VQn?7\b綋UQu~0sygd#^QWCśWBY WmVʹp~=+nUOm+YC+QմHUMpcR_Maӯ^2
"Yy2lu9U!X8EPg[ea۹rE
$;V>F2jnҸ)$&]9=T2|@nSka^
@4Xi/OuyBa2?E=^s7Wx&9ի;ρƚ1Ws\lt.Xqfadwjm:˘_BV_hWYxut;,Vx-IjUEZz	1~iaXf1]˨#~?[٦InD1]maOQc7Mx7CcOήc7E',|'^).rtNyXQ^i|N|g-|'+D-T#1!NL5bA&"dQc'N)d 5LțW8
ֱ׊/k᎟(8ߴ-|/\P.bS]0P[w-|ߧHQ횶A,]|Q<
P<`s!>$&g{,:Ż2϶ث4N貁Aى[D;W.	 K¿kͮ[}kw[l\T-
Ur;L#nD=k?v¢ػc^2ٛ{)+cTE@
9r@~]/BHۥcH[XyoPe]
0-~rCBd(ZZQJu!mF[_gP
ap4h$mS	g!z!C|2"l{q%iY"h#&yCYQϥ
n%ꔦ
_[QUQ_>u-1D}ն|E)b!FZb0[l9el݊"y\A:ac;cX[@x4aC,q([/f[p;`CoI`Qh6EmU.ԓGZbni8alfi8kTKLm=,dtQlL5W=	̲lCSOsRVxW'_v6ΖxxnODE9Su%$ѵHD
xʕ:]ȳ4q8^>m:aYb(iTEMwmPbST>7\ʼnlu*,qȜd/BuaWZJ35)"Oo$jaW!)%;ו2EM{{$xm5)b~q8gXLqV{bwE{!kq0A^ИtneexMU׭98at\*w97y;aOaK-mSe
K\)"5w[oXZfk,qml':SIz,`A7a/3?eF7
:L
N%K8\fkSTH;ZHmUݖGlk3;tkHGdx	,BbP1nb-$Ϛb+5#BSlc6h&J}BEOS<
=yʶ|1}Os"މT;ßijkΊU8k!v?rRj/v k,axMn7,xC4+@([u01wz>KIK{RQx,[a{kAfƝGI֒YsN:$ĸ2w.	#_$봄пOB~P)na;Ӽ;KCSR*!VY>eMQ ǎ̠,AG.6):g,o{,ͳpѼlY7vD#]&ڰ
$RX8KR1`

Wdǒ^i89P_˔ikC)	WSD/}ojѺPY|vxCv>(l^2qh;M?oQɼҕ3gL[r3:h{(@&GRt9n) \^h>]AKeB*e՜xI XRb

  C,9TkmsUՅlvLD,|ӈ!GXr[YKfTIfY2[Mӳ.З~)G[2߉l	L9֒!LU[+tvd=Ja,9^NNWdƂ,WE%so]m`ߝDKN☟bӗqONӚse_N
9Òv	;'(TOv]/DK,9KΦ88Z\9גrH~46JV\`Ʌ󯨶oif%j_\!Nv
Ku89אǷ4'B4`ɐ\EJVI/Srn|9+ܔHu+*q\_<ђ$y"$uuk9Ǝ':giWUd	ء!)=-Q9xMє[l,^K5'!zEk&9"gXLIAi?hՔX\B5J)LC^,l O]<0[y'y	]I%.WJz_x):g'U34-	kK(o\cկiΙ}2	r%o|WL,y@(f,vs'Dv[L_y)I~l&IPGQo\=}4UgŸdTͰ̾?*TC|J,Cބ6Whwrv|8ސ?rOݵ1ZE8V݂$n3q{L8EۓKrnʧHօ7N>Ҕ.vyK wٙy
CD/RC0ږ@тA.j$,ueTfOdOd7-Vd0ٝ|ǒb_Whтh%'PuyS.l?}⣃u^2~ʮg:tu|zK>ܒ_/i*Eӧ,]q{bq6NTV9׭+2PoMu>Tvlm"UOl*F8zE;>ptM>1K-j0'4H[>ЌńC9^
{0#{؊Qʾ]{ąYt)Jׅ
:@r&O{vGV	59!C sDO>}	]m:upC;J;'/@{{s	eQNYq"}v.tBG,{@)L$_6GujN.x1a;8 7 y=
/!1l?Xwwc1<:l=ne=wA=LVkf7w'C]׹#fr9Ivⅰl܈`aS[dxO%+(fT`"-A7&T?Dz]wO/;_GŷG!uulի]ҤTVikn$$wﯨ
}hN,t~o;{/N,ODj\|2LMf?jT%(S?)`'tY_8SOﵢv=³:Z
)#
SB%ܸ"g7X a薜g s#৯F6ǩrv01@U!ypX3L*F24;ӤӚF+KkQübQ3,dhY)
	d>*Ak)U6bBlW#P	zZF;oPpwra6/B6åM^•64z͑Kq@46TdnzCjj4&˓r{'a<ƀ(ڷ6"jm;Z)u3<>nRb?ɏoۏﻍI]T@OG$/~qu1_4B~Ѷ¿t\_"z˗Kn?\
w,
O
N JT'Mn~M.-u؁wbZ(Ӄg06zrqp38\Kw#cbNt-Ǵʱth#4388tjba,[moux.L$>,or̔qJ#z1S$85H0遊3ъs\-x45cf,=+DGqu1|ùĆ>3k,m:Oh[ڠ*ϐi\ǓX6)Q8uWzV!muDsc	q~!.b%mZu9?_|
?_gK>?7=Ϸ4p
w=&]JY^1¸aal9![0w0^zMdnBbQx
K0RnT|_cL"1X`,ݠx[GUO
$4J@E.Ll0Vg,a!X2Sp,`%N^P}`55M!p"	pTb*:8	ϧwЀ`=>'N`~w$X{LaY"犑p8.".2Q
i3=r^!h;`x	n-;U&Sv9N9K6ӡI^Mp
|`%g
c*U!lWТVAjLxB]O;<^P]jH6%O
x"xͳ-O9\
z{	_x*7
x?";~?{O_-}y_^޼ a2i>c
h0$&X)F98bxd$*
}Ce*A%Rdk% zr,߂N?V I6'n"NQi/^^At*6QvG7T\e%NmxcqO0L
P]F{r{ıш)j5V#,2*D<]
AݧF%^RT&xC`>0PDL-*Wȍ:Tm.V yrq핋ԧj4c]syp`SPzs3{ɵ?z;'6e!T0ƀ
{= 1Ҝak.fp}
E
8w?dLGd~=W
cTwRt8R@QPf
L(2QЎ9Aj*'i?T r#~@?'X^la˗Fn*آ=nAnrm߷#
WȁŰh=I@28FPá$GA	fsjYudeo`؎tv,`B5IH
Ƶh0Eˎе,c~Hr8<;Dg*yaf$}AQd'E@iH^N3HO3BܝK.F~
ޝVs	e.5ǎ37{Pq59}j#ZxmrA{ܫÇ4/F	
!`,*,)fls'dck	!)ڊ\	8˰~\)a	UdHͨU;ڭ
hlwW>ڡ蘮^u5M=]=MoQщd''C.ӠN8bhM$˥p9·+p!܂>%2.p9|+P1HNjq`ɥ_p-.
<r1/j|:܌1<
Z/vB*
>5E6$8UM#{x$KY^z1`/V3+S0Xvn:inwmU"
?z1GgZʧ\z&Qj7B}
j!@L[lHN#T͏F>sf14	|q(P٤;bR44MQt.͢HNKhs䦊yr.K(ѐd]bqM?*/U,PCw/pw+4/;Y%7tqAj|9?ܔvaX%w§J^Xy9
WҶt
k0
F(›hkj0n$gfږn!Gv8ȅ
p3mKMp?}	_̿DAQ)g:6Sn[aHP|GAAvy~<PB*ybSmg'Ic+72'F>L>Ȥ)$p >IiCI=DsQ"=4[֖iyB7/g+CN3sE"%g*j9kV?{y
=^~~e^܋OF2᧩]1_x.E7΢o=K2"Ne	.+]:aE:eȧMEśL/s{!%vq0v7˦FB=lA8iX$v
_Oo|~q&|M|	)R|
kob>M=\Ү)>a/h٩Hw/TJ1v4B;caqE"-ȨK]˷%$=g b6HԻdiDQ6j p4DȄD*liI5}+Ǖ1IH*2)=o"H6Ա'	
TpD>vڨl괊dm&$66VS$$$/y>0D$BH"Zd鲀VEkj(r1FKQRNj65ARhM9	dnNNcqALn=_ږp}"|~Zƶ倘0Cy}_(~mGjN-}c=![C]v;eJMښ=&ǓMxi݊1pW0A
8ˀd0`рL`0/Yɐ4dRn4!5$'YΐV
	&yK!9 9Xf	Z;CL5ڌKO3 ̓'ɤ&N<?7REbQn
IV^ʛQ1,H텫
FCu
IV&Պv]^!b(~+	%FC"S"7N"1Z̤bX/'YfqxCLob^L'[4CzL%2Y!+<-|PErX**Bq1?CF8\(5抯cFX+aT[ď6xEb| _o>co’$[JsC,sL2dym^-{dsǾYǑל,8u/rpH»)_	
PķRWR-‹X-*%ǿT{b=Lۊ+!n+6CV|	*VϜ% C'>,y)\S)xW2ዷq*!S1CHLE{Vў=jja0@PlݳOv>Sz4ӳ?$P?*-Rk6
Gm=8TU`xJp:L'p)^+5xtXתu
T oR͌O(Us~.,RUܟ<H{;h4S8(vj:\;\5o
%CD/yci`C)gpPG
u3:wLh^"uhCh$G%Ng![T5g`y1)tm^'^Ql†}0b쇈>dK,=¿tSbA^H;@ZthzoN#Zo
o
&\9v-o/wlH/:M\q6zs)i)y>Ag:}>H#Lp(nmy.}Ep\}
:=gsrRr73ә	1"Uו7j@R
Bfi^Զz#NęX"*ZM<1rdr/W٪ u"d*8\V$Z@xP
<$ρy~^yZrLWpy5fpX"oٲ[q
ZyV;4	ϑwr3^-Zy/ tѶ:Dt[juKB:E$Iɾ^h]8Nc1]Hx
g}.RK4]@.)J6Ȧ6
-:OkK#4X]R"k6UvvDe
{0gאٺw*wynZShK\bwK҈'FĕП	NHHwRhIR%7~R@zwܜVy+n}Z}a:
.9Z_a%[괭r[}̷҂flu}AY>)^yR?8p/T??,wS}.M"1^L1ȏH?$)ȋ_t/J~WP&-!+pm$?Gտӿ[HKCUF[+t|hpra9sm08ǐ[
s2mu,ǣ4Db]46z$[+rAsEs_1yv.KfT-'u*NN|}z@됔zxRwjC;˾퐾۠W|E~8qOt;猧]9*\`qohtΫz
vm˃.*H	a{!=M3iG)8EW}Sh*B y#B"0@I*SpJHJxhT}!T?\
AB
CjQ8\eiY<3-w8WwE%^9Q=2?c
YdrAY!_U
.2OF5{coDvD#e1&*=	JRNUrAm{>	-Sц0\|9MW|u(mgN!^Mu6Ъ&HxAMXgֵX>>Xkkvi:XY6~nw[QfVL[JgbQ,{@|ܦ|ѹM"**w_S*?wB\r
~*$1ODKWHC*(HW`C\V1.!_/SDUoéծKh#*HҾ[_vVu~Ue7ЪdK2{(ʦg-ZHKXDKXk|d@@0Yo8Cзρ߅ΉF6l55YԥuT[rN;@ІCA˜n[S+[գLw[Tzp[|Z>?ӟ/5CvOl{SEM?%>PO PKKY\A=#N)com/pyjavabridge/PyJavaBridgePlugin.class|	|T9M&GIX&$!Vj	$!@<``2g&@\poV[[.6UZkڽ}oU}}odBh?o뼻{k?MD+|0cQ3͊v߻7
Ejk^"2&$/S@'Bh?#թfK(}dQ@d4"4;[7 HvB=*In;7tASu˙[o$sYpq05b2&P$F8@\aJZeaoo0\P`#jPdW}eK*u;,}@&h-]T>07n'(1".pSijCGp¶ܜX2a4Bjhg75p (t֮	mkaF3'Dt}0iJr]s;1W+f&3%ⅴ͢r9B
y9x<@L4/*	[2Q~E;f/PnبݸmE֖3u3Z%b
x)sʽE,R
lp,z*s,v^7t4Bo}H@g}JݥLhc:tIYt=RFҍ+vgkݎ=$3OZ/xE7Mn'#eU搏n7tEoۘuXPdgir.poMni]n/F|t;aѝv8SYEΣ1$$Ӣw	=qdtȤ{,]e(*y{n?,VTdxrƅOAbKE}t? S}h3ڹg1=K}!}>h҇,z>;u&$vkOn{usCw\67YX }+wC=LZXkcϔLVGAsآG%lODfll
IX4$Cd[p!a[t>KJ蜖0;4=aғ}`bUڇM9NZ=Y Px} -9@_zEpZF/!&7*̛#==F	$d}CfqwFX-^!
Cߵ{}AVmKdC<yEZZ#1P$lAQŵ1'%SI?K1pJA.8=їG?,|17~n1[L33g,[}E?A>vFc®.,!/$_-,Om^[a?zQǼP\fsыym&%:wX\[\Plv'I#иe퍛;"noY\\*Q0ڊ䟉f lq-/4<ޔ@A4n|~@QCt>^XN&\O|jD\7v=C'n?я/${3FB{ccx`8,t2Vye%:gx#WXM8p8i\\ōڱ!0ym2"XkI|/t:f,QY/xJ[GMǿ3P9;
xo6-#
WC.cZ{ŜvK&xPhB!y]NϕȪmF>U%Tlq&Y~B/Iu%߇h*-efu˱IfGlT
Y0)Mkd6nqBr;b`Ow0hŢh\\YkJ"='PR󬸩7*P\/q+[>:D[i x:O
%+wS}[:e_後3Ft]oMĹBiG`*,-M&8Ufo@,+xӮH4f1OToX[-"ћB؝^>5ܠ	{aOZ/Pw0hi(1Vn{>m跛D*rx^H:'7xa25ƽP\!F{yQΕve2y[xe;Ҽ1&</G
r\a:\!H19iKx1\"pE,.w0܂;]gP0jł-\1EuP
b33I 'IrW7nojkolkohlܾnCCLdI?ş5i?'~i(yXb~)zB[tB*R?R3

OT.T/DfkX^@#QC
se	M,=""
)(yPmr:nTc(U9-#I,Za>gTFtyy.썋G6ٕ>A[
_Z+~IE4Q*+)в#.L?3J{w0W>|CƎ5Mo8ߞ;'(]i⁊usmm*ٳ+WyuJ#x^[

=ٔ,䔥H1&Ejq&9X;\e`ju<ʳT([=;CZ@p;b>qZM9+e	#uzDDt6Ty$&.RK>`im*ER5RƶOMWgjVȅw+>l7ap"zg/WL5RsQIQFޯ5ݎI5szSo@^^
UiTImH/58ֱk{뺆5]𘹨HoR/,Tl.]qeGc!mQYjZM&L#&X#%:D'iJU瓑G?:ȥH-Kod#UdDRomjiijo\=ʼn
T0*cylcP55ZkN
1I.nQҗljR-jl!W.Iե qL\ޓ`6JD>Im6U/j\zKkP\_>uT-^!-Q1͙/;,-%!-ь-SЙI;!=e2o8K'Lm{,uȄ7DEW.:
I{hW$(D
7+Ks]˲zOPtA\^[;![H#
uc!j'[tI*8y4$r[&̞`"rP\na|+{ݙսw	,FpX0r"=q
%y+6E:NyG_B,}}v7&/o2Qפnq9s!r(dE
NHk5'S4I+RE=mD*ww-}I_z82MZDrUZy5e=1_} %!م>f[d)IƈϷҍީŖNuC8#2W$?f3Ft$P^EBS\v(Rʵ5WbVUȪw4+]ogs@'7{|d9;B0T(ۅKsF+ebeT?QF2>c?CA?>['ڝ#	)96r1\sɼs`ܑKdݠDguO&21".9e#c{%6VvHt?$Pe8Ryq	[eH$yi@|a.jsI#	Y.Kk|qZ:Ƽownc^Ns*y-M;rN/^e?Os"iס=FzU4'bV;;i|͹Ry$kLf:g0ь䒺r.y4~(|qNH"U{eL0
B̖9aj'`ex5@wJwr]J省rb8Pb/2LC]3|0Z*Q#`2nݩT1V=)Th&^
??g'i$Yǘ(L8SK0}y'!_RdrX
Bԍhq{!;a0{f%4[AQWq0H`2啽BE&=2S
=L
_;ޫ0|[9N? 'ӯRV8Z:W4HemZّ-qIptj(58A S;ݨmX߾\R{}iɝ+}RUbGC>B&h/rGgJJqzI={kҿ0b&ސscOH:nAomU-E2K2WTE8SO*ӷ
@_.hPT5̆r$"RepBc`<hn&"sOH`A%tݰ` gZ:DI]hJp>cm*ѧv+4Ť_JqOpJ8>%\0A?@!h}Xh
HFjT(Oty:RR^XU"MxRZH|σx~4MP
iIUPuQork@0dPKl&aF
YUCW]Aq\1x^]VO<ڽ'®\k&C|S<iB5NO9]_֓3`)Yx
&aĉN癔j= 
gP2ī5]-'vbSm٪ܪmlOY*F@7	^@|xaURâY 9$<.)JJXk⏿$׊") */D}Q=cX㜋ėaFz%_(ˍ'yI*w"ϣ'xSWҰ/?o83rx"M-߂gjh|\SԜ˟=m.oNtil; %Dy\N!
s30i{92ìL9;r|r+|<;HtU@W=DʡDn|*}L&WU|**kzEcQ)qo9D1~:gV%6D~D"9ͣ.|ˁAq=ƏgɎ FAHtr~;)\W/8I!!7
8+ɭSLM wY)R=3G9C$}MJWP>&q#̈́k/|	j6jm
i;&dwfAF2KHoM?#M/r^=<üV#Q
1WCin&wUF|aANnZ^YLKrȷz<ä_}G}WIE{ZOj>~CiXRJ^!ZyK|[:t3?e]JO<چMLmU5CMT[oT]ށ;XD}㟇;	69R* 9LRNwc`ˑr-҈),RG}K}ɘj6	#5sVqukh
fїV)h#>*	9~gJj\6Aw)j5,wpTʩ]k	JOk5,LyVԧ4I9FqөЗ_z%I^t`'\$OrD	Ճ9Lkj:35/g0=kB,IVM46Dq`F<8Vy{akwm)6@J柮iY5tPKKY\"Z.com/pyjavabridge/event/EventSubscription.classX	x\Uo23o2yYڤm'
څ&m!e
X^&k&7/)Bq nU) 
iHQPT6Pp}EVLifTO%wϹ垗^>|219j# Psz~õ;&JxM+בvҳ@`%7ִ0/ˆx_heJ$RY-7]Mk'Z:nWSG_OTdk;
gELZj7DXV(?)"e:1I HF;# JdS$\.SIӋu3$VꘊmsO	
	:p$J9~Kl\,jsL:L1!kIyXga9:bao׭mY@DJ訕b̪تQͺڊyydjٲKHeNI^Tp\m3q23'xst,""<z0F,/63avY;&J'1<4khѱ̘_ĵgJCkrܝV#&HiP{R
t,
3rLt-WCKö,5(^))ܭㅰjXc-^sRKU}f<+
3(ȗ[[4	9=}XSz:fBzp9Ťϛ s3Kul=
'3Ͷ͙p/&ӨRcZFRc2nXncrk#zHܒo+bR/ʡ	p\|`zew8np.2n3cqmD-0-Y1rxrtv/iLI퍥6ma\cɢ-f$1XW扦SSt^1e
6]gZ P&H!of\DSR)+avĭU+0%<ƨuKt:fn!%1rwф}vrC؍ ɫz,nGJe9OeZ؃;7)/@[$:n^)NRYfM^WCRsI>M)5yw:>yݚdN05N|dP')D0NqNAIJޥ;5|BYj0܍hG~v

@)/}0JStm}uII#En朄cΙ=5c?>/]=UȣV`6h
:`1hƬUʜ4mV.gLY^ә*}mr/Ɇ:~_OP %P DyUoGZQ	." 0'ؑ:=VSr'U51٠2{G=122Җ?7RsZ/clʈ#[K]ag`H&
]`NwZGêanÐa,O0IL5	FJx+2&&fLa_V!Co-!?µ/p^^yj^I9E=
O>5׿ȷQ"H]}C//qT0B
 ;;|Tfq]'$;`9{
_OͤZ~5:
sR(@~*$nRR"S4R4#R7H8(>h
ĴH/W319T[X\XG"ŕz(:0XimO9h'\\;վhhhhhhh9{yt<ýE<
roN7OƷCsܣgzyηw\Pn
5f4:T%?@)qfpY:ھwPFPu"5qq|jڨ͊=OIGahKϲALHN"=1.ª)la\?Bh=WGhy09jFcа8]CͱKcq2#VB_Bw4T4f͸&
{
ko֮}ǟ|xpo}Fހ+QF%3[u9
܉:C1=
R-a#H3Te}3{gA@ލp&(
?9^pVƏ(Ce
q0+c}]G!^FO(k.DI]?у5b0,)\M#弄./
Cy|D!|l?E*fiHX3	O	&H_P3~e|?4@v+ΠY!,E'n@^Sf^rZGG*,E{nÌC7C3)8hušYUMx"̼:zFpi4zy6J/g|]_\S52Y+fX3{rl-~22	c;
1TG6(H#/OH^5eQ\PKKY\com/pyjavabridge/facade/PKIY\(com/pyjavabridge/facade/ChatFacade.classRN1=!K-P	B*"UZAٻ1IFS>;)~Ϝ9-/
QLbYH3=9e(\CjbayDd<v#ʙ-iF0Vk_1\"*",ca;w/Q\tF2C#?,o	a(:OQyV
S#B}_b5Zuzlp91ZtR1^{照#R\bT'T#yLئ#ڥJrmO9IXF,35`؉/]wdA_"M–T6X*~v\l5
`P|K'NQ_X`	1I?LvW>]a/
8v({1{v[>{PKIY\d:	@+com/pyjavabridge/facade/RaycastFacade.classWytTWɐ7<y		1ȄgKJ}y$L慙7`ݪŊ..ZTZ%к6(VZjUjU?Nﾙ$~v]x#_^b
`Tuu3¶@J3fګ5m
<V+ؙ1`mӊyEUL	iZ:xʽM&
GT

Bفx4R
k$Y.qE&-i`/xUYW&5b]vw7"a![bԘzlPpH[q:b偦AdLdo!n+r҃0N<8Ltnn=82wxpA%LBwSpi=5bRD,ld~DGd&m8c|2L¹S&TS'(۴oޫK
P)|05#u^Ci{7c]Lg懭`߀쌛.#HzĐvso2cdoߩ;9/S'ڦMyN#vɺ^tMC;$4_IP#qbEQnNd֦{&>XW4?MubM2۫k}Iם4ch21E#y{."0ZD"Nͮ8{l2`O~빞*~oD6wUp?I`N<%xp)D	?^JтUkD7֊~^܃q?B6shQ\xP)^M!(6"%T(g$_dԇ1|T0ZCV2f[6%#׀cђ1bnAIvn2/Ree(X%2fs}󲲲.#䬼{;WB?{c\O:^ge	!R E+8,*=!KOHĄ(c)!%1er-2~EL}!1M>N!LƬ~PKKY\Y$'com/pyjavabridge/facade/RefFacade.classX	|fg;9X`8pi.\ 
Db9װ!G VZk[zZm`+Vi={Gnn7}M|cJ\SV@GH{e#,4#f|@^Uuk(PS*05du{%Ӷn!3W^3S?M)(F;=U̓ǣfwq3l6cvj	Qy
^a׈^ѻJQ`a)Bn$p=bEF=FrDn7#%	Mʞb
ioG04->Tbi*c@	,*P{
'͈U.8w5_6n8*RQ'#0>jĬpߥ6&̶ki80?76-kPP'PuM<7+|W莛V$=MEysi4Zd;iSFy#S]#U}8CRA.pIg@`TIm)X(0%:;xа-t|G8eZ"a3b؉\*0!4c2lEbT
xFPR
eEg
fXYr(fU)XK;1w
7x[
uʧTFvS\VZAFRWqZ-&c|0WY6iMآb
L˔A*|P P^\
i:edmSB#C5XThȶH;wU6ҵt}Szl21	:&a&(>$YcXQDZUC]ooF|\M*n-?LjwXm|RUu]z5S֭أO^|ei$B
uzNiU:+>S2ȾGI7V"ww
;!En͡g%>⳸Ѹ)3vk%ϩ5cuR99S>lTYl
ztVU|	SNra
Qk-,+9
d'B\v#V|xs58GWFmXב08mV{9+܍~L&1ipԦ;a2dg>P7ly&b1>dKYXyDzR`/.%1SQL);cl/XoGx"J;ksĝ0iȽZFnT'U=gph=l#1gș2úd9i95	UG4b_<Qf8U=hX8}nwʞFtpݶl#yErRY΢$28TSF{DURpB3lOcћ;̘5YI9:암*O^ʴ
nIk-CR6!1|>\Փ\٫4<õz
r99om)q-%ܾ?06}YIL)5BI.(j7,a~XԒ`$8<α9>k#hW4 (t%i>KFd@_dM½ՒLS✽gdo)R+R9ReMI6чݒ  ?w@$5`9|Q͝w$$Y˵H8[Ew^xD|iB>TkPzA'z_
W+|I?
mq
ZiwF9
ICI "M2_Y]h2ߜzOb,ѭ.],ErviO׫j5$/
B}VtxkŇWľ7>6Jy2>ኸvvmg0iLSo5XZl`v4l\q0>R%bG=^D^Y^,%X*(20w2y9^d_ec^\7ns]
\l~}߶*
[RjTd?Kg*[fPKIY\7	dp+com/pyjavabridge/facade/ReflectFacade.classQN@=#-~FFĮ
Y5a?bҕƅGD"n}{Ν{g?>\4L$=]^̐,@Dд;23z!	:;6HR,YZlwoNt|3*qe ~KDsCMIOA#~4ѹP|<&ay a0p2P=k(hR

xY|{,٤X'yMBZ|Ejj^zZ=!L*"ab.CPKIY\d?
,com/pyjavabridge/facade/ParticleFacade.classW[p[]ǒ|-[8~%lJB`'Ԏq℗,+,Y8Zڴ!R<tG送ta~0G~ιq:OtgQ
Tͅ΅zdwtz.	%cN2T&;rB\,(N/93hw!KJ.O'pPMdh>"P3|}\&5PnԸP:\D:ӿqrP)`SwnA8t'zP"3хH2wh1Ibd9@[,m
C3ć)DĹHKY?|+C+7h(ɰb3|s9hWi*`(rtӀ߅.tle$eJgp{=.b?Zpt
T.v[dnF[\AO2l:t>y=F6888ߠvY,2@ʱ#.ܡ³©jӅo[6TGZVϫU*Hz0ZN :)=(4-Z.1=v!ClH%P29OGR:ñdt$3Nh¡d(Svўe:r4~(h8z]InKMϭo<
GBB@	-k]5-n>xϭ/ƬTqV
F_%;cq2"L$.ΞFrhNsb.(Ki[2"Kc"*8©l$Î;z:r׳gJ	#0Jɨl.´?aOX	T":ϑ^_'E҅/zOY֔eMYiR/Ulv|tCVl㩅L8r8tQSErnZ%ءo18ބx]wWh>>]V0ucݿ1*Fh;QEytP1Zb{k	xի0W9H۴Mt&P#&q{h
Z;wT3|6EΞ%E6\u-$cg0
ݎ#GҊV|%ӳ]ta};U&~#h'+#l҈OQ6òI6ël	8dtǟXUkmfc]2[/^9	|e7U6~ktڷ.y0ta3cL&oBfЉ	dL
_"&³qJ4ZF'24Z$rjtBD=@hZj5zaz$^eM"U9e@cKY_xfk\lT
oCe8شKNEԸ4g&=)0I-L`jwb
HݤMx"~}Xew]{b|E5qnGOa8r@!*
f&U
&գ&qV磈`$`e|Hˋ웦芞oq=_ȭ˚DR 6؈b#z-=eG؈F4~F$I#%*j4R!NjyttUnԬ+GJ>GRs_w58tMɥ;,Au"W1lfB5lXT-mnմvkZw!%fwrK0 5=r+3@Mʎ^]].Z[8hU֋0+v(3w,[
S!>=v
R_ppgem+kٕkem1s~yeU:Pmx|dO'dlɿ3w	$O&D;#3?ʞ#kvyãuivQdkG(4@?GQh Rh):==5df`lk66v|˜+PKKY\ao*com/pyjavabridge/facade/RegionFacade.classYmx\U^'339L6i-5_4aJRD4Ԅ-iz2s9ɜ03	I{Q
򭶴 PQQg^1OOś}NN>:vY{^{w{{"j?y29*%DڜQ;hD^F"G]}Lnʍ@sp:ՂՌLj`/'႞iaHQG~YuP(ܵBNlLAB7E$X=[dXSYD/2_MI&m@7׉J)'Z$Z0Qg&
-t&^jZ#Q堚ڍlB-)H-%bu;m9F<kF-xZOHiy#3aLY=/2ea/ءGtP-M^t-
eԄʎʢfI]QJe]qq?(“	Mpnz/"]+ܪGB\A%
	.خSn#WS(K3I瘛3sLi24]Fv6pb/-,
<4$
[6*j2,3an{{ή;$v`|2ۍ$^.=]?<اv}AjFBVaÆ>["ˊFAmDϴn$XaXJ&]5V,]#VVKXgO<@4I#| X31bAuh(3vCj,'`+1rhh/nH&c8ȋyQ8AfmYgz^.D/lfk?g.Pq>Z0>+8PJ"móRzJ۸OeWNM+ed2Ɲʡ+j\NelRޥ+R])MHq`m%-/YGZ`QM$HÕѲ*!C$%4wF(ʷKU^_`g1Kh|@h1Il8F!_ȩCZ!e$nD
fѵRkM'zw4-"-gGfD;
/9xbM#dF˯2Ж4+
)~K[ES.OjϨ.yOGsUT8KpPITE{$/d\Qމf%K^ y2%PtHg
>+Gq4#9ʎSx[q򡭼7HU,&' q^\,|UPV>N!mD]2Kt7GeXZYSA?A(EZEռmTjQ`UnIDUiUI§QRtiƻ!Vzֵ1G˅7W3YsRLfAΧ9c5fXejj	7s&4LOGMIH!}
SH[J4IAd݈p,w.UʨIYz܃tr7|gY"ָx'ޭq?s27L5d
&e~oY@C
i`C#2@ς1+;MmY'%pz?l:V(uϸqQ9QyQQR!}KH BntpA¢^$_^aH>ظ(#*$Q`^jв`3%¾(z;j`JQ*̉d~慫)z OїY@R.yPJ(g2Fz-ABOU!;t
>9LpH	jzvJ}JS#38&h/qt*tVoJ/bz^
.
>*òUT#9:pHr
MuӄW2`2NdYہ,|nt?sֵbbAVMd<@UyC\1$pIU
C|0t#^ŪhhZ&&&MTA:!0)Ɩӈ$x8G?G{p*<>r8}dP@EA~}o7h?mZȑS;,\A&nm4Mh4miFӴi@ӴWHW
!pÞ^cg
`\O\cU;yj<9jSH!\5"3z0Ǜs\/țmqTn"9\pDf8HAq‹/W$DE7nPKKY\N<+com/pyjavabridge/facade/MetricsFacade.classTRA=L2I@31b"N V(,u5	Ct2C{č**>@Ïp%nBDt{N_"^ƦRN[lY?e,gUW (#
@\*[YcԒc[ꂈRpsVz"9DY<6Pp
vN˸hsbbL'mڛxN#"Kt'9d%fꋄ^0u6kƖnUz
:+._Epi)ЅM\\BHʸ 
@X[Xq9ؠ!3t
f.F\hF%Bp]ƨ	l'M7!UicO\5u$YdFOPu/O]J[̘!YjkҪ2\k'=N;5^R'rJpu\VPؕک5|Ҩ9dVd8M,WtG*V+P)iCUtٵ%<gEzz取V>Zp-PCmg)`6xy!CQA5Ċ8hA.7<ބE|
G|nO_C@2z᧱$t L2Ns^:D=Q9]HZj yi_?'x2hdXv<"cLI; .cx_/BrPTC6	nO`w㓘Qw
DPKKY\"/com/pyjavabridge/facade/PermissionsFacade.classZx\e~IN)b"ThҖ60MENtdfK
"(Q#poH׭]^u˲wv}9sf2i>O{}w}O>	S,
?uF,iFb;5T"qw
.8e&䦁lbhČ
Ɛ5c\.N.V+ԓIF)Yz'..WuHKt,DҌ37|N`a\['F#=D`$'QKx:;(&1J'bIcvK峉HGc8M2Q,vGT⺂=$ihtykWaX)W.
5Fd.;vmksWb#3Jjgb@mrd
y{s GqR5%Dd[֢AG#b̻ioFnIzV	,'rs,=nuEdӱg3ɭYU`j2FgCC>ICx9XħkYuiv9Od\[wjMԠiA䗜%#ݬKc ijl1S٬1!;sL<@U	%JT}^go—4<8TV&Bhi,{FǣwTNQƢz즲<+xV*T&@{=oX}ai[kW5{`,oy3:ج#)#_Ȳq+ke^/tU܊q7qߜx"e21_<=h$wلn/{lP /嚘?,=]=j0#3-ى& )euIR/F.;k؃[CʩJ`Mʴ4YmzlX[DNQ>lل%7sD`-u	8*-B鈕[|B!1T1T#ݷReduIEjvHA5.Ik[_iU6[^'!cMYY'甯x~i鑠҅yqBFW?ۤ
BC2/XpBT~J.j|Z5!aM躨V X\AE?v'?coϹb{v#54skh!S]my-'8f#cZN$/U|=(%Uo<F2ȟM m,ޏ9ʟ|懡55	Ajih-ljnY1EM6Bm
45?Ӂ֋I&_땦e!|S
Njs,+~kh?	=;U?AOf;}?$,9=
gHg{ZL+E^w9hX,se\smP<*OE8iT"3lYfyy3iaG rO}ʩJyGێ, ?/\d[+sE:TK莣VÆ.%~-6;"_(:B:^9Ro:#?:,}nz0D<&4EJJq8xmbB2#,A'ëY")#4'+ 78Do"7TD ^Uluk޶>m=ޖ>sclc}ɷOv7]b+yt!
Vd^,E6E	uow0Ʉ	߃HUٍV$r=lnT@Е2,*tj6k؝J`3Uh)Sώc=?Hp#SV'ȭN["FN^B$°C|zioXY-|7b@4v	p߮E5CxjȊxF90~#⃚h|QZciN,wl=Xo	8`G(%Ј*$%oü,Ow9$1,E:$yf],$E28q=bK}!E!вe$KU8Xd5/ɴ|Sk"$L2E.$_|pM_I,ZfrWwj`Ht%if"v-g]rM3>$?~JIfŏ]M Xg~?={Q2[sXl@bebfK;aWQbO؇SWAW=G;@jqS=xn>	N&7Ci9{])RjԾ*G*g.86=J-N0C<5y$cУ,Ȫt.P)S<2/*΢:C2쁠UboZU؇ڨ)hG9G`
zwsE+fJMQu(zuQ-3WMp8\Џϲ?b~p|y*o KdYKBw⿆smX֎~fD5js!';Yy>2]k,[,Xx_ɑ)feq	"7З283F{y>Y4²>KAԌnvfVPÄaq|ROpxҙkU6[Y6.u66YL%L^7HNy uK
Dnk6oz0:b
rÎSa'5y!yZ AxGxE@,Tӿu"" PKKY\s+Y'com/pyjavabridge/BridgeInstance$1.classU]OA=S
+`A  UR][("L*i;lݝⳉ( (ؤ{g{3wg4ZBf0UxyޕŒnfAyM0U)8Gt
jD;Li\;	lR*\+:q@!t1SnYztԴּZJ{3NU-mkWa5qGFdkkR[bR7kes*fh-	]s2JKQOIqdh'%UB@\WVn
01CǶRH1Wu*T.(g;"#=-/U,g%r(CJ,Uyy<]w?;~2HSB:,wyYhRF0n
6Zc%ƷԧYuN*cY'1TNRy659QYvnAI{`g|)fUv!
3%N
zP
`NĭӉ٠\@_PKKY\ޫ|`6&com/pyjavabridge/EventDispatcher.classZ	xT~I&I EJe1ANhXT:$0230.uv֨u5uC%Եj7ZsL&b=;|ۗs=`9&<r'qNhg6ծzݒ
Gy>x3᷐KPkRímvv4(%[qnt-^ӵ/^Ph#"I;Ӌ怅bpq}.9+~δpga$5'h|
0H[Qɏ dbfc~`y`z6ئmˎ{_7l5D-;V%v0>$]ERpf[GY;dK:oQ\
]N2嘯9L-v_gk
2apnn⣂}Y"\fc9Y"?'L|§~QhQFv"m*,h^+UzUgV&%	mh(/X4.Qs^\β--΄^e_Pp2ذ4뭴눉	
BۘH
#^윹y,۽J:UȀI-;\&ԛ{1FUFmʍw>qCK00`PtR$ٵᤲ9T1X^@һJk}>&396֑*^eI/mt9]#jl۝d~~m5Z֫0g=RWްKA Gğ-eW8SCIX6?tZ9|pt-w/Ee+_&	&޷p8TF86n7#pB[

LD*FT'XɒRlWQ-GrMɳTgN7*N|U'WMv{iwnń\J)#,)v4YQlcG^76.o^ܰzբfqyI\XR*hWHT(X[5HڭS_XSYrOZbJ+{IyrhBSf%*IL\Eή¦*;d=R@?b;%Rn
wȰwjڤFuVPrNR֥ZrU'8z#VhI2ЮoX2ǔ-zu$fYGDj]^YK	xgTm͖
@wF:(YhJ%$Cֆ;%ֽgvސ)*RK	BJ)UCػBVZҨʴV
[CVdʒղFGtaɸ>夭ʝZN;hcMgq:a3KyaF$afYj!}1gxA~9S2lKG+D+cɕrw9_%DĶ;ky+4-[!^`;_L%7~$ە[dLUk6Ԑ-EnuSl$P'H

6ÒMvr{'A(3"f>x|Ô,[I`+VêL/eLyВ=Q3{ܹג}i:d1yk[؎P [̡T}<{8tϡvKaNuT{/8meNõVeq6Id)߳#nWI3Uq*߅RGjZb(R>^M,s:,Df8$ǽhKSnЕNDB~x۩X._8`RʔW-$Kw-YMɌV~g-y]_Xm3SΐA}L-<
1NPW!RwInW=U>CՑBPj?}UCܸri	]|5Nq2/SZF*	7)12N53a@j5<)-|P{{6
Ma	؎Ύ#&U&#[1x|=Eo4Lc%%T̒C3K7%pˣQ;S;a,BgG7hd^Ϧptg1&@ꏕ8
?+bh?yc1.G2\aIb5RRYfeTʠgJ+{(_;_&(c
sV!ev]_}Lԋ)
=RG\=Rt[r׏&*r}՜}՚q/&	LLEyM`J~TWbZ5&5$qx@k*i*m2@Dz}Q"I$)3YӋn̨zQ\毪*Ҵd7+

nt.|buIoV*U|܏l
CӪG'Qm3QYl
d[Ƿz98Xgc1l,AKj-E+j-sk42-Ԓ2]'Q{FdG<)C7*(T܇Q1'ּ7b\
HA;=tW
.Pn̦/.zzq>|	|V}>%E\GH򯺀R[\m).'K݈<{ra{@r{:3h>z6 Fn^_Dyi|Q|ڹB1hd뤡aGs\	(OR܀xOE|
Ƨ>C_ղ9VMʮ<.q-c>O@oXLoDޡ[vQ`S{dQR'=s(A67uF=/aHOӳy͞Yޠ!A%x5Rd24>g n>QF>|;U0:ޫh7=1SjlɧP#VWȮu03P2RL_MJm
1wzh_gx'koAb^Yf{LA7܅sx'm\(	|aoBߧSbi)3a>LijR|_لJ+~$Q<'yI:O$OVLe/~1RNnR`>}v0?
ϔtWQž
.%N(z"-)Zl:?
{	PmC>E}[Wr4T=NnnrCM˼g
ĉ+w~޵*ڔO:cq
SFVG!FeC|JQp:]QPvb,1Z'Qz(4jiȱϷ1Uyek5mUG
FZ0
Eis~pc39ȂbKc;f|Ed4]9r%0+MJIz'cݶGbڀ;${ȩ49hbOB,HC(ǀ-Y̦hMC::TƁj*`E6Q_۰,{#Z;
_?KUSÝhI0@_HXWZNF,Y]7.
db5bNPT6,`868Te ">eq$LJse<w+f`PZă+0(9q汵!V=4 bAbɚ
ϲ@,lA'gh\\BuAaNZ=paNJ[H8AvN
F@$Y
 IV8QfO{iC8>IhCp|=td;BSrr1}A1DD_`hsQ[]	728I
\W2Rrym󻖕'3*Mp5~
ԎnzaRr]|w퉟qqfQw=D݌ª4`ՂvLXӝH:CH͠n?^QU%؞K
AZ
Br
G.iX"+,Qԇ`
BW{	Cۖ-<僇T	m؋:a	۪m b6ra f&1xY,^C:l7Đuũ0I?!M'lN2Ptzn9ӡ|4ϰUYHLp`u2oHDTCL4	}/ʀ-͠g[ռ`hi]xR߇ւ{\(j¡YpB)%G.}Μ6t~B+ruX8[U $@MD‘k3&^_RKƀC	1gzer\{PTF4\mP"c&KA	6t+j!Н2l$jv#bFce1":dׂe \Xr+CiyL_X֮_%'k-NeYXl npmcz*u#ؑbAF*h51kPǭhclSbD3,n'-t{D>Ϫ- !V&
mֳڬ9C[QMl6VX`aճ8=FW{r!G:>EQh'rEGYclBƗq
lX;FFk0+'y<Y;A׿y[ORM~hohLQYbvҤSj<%4KD͊S
]iMm3QZT#w/9SԳN%FFF
C#?vMulXzF&45*VIjT@%k?6@M&vnح6vکk/(e~9ɻw@MTlm}f^ocvn~Z{P$06=DgԮj2d끕
ڨvH
I=0zd4 2_	WQ4=e?>z22$&eѴL,<{Q
R^m=ZygeoW-gPȇ#!8T3mQײ.b7i[BVL7c}	덺m%6/!߄PM!bZ
Syqu8?AiWr|PͿŎi(f:د
V:74.T}Ke>l"M[쇸&]BZ째&'Hbٯ_YUn
hFǬj X*GEK;Ғ
92+r64iڅ:&ō8(\;*KʺĕMTH;,PkJiOnvijdX<3n?T؋f8k^FD6fZg^m>u
|j[<U;&͔vj۪MJ6V#GXHChhQ*ϵxϷ	Ѳ0Ie@/T|pfQiRȄL>їi->+nJc;+`j2fx80L&?VYDjKCjP	sٶZKI>ZMx	h+NۆxSH.SPiOf,A&Sކf.%(NT^g|g,pMո-y䧱7Ąf݆jRE)]OɈAf\6\|O)]GU[<@']FsxF'R
켖di%J-rW-G-
{	rDZZNk~JPUfWV&3ZWn.7i]6	5D14TY<2ķa3Y@˭Zr}a+ rOp9?G
2&UۄqD*7_ZIF*Zc,WR~s^4DW~]oJvzfS$VKlru|3Tֈff2J,\*%0nz~oMfC;u9ݭd$r-~mѬ19jةvŤhnlSC]6̽Ww.#D9RE$XWbG6XW10xw}ۭMhyCݒ@m=|O
7QBl?3%qnn9.}O򧐓ș#Fcn"[WTş%En;?t/Xs1bni8l?b5p,VX\M7UE*ܳĔ3&Tn}ƐP'"y%bx*K)[*:'|~`TRqaw}q2Ȳ2 =cv/^(?k<5xAiI-*kk*18Z9Vu
KdD_1сXi<[7\*2Q"cpc7Zؚ䶂ΑA~<2+BAg22;?d0:rۮFDY;Pͳ4ff!c dhrCB6jSH~C-;''C&D"v^0ѭ	:]nOi)f!-2Q]Zs4yvnG<\Sd5bp nw2 KEˠrå)#Rf䀋,Sd[`;׏'cZfq-NP-r,1T"xPٞ1*"bۨkWTIT־n5157QxgN6SMhrՇ#1CԸ'Z6XK.1e%	4QGI7Qaqkka47D:U%ϧ,1Y-:|RI8թOGj"J-1MLG#UW'ڏR3DS8qriYbw<.qzCW&jd8D8t'E ̵H:چ* 8015\[ħxO90dzG_XK{^0:TqB9Jbe}[yjCYT%%Egulm	jT|{?^J2B>F؄Ud	Ia_QG$ea%TF5%"d-L)rݺhܢkEI#S,铩z4
#؆dgK$IZ$aH4QCf&(*P==ze7Kv=pvicb̐Y%{/ȕa7&fJ3XR…̶9 q"evtpx[ wd^nũr<GZrOv)
"PRDSC-KNvWoGy0P\h԰?"")GyAӃtk
hKhOVGXK2Y97XK
YD,K9<'ɉ$'J*icW밸Э6-MY/Qe]~i/Ćh,\7#\;SΦ0$hv"B@]ĀFݒ;Hu(ӒVj#
ǒ{#Gpm2Ry;qN-'ɮJ%(JݹA'䓆|؁9	'n4)ѸL_	ڗi|.O&?הhR-|{.K]#4-ϼ&_7Dox PppԺQq6(& fn2g;?WM?͒pΐ&GX\-@B}O/63g[e$ѩvי
T=C0ÑݧK97។/*bc5UCmn\5-;\ٿ;<;weP'3l5yͲi(|'Cl_ă
UHvńJA)KخZ,<[h54I7\Q"7h%O)eZZ
.@GPPѬ4,SRbQRj]Kt}sU=':&uV9IAz6tg[ô9]кYZw-o⮙ghY	>peCU>zcOrStSǛZ6t۟1t¸
R
IKM-GZbS
cSWT]SF16k-(m-}6QS\S;:="^Gjc,X'̦,1bdEh
k,82S_"1C(G ~J,m6ɆMԣ[(Q)	6/=h=Ҧke]N@.SQ+HY@]6|֦S
=U`FB:6O;QQEhh.9"NS''[)tt2B㦣1-mVe_cq<7'=2i2sҖ!
[[VwKڊv$Cpe bt">4A7a\hQkEQmBΘ|B'5VZ,Vk`j!mjg &jąVM0렷Z@&J]`ij)Qnʎ.E6sh%χvv{`r%~tOSՆKЮkhMG+ubik7آd93Iz!na5h7Ydcנji>MeRv!ZcjwyَbH;gkN_b8vSp)pԾSu⋴loەS1&SX.uuڨO/ބkT(sJ_|X=>å#m'-)c3A9I%
%IppvŁʨ!/h0jgC(_dh/[+ګ-/Q)颺T_iįWQY:`h\y[!5!d޹\igXڻ{jwM	RszY)Xڇq6.3cKDT[ٝ5pM[O>׾0/-?۱I*pF|O\Q:>`s
,k巶s{eq3Xڷ5I
V#:.Ґt5ڄyJ*J'0ysYFdj?!5%T3srSEMB~\N3&گᄒʉF8:ә
]X$%2h,Pg{8MLD1*Sх{jna%T3]RfX`M3p3\(,Zaz7Cn=.yE;)z/ռҊ9s'-\> 5aTدLg3#K
}>Y`}O2Z<}&"hL}ٸPKpaN6]FĒ;H6ʛ0>=b&h	0u%t6{9>ǩ`"5DBĊ7l'Z|>yrĹ*qX	NH	6]^jӈәEe}H|Sʾn
g鳆5aO(Mj賑7Ç$8פiI>~3	hI"bi/؟4Ur{niK$a0Ups(E BZ;{&_V'茌U;b0ul*|!i+\(;ťd]ú{yNNگv.1c-/B'a]_SpbAE Y\`'HfKlJ;~=>Iu\jݟSawG^CHfDR(G1*>oݑbSrطDQ۩ASv)lxvu7^E|\XyELGW<(87=1aW
UwzFywJ{hIѦ
c$`hC+
ʗٙR^C!Q8@.'T8$`tvjfHTmZHeptդ㣉h>k>O_krd(FQLN+Һ'?%W;Z$5DQ/_BJqu06{d$QukiW
:Rcp:j0GP*
kG=:bp[".q2	/&HĽt(~G^WsAjzi
,3D+3,~2$R!_NbNE8N~؄b1jQЎgI_E-nѽGBtkǟ׵(isO&ʝc6פEkV倥($(mNNFNzM3[A6xdRu9e.}pQ(r.GV:Zʇw*`3=o&DGyb	I#2
.nyi?%`3ZNv>7Y>O%álE4͘Tcׁnv=x,Mc=L1#!08	:
gt66hP	tU1Uq6]7EHTɵv.8w8%Jb>En(BUi>MP_wu:HOq;FC]qf:	G"YF	+xk` s{Ǫtۨ	iHX'i=];Sr1Mu6;M>殪8T`يg8864Aʞ4
dN&d3G3j'tFnҍ3[͙
91#1c=elQv]h#q)ZdWz2#|#Iz'S&HB]"y,Nvkp8B(So!g[pU)!,gHqϸѸ0n[[d_.,S~Tq4jShoSoݐC[3D3Qrϸø0KVm?0Euߣ!Ge-r ZGt
>s0H@z(0R@Ƞ3>|WEpz߳A/87(.D|?_y\4,a9
Vb%0Q=Kaz^WfآyOc'}_=gUczX'&᳄F*C	}VVGO™`)R@g~N`{RvɬЫ9ٯ99ld&sw@&1yј8Lcr&rNf퀊0/`,͒;,m~v턥; yu v|?}~V{L"Uo'\.M?k1}|;L߁v];]^xv&,:0iz!@,
\J+0 %.e;x\x%!k_JKo(4A@|{X]zi,.k/҉1hQ?W)RJpOa]m
@*d"Zox jsݲۣ닉gnSumӭUl0fsY\?3/ѫ4l)Ic4P74^в5IG#b^	آnWsRD<-A:SST++w&xa|!3oww$b|ß=9 -3yo4U_$aCP=w'3v0_vkb!,iH#p7ÒېuގDzֹk̨݅n$ݏ7i`5X§J
ĉ_M6vt;^FdG蹝M8&ӣ++kb[){މQ-jb9%g
py\yʟ'R8)<~	p6ʊs5IBU6{H=/G8:+Z+ЗIj#~_`:ns(!S4obU.`G{ha`Կ-ov'`0Y1z7wt	==s6l9*]ml'.vm<^lb!N=Ķ6nb;6,բ0{p^CBc,Ld4^HkX7yv9u{>q#&6KsϫHo"#}'vқسp\Y/SWAe65bDvUdR"||tfY?e4v&OG^LГ_w?ߔOOyE=ez66E]=d!ߑ9~Yg8zuOdB<_
=a&|z#'qv?r_QͅC$NagULǹp;῎Y*u;ϻYOMgv?K9`Oօ=2K,׃y#|~ʲԞ\p|0H@Ȕ5vmtv6FFAv$zD=ǰ&
XBG_nc\_a&{\>W@PzBKR5݀x㘇Զ~(D"vyuA?}rz\T){qJD<{f:RA|,hboܧ5	H};Dse>7t;z|U6Q`%]zI~莟
|n{w%|cˡ#~ȢuBW1ޯw%oi:7}A|z_h\|XOOW
&aƧ*(]@ReLO.OaFn^}^!Y?3g\?WύyMFXK7Jz~׈9>l.3Ȧf4@6+pdui6z6pzϡg_yE&޳r6M6	O?Vzְ	 ܀G{0Y.{WXnFx#xJmðw]`Mp$dkFNד~?JQnI2@"M>x&NaPT}%.l56C)G#T`v,JEnZB|nz;a?4<a /ӟ=q }{~&"PÝMɣ/v
O'}#AK
Mw,En0$6	qg/>d8eN[k
f*okz5qJD^9;N (2L` DiW$iܚ/%KA:|9]nħM;E'z$k,0Z	QKXla*Qh>\S*hV|[=]_KgvEoJW+mTx9v1n?~gN#wL.hU_Y^p|U[ӑ=tdB3r9x졯_otvJ
_D|p;
?p5oid/}@rP6:t][ZPLv}78VʷmlE27fN"=lo4we9iإmnFq^e#z@lB\5E*Q
=؍[v;\;]kd[DxȼC2/	P_4-ZAʯ80;t'+R:TSCVj.fY^W;X}i;^P'S׊t*e&.YcZ?Rha~=%;sUd/+Yzw\/wh̀?Yn[jYfsퟰin-?vhA+t.
G`<7{pmq?G\=K6A{?š^4@Mq=dO}
D|ŞC3y4^BseuϬ{
%V߄2ya>I"ZaOtwZ_	HI%	#G-WMԃp$ @5V2!%PudC8Ydg$o=sT`y{8M'4J"oro:{휫|]?xg,n5b8e.S*ǹJcUJd$*SG+SFD7]/=̩yѻy궬%c}}py~gB԰COL{F{=.s\Js\%J*4uʮʮv8K&hǣ%ӏJПkLWl=E<jȳ5G+wpJF8BU:Vl"TqYzboyM"Z)
󕁧YZ^)FYCbf蟥byt·&QRBopk[˦lT6DJ]ЛmLRfWiNy[>+|f|;D8)XdkXcScIsjFwQC' Y*Z	ܚ)B62z(k@c,]eٲm
!MbZ5[=߂

Hs`IP"P

EEm)m7}So餾Ezd!EQ	S1u~ARA
Sajjۉ-lwlnbCO䗂JX`nX~+tٵ.r6r#s<7JNCBOlu"_w5?	]ڍlB8y8o+Wevh{3Ɲ]~ЇGTFۛ}0]P듕11fb${f{@{W4|n{UTg?G.}N<^,/-0T%Sh8&YL)1jӭۖfq7:!fP3u{a<P!y68?p]uXHx"V^UDxWa;<{cDbEStc1C>1M6\ߊD%&\߯p!yE؉0Kv[/@ewm>#!>B!QO|dOІuqwQ>]?9C&rt[[`khIQΐ8ţ|M? O<
!hn-_
		8Bb<S9NϠPO(_$
b-,i{8gCH]ԑ;Q菖}a
Y\Pg+\mIf>E#$9C+sɓ"9vyD~XES;7G^|v޵3
Պ\)Fkp	e2Ζ2F3*qN'QT2N	*cI)tf0HeP=anڽ`#uP(ag/F|8[x
vYYLG\nj8rJZcCQe]YMvKřa4`[R%K'i"4)7F%R %{͕*eO?)2v*Jڻ,kB;H]Y2G]GQf2)r&<'"Y2#7Oy4I9Ly17qDr r!V"c7n=,4Cy^>He}+:_Egn4)yOх]`эXѓOY|W|˯?[!1(rb(ߡ!(GQhQ$ƈX1+v]*L	YObSJ˻`OԷ(	OC
DFTnA&?
EJ],IK?X/WXS0eor 1ɕR4A8rP+,"YץK3!By;l}Ht7Fg=YSWE"X+0`e
J3w#LB
?>s?"PgsO|Q$M䵩{<>*a
>/[5^
29nF2M26R4qFQFʨ)c9eȩY*ܤQakhʙ	h0sjA9'9r"eMW1
\yXg*^-:Qcb9_%WzID.OX_'8SY8Gd@grq>qX..Qq8M\)6u=>UۡTEnpgL鯡Ia:H>*z&2ͨcbJ@buPDyIp\	KMo9?Lo{0cِlCH&URoWAoPkȅK1X;ȵ.w0'dߖ4E[]`Od
,VI!'9=ƘV=֪Ѷ"B|i3v˿r,M19ytF5Խmv-GA_^F/1Keq~<^oҾ,=rX%XYSŢ*$*N!˽{{h=)?JUf>|Y;?vʯvXE	(E(B
nzzu]ЙHw߻䏻4X{aT?I>Y<CpxiMɆ]Rf=ȹaWXxM}
xsq@Q8ƱpҲTXi~2}O:ydST*?BF%cLhߧNpRC@<J1cK-C'HJ8nSHqx,Ɣ;1bwww]AڑӞ=C8@2NO'CԐ*?Ln?@
Bnp6rITrlkҠISȏݴ۠jpfLJ;v̀JqJL_A֙v%YFLߪUm>|l?mdzR_CzϷ!G
S8bo2
U9#cK0]ī0_`xoj{x[Q"TuW✿#KP~9B_KCpN,r]nx&cNj7śV{.迡0`(s
􁔄2rrhZYeZ![hUI, ZEQѶcW%Fk$癩G~wtr;}t`}0*V'y}ǝ/N||~UU4Ei I_cyNi}z_b}z_B}dkCl݉ֆ:1ن91٦x.ڡ,Hb'* k|Fd%qm#]7[6{?>7BO|)o6Y{#mlY;	OYEl#d㢪Nr]wyB;t!@EY'Sۛ-"/ k6/o6jFV6OP^]=2`呎\dFf7iǔ)eWKl`6[_ߤM h]6PҺ#L,E&MnJIo3Ob*Z92Y6Kxӎ'z64N(QE:m]o D626vzQ&mN0 22Mڢ"L'ƭfE9{@>zU,|x
Eoѓ;U]$_%?.#:?QƉ_Z=G2/6H
.&l>Hy]	Lx%{»/{÷ݟuH9-1V,qr&Ƞ qC8ASYgs*U	Y;/2؃h7^RFub%ɎvښӑH@&H9I\)H.8^V
˻CVRվmL;YhȌC62lVà.h{6iuߚ/Ѿ*+pKOl-BgY
ir:e+gE8y󦟧A'#^gi)'o7D xsKxd)vHs\_O,^
<]wDp)q[fcvUq4}
yt\C"ȑP
(`\
25i"X*U:اKu)FbXRqUh0AWT
AHSQڽZz'@TlOwM\(OScviR2ڜlpPVYkp[!l.p\
dujo,ZS91K!G"9No*P"}Dp>fGX3'/f%4qI^nkGORr̓si.`EU\^R\SF'3gft.p)CIF"Zx2ZyR=Y%_s:oJ
>m#8f"GC\|"Eo6i[DX5RFT'hЧB}]]mS6cPꖽvn^mFW;Tɋxzzed)‘7j:#/h9-G{
ޕN*t=Fo`hdK(+|{ 
BHlvb%
	atAʨҎvjkRm}VGHX
hk[ojJL9?-Lr߻{s=;?$J~Dj
)	]^'~	P;0Fr'=2&%S/{v<"A'Q;GlN[<#*{}'~RZ|j-?@-o?q);ɵGW`Pp\l\ò9v} tcp<HE~p[x&q~lz7~e
F;%/'aF|3輻mcٜÌ	󤻢u%̯1!C9|Avy^a"҃_NVѼ	/?Bsz"r=Wv$'ddx]c#ټCHxV_ 3Vc&*S?
^<
O;iKl4/4
a7)Tr6MERѢTtWkLHީo^/'! vy]
L›D܄;IlJ=I>LOV21G[փpnCG
i13fL
M/2Q\kbx&3{i}0'cG*%A~l8iZ;X$z&/T;c7F,N3Hv&ZsV,]1]Uo%m΃e-daI?!AԿZCt
){Җ479F_߲\.z-0>[a	-_I:rDxx%uӷ;o+ڞfs͚ƛ;?ݜ	3j$jhC5S)36
j,?p0	}IΙZ!
B3\zslzp6;ejz5x;e0d
N$@ԃ6Y0,!3F041&cg9nC,a13ͺ/tH0N9J#ZJ{tTG ,m%x[kGpһj[s4h#i3T\vx*λ778}[.fRRZsx䠡yT`p[R#H
c2Ixz0u
z*ڙP~@g
*_bQFes+Ēxb'
O<'	_A^&i8"4pSw~܀;qWpD,(HLP@Va6TV8R5.W`JwɰYM;TܥNm*
ws5	vjP1UVSwj*R‹j:Lץ$I3m4sANg̫o|J6}BCRVam?$6I
p=T46jeI{-fm3 FGGⵐ,vnN%p;A	Fuq?qz$`&Yno>J/'hŏ_A֔c|{CATaQz|O[g86,b]aQur's=J@t^i.291f/^ƭsֹɤS+6_ZEƂUE-!=|4
`6|⛰߂N|VXU e"L/
ur	ޤnEGT!I'(DqJPp4^G/:KE#	
7۳2lF%fUY-fg$a	rޭ=>{?PKKY\com/pyjavabridge/util/PKIY\*|/com/pyjavabridge/util/EntityGoneException.classJ@iZ-(͛`R^+o%$%و},OgWAA0?,
Ez"82).V[1WKKFgNo֤pa]`*YsVӢPIkL̲+PnLշ2+Y&\/1wODjYx/3ֹ$7ĩk"^;//WV!8 {띛ÖF߳v|PKIY\}Q0M	(com/pyjavabridge/util/DebugManager.class]SUB*چ6Um%B$dI=aDBgtZx~Q@ ^dg~3GBhB@CPG3Z"{|KǟfDV2!gM
]RU"w
i!C!]Ct2\9JZt:-ؖi|%rd0[>%Iba߆.D5tYԔN6ryiD_&AϩZׄ6 C~+s9Je:㚲kEJ4cTZ)a:J8c7HhHasiQ`|9t1
:&1= *n/vmwg]7:NxKxRG-;TECC[^H|RԢ:aJCv"JuO}$ʼ(rːZ9riif>1qV@Cai; fu+!3L&7bz%޼@p1ӄP\׃aa1bGp&culjؤpq)m7_i5'ɰ]zn@
Z샽d0g؇D<@08%#F}Ko>\B=? 2ys!E}>67`Z؄pEX*R\YM-Z6E&e傂
֕D-8j.yA]ǣ8"U9#
6EV\vB%#*mP5әEg3Nv36Nn^1&ș
\ĥqj/kZin#19נ4R]LI(jJVF#q56/>B5:3h>-(S8B$QdT^zAiqye5^EhyVRNKZJ0eEL1ёFCNc4bqjGixR/MtSѠt	SQg`SRW<H">;ʢi.$2*uHq@eՈKjx(5
/E
DP"b]JC\@RqZ2e:KB[8)3H>Od4a`[@[Aԁṁ(){zQ,*&rAQǜ2QR:%Qy‰
Eڣ^-:m5hd <Ő֦5}LF[d֠PvCwdS=dٲR)NJL a
))uT6ҍtAJgb`<mHۥ`@@ r)[I	"AB`,BT2{η>ӽ}(F@1%,EߠAYl1"pvh#;C/‡G xpMӆP;!zԠqO[$2"~̌&ӞKAY#@b_/AOLFԵ(ʶξM{lnzٲ=óxؚ|؏mɇ{Y&׸+IM/$7[=^fЋ]j(+h gn7A7}Sh(\jKlgAߑVGZAXz7vm\/sw@K
rGX
E=S~F?[hDuaҠ_ѯ=Y$['codQZI=.,2ID5?1"l_joޑUԗZa?;nKOe22	ׅ]Vse@8&LkOO+Tt=,@
5T,vȒPgW8؈G..uva/ڍX
G1.[if^F#zdžٜd@~iJ2ёJWIy糏)4VDvv,]j͏3[Mmkz&OXOZ_fO6x\>u@w88к#펴y:O3x:6Dݎzъ)p8LOgT>)qBaEkq9r7I[h$KW?LbT#DX:&T	,.x]ZB#		HRDԹΕV{mq(BK#sCdjru^0R2ۣNQ"(Bx$X`EMP' X"D,x>_ .d,
-Iy^ƕNE_|!/gV4q5#6,&+y97)Yae*$^%s/ܼFjf*H(%yvI
drDhk
^'tV[-:x=fpۇ:6Kr]:eaCRSCIq3j$18]VqCEWsJ 6naapHbVކm_XfT1Ո2[qQ?_NjYYH+eN:_VS)RDT.rRfqUnʋO;їS=+
6NX=Q쪕K,YJv;a5pFu6s.Jnt@ORY=BC0!
.@W.i#`l-
0y5K6a'&py&1A'ne:D*rN"ma|D65!s]U}Pt~$Q[h\Ú"D::N)3ў3+<cM,9{RC2|
I}_2L ReRmUrhЍ܌*?BYmH=MZ`jt/*Jz[`w
=l3?i(ג̥][[enܰvyCâ:/dyXyq9e`ꗐj4YN b`*V5z	hRMHbph8Kz{ydgݒΙFC5Uid6g\y;ԛv_
(XB$ǩXp/7ĩ-i%}J{Ey),<;1cK1"T(ꡗhGd=5,ZvYâQ=ː*3:f婘s5^/jmAyUd
BBq٠#>>ڑΌW'a%JXEu*[*oZq3J<
}S2+=Qz4)0w8uX1+!MG0=s{^5H=w7vh\:6nJ6'Nu$bp?$s7ԍ.IB2x-p2c"֋Ի/1SɑvkE
L8
Yzԫ7* ynW˕o0fK'ìH>etoT8^.-8iz&u7I8hƙo2YI?Jl8V5`eBJlvZKC,RUI@;D,eY{3d[KK,R%P#C`yhnZMQ
}V/)	B+v!\rY}| k/x/;8KY\dM\@ȡI\$Ij`:3]jt4gee#8t!|k.Mz_TT4t, R!̥"a~/bkW2že wA:#[.zQ*L:-V0tFNO^QWۧGRyQlȂ#ZP\B**ȪZ2FF[=(^{1v,zq;=C}.]BOjMhW^m=m}Mv'k^:}W}UH$stD{^~@/i?ڛ}m,WS5g}9^wn8Sgy7EE;YgQ=rCr+D%p#Ki|^̹ $.=r4;B
!>:h<$y}PMT/#Lv4BD9I4x
dz*>Lq$9)x
f
z'	iSRm8WeK.h"^YrK.)|%bؚ-K.-Vlv`Sb6dE@^h
lHi˯W
R\)Hq ŕW
R\)Hq ŕW
ŕ,$ҮD:TXl1a\ԒojwTKV],w|cu^j9րsX}ujsvFgT,t"Đ,Y/c̠ZQ([չ瀮euhvQ[RK`uK־Zz&=&KuY9Ck^/70ciqKţKW|CqprũZjqjũZjqjZj?jN[Qyqx?v(tꯒi'G@2q)L@2q)L@!P!S& ҏ%{?+I'q	̊Gೀ9EG}F8B=TPqzjS|ZOG,{EfaU]czTYhzd6|7,4Ѽ
ܦieY6ZDê44tO$;a7$zk
]гl=[cu=4z?w#uH;EYyu#o
xEͪՕɮYl]Sm4tʍtS6eON[YbL#{Ymjj?YYo2A+.z8'Itq;1^nf[1G÷lށ	'9qT}BuGz1eߍN҂9~nK4bw
r^

r8LU@hd'DLѨTq1ӔeoKD1X\*VR/%Fz\uJ4NrAي8Er#GIx=
ؗO-6k|*mv
Mi#Q{dd
CtS WHL*,$$G-2"8dz,BKٓrBgO'm/Ӹʹ*ZgP;n[{az}Q}4ARGR<"V∸LiWN*~|$-VC)&HCvǘN	M۩\4cCOØW|H-47#/`h~)=!X)Xp
W2RAiT&T$/LFļ(?U5u*tGBW/m8J
TDu"tہm
Š{3tݲTH|>bK^JM|!xut55}/񥴓WГ|=ǫop}_Ulh
k^i5#\t5Tr5Z+=GUፔռ7T
܇A{JXM)JYOc4	Ύ|J`N1wZ2dD!a+oBc6GPT(4T!90®C
qʯL¡.B\v-r,s®A5l,]b2tųK\O񽄟Qx ɩRD;jdRHVTU	Ct(qMb*2ƃNUdLNREFF{^,6t-˜,*foN"l:@?Qc^.ONU!^oc,43 oS/Otk@^k/@7&8Dm#+oWBb{: ;SHCY[+?V	'?Kr)}wwA.GƬDИIqc!pZ-6pѰ=jdx%s.&ÖJ4,@aRVJVV?uN|/;oM>C..{~cIЙeϒqo}W%o/Wy
q^pK6ހ1T!ht6N|!)eAS/{4GRs8P.1W'Q%㻅Ʈ׉OqfyqK=߭>?>?>⯄ /œ&nw)ϊd?PKIY\R'u,com/pyjavabridge/util/NonLivingSpawner.classuPN1
ICHA?t }rr'/pFQ;$ݙ~|(CpJBebmĭ^k[jbgS0V\
At,D.:'<NɠE
:tb_9'&d#lVb̵^T&:GZ65b;mJ476!20Yw(= b/PKIY\Y/K(com/pyjavabridge/util/CallableTask.class]MJA_QqpY1 5m:vzLOЫ*څkS}ԣ_8..l2%oBL77=^y+NaQKv;8VK6wn@1(
R!͠IY}isr:s-NAev|8z`ob
VdTO`&Nߤ+,@\V4.9IԶ1EXl`R,TL:,ZgU|5N2Bp9-ۣ4%
5X)Xz3Nt5ֶNfب9VHVPޭ7jNE6@kPo`:$l/ٕHy&ES罽T&/`]Q&DO^
WBlt7'6h~	z^6)4.p-9:W'Ղqz);V\c`B)OdehN؂h:֔K{5#؅ZZRVr{1taS=`~bO$"Z
*uo$3cD1>Ca?:.=)X<qeoħ^oa4
o›iAsi~\xySQ.nP5~|-L|ݎezs03Я7T#]
aiA0bMb
hvد]er]2Wh8fn.FfmfzҖC19nk8}vAke331xw&hqw*,fKN|{q%ך|}Qx!Lv_Jv&}e`ˊg;`)1DhZ&\&m*K5)TO'S
Ѩ2Ĭ.[L4%^-
+ e
I[>_O£x9uycKZbN; L[M-ǰGteWPz
Ic*V6F^5[8F
)ʹ3x
K_d,{>Q[{ξ\Ky"+9[wko(|*4d{Mv3IGx[TXhMeۧW]S>~P2tr:ru](v¡9H	!SH~MEyu?SQ,gmc_*
ǓTb	_&W[g^lzMgR/h7"(	iУ̟qOӆDj2%zJMHe$bTp=K*T,[rf\ڶpy[;Zn1UZf:gL8u2n7lac_JƄ՞천fFHumNJ'KkЫ&O?4NDkEEgi9}
H{1.a8M♺fB&F1iM?{ՠyЀ55`y?-8+q
VFDE9=܌MM9͋İ

N3&sN(7j,M0moe]mH&ljݠ}&pnR&PfY[&MI1 Ӑ]l>d7kN	:9y@ޠukZm{ )Q{kENw0	Q9mHM"V
w&	_e7z6/32Bb@Tl9KZy|[#™ق!uq(8|F}so,HH-+^{UqؚӈA0>h,o_{u\4^zuE]C8åSУ+`l#~(QCk	@k!``@2IlQFp[7Hx!-|PY{o(U씿b5)U|Zl-UUeU*`PU5''w@C4?6ĨYLk|TG12'G6O`a3/޷x"a󥾋O2>bvKQeXZq9.&lj4!aԡ<9ɓ}W>l&|
F#$q5ۊ/|D5.anـق=RVكvه}b:饋!Y&
~xdF%Ge,g߅gd\0N%R'qIՒ@eZcc
GQxr%-%yz#KXRQ	AͥZ#8*d<mQװ,`Uo2qVC?o?%NBY-l oջ-}#A'8?NQ`F>T,[/pP?GF5aL	hŷY#m_7!Jng5#bՇ·Gz(~ؾ)b?=UH&~bѩ`guvx#)@=1<")D=uΖ(QٗP>;!<Ȓ|>!A-,ǖTY<ЩwX0c02k>|nud`1,X\l22olë?t{102񿌿p+N"NєGlluutoeSޔS0kɾ~V,>DUr}YN`Gb>e:0*f#}?чݞٍ5?!*Hc\J惺'Z`dȬbUk/b,A;U`^$V~}!F"܅=oc{U26~?LcOЖeQG(vlbQKB6SHbcSs
_EVPMҏptiW.;H
mmy>"x{x0}c`-#oizX8#:K̲!Y~c
ډ]-4;c*3iz'|4{p	(8-s+]Z)(D/54$sw!(
+TK^0S<${>>f#aߖLo#e]w;P{dCD^O&4`C<`_bdO8yOͰn	'm?i2p<*cA\)61
+G}?7pouEfzRY)р
-+'_A=!wK?PKKY\python/PKKY\4iapython/bridge.pyikܶŸ[)WR~0Wvٓ
%;7%g;) p8/\rڮXY=5dSЋsR׻}xE uz&X/!գGtUÚ1%um\*/8i?rVW˜nSߠnh`UtɭgM2e;$9K-UPWEJ+*IXВk~~0҆4 ~kuYf3/IyZԓ`lo`.-)UHDd7y+ G*`%?ѕW`IIf";闫$%m
A"%n(2(7UEPI*XCK(|tAVU鮭pWo.Os!6i[̷NpJt=2+'4?Walo֒6-`č,i
PqtEXqRy@mZV%]{Uv‰"CH9ihAQr녎d|g!AK~CglCIn(Qo)11ftR@*g&
Kk#|<]DI%{ywEN
"=ހ{
%!ںI(C2*'ܰASRoɥ%s7K%f(JȌ-NnjvMsγڎ	GD"m%%k.zkڤ;Ҝ6((HV-)y[5%sf+Jlybf涥B*@juxj|:n8Ȟ:5c&Ύdu
b<֑V ޓI_"71r]F籭iuJX/D9DERk$_]l/hHc5bΈa,V(c"ӈ"91"aσtWyRf9K.+鼰S@//hJF:'}'FjS될X<ǹcwA!=4x%g\r&W#5M53ܽ!nZAɣmQ$q~U6uESfX~l@אr)[JyY+4ٺ4XmӨmptVm
R* 6ذm~ZK{PݱfimIQwP9+>Kݫ^+:l*{E5ڌ(3ryD!R3`8gTc}*ĻTtiOWǫ|J/LʪӏΜla|l7B_Dxⷉ!%}pR{~LAi6gXV4UgxgylB5>`&K.Qvx¼_n7ph3&D&/sB֟rY|D7c펏7#E]㫷\[P~xՋ}LKcˆ]b;ٷFxË%	G1g>قZmRkX=F:W86q{D]h$߿}%I6Ϙ}O;q	=AkDNtF\xPBfs [ߔ*>5)dDnvɥ}1#$~\FG'׃E'$wןi:$Bn=NxvpN'7W3Ih6g8Uwff\w0^PNb2Q톗Ӆ#K81j	&$BGGli5A/YN8=(XwJjiNE(!"EbAUkq

]~fIbzuЋd(6s6m̤%9ﰍ<	"mJwatY;!M'ƆAP=9U7"'hyl`թUXfmѝ?ݓ`,|v؏\@r|,immPˍڑ}PJA6eo|S#O_ZRlG;:Įp2VB@3|Rw&4d3ٙ;*or!fWy9ՕՉT>()ֳ'B^պo@NvaR֡KCޛ4I}=핹
O:*3F<5Xy{e^oDLjMXi\zIKv/>PI&˹*Յ>4US5Mp+u|4UŪh3|2h"=hmB^Lll`%PKKY\񁶪python/runner.pyPj0+N6^>	.'-(A6ZVD6=kfwMf0؜!.}9TV]Lqv:hyo\:mО6GƜߤMu?%ˆn=v"/@yOq$W4_iSmG\HޤQ }PKKY\ħuuJpython/bridge.pyvG
STAXR/ciJmNk;l[.
]U 	jx_{n,gJ28G"P9/e$M)$((]:bU=x0GzWj;ӼN(z.y>Gы_CEEӴ,"X#U~w٫tUt1|EPPeyV>/,A3ĪZgZLjgUL/3ˍ-7VlϪXe&eZ_C90HU
#'*G[U66zza>#A??7yS|H ^AO 0'EeV|1DƣC?Q*HN  aNJjWχh>I-MtQh}#hR1TO.Ĭ:/@!X 5˫z.+R*Eݩ[
{Z244M+Is;ׄK9͵M^}>/>Zde7t/U<&]@qz	o
]ĩdxrbH~I.↖ޘc	FӘZnO0TjbTm
 551Fb_G0B,lQ5o0e^9Z8/[q2݆Qĉ/\4nA_^~
@3>z-[j0/e<4;F ^u%bha9<(9N64bp]NA
<!ĪJ팄%-y?݆dk\M\Q:\$L%R1~
h!Z/`11Xxrb(ɻQ{@c$=JbBI)hVj501{CUa1i9Y~%RƬE#YU"3,u!CP,4gl?2n#MSרҢjiK>-d-rijd鄅/{fldR}!AXQ%)m=Aړ
qb:H IQS(=]i跠#]exBǴ
lT8 ^ܑleR9Mh1VC{^FK)IG+O|Y(\!r4(DM{BQM>S>+X5(I ܗgTbnbU{
̖L]N	#geЭ&
%ﱀR	"ͫ
gMQdTM6bIK0ӈûM}iŪ*A@lA7[Ehp@l2ZX-rre1k*XUH5n]݂x'оӞXenRT`t	ٲؚ{Vj3).(p$6[Y&ek䬨,-/^H`fJ7hj^x&ip7kF4/%鵳njq.$6zt$X?l-~$vP bTa)'%=0лc)Xb&ЄY+Yj팖PU,x* 0`8g0+8OGh0:nA3
s3Q$C&vLbѵ	<@Ze*R09Rtʼn=+ڷ)DcL
!cE+*jwΨVQX7((eq2vҋaLz]WT
[xE**5H]V8rXo
bNU3޼JfY(ȦB:hk"vnZ
[+@ҳڳ#ls;yA^ү+N]j*Rsq7%52_hW"U~%nOKH ;4RpHЦ=DMzTW)tnu]j]MT\1{$}ҳX8D\_^ޤ|js2點"y3w_L=ԼvS$=շ쀑}jkRǸi
EV\1z^7VgҚWpWV+(tDԎd@ޞ.ނ!g<¿ɲyp8'4NŒy00MTa't^!N!~T
>Xy,tlrzl
)
iZ?{LNt,v<Ք^^wzD{P)iS\n$@~T{(bM\ϝӭEsW<@k)נ'8vGxӌ}5lqDE N*^Q':Z\jK0EeVrft4(]
2Q/u}4v^˝}2L']UX|pQ^"q3ЮѺpx%rgѡY`m`᳊R:
Y<+=ƒhmZ
482
G57`S6inXu1q_h	~XEXX>TGIk@Ck2éyd ߷Uwp/MQ "`2(9EF&6Un%bәzK\Bk<\or^rt٢OchG: L/^z0Dfc0.>t@IYC_v* ?VnX{n''_Mndeg|[&v1 pvhVԨ<,+jGZlw- ç^PT}!-=;PP.FvC#|@pH*<,aRDWb427<?YZtan^ٮ0ID$X$Qh&ǺeD5.wخ5 ЧPkRY\K0_qLe,rYbٙnx$@M-=y\/eja1+)0MN3:=KUrhc$izF'"kK0ٷT!.iEMCHTȵBF6ly
2l.HM<vQ҇!&%};Ol1I8/c$3i@`l)v>$,WۺV0hQ_Nb>QKuQ:!$=JabC϶5~@ۼ3fTԾ_!_oâq	cN[G5}vOP-m:Tg	Uv,}kZ]g[82hbUi6mUw5Zmmn	ܿ^W_K!:73G?1/;.żg 桺?Ft. -a\s<%O=L#H: xS` G*A1oҬZlع6" ux24fd#}j%yV2jZ=|`J}7OiԮ>sZWV_ive"Z,鵏tu.twK3R66-0~3opx.YVjnϊ@_Bf/񊺉C%^q]5i.U-%}Ah{T~Uek48s2&45H܀#Sr_2v;[	N?ݜKr)Nrc9k(F?L)G1?.2-V5e=`rZߺF$Q%Չl=2{[bZS@'>Ē3@| dv/'jߟ*?;~<9IN	)P0$y`
:B>yR%PN7o[.W!/"\ɑ`d&",CU"Bv}	QͻH3.jmYNQ>؟>:w15(hF,np,~&IDמbF< h/“_''ȸNbہg'NON6͓8d_+CM ;ƤmG!{&؁WW+pl")cJVgmA%D&CݗH4GQP'bAǝN|yI{)pƩSN>py:=cK+>r6tZhtdtRȎos-{Qc$_C$ڢXGb158G}u~SFY8:jw9pB܎){^ZqHXD}ZW~^#;zu\oy!'懟=
owxEcz; |XIv܎󼺉<.u:QDfmX<4xW/{Z݈\ڊߥf!\7tQig3rINI5EYG
Bۺ%IAg7(M7Vݪʷˌ9VbK7X9&տ6im1Rh~淴^-\nZ_e/
7#QeeF>+;_cFFnD
O7P
Eck?B+~dFN1cF@HX,Λ&3r酖',
[`=#xOޓ۾.`*D\eʢ#cI8x[-薡˜gabqZm=s'|
,b _f׼|_.VZ-tP2t)E	5%|	%@E`S:_D_IhTq#a:]G8
:,:Atoɢ
YZ
Ğ8=DE3s(%_Cu΅bw12J4 vLE:[E]zכTc16_36)v%ڦkH+nk3
e %؂Z\a^UTW<&kF$&RւыQK*ARUEFE3N>5QL Ǡ^.dxo$cYJ_h0bie"@e~L&{y{OWLU
M]O1Q-_׌UDk3ühkdP4_~L=!$490g ?¼4gܚy?sR U8hk8iG~<\%݉U|ICڗ05hoS"EHrSPft!d!:
C
@IyT
ԈɄIe_쭃bat
2w6i4jJ].IoݬuT,f]ok4ۘ(O66I1˴ib/&
c;K!w8&>Lv&,dd!й܇.4tE3|nQ%;+6ާ5DqlGT3?(FNˆCύSrpR!MXk%^Vu-׍)T	"")۳sίC"sE]=o`Ԥ)"#/ّ8Śarwg݇8'|3ms/ϧ@3#Χ*[	嫪yo-
{CfHzEȕr4uٮjcy?bvZ7}U;wc1}~60RX_'[P˱5,6c{2y	D)zޏNC3U9ݽ|Sm"Q>?SYiޅmsVPZL5g͌&15v=IMO_$V%}lȘn=arM+ߥwɍ2ֆX:O˙aڼ݋\:h)+f"g'lSgI=}\1z}Hlм}cnfs_8ad6ŅRB- 
h
	*.(
T=t^ZդuK3=<ՏρxZ+ƴ̘@Ӻ@="ߞ+ӄWP	;
,@cZ0+Q405N
9Kg)4.}ןK$&yMXџ¨ۇ
zwwc~|u5TE);6:
Y[r:f*p9m0lfRlny^lԯvkp	h-WN{J0ʟJ!5dsz'!R,㝷^1]}_!V.}N>}%"w!G|9Eq
*i}\qRŠ:Ao؛^XcV|ftpk7}o4JcvÒ$h:&*:}4\e}3|(҇# \B0?iMԕL!"nTr%dqP뇣蚖
aP<1~,r:NDdGCMuo-="$ԁF*5AhTezi2t3*+|د.$Xus}]0ZQZ4-g
ozógb(U]{"ZbwJD<÷qa-/Y,%[`$ByGخpT}7o:AW:jZlWmX\wx#v]'1joZEҞ0m[pJ#]6RbNBR!5Wf2dcijK"#h*Jf[,~OPD湞L
$BK+NP#
j!*5Pd{8Mm2l@R'MŵJh価O<˄UNz7ip,'?R{6<)<%QuQZ0yu΢<m./z";fjpxO\bޟG
GU&&o܀QMf^B
UrL/?8A| `ZcҺ ڣjW;(ʸ[GNz7F	[ƥ3QZBXrr?1}UC\SO*v&-]i4!z"h4Qo5c°p喙ț~FG e	@8F*ǽV@tJyǤ}/"aTɄ$,1K@AWzF4\l翩"֮0Hvv{`P{ԡ孳.]JWLasf)o'DLs;TACNK>Mɥ*RZpPP*{]LNИo1A/cܗ~ $Ȧr6MA,!ad&@Zrr:(@펼KBӻ
Bwjo F
pm]R+
CjIvUʠiץ6do͜ISU+yn1O!5Y@)b.NЪwqY W"tq"
՚S}g]
9Ch{p_J#\iX;ϊR$*Sx^,OĚZy	YT+(I0TB{AqsZP+od*:wr<-HYhowUvU
E2]Yt2dH?i@ʮu`/degb0.ʺ
,44S	J
˖EXaWf
K?ӫ4{z}E%Y%)Ц2;75f0$e/Z	v8[]%9
qz|ow~
]b)Q:}mj6̈́Nb
HcS0]5	8ŸŔ#ԑnӡ̀$@Qe}Lnw`
jP6+*W|}:î̆WfUYb?nb'BY'L8o;E%|NĄMy0!,J#+A%0jDXH_M,n,HXa9eK[I
ǒ4tJqIëݔx^NhxnjnU-JRG-u.4A|))eLB
ʞD%.mIp
-rO[}#^#4Ss}ʉz2‰+Z"c+drhGl h$xdsgd-u;I	}X}	]%$F
I\1hܙı]P[#j`EUJf'Rʹa>ي:2.Ѕ9]ٳ"ZN.RW^X3ޠʅh<|޿\.[
x{KXhmMd3aakΙ4dqoZl`ŗasML7^7	qx
<4vE?]2xP
~J9X$ԟȉEU;Ž;+3)XȯU
gKIt*v6s]`W1[z/{G,+zf^gym3Vc.
E=7&yǍffʇ3av	Ʃ$XW飵C9êO,chC~WHbpLFh;ЈnER['HȶEV.78'h4ǧPEnq "پPagIA$1-e[[ꓛKtJ']u	6cѣʺ=okX&RjD,b[dw 3quU.|[F(\)
Yli
n_VpƎbSϊkwlfJȸQ#x顆'9__TT	g"Qu[J?T

j>`^e;Y1h]7.%P魪5+}W'uu-ӤCxA>7{»4٬qFq:ݱ#Yۖ~fom53'IN06mN[&	LUu
PyShQvys
7[91-ɻ|HO68غ@::yZTf4`ݺ^~
XLX	)H.ԋDD_u|MhH3R,d6@ssxJګη\#߲b-&b#	3NF/?Fg0M/ݬtDm茢w04L14:t
Gd[.Euu$۷p{{1*+ =`^
Xi^.ɔʐ*e%3S&d妊M[d䘋jti{TEW% V%w;#dhHc敂GDP2T)U4$T&:$
Ih#Vv/6nd
nc*;Ww=oA"Ktv +nQ.3P	,z%oլN۩ OMŬLF^u@:1}`T(*t=
o
T7Sf!!TuA{g:l{ʾO	x e
oĈ\3ϵH(b7F-"q3X'J|_}m>o,m;ׅ%(odzGw$q_SY*+	3I#E;"}Pr4Ok#6lԞAjK٭8u<'$Ѿ"AiF\bR*ѽlbyY"Cr?uujpshL'D`zG-iޞ&75qBT?˭Lsq՗yjDpn;I2.r\2<9-g;H|z"(JIgѷG&9gY*7.EB8NRY䫬y4ɒi'q6Լm$pNfˊ+=qAg
 O$QwHWA*6e}F4.uE~>[8e2x?`A(`Dԅƈ9`rۣc܈y(ӻnw?%=0[/8zEE1tSbjY_
8ќՁMV!|,x_gro[j50o2>=xkSsMk|,s"7P
\!jSf~
MD*qx}=ÐOCێ@p`<>#v٧{Q=iFq6ddղh`Q{rĽDAşIua,69Af^YW$@NXjlcRe=6,HY"dUU钯x#v/WJAMmzD*lNo2~\<Z{
h1dE8ԙȵz@u:b9MVb]|t`T_%(榴+M+)<".ie|PDYByi`)8ϕ&+0Sz#ItfV{/lN1,_pV42IJǬ>`C拟~b)\->Ũ}xJ1]O?Yv׾6.BXZ㪙s30
;k6`Ĕٍn	c/+BdUP뷹1,l?]Dz%M^ǻWG_sd/4nL_qx؋wRŞ=d9Ph>gc@v[UJ脄:ߕw Y<[('ݬJC7T"(-DGgo޼sr	~Ya(tU>u٣N)C̒ءJfyibcR҇ݭHA@]!fz#B)hwaa&D1p9~[GrBMp]&|kDՋїo8nJ2w4$䊔X6"c
~;=pݺPZ@˲74PA8KWo$9~+,NΎw(UnFT}8
ϙ`Ҧ,1%3WUUPA]͉yiӳϰn}919y]+bެPX2'W^3
)]#ƞJvėȡmj\ªw`PU8slSO"X&(;+$TIب'gn8zKYO#^dfZUsߴЋŝ*>\#r.

[d;lU}+ATPQ+
S0ńǾVi̖ijx=B˖ċUܺm`S/c5_֢m5SW(VVm[NfR~tzyx{䏘>n"]hVO6Kgߙ;㝍xϙ(;ߣ
r4kfVx
mFxMKQ4~&.tLƣ|YQ28B4
NMKlGR.d+TRuAjӊ\FbMo)5Vf}"ʑ(n][k(cf3v~,4n5{Bʫ,{8Tn*UӜt 
m3*lE
+l-tQfUHV՞t!r-_$
"m]nj:ՐRlkF? 
(mSjVdYfRa
(R+v
i v^aySeJO<ŎZ|܏{(yg:qKZY|XWt&pAb*%+@7]7
̢;$T0}1mкTWv#/{ҚV$O]Q]z@&l yGY̹ٔPqO]tJq!gv
E/	ooСgv*EUg*[8òSH4~Lo!SRjKL0~&үتY>0O/;>mcN51O)oJX>fZ^)e955o;İ5z̚D=2+\S^7?vy eQM쏇/^;+]7Τv:E5WeQfYsdBd`c$(Bd"h@O[1[D!O5RNy*ƎLhp;%gY@f0'J}5LcCrQ}oaZ	|̴}HB֗<X:4^2x@9Kf	{_	XHh='0MI`oM;k\@R_9υu-&f"*P^P9=zYA"VqK[(x9Ws&%yBᥰ/O\Dz()f$A~3fw&ZjFhha6`FWVCtt!h,)VQN5H:ȨՋIZB7#Ѕˍ+2]V.O`pX떆/Fݵ=T
F%nk5J艅Qx~t݌1`Ю	QgH]F|}C^n0)` 
PM2E±y-T)?=n
:ٽ0x/ljy>9zw2dsb>"C0j!딴W[[*
vd(-(G(W{<^8qkYFhwho*(hB-h\6|]_p8U>^e:Ѿ\S<]sެ@i>j|_FSr%|/}O&E^hnML{8{#g&/`7GMKa@01~~9~m(FLGG6bF\4kϼ<ƜdaAcS.D[qB<;YA$gztrnNGⅰ-.quǭ6-PRLW_EO0ԃszg?o؟k
l{*ɮ@l?Ik1G~	_.^CQm=1/ǿ
08bZ<
k@BG`x%vi؏
,tT`n}5fk)1xFH_>`їz"z Uٓߛ]&G[Qj7ǹlӞk8CG৏ >pIm)j
U
@JBuL3`mAp4OshNA[5~.ln$I#__vy4}ު G2
1̆.&JQs?w4ȋW̉]h끉|pԱjhS!:Y9
ZRہ&QN$iONg;{zIoդ4V)Qa5 o
:<;2%WLo`glBr[ܶܭ.wkm-Gcb{(K'3x0e[~@ε-oZnp#ѱ6RnT\ZE֡fV k-%eOF;>vUMzwqӰcC.NL0bėEg[AiǮ=cԃr
2Aɽn]n:S/=C$~6:t&3`\mltO/ݩeXBX䮩&Z0'Exb
<]qrvx myZPg(@#`]
9Eib#r?te’b1yltdO̥0U%mac{^LȤ~%l]L~??!UUhn;j_X+&5yPM34f%3ǒ`EJ+F3_M!S"WݖӖ(-nWb&MXhwbH%IvJD8XJu?+
5r<\O0!ͮP+	Bi/OYE%&O.dbMƸu"O:f+:T/A()IxHd5:aS!Xf;m
Jo>@󐗇Y'=x7M1Kt@(4L-tjD42qU/&˃JdIq}\[%k)nfez3h7@M#?̕?4y嬧s~(*ʒ@G@O2!f:$wGD ]•NluQ
(7G2HR={YgG`Bje+AFq*zO`ξ(3>
Ḃ@{n9P|yYj(tGjcu 
ts.UwG$N.|yr&Rjuk?MxMfv3Êd#1DX 
FY6E_vGrQS`3yPdJXȨUdlϡ@59Aխjz,ǙGCRt+m0<0@XRD'yV,N]#Id9:Wf1U.4y# ȄD&D{$Ce&;oQ^wUqzAHש^jLT8o@?23lpܺi36{eTCOŰ.0K>=/ˇ&@9XsnjCH>\l}qN%+]Op`L*ن$:]ɟH2MY8#N0cWnPבzgdXCw^qW2#Wn𐫍7Pfy1/q9VZ:k̔
jx`Q|lMMaLr=mi!ZSxYTf{DB't4IgXm	
^WC
3l4˟(0r訬(g˼x?_GA@SP Q"M7(2[rA|mHM_bQIG̺ 3
9aʒܮ$_IM	HKМe9r.-nv)D
sb&0ި.xU*}훬2tO&$oƻ)1>2~t	?3
W`vF9A_adԆO2r&92l.!ߋ㖒@3GidV@6݃$e`e¨bOd1,B۩ZSDz%DuN&dX[cd~y,w :ފ/B)a߁cс||
A$\dP9 xv@%LI>?#qbRb3EjZ,)bd)#U59>oE0L$n$1=jt#LY5/Ql		!e!aHJxy^
Xt.1t#Y嘶Y:7hR%Au7~u"yŏm13<%-Љp6[B]K߸ Ġ{B~Z2
2Sd9Σ*c=^_/AؘFp M8Mr@DSlRĜ6!j4]S5QftBo}ߡz0~8£?4wCm-i1ÆJJi%8v橠;w\ȩw_v>GL.q<t١/1!W䇥fvo'=c(U%^ѡgYNB:(/UV{&UEHVЙ2:pd4Z`k֣!pHs_(z"4ktr$l2UOƨx\2&qN_@Eɰ0AUM~8DGevGoG kOܠVP3?,zMϟ
e8S;(4MAHXWy碤[DW߾^ G:mT8y5괺l֊!HfTkOQTS%L^
k7o"fK錢y~BL9<Q,߁e@svp=Z	QI&OiA&rXI>ͪB/",#(YL*z|(PEt[?i0;C-TX7a^`*r>7r8	ũ[(T:|ސ_̫A4T
o
7Yϧ.||'Q⊮ûSz81cݩ3hI.I-i
[䗰S|aDE"ϘcT-5~e6SmWC)}1W|iOM-<'BY;k
hnQwt%8)
v_iK'wErZ{e[H˨t_X9_!kSP(,"j}w-m0_2 X{aȆCA$E>}[ۡ^\(Jd"%"n8p+Jj
9fQ!ݷSpH&
vZMRyN^n9K)Zl
9Yi.KїRsq
nwW`@7[UuTq2CE|s>+i{|m]	ԍ3lt
ur9/TI9WF/[٦2nAmj<WF\/
~@v&`_39,魉5nJX61~Q7d^4Axam֘T^΀ٴ%-NddٵкT'9f`3uEILrI\,r9EUtX;oֹ=GW7$y1c9-d8N\v<]@t^͙`Hp
H)N&RXiRXnTI車PKKY\python/__pycache__/PKKY\x18.0ٌ)python/__pycache__/bridge.cpython-314.pycxu(@	)R	)Je[EezIE
	(yrṛ
	դ5Ӥ
Ӧ7mR`Bm6}eGs9O`AR">ݝ9sΙ3sfl,c_
=/,׌C/ϐ;?3ug-qK
[pqa[vΉvs㹇yq'㎸z;{ۑE")$^x)^ex-"^xW*^וx]_yuϩ`xG.>=^wdB/"b/!R/#r _IU俒Wj&_K_Gȿ=7HM俉Lo%mB$]俛dk{0}ޝN2 zwM'C֩uG[7
Ǵ$@ozVw=p'\#C^kSFL[6`$;J`TXŽ		a'	wF/B&:h3B	J݌Gw
݂P@W6Э U7lCh'A[(VE5:vG݉tth=;M`u:܇mAGh/ӽu/Bh.h BzB@uy!@7 Ѝ:	tڊP@7vmC9mA!t@p!ݪAyݦEmA!4LՖ8AۡyݩDh@w#t@A*hL}qVK#"]Ra!Q_}'LĞ4JnYr?ޟĿA_84se<-a68IЙRI0I%54$B_^Gx;QN̙fRWwr}R}@t?R'o8O'AS^	r2ޟ?C?+7>_'Io0-"Qq?6GWGy{-azؙ`ìbjIR]rOh9LmʏōlDq<In_d4??;kk(OZb!xNt	]~1i
cqܠ?;BCaP
. ]F0>zѿ_	11<EE!Byh4>4ahɸ|>qys9ǪwֶMKnec~(Q-Lo
AF4:{ђE(opxp(v0Lkn_xCOw$k$R)6*kVhul
2$.\)Z,"
J#jW㵀	J̉+@qxd^)o	ZɱD,.KՐPbqM)=R{Mǔ])DLV(sF[mj#?cI
Bچv7b=\
WC.DѠ ViLX##䅱Nn}}d>ny,>%9N-5KiȤ#WCC+<)A.SJESHb.ᮑ5XM(D܎c9?LQI{L/
 q%#P|P4"	(퓶*{}•M+tI[wT!"scx4৯.$m#G"֨8I'CaBI	"mhdy_Ḁ\5t"]	BbI[GtTlC#Hڻ[hX눏,yP`8Lj?d^G *
}QLZ;`2%B2#H.E$ Jtv1zt.1(!M1@4:|#Ã]0}PZdBaoSe,-gƭ%n9§֤vpE1*UȦؐ
zadGd/ɫ|wVW%wsֵoQ
C[IHcؓ>`B?vBԡ	Ey0)Lyأ j̳^6yam='[*&s:$Ge2YܫW&:	cxHro{{mWtA{8%G`L-G-XQMVc Y"(4btUKcsP1({7ΑړP鰡jN>9g
gbDi^rϻ_xyIERc+Ci%*:XƠyN_U|5o/^,N\!&/u4ס͟3ǻH>X\>3$FGF=F_şC]($s;Ow8j~NqFFPm#<UX9^tedF֞NÊH0%i	~X&za"}qQZ$*cE"@hxPd=p(3XDsMGzJrpq{
bcIN$kLae%]
{j߱P>̧hʉqDO:NMz6󞖶bŊb"j:j1l(A܋{: W!q0kFf*V˭r4q%G|ͯ!e[0iI/fmL-GJj\aܝƭM$MŖV/TB|Ҟm"ܵ8#o!ot	4Z8`SZ3~Τ0Ѓu]|9]\LrDbp*'=9-mT*&!!ɀW%+Zx
u	%An|Y3ъSgvfڹɋӝ83;6pN'RtXC6ìh#"SfYR=WR;SR;c_^UZ%uRp IK6Q2*Fo5753EJt闏ko>SF9;303adݲY_KFdfXѱ((;Qr0zv?/?0&1'j\,3¤,ѣE(ٟ0oLET۵oz_J|f?#KO$D)>&{AQMǐQ^?S~>FkzfRh0H{RD3ddztPzzw8œp?O\"%rUn([My^0a|%ʌ`&]~AbmbAbぉd^RMXz^f%p7nI䪻^9ޚi
oPJj!U[FEV;L.8pFp<@S>Q٥9XYN\Tb撶*Vڪ'LeIL$UY֞oJP'thw1woS-"_iտ(0tyRcBV*1rF+2AIp /7DPlxHaBLׅuF&0yQ2<~	^-fkt=hU3au5*67]sU3UG:zKgu~[jIkլ+B(sqțj_Z\rrѻJ'{ExUM㨐,6\z:qL"L 0Ty&{°tu)	ʓa\|Q{
UR*,_:Yg",[Nr3-Y&{vj&ij
e:vz6%zL
[b+=zQOg~Tz",ˮOѽ(tG+K@܈q2_ML
WYc}6*C'O`VVVN!);D#})&\y'4mu6c	|_M N:h"t2k?5.XTWFZtmKD:$%s9??ÞRP'L+ra1&BAHXLE!4_
&]/NBvo0o	` Hq!HVJyDҡ|0f¥^_$%ց偗|%[/;%O'"Sꃳ67͔l&JImhN%͒ykV*j)٣m1P?Wbm^`q@nD]Ӌ5	LFB ZA\+"#<2%NuBt/	M=NhBK3`.)c	HHr01W|
f'_m08{f5UUf5Zq/:NJQ譢ܸD'}'+LR{MI:C73kȪbլi`%G˳!kSQmew\tfifd\1俤DGd+~<6Iq&CEAd'CƘvɼIRAtAYT҅6tC!*ϗX
1@(]m6|.[cBc<1STRm7eWOu9pYZ9><[yg,^-UH\'ݥduýfW]VKpC;w`U$F$án'B<	7v.n
Yr$hyBrpjre#Uzy!XYe`	2լ.
ZnǦvj24]`5{n!r`\v
9BB>/!=gwqwoӭn~eٞiR֫VLWm"\i~NIs3o>jq.0e nsRCB)CoT{~&ZH>.	Gg\ eU±͹θNvϺ*~_4pz;
W>MrБ|,_k%/fn^"637]`
`3<7gL)H窩&qj@뙿NyDWj\9Ӝo-(EQj8i
rҌQv\:u-n"
_MӦtV]YvqEл"z2)JJkr)򼪷聺Z(H4YMSZpNWC-B
dhv
d-&Ph(Jn˗ [@.5$pz20]˫*utIEK$e*.A)-]/?]Mͤɗ	v	.CbF}f^l.
5Q_ìd<6"s&&mQWX3C(wG*bz\;3$oe:uxC]F.UD3:Azס@]3̭-i	4`5 o@j>SM85@?f{ز\Kq#O%[,
T0QJ4=DKNYHq+n-YE	{iص=dY[0aEgXK5AS.;L6PPoSS'%⿛
pcRDZnGBJ2Y{l(m2%n;II%$͌u5礼:Stq`-~B@M
,!'ނ৬2[K
JqMXM,b;*L#kռm̈[x{
wVXlrXluFXUX
0
۠6ٳCl`eeL}ljjP
O
Ua^a?TU?
*4EYUSM̮h{wH>t\߳<3SfHTp*lM$~N	DJ^04q	Wf%~
5Pz#_gaJά*~=I+38uN~*	ΕôռqrZ5yfkH|.)qNY~&Lk$iuix.#IHҚy֥y#x"Ik&itiً\|♊6{;t$ީ Gu$ޥ"n]|7?!S}ȸ~~7c؞Yb(Pɛr,!CYŦN>Tk
1ZpHѓմV|`+mFj#q'8|	랃m\*%tϰHbCCGZſjbKk|m*oX|j0}a+2,7a-<j~Cy3l?yusε7k'yj7<.AIy>--
+k?{'+7_qܬѧX.R^u
՜7;߲אgnn~ėNQ-Vl)3._Y²sf
=\ԙYa@
=D3[{Jbȍs3_Zs>_Ryd|uDdWu_IҖfg|=Zn3SAlel*~ڮI\g~&a|XaO.k-	kލ[:U*Zw2T6?v$fЊȻ5s:yqtS"Ay7/X:,>y#B2,P˟\&8_Pq11[9 FQn;4äS
Bc= Dݦ%&HNt:K
6,:lB5f})iK=ʼYƵ2pW$־JktieiB:T0:/nQmKP<
[4Ǽɜs$ȐM!r*?VDW$9Ls4Ѓ2\F2lwYU*\E<~<.Ѣznb!ـ}4Y$#W4d0tA;ytq؈ԽͽD3f	dlʄRQ/[d5@f)s)g}?K.6p	+ϘVWX@W_y{&+Q݅ߍ<]gsZbsaJ)5ӈ$PHg,O&KuM#VFsKA튚PUh ,˴* $OhqzpXuCG\J
cT:thBꤙ#drr:jC1c$=e1q4]wH%tjjvzn;Zק=]Ntc(FkObs-E.+Ԑ*H3޽*(eHkVG"E!y=L:(!v(:G$:+
3
7
<(
0vwJ(VƉS4cEC\d,vYS-:tƨ艡%=.6/Eы4J:1tl߶9U4su)Jg8#q;pkf5NG]/,kA1"̲fZ
E)W<6yvӹ<-Kl%q5sMTWҚ`QR5Vv_+!Jw.˦`=ҪN̰`In.^OUOKY1vꀛON︾	7?&9{ojތ5C~q4
fpəAА/g5UL^ky}O^V.bH3Y+lAxy/nuZ;
}$	q"5!ETHNAVScӥ	{$GrK͐YU	6˫o w0í4BbD
|РӽGfA"՞e'jAF$FT/
.x-1v
Nק+=r	'9|s\hj4t!i

bjqYB;&H0s.Sex(Q	\jwnqO]IeɅﴹOt+I RJp$hՌ' 3mp.+z()~>:Taߗ~ቃ?ϞHn|PqbxJH
{]jqp2=MK"->ڧ` ܇	tCmzqRoh;mc[:*T6-J?o'lS4|pM/ACDJtI¢EcT`}Nd^ҫ?*hNZKfl3XHekڭNbŚ1A'T|B쌲@A6+7+!%1sm$nYFy6π@Kv';N`d>a&A}P%8́fѡh@G?a6hĬl-˪e1+9hP9&rEޟ6z}zWM,iɾg/nJCj2od\J,OJ6uglHK>n1s8t0C?LyFM@XT:Z5Y@-ef*OgUz1'94ũʗ;
QB[@m_+	t!kH9F@YIǕP\0\9yFbV^CQ<@b
).V.j@jeQfGїڒSwp+{RkRNB_8{UkIPWm/NOCKrT!oX'*/v>WLYO4-y3GZu-G<]/\+G%ea8>W6w@~TkrppL~ǧ/|Şn{_>y˾ĺ)לtڻu_nK7<֩GݳgR|يT6#Ezs\:Zbփ^΅2#8GŠ/Z5܄p @_i1J선?B Bp=aM|_`7C7!m~<5-!#W?Bpw x`WA%dJ4yk2Lw ~%oJ1x;z~k;$wmzR`:m:m7$4gi5
>av)VuJ4Յg;m;.G:<xU{EӢֿne#̗$4fzB~IM@loxl^Qz[-.`iפšTX
kavcK}'Rv4w\[qK$C**
_{ÀPΜj7/0\(| S?z?pdo}dw⮼2{K9&^cI#
NjEâH<>gf})GC>ڇOgI#GJ>HZ8)̓*A|?VM6<9汏ěu5$jvO~H|/^Ovn9}r|=x?L?HIo"[Iwh~HKIo~Ϗ|k3<m%҉++ƣR\K<\dwx)l^1-}@#<&;³)lzGx6}$}a3Sd<(2ˊςy8'2̉N@ԥT4
GBTE
HO'|5={?TTw
X,n]ApmMPHF̿Zt4S8.2A/t-ig^UkexȐF`(B ţGC> ygVNW+ͧızh06MLN>NBG7װSQ(u(7!x\LJ`xfRX>S30uȂ⦳8퀽Z9D(WPWFP֙)|{'}زȕ!DOt󵶱8{Xu_<ۣO4666y;/5yB@'8JcOh;{4QKyPzF/B8~^z-@;z,4͒&K=}f
C.UQ&(b^duVdt*=_EcoDC
+{nl!\'t/X&{P`8L0WCY74m
Ֆv,Q+˰Ndֲ=/Ee̋}Plӆ'ignuGNށGh;b<{vA'mf*+5:ލ%mH\/J2롽:E\N؉[x~^&0 ߌ5e)QMoE*W,'`{ԮlT:KnsJ9Th*\^#˻&%[4RّiTSD1]m
M925Ɂ{ؙEA
5mQN3Tkw⫀}]-یm.^P\A}*0]bDkd؆ʚEt[Ԁ?>0Ҍ*(=(x،xV}F

-рF+k#ʋ b\XͰ	>i(ev@QyҚ1cGf7O!	8L%đO_跧.fSO.'8,F1*[P~֧dL4HwɄ%L_Q7Q,G4|$U-Y_'2B1e&#O}b~x..F+YHpCZ%-~/7xɓw9(xYE76SQp\؟{\h3!r1$F#%,RKqD994cwbϢzH:qhJ£X([+9HB=[F0l[xu^iyoI1tYӺ$V͜ߞǵ:^>赧8_]ہQB#vQ8Tg\@r+~pyլ @`ZиDMu-8K#	^R+ܜfE\ELEWW
{]>|Su:2wnC|45i7\p.$KC("kn3L~*4ǵs9o(BnjhX" Pȳp^'6zL)
.aCyM8F۪j]4ތ*sz8NrL`X	,Oon
a[(&&
?rn8=<}B RCh!JHL>ΣKo^L3'<ʴS.i4G>MNIȖed+'9mi.
aWޔK5v~-R;gf}L:u:hLfϝ.&EfbRbbS121y҃'Ă:E!d~)tƣjdQ^8m}D@8ND
\'b:^wD˟&Z/ZE뒾hLP2xDɢ
2TrgGddH`I92 +' hT#o!2(k5t9o8o[Y|zyLDskb' nڹs@bC}eRoǤG*0gfAI8̞"CO.JF٧O(Ќa\CԷ6lt6=@H5c~
?iKKy^&" pk^Ȃtq_YX<'㲾"+86 }ey\mi;ho@S,ARցH!v܂,8S8,rY
MI[,CHs1~tKsm?C8Np \9
O״yCܟj²ťpfCh[k1dۭAMY%m$Z
.C/'sW49h.Q^ke>?(vdG%'.Rl81xqVŒNz0(BrmÖn:էOp58CV,KpoovH=1/HD5Y$c28Ƚ4r:}^W/\|J#GX.=ϖ0'ǟ,JnnqisM`&LjySӯ
LbJ=熈0F`tip73{<ޛU,Z['TR5-,\uJEY1GLgC#q4àR":2;ixmFg@[N0N<}{,<@2I>mw)
qOrzxP]p#ɒO"q9$6K>D
[y'xks.#,}h#{3aFn"pSznz=hrrJ,-!gRY푅\?x9Rײe[Rd&gԙ؀j/$RlGEk!40]܊y@9YЊN%2Ka3H(^/5T(OM
F6y#'w]o0M<12O
DGQlTbx*x$a\$҂\D<m
BE\'۸GH\ĎAE"s
ːE >J$HB^mUVFꞇ.S7*K'ڞ_cljWi3F~[
RG\GLGOywɜs(q?5<̉
ӊ_gE	\%\cx<>kOrq%(	:'~]AVx,Uh5E]ϩ
Dʏ=*"RF~ÐLn[w[+3Gr氘r]VC9CyzԧL \*&gRz<>S=çs˩åJcMӊn]sX%9giu&ҽ.=_t=,Kw8Mqbν{ODy}t{sC7w_ص-xVv= gRcו=3?Yr+T\C7YqGM$O|ckcG3$J\_QZ1mFQM5Ѵ.]Nqwr޼W|WM}yׅkyp^Zw9Sɴ/%M"}qJ\KꙊ:_Jm?&?
S•`fHTm-*3&Ѫ?/UR)Tl2~Xޅ	3q,tި^_C>6:b]17]OɱO;v~ σxL
lF|GCfvNWۮmqwRg|(Bۃq'~!x_Y~By_sP<p8,DA`rAPAUA	d>A%1~xdG
<
"VN5~B$6НG_\`!<Īvt\ƮLS4/~2FgilU	ۍ̘;2C=
܊1ag6;.ؒ
=s
);U
0)[ܟTrYN,pۇs%rx|)a	pDP=9xC*g"=gt%,VGZUu),o

¬WXu.m0^;0@G}\le7rc9V1mf8K}+uNin!]ڈלo+R",Q-̆>n=QE#sc>1/_5rrꈿ
oD7\f\g]wb+-PܪWw@-X
bVOO'״l!%f|ᖋHUYc}T)C&2fڵeTIӫ;iF:T=sFz
#P$Ќi4p
/Shrhr_ȯ*&,U;5c
|μPYE u0o㝼x7jΫ3G&	w*xAnj	G,$3Df-(̍(I:-_手bf#you? W7(PDZ)A/IXI?Zh;VҙIMI4T⦍3NA6DMݿNNK5N;{}}HIoﾇ{=sϪoI7xfEUV"8xY(O
ϖs?ɢ3c]YJ"T	R&[)d:n=S*uTNbdJ%9La4ͣE]&K+Y0=EmV&fuZδvJb2x(  x)/568
1Q40)'40Y.5	I`_2|ljnknNo/tN"E/mzqtWkf5%'Ux}ׄu{/{%
ZJcÑ}{e/Y[_ʾrpVƯeZwym_`=2w<29ǍLsw^%x	ܽCD9ܼWO^? KԿf|8xHFuoǿx``.KTvU8*tZQJ6,l".^2&;ZMb"So`gTT*%@ZM}We飫cIKWk'nMx4I`Ci#an+	UAhO#ϓN1"Hfs$ф-g]\L\x'tBYJIfo*TNfOt_%I~ts\o	(^Fb'HVئ/E\╦M+-+0wM+=(h4I4!"2UvjƷ2q):,X1T/+~2e|jW=gZ;[zó~3pgfvzz3Ե=
ƞDS4n⟴$S٧_l=d:2]1;4t8	-$VcJ=k<:~1@ٜ(0ayM
v~㙵&yJ`h(FNhJifE/BgrH`O &O
9a+dv%
T[#02#:*A+M?
̂2Jڇ٨_qoTV=+L%4B/}”_".yVӤ5<[GKi/t,tX|ǧX{hxLqLu27fP3aP1cw7DRcprV|߈f63E`2ij G p.fjQ@71+L(4lM؀JMi@K699>y ]F7,0y`97#y
zŃ:̬b/|)Caҳ	UElN`)Opz
^L8>KKؾ:d^
,>AjH"`_Na~E^~{MP`$aG^n|?ؖa{nЋņz>G\EQfCI3gXDU[<&[Vh
$ JUOh@18]s'V^Vz	
/En
\V+zRi7XG<<[(2?Ц@ېu4xth

J7Ʒ':5e`*N3K-
lTV/hZX.:,RU3Rc,/Ƀ%j4)+tTRdr/)Wj
P̢4nhQSdžKRq	z,)N͍*N(2Egqh4;Pr|P8G+JGt*HGtJg1p'ߜѶ뤛ݐ~Ko%9(XZTmQTꛥOW]e{y'huF'Ȅm`.[4P&K;;,(Cyi12ĸ]m]nK'CCIr51C"CYXh lY6(8O%b,nd-x?2AӵP}m7K$ڛ$?O<m~!ra+UU^ÀD--PkfqNJV!sEjږ.ltWo&j"OTJMr)aT,=jN)TWe'dc5
	Pyx>#jAV䓑(\&oX̨5Tp1,*	G
AOT95TG4ɎA3iUymULw3\gyNc$&ccǪ0qsCVRx}؋Q0mʼnQ0FcA7@8e0{ȨozyoegS#+l,nۂB߀G]"5I3aj}kyy2YF%+h
*C-]yP݉7OȎN7O>%WZ!e}?@Kn꬯ԭeC{INZ¿|\P=F3%^y,ʟzLn$m+m6bB
]6&r14Hk~W
fiX|,x5}5UF8Uře^@2`^o4\k83߬}>S?8g^=!Ruό|Ĵcõ[qŋ.ƚEI[zZS[ZB@-)GnL  \M&
BAVn4CNg=S::ׯQ-
Xf99LyMט|c2y]#KfNj`b{t'-ۤЅK{?mTUm!+a_.y,Kt;T1dr<\egD#FF(]}4i9twz6gusa	`6hK20dZv\qZ~dCzGgWm^X3j]!\ʓgτ\VB^_o
MF9O<{fAԖ^(p
3INWgd^_OͬYzܻ.M"9#R]7qHĵʡˇ-sk%6ݲpy^<::ov]:tДeVÜdҹr?zn20bpA״OIHᒐS/KzZ<,y(DWbG00}TCT$f+ݾ#`, 36k2ΠS}~Β/0DC/T vD	lP.C_65nU
0a{e\`nƳ-;{y^l`pr9wh|T+$4EˌnrH:]5@Sx++l%nH]r0Fc:Ste!ǺpNS֔px?E4I/3GNK$NK&ഒFJM44OɽG/sZݘ|ېb8^F~>tN;#q@s
.Ȃuڠ?[I;xy]`,i+R%LMNWe
rA%e_RdHYM'n1􉈷phfdt|v-KF#ۓׅRa0jyvu-0]|Nx&Ny9	C	&	3)A$QN
)i|\kF]ޑ?8814n׋/22sPa
C*hl6<2;SF{V9LU)A
j$
UDRØtYÈk^AA,Ylx񽘩?3d]~yݗwOoldE;˲NJ`,
j&jBi>naćL$cSXKLHji4bE:;zAr
j顁4c
[H$ƨ,6'|eQa>f'2pYPu7Co8ܷR`ra<}A׻d*:"\ݲňNJ@J(k,؉jCi`0Daܕ`;%fɶܝ`t)a6,y%`Q$Y"@l]IbYfD
%a` ~!ݫ
 K)))ÒBR]v́*	쨃cG{h9v@i]4f&9W9Pn.-7BNaZ&fR36߆T-8mBa c?.IͰ1x%E!#s7R4'Ψpj"Cjf_d/iGF%&%RTB)AeMñAnnYlns컧w5#G6m\ؾ)d޴\L
tG|
xEp8jH8ӎ{z&Ap"xn-fqj܍75u*e(+dqQ\n8QlKcG?0rꃟG.u3"Eh]"
ĤG3IyvUM(<8}}9Jc9%svt>zz\
yɱ/0^|ߋo78ZwwwXhYf#FOr
1T^@n0,x^kViyO'tq_yZ Vu/VL{K[(s$Cr)U 2%q:=AGJimU dn4*UՆ肌 
ҩz?-aP^_2_R3\YRIuB1}fbbDue96.
,Ў[QSgN-/P8~@S1@4q(&NÄURG
\C(j?S>QĖ-,`IHаD8ǐpQxȯcU99rTG"Dp;Hz:jDŽD Ya4T	h>6?	A,홋τʛ
!P%P+k3`f<"G\"
}7(7""95)+nt=4uy?J10T蜳ճ(*vb߽ Dj6pׄ,1eFA.|e\(rUBA	~'APQLޚb[r>RhI\5<":ۜFAgόO&va5SVdO
/_P[q4>Pb٢H}%sr9v)	%5:FLUcԔ{d|䧽4y𾫗(DŽ`&W'[WD*Os2gc2E_Ó.P"NjM!W-7T7MƔnJdK˻ﻃ^+=;I+
].6jYÊ~MЄ#sCuehy_
,|W^n蕲AqqRjmGͨdj"AQqF@gAD;H򝓒A@^3me@`t/256$VG?eҳ%(N?A*k$.));C#5XFFxYzNzN? Kr_/9W
KFsTKwi*92e}ro%jd`a#ᮑUTPbr
jvwPe6wE0]Ij~)}CclбU#'.GА/88p?f?pY,m缧G|۶Y>OZ:3;v|]e{zd'pvtbECqH][l;"<><
y!oF_Wyor8XWdk lT061IHf"x1qy݆ciӉYyͅjdt`Ea:O	;@Y.;(2%
K>~=,}͊gig3I$at]+v+8"sf&GzD{ƨI05PBʞ2zd{<
vPѬ{QKYzmE^Y?W TAw6nZ}Z}|9W{u.>?RTlFdUY[,G%6N呦f8F\IqZdm#Gj\qԐb;8568mk&wi'%k3^:wJjtKuFY0wREׄ†?mLlبd?=/e9SMϝaLXSds
M8	"}@EcczqK̶Ksќ襪bDܮ%$iIVfɢ^0١14MLO^٠e$rj!5jr=+dv	(:|V1kP6u"8>c@21rNj~h/	~hE%X(DXazF3_0ϙ/4̕4K\sTL=!-U]ޘM\Ҕ@07'9@ǫaa~͠&2U,ؙ%W_Q3{r8)4?j:O֦xOd`Ir#g|<9%UUJUlj5+pՐeK)ehJ
|F
rTW.n3Qe%e=eSn%*hXI C
4$З$et.0WcY&I*-ҖyItjTmuiүCddG1&uFɮgtǙbuZR&GeUQBO^&8\Խ):yK,C;֢S,ըI2ZtS˲b1p/.~\Ndes	S5ϯY(dM߬iݲPF͎oo?>ҿBZ'IM[^;дF=Nu?r%Tˏ<=S=3kC+
Sd[+#εo\-yjyhhړ<3<3Tu`p%(lq]}waZL;%͡x7frŏ_+;/8CG*Ǯ>F՞kᵇuI
:ԽvS22^3\-i\V8H+0	OI<ЧE.:X.֞is/C$Ƨ]DYVڔdzh+>N/"e!CpWyyT֭u1-YlPbtAff 0AF0,L^2)ƛ,bG`w2VU
ay	8;2B
|^G9#)O]+gpdyq'?M`)aX,9͔]OJ:	ZVS{Dөv='
VA5&5R		,&~vKLP!Q )jǼC=AFƺf1@9F(^s9o6wxӜ~4g.}x^/Ypnsn;wkXb3K'(}@<89$DX}]=*[0SƩ['o8QR
~刨H		Vkt"58Ό	{}=Q)_@@|1_5-
5rT<@:1pIq	cr5@`rRro&o)=-BJR+)J٤HH
DJ3Ii4VTu(3hgdYHa螀k
B=*Ĭ0
Q+Vw@jLm1AMzhX j>dk,zLK*&#l9d-(rN;Z{Nsoq>Axݣ핮y-~">={)e]UhQ5vVE둘xH=^2::t!c㣀FߢE"?{pJ7~1jw6EH.Μ51a`(9c:?ORXB A("J;B9vA!*hnJBaCq@p]хoP8$\_ڇMvP9ݧn
7tҍW?HFlFX}M`.)DZWNWG60mT9hMcX"=)a|^׹bk9B|S).8ĄAÉ(+|&$DB>ń)!.%ˁ57ϕݾ:n.{`^f5YiG"%/uLx"YDvOwBIŞHf>l^J7gL KbA.Pdڣ16ކ%;'Eңre!'q2bcjIX&ܿݪFo'h͡b%Jonjӿ7qԠVxW]9Bզ}cȼqp*>P-RxwT.`
`_SeV4C-)ot߷LB+G/>u3wZ_PBqo<}:ᑴK`o5۴L/WX8
 ӆ^<ͤ-${Ƽ+S΀UnQn |5aXg:7^{Q8>?5iŅVV;0뜬p+E4nߏ
(i2|zT񩫟So>v_Pw?3
~9dnNrx6Vm"A ܻ(6W׏c+I%:_~{8aF3yhuv:-{Y{}縟pt$b9C%q#H|c^*$mzlTE*kʚ?4:|FyҰPcZ8C}6j&D	ҽiBPmA!?{ V+?z{}B!|{uS]G3$@H%QTИȓ/($ߖew9&MjGϝ`qKg\W
%k%IXH5kG+ޣZRUCOuQ	-bÍ!_V9
:4xE"Y4]?F!NF'ܻ`aYZPat쉅6o<.=<.fOL#VvX9{(dl/"B@0*ȎφPD*{ei_
ga`!'jU
|A~Cvhl{}v!q/vϲtT[u\خ
4@	@Qrb!C/gR0dpR>x50D&)-jr%
Z#ʘzwZȈs *QgІdi<iV>1Y}Y5G5?d2KҔ#M\YSXAIZ.e(N{kF4oyL3Z;6FWbk9
t,a@ݢ=L	Յ_+
bu6Nge5f~;*ط˗?E}~Qa\mYuU}"C,M9h}Gvz;[w#aGNUtZLmuʷl"S3X p!3
	d Hb3J¥e>ϹP&#k;24'Yd0z5#x>)~*#
նt/EҮ%`JY(chaYZcrژ193`VLl&g`(iM	.~	=|dWc>%Iv\pVDn%#y*X"ȣ')ע7	X91)TL5X"	CcwnRhQ $UPwBg>:
}7$eTw\Rue~FڨDU%4Yu&/UMU9w(:{bI#	6}})h?5t=|N#%(LQD1b@Dā($fsτs]bv@l8qfFBF\F}6X8mBWL#9np̻o븒#V2&
d|QJT|*0,+hQE8B+:`\rPZY?ORPZ:ɠMuED)C_L^hAy&dQv% Jv9]lV/vxeC("0,6ү|,R1
=
##X=J4KT
|?eRS#`R:¤DŽBfhDZxheS|)sorInOUg)Ik\v Rh?եj,3wCiVssߩO	;iWH/jQrSѡƉdkN)aN(d-fvi10ZWj.yI"(ߑm‹O=xnp(!8?i:lrrTcUvAdS'hՇސb
.xn7>h4ޫvvD%#qH)D6+Ln+#EB*H%2ࡘ	Aso	w}(CP4u:yOLwIaYG@j
9]#J~krFM{eэe|lr沫B'L{b^ܐȖ5AӚXShASp	](ltRH+jg1	%Bh<ЄZ8fsKcJ鶮lX2ݐrBK1h'=ϫjchHnvmڛ`n_1{?I'Cl)Snf1πբLӰ/B0藂Tr~FL}U*VZV̓Òxĉ#0N2?QLD|,]!HAo+r#sN:77E
#{휽vF
׮HE
7HΤLIPHDme0 ;M6U4`@G3xهo,&/MPU&_DH
+՟0.vF
elx$^%wQ([}Jk	"2Qs̅cHz,,TZv\$7%Ç6§6UC_bC>^:4FR	:K菀P*,0}>8O

(>b4 @A&$AU6lpw	/bØ@sKb߃XEYN*z0C9*TOeU$W$E()h<r'|1#K*|%
䙃3ӚDhL0qWE?H@"QaAmY
w,sxCl(c@(R]%J̖!Kl	e̽gBayJ&,e"| Ęp*V%p\
K@=6=ٴZx4ڗ{sA&pY"K<2
l!Bz%WS/;jjbI*kazK͝pCܘE#L(lzmiG9dລ7*=ۆ4ALؔO1es SfHK˱~YFi~(VHrZU@nO{A_a˔QHEf,6w::U]4t5[M*UM;2ܧx=>t8'çF3+08rN0*C}TCzJh>Gm	dJ}!Qh溦6nڼedoovx\a _:;%^}@vE斣HzЇQjm{ZܤU{hcj)5!an;kk	֛sӏ̚APnu8S
m.-+̕_޺Pajüycdu/$_,xͳg6܆)לds@8|[#Xq'4
L* ".&D0s$XZ{4lQq-ytG2b;_&u,'[>rҀu1}uKȺQ]O$oU̡hڑ{hoZε架N_$_UCs	*%ɴ)EL9>ɊgL_/X{3{U|˵Yv;[	glʓVFr|dډ6Y~yBN\NL`vm[Smp}[|^5f~GCMöVV?sI`pzX
ä1JNZ!+ubj:o,kDT8U3c1WJ-$׃OLnJ7hТ֞ɘ|'#SmL	Rq͙!5֋wE9st缹>AT.X[vl5"-9A0Bv~3Ũ"iڸ-إBl=ғTpڝ(~WcW<6uxJ9\׸Uh9W9nE^ɬ5jThvT]`0l.jͺ'/3&:&a`@ntdT1QK'C:cT',@e1H߱.تlUӇmM	m+֩PfNNWku|%cv~k`gfjY?QX,[CUdMN(E'?^/j`v~X3̥sҩO=]sJy[ ﰀO[˕wjXȡ	aK1Qz]ȉ2/ثU&Vsb%-Nw Ӑ	q1MeJ.J\9ŅC*Ҽ8l7k+'a7E$>@Ē8$`0e&aH;rP2ǸzD9^:HhM|o[e:krT֔9o9KY00}Zw,tfAT»ZOre/~܆_hYW1z%4IE6-4R-}g '=|.jtDt2MPpeд E9͠x;V0J٨4w-P!]@ᝠnRz0on6Jc;"BbԛcSUc_
?WV@hn7=[qRGâ9
ZkL)WImiŵ]] .)p
t
kf€NRsb;l*2w#ԶF6AT\:F2=-q|?UsysMĚsZ_Ȯˮ\Ȯˮg/Cso5@R-&kZ?l2jV%䀸x"Z:h-P܇lrűƒTIG۬57Q
Jv77ʮY<{{X/[ly8B呒|!.TA@4"rr%4۽\
1\w99ݕ
iƒ"w-b<-qד5X@uE̽\7u{}TS~0=pApk8c5H#jՃ٢)7˔bq
Îp'0!G jiw-8%l`j#
֘VX$վ~Bڌ$㫤n2eO5s?V_֜^lWKթ6<7>)@6AqGw%+QܭRܕC$3R{*6VUW-`z6nQ۪8w\7#׷fqgZ%NwT[+H]5Z5\%?]Wʑ0"ltٓNM4$D=rӲ}Σ
;ޱ`9tj1)L_ر󰱠!qk9X	4DM^`Ʃghdd<Ǔ=6k4cw{s(YסU|,݃@4
$ԡђwd818E}3{~#<3|p!siYUްUNoxm+l[R/5rbطEg5x/@ѭ,l9Ќ{S]
Q+A`ps:x>̌p%Ǵ{os7H+Ļy8/x&'rsHa5@aZzBm
I5+/{4dҺ;ͣo404B e/\c'$(;@9nq9``ɴtF_Wcap^5Ջu =Sp(N!A]33C^vyᓡSC8I>-9k}Zy
m1_yt{ T
jZ^m;rjN^11yn	w>
p*n.I+H4j	Ѕm#i:&cÌ#bGXQoǞ2"DӁquS=PkoEy7GmV*~2RdY8T$㎽ޡ!!cnpX>2KRGt!X,aКC ЧQba-!u_**P/qHZd
Y$#q1c\1g967-̙\+xW-MuZL>G[G(='NosS	FyqP~/sKҿ#n6 =9Vok	5:=>ŷYa"sFqA5,kIFhG'A͛@l?uC1]#>gT-H[ylOUeuR{k6jzlbOhk~NC<HGmb}35BvJW@G;՜"jp?JѼ8BK-N'5ڪ9ys]\τ%wrBs.Z3aT_J>8!ٲ'El[dVpmw]v}m6r3U6W4CetٲoXK#Փafw[v}yof|]?y";_3}pњk̘5/RV7ш5{޺*R^3=g&Lri<̙ف=.-=/XW!RŖ`s9[i޶Qgzζz̼u3t?SՈ|F-pݴM+B_+ޯ?wˊ6eUfmn|˕G)Y,V7[&[jB6.dEpAr
مgHI|Zڣ}Do%Y>]|!5.ߊHeZBp!RqH]Bۋ/DjԤ쉡,]>gR_h1-u?#pD0ap8UgSr\Ao*_JbA`K$7텟rBq➩ms_kE%E;ȬK.n`v!RzſYKpqQ4G+.aRP	J1HNӏ]팅6osKZuGdQ]:Uz0ҧ"(bHK,,0,éiS0pf#,JppU`L+0S<5z<}`|aR9$ĦX,$	`GNoK~moRW2*oJR(c}׼:ްF9҂X(#A0E*F5ydI|'%c?.p	-9[Ż:V%dC}x$\)K
ZK#z,`[v)wA- hF|xdqX;ȿÜHItpv\-BkPs.Mr3x8,"I%$*ҽKK}nݖ^hYi jqJ6Wyn8.I%D*J֠XX;\Nv*k C-G]o}d3>;C^iwM4x>Jäڸj yB4P0^_W8|C	2'XPU!{BrIڹ	3ZTeL"TW@)pm\돆|$/g1c
apB	ӏK'e炽a_5im
nC(i\/3-k4{oiVui`'_<E @ OQ$(R(R2H-IHE@8jR@\A\\ÍRӍ0I#I#!z{{r۟z~ovi/ݙٙٙ{2gTae[vXظoV2|<Ĺ'-#{XRx}-!ue@VI'x)Rz☞<96r/+9qgXL_%|,?8;B&	PpN
b@+HХa`F8z^aqkZϑ%UB3c3FM2
ʂ|Bɜ-/WcqO[tZ&Bϱt>A
FkiIJ?/8qI!:#i|QiXY]Saq-MD]2x/Q9p3efJ-r-%s{o
dm ژJ,DMafG6q3[a,'Qbh!+O_hAoe>'1,k}c8(8*GĽ%mx^A~A l#B|*&V_,[>/zdXPT"@hut0{|َ:`-wA]wLyؖ!R\kӞh]fp>.lJ5_YQSy^='IX7SRgO25
0¸OZ
PQ嘒e6~wvͨPS>f}uQ.峜gNǢ.S9㷛X禨ibS08T֕oECta_l%yTV3W1]E3XDNƟ!rҔ|po}ˠ}"S_tn5Z9_k|zZF5Awa)_?3xpx.'U(2>F5\3wg&0ēʅ&u2ZocBDQ^zJ>99A[G15m7x>~2bvb$3N7>jYOL286}<&rDxB1ǰsLQJ*1bg蘛6^k0#?w2oj7˂2A͢܈4Y!SG!޴,0ira|V(wvOw40W̫mܥ<,׀^}3
Ϯ!?P!l-(?*hJEsu,R,jZJovzwDkE3ᢖhÆHCgΟ
;q08]WD-ů+^UjzRӤMD74
6]KerS(s@dFrk

h[=hnEu|h,ńmYB#*/ʋⰪ^WTUwDU]CwT>~d 6;K}~M,FE?s|%_5+\mܕF̀M}t3],򍐿oK{D[$λ"1n-~N'8^󠲉{,އI=N}U}~ 1uĔy.~QqJіfwQ2a\	G5$	@=#_UV|)wU+g)CL.l_[ܫ))bTŵS.'*CbQyc.e8:
1r9wCtJ	2ܻ|CÆ<2Tx@Eû9C`vD_ԗ~m
mYߋ?no=qj
YW^,,=72U^Ri=)-feS7o({B[BY[vZSD].-H[++#_BzɽuWrGcM]㢮1j0{O]<m6MW1qcc
0jhSk$*S#券W%KCDS)oo\̗JG6+dhsGAM7{CG%w4_z($rpZA_TDKsQmDK/]|R{]rQX֔ﱏ2l	p.Pש Ċd1I\˲~4YSfh%!{Λ	Ŕ==y2;ay9`蚗'P)1:1>`bGM趵L@U͊A#]YUڥtXo%Ķ+`iPG̸,[aW8B0f8D{ZČj(QM@WSixƎC᥌S\T2-i&eB;_K<(X+t%e)}FzמҙMKRO^gWU-C]Κ*TSPs*Qd
I
y)[aqJŠmu	zEg9R%if?ךT8kYY~Pkvg{fkvgkvp7V`ʚTfʚ]
jpŪi <9dSƤdqX}EEQ+;q%:#hMySq
v-ArC1uߘ(qȁʨ7в&?`]5n4:`HvI4pEtL\R3SCh}7 Rrܼ9xTtHHi*/!JWt5rzX4V]!c[H׎9鲠XD۲@ͽ[jO#7Gt:DPGt5>//	K|G͗/6W!#=^*(=G-=֔&#"nIo
-lX(dw@pYFsvQrkD]n%b!fԴڰ.z_g{KuYC;"#ґC#Aψgo
^ɒ
HܰhnV5|ܪog/tt%7D
8OO<
?Zio/'*dP5\_6,40d`T}6P86>5.xJ3_>6~rߦy@;GE487JzcX_&O~%40gྶt{]ߘQ&H-vѭjGiTِnmB6PwY:Hk:
mrFmvWv4Qw6 ek_-({SJk	:J!밠_QC)
n_]ddhj7cHcDCΚW)'NHV/&$eDȭ
ot*)dU%-Ԟ(8J:J#Kbf6$"V։J"KVK+plޚ1՜lQ/a&2g**X%+i%}䅓`VŝK/n/b`1SW%ť`[
!*`dæ
Ԙ|ָ.5L
KjgGD_%Y	phL'U)ՂwoJ}ϠLRʪޡ$S Ua3Sa%
ȤW>oMͺ>ĸN\8g!eMFÊ{?3`$e{+W콢t=w"KkUCu~K#eGQeYXc݄#L6<윘9.ї33cV!0Hr 
$K( Îd6z!
s̴R@ĒAqoEY1vMVƯDaz_q^9Q-*ˢj7|ˋ|'~%7k߬.8r''NFnכ{ػ0xon=0[T|=HAkuacg]_677?pPO]_K>'-|v;Pm^=x-wM"*eᢲbus]wC
oX㎾-qP!ڐXO8x[r#:XX7FOǥ\T`][[miS}@tϑLwILbGBY@"(_Gib6{rܹoqmɿ20V
(N3'>!T9>S5RȨ0M6RNp""|1ua>n7WL$1
Hb
^PE˪gJoX{DLHp-R=x׃GG~(ƍڸ
"<=/cүЋ\eʡ67.d7R0$;6IΘ{xrjgpeG֠/āl5hlN%Wnx~qI?0Lnw!(ID9 t
'|>k·%Nxlb~=qN֐+0V(p-t}౾q2;h#wkS%s1B~;Xmo!XmOc(v
ljn
~NYUż+`'#NK,qDC؏2q.]W.W]G
%9)	"\..okڄe9-}DT(bC\>{EuYԔ{5rNT4ϗLmkjuO#	!O}R@5,Hv?vrqBi"nnB;&egR++,ီA@e\/B+ќ&+~+DtNݏndr )M!)&1$zR/,SB?ə.hz?oQW<0AlMڄXmȁO/A
8/-	dt#e$
Qnr˒{@}H%}TrCfVM162{UeAaWwg[85bYo9h8&Z3ee)qg RȴLlej6a39RZUԒʂD|$1f:o4A16vH:!]\gyrTW¸QD Ɔk?$vH 9PM1={rf3vL^/H͐![s!G3/>y!W_-@jń<37De+2E/fޯF|TGȴ̲`f_ɬ[ss/]Y_]oQ<,x},6FAu<\TW.^GmQP[Emݝmբj){wwD[])^l<.p/,pk
CBR!	+wD;?y(ڼ'Iq-T^X=C&[)Q'kA.*lљY@.KytiC*8`SʸYOB1xcn`6l9qblvc
pqmq=8qrgͱ*
ToP
Or[8\Gze	Qf&].e7ڦϴr_\NqR!Qn!O
jsI2pm𓓓	<	n⇟D_#*tuVY[Ʀϲt;''Of7NC;z>6]t29xc;267Ußx~frb]x1'14e&>4zge5b@+qjq@|
SrMP_oE}}]KC]U[e|,zvRoo^j1SM9i996>>vL"dly99Aћm)lLL2MSbгY du=ܷMh8[D;D!
SVj@0 51`;R
E0Y5@*Ʊ94uCOJ-Ν|G7t9yD2K%s%=aY%GdAY)F{X7ΚKˈ]_xFGGiR!`Ӕ>	"4d>Pp@fG%Qc2O;cQ'ٿY$yY%}}-]iHaEڪb~oOA|;qт?
pvQ!!c0E<`C;(nhS";1|!L@dJJÇLz'	*&FVrM%h)mh؄B>*Uzӑ& H
_L?$͟Ar	=:,6|&nr@fغ^JˌK{ʮŬ+#
]HC?Ұoa߲@9H-(	g6#EsKGL2<ʮkDcd0Ȭ r/$jkɘ4E]o=ȳEAb1ď2;3kk(w3+oDnlAՈҒ:ѭ	"TV	<eQvj*͝J;1RA>SY,|"D)"!_sH!6	-AWırʴS#ǎjiM5c&֤.+Uk>NEMTf"XjX_
1%@Nl"iacv	ej{u|R5j@FNO{+}էMr|(	Yn_!&91KMQqzISbPסF`	TP	ŔN1Q"`˝u@߱gxoL
pog4}KRt{mS5]*s]Ip1Ԥ{b
ӷ2N8>=?;uzbJP9?ALN_x:&Fw0q=pM#'5}5ۜ
]P(f2sƀ(3Z\eE3zs=K_ih=GOmwUzF+e`ve$=рV:"%QUF2ǯDUAsU4ZO$*9_էSJhv{Sn7I5
:h/ԁwNz5/\3%A\ZKLɎY9G?HTa)N)G)x
#*F?+B>+fDX:}?TLYu]CJˏ	V{]cMGcMƊƚMmWkQ~}94ޠiG)*(Lc|
=Ris1{bEFZk$-9ߍ!:8Ψ=dp?38{0ѢY	E_o$Mx=+}o{[]c](.[ǀǦs!FZJJAkт/&vOMTcQCpL@@ȃOƦb“w\Īw]h-0
O;GOT;
L;pd==y7ob5yAQ1>JT,b̜ʙj08U:4Hz|2SƒJPM=m2NМ~\z*&qMe)&1Zb!ur¡tdU%ʧ'I٤(5bHv]fە"'mIɀvHiG'H8퐬iЀ#H(ʦQlu!%RV<[%!hv](0"FX"Ip)\Hْ<ޗj-͘u
mL֬:	3$Lm.'h䬊ϵ%|K|bΎSʍ!sWU$5-,5YH6޳	_>.
9r{fƣo٩?gg0aΓSg)U]\!r[}.hʕ&۴IXII3aS)ɪMW"5ܚHnS0)nk=Պk#uŢ"j(h
>7;mZ5=%]gŭs;+=Q[VҳPMCTg"[
t.rH8,_ubџZt!a#1Nok@R.DA<%Bex
ڇOwfMhllHރ.G;F)3hk"fkUCְIyʬgMfǖxREMj*N"&O*bOm%F>#*UMM͖ó'6cd>i;֨4Ʒ,
cRZ/Ůw!-ppm8ĺ]oĵ)7&wh O<8a
:cT3*Hv9[/vpas]1Uxwskkiȣfoݗw{7\~<0n@NK#[),mާ}O:^R]PyWٕ9~pXSH_rkÚ|UvY|Y={tU?o/oWP	d	Ǹ	
X=Z8Fl[Ń &%DžŴAT_Iݪ㡀heЋPwjiSZbJ9`	1F2$E>m*mJ9aHW:/C.J͕ăEs{Hܡ):W8+ Z\{s 
g\ւ<ꁌb@\kjg=|hWpkCe]-{JIRHD4Q˜6],>.E.K%{fI-Zqb=DgYrsM唂9S@qcꙠt(bM%1p\sNghe;v9kw3jv]kwoc vE#%`'Q|eWwujRBYqJ\ ]PC)vrof ԊQw=QX8w`w[p//]LhL>N];kͦ\$`:OOSºG`_CXvq;3.bb|m#P뗌-{y
"f'%ߨ
{>S:Wr=L^;Q.kˆ4Y#꠩[?_m(:7Z,z255T"Tb5Mnϵiھ3+J5-PVGbcj+K^/{_*l\U
m-NB߽b*z;sq\4WR%=b;\d2_]^t/ekt辽=dv
(L&Us|@{GBso	j~fەboM*4p7!ZzevL{fo˽/1TeGٗv_ubXԖ-`myh^!-
|-#F
n::<zBRfO~λ2}ηgC٭h!߁p:E?({l$hhJ	|K8`!&B?׌ҟF%N?Ot[]sQNiNKZQi(|Nxu4(
LsEJl?8yDP`?y~Ŏ2?-
tm?^AT1'b|҈.hZuN<}>`ѿPBBa\n-FO}.YcY-<e=K2G0U
UCͣ׏Lz_XX[|ऀF~฀ytUySߑ%zJì[$;k9ph'X8f`PX<%$T2 1%`lxiቧ}.z,!C3֧
!ìٸbj!o_oc	JsBV|UuQs͗7S~{فկVG
ݡvO/DU).†*|1o^4o^ji[hC9MKe~pnke{C-annǏh#+NT
J%ðCIܴtϭ)y-
?*;?BDB>	|XX/
{wM6MlZY
W#}"rc1fVZpLuqS(hӟv:cQ0v010㷱wL$opqxUs{0BITY{ʊe1]e)dθ,P뗕S0J\:iZVCNCdeע%U5&:3	+lj$00/نu*1D'nذ77asK	\#m[+/*^ye\n`vX	$&r!O0.'Ǩh(m/0PQl	7T,vHYx0w%Kdz
AD!oJ'FVY"(35KRK+
kZDښ%,^fqjű6[.5fi1~gGiqVD	A?9+A	gMv"$gČؘ]x!F+nNLbDf`XcN	BL.;~0ď[7,4+)sd7֠:E`^5}=H>8H
:ŭԌiHxjSq0
!q !
ƒֺ	P4E@ЮYgHH!0
#>svnLr9=tQsF*6+4FHQ(exJ"EiRVΥP5ΉxɕkbonDZ(-ê>+_w|w׷'ߞY~yPj\o~卖oy{BOZ~#9=m>./+
ꊢj#:SiL$*J
K*M@[R'/o~HUlP+!K>"4s˅,UI`ХW#Ei6kBƗ&|GCꈶ>?/]s%vRvuW9RM{\d^8=;3XRPh)]wKCeKڬOB*ŻZW=2$DX`'Ih+d~|GJC@ٟ6="OvwE$J/j*"hZJ=wd~|#jEuߧ+ON%`7)ߑqVh`xi-Oj|mS]&'	:+s"HD30rM9H'LbvY}{,n.H<'}gONX(mY#ˬhbf|<&{h3M8)
vI(T!ۼ=53	Ԩ}v;YoP$.l|͘|lb|{;qvtr?J?ko&0+WN6'sdTѽz`4J{ijO^1|LQ+j=/m5+^TO#2
_9gƁYqwM!,Ïw_kh-*\ݧ5+Ny|aI51T`834wJ1@`J@$(u5rTz*\Ir`I$qJ蹊$]sS)Ë,nĈ7e	qe[160I>pVs@kXsά2ްKspSј\LL`Ӱzw7Z?.^sݴeӗ.iN15~wܸhn/iW:}Z$K%㡌9ʌ-QU7y7+飯	MGBUkK_oS=Ҵ^R{/u~"b2:LZܟfb_{s, a字P*Ƙ*1q<# m.%CmX߅Fs{N+w	z_J!1*LL-wpYD%0%ao,Y9D">&qON;',ոj` 
3?79\%rXc[z]erP^<Sc|ı;X	ޠ໇=j$R(_<D_)? LVZ*rBs~يrRf	EAew4,ZTBy>"=-/lAOu.6[7*z*?_#i\H$p1lV/Tv,VvD3L"o*Q(euҵ:jF̋m/<+y_Z*\)_?3ՒʿِyG+/*JyM*Τ0&+>֩Ѓz]$@`HeY~
ҙTT0\B,0|,-AIv$qJfgL1}Vך`K$__$N9 zQyYXPaW(8ˣ()E2^]6a/6VޮZSСV
۽Kag}ˮGPb;q3~·V%7T2gCQ`9B&R(OvX)S)
ghֵV\kLWk}&KdJ_TI&:I&-wڵ)SMI``>&}YZ/L׳v%+qΗf15y4ao/CfsKaRjF9NǤCU61Ɛo֌uk1ش0?)\QtآMPIy.SB>aMIkjtII1{]$߳$C=CD$1#EufK"	c3CyP2T̩Y9S/=5j43"(lgn&d&Rڅ4(|e	9N+GJۃmms"=G=G#P򊹞Zy6.WFd(#\/IfoȺ#jl}rQSz/qYաZ0z{I!:Eً[|׎Ovbp鶥̅oP<]ђ
7X==k[|Ne.xK^|=1^hEw˃20x}OW5FAC4bh\44FQLPͯQBE^[Tqe7ޱjx`CmkX5"5Ӷ=#Sâa=Ҿ7ؾ7o0Ҿ}4/gr"9
PN료9-~wϟphew7w|ݻglBM}wyʞ{FάM8Qߣ*Pv[XVhuÄ7 %^2*$;GIE$Ao{>cch~7H&0[V0^jOՈ}3fB"$9$ZH!!q$B9X'¸ /c p4FVȭ1YW,%1r[U:&!X]*KNɣ	)s=#~#`_&ښGPVs_FhcpJ׬g…mRa$ ~D?"NJuÿPu;Y!ӒFXu;z^"WsʇN܉366wo	`@4ll[&;1'4vg+N-V2D-zm;vMf*Ealӝݝ(sޓ#q?f={=sDu/3d֙$Zl/$5R1=}1v&(0Q*~qIǿ/nZ{_}
	 2iӎfB_Ew=t>0=f
&&#'Y9coE+\zǧgw:;2èn9U@贷րR}jsYJ9}錾td2N='gܪ[4ěO<0m󪦿ȫv=2佣}S;-^|>ww_zpvˡ-šOc3K~eӜlFQ]uզyEL7ܲLZ
#J37 E(åm"MyPhՠ	DˣEUE9c耷sPET*I+d/;
|}цsp7mYa2œ,\9Izs6LNX6ɹN]MVdel	9uh(>NlRy5Kf@;Z";~b1md61rQ	I.
q"O	_婛/Kit$F; Kofֳ[(COw4u75ێX[{O؎Bޝ!9?nCBBJe.^PaK
woX`|!%An>]CkRwNS!Y/d=a;RFuHA%g#d
?chKKdž	|]w^L8n姅WcȐSft6kdti^ͭzTm+l)`h_{go
N^ͬpi3nL>Ȩv)'O{+cđUc	2]
S]Sݷaq_hJPN	ݣωKl֝tLb^5Lb||5Hzɸd\װE'0$H?WE8bI1@+D9hi0EQb^&f?hZOSܯKϡXm,UPscHd؞XUu''ͭ?ۺ,c2GLz{f@ZK>4f益	?F1˂[?8vba74Z2eP25-e
Yˤ-
b6{AH-T vQGD`dmD@	)v9nNw@ޔ_@:.qKIi	Q0(9$Hi%mHsڰKsܪOj?#AfuxL90Vj+DqJ1)oFWTP~F
Y<6l4T~&~XO5wC̸#
C~bh;k2ϺG?kKފrKNcl4iDv0~]]*u:iMPcZ`IݛEO;W`pJ|Wn2oVK7@=W5Oxkylt4`pP{G|Kۖ.NWz͉k미 qx!kLx7]|2ƕYMYT1-a5jtiVþ*bAoDLbbjxZLc$SPd-&&c'&pKi+ꞯ3~%}
Rv؀8&J%y)ԛvw]t`v[y7]
W'UtKܾt+Z1(oV
3RE=)_orMo1>y_{z?],ozQ7
Hȗi0]=+&67M
/onWMFH2([a#{dd6H}#奶
V^]ё↛N/lPFea4[)	Ah
r\`6\
F"on6
/R^tV*zP.mH:NIb0
thAi.v3(8#4Lx}K^ـT)E|f;ԓ^t~㕩}Ɵe:W4S4I}荽ZtV29.wkO]O2>&mN(/SLyY"Lo-V=(%<'Я!UGl z/-@Q
k8M5m1d}.0'"\,&d"[hu`l5!L*vx>#wD!a4hcu^[*5ܼ|Gz%旜ukz0ʪؕdՓDRaRHy)l	R'6#ڀXڛkJ6?oZ
fJ,,!/Nn6yUI.u}C##~Ozf$=կ/+W7$ڀuphH&;/Dm&rG0X}6CaɉbOsqp5|xP!PE7u֘Kx;F2h/nD$mn#		M=GGxQ0ԅd-іŬ֐)ߠp`X$IRPN-LO0#{D]0US	w[%L8ap?$F9mm~2~˙(m̢D%S.gje2g&VUɌ˙RYZ*[V+dYtJ%#剖r$҈<%"HJ0`!',[qЅ74Ӏ:%'#a|)[ӓ=
2ksz"'3MSu%+%_8lDDS:\i`M#ѿcguʕ`MP˴B΋0QF(!en{kܻ%\PVnT!9Iv.^HmJNLs`6M[ϛ0tķZ9cPZ.͉'l]!s´*0\P)ˤiGOv7;ݍ~5~AeJB!?
xh7?|0rmӾ
#߫41^(U;!X8xMMD!
|}iph	Hst:{tOjϡw<~~0^H>=`s09XB^pG?9H:Pt̽;~CQ@#pĻ:={@+Vp&=0#:V!:&w
@'^<Y<}F :P!HkP?~.:CA?HѿC㱨xfPЎZ9k#c4>}}HN8:0>l?Zů)]}N隐L)s"Wr?eR/%?TaVO̟%Ȋ,gnH&,hHKYJX0`jFk22MXX
,g`L6feadi\L#|F.BbJ+
X9X#KW
n
޶jj1Z(e7`u=5@Z#` m?`"sĭ^ԊxiG0A@"~@%#މ?8zDFqO!E
O"MSz
ӟbkQY֫+!*% S8\fY%p'n$0D#&)v%DCxh	4X$GCJٞ]o/9
rXNgɎEem#ٺ#DIvDDÄF0FNK(nEa <"d;N4"`I3bSV* r% $g)!,)
"EBA.#Rd-2#X%9e bdʠAD@4\&,
5AD˒j7>TQAA4	)h8<*\76q
E#%ed;dA)%h@?@Eh|"bJAHQ
LHDXy,ZXL`9!
s aRL^tIwwKA%.#Dr0s:ai,8*Ia!3$!Ke(Y|_aB#ˈXF<2_Hd*WOY+jUgl
-ҋHҖiHRN
I_2+HRd,K,\F2HH"pE).=!("tkyL'^3a
MTp[ox"E/:BPKKY\?
plugin.ymleO=0+j88
bwqxm5|4?4Ukq;ӨC9ǃ!PjQz64R&3A}|[$7qΊ4nXlP` _;i=ƆGS氞5(ಛ+<*4)d)Mo(T3iӿ8^PKKY\	AMETA-INF/PK4U;\)META-INF/MANIFEST.MFPKIY\Avcom/PKKY\Acom/pyjavabridge/PKKY\3	($com/pyjavabridge/ScriptCommand.classPKKY\A>'@
com/pyjavabridge/BridgeSerializer.classPKKY\A=#N)Hcom/pyjavabridge/PyJavaBridgePlugin.classPKKY\A%lcom/pyjavabridge/event/PKIY\m]Y)\lcom/pyjavabridge/event/PendingEvent.classPKIY\KKoPe'ncom/pyjavabridge/event/CancelMode.classPKKY\"Z. qcom/pyjavabridge/event/EventSubscription.classPKKY\A|com/pyjavabridge/facade/PKIY\(|com/pyjavabridge/facade/ChatFacade.classPKIY\d:	@+~com/pyjavabridge/facade/RaycastFacade.classPKKY\#j&K,fcom/pyjavabridge/facade/CommandsFacade.classPKKY\Y$'Xcom/pyjavabridge/facade/RefFacade.classPKIY\7	dp+com/pyjavabridge/facade/ReflectFacade.classPKIY\d?
,ncom/pyjavabridge/facade/ParticleFacade.classPKKY\ao*com/pyjavabridge/facade/RegionFacade.classPKKY\N<+com/pyjavabridge/facade/MetricsFacade.classPKKY\"/3com/pyjavabridge/facade/PermissionsFacade.classPKKY\s+Y'Vcom/pyjavabridge/BridgeInstance$1.classPKKY\ޫ|`6&com/pyjavabridge/EventDispatcher.classPKKY\8bF^%jcom/pyjavabridge/BridgeInstance.classPKKY\Ap@com/pyjavabridge/util/PKIY\*|/@com/pyjavabridge/util/EntityGoneException.classPKIY\}Q0M	(Acom/pyjavabridge/util/DebugManager.classPKIY\u&%Fcom/pyjavabridge/util/EnumValue.classPKKY\#O),Hcom/pyjavabridge/util/EntitySpawner.classPKIY\R'u,skcom/pyjavabridge/util/NonLivingSpawner.classPKIY\Y/K(lcom/pyjavabridge/util/CallableTask.classPKKY\
.mcom/pyjavabridge/util/PlayerUuidResolver.classPKKY\*	*{com/pyjavabridge/util/ObjectRegistry.classPKKY\A_python/PKKY\4iapython/bridge.pyiPKKY\񁶪upython/runner.pyPKKY\ħuuJpython/bridge.pyPKKY\AG	python/__pycache__/PKKY\x18.0ٌ)z	python/__pycache__/bridge.cpython-314.pycPKKY\?
W:plugin.ymlPK(([1;PyJavaBridge-2a/settings.gradle000066400000000000000000000001711514752343100167110ustar00rootroot00000000000000plugins {
    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.9.0'
}

rootProject.name = 'pyjavabridge'
PyJavaBridge-2a/src/000077500000000000000000000000001514752343100144615ustar00rootroot00000000000000PyJavaBridge-2a/src/main/000077500000000000000000000000001514752343100154055ustar00rootroot00000000000000PyJavaBridge-2a/src/main/java/000077500000000000000000000000001514752343100163265ustar00rootroot00000000000000PyJavaBridge-2a/src/main/java/com/000077500000000000000000000000001514752343100171045ustar00rootroot00000000000000PyJavaBridge-2a/src/main/java/com/pyjavabridge/000077500000000000000000000000001514752343100215535ustar00rootroot00000000000000PyJavaBridge-2a/src/main/java/com/pyjavabridge/BridgeInstance.java000066400000000000000000001440131514752343100253020ustar00rootroot00000000000000package com.pyjavabridge;

import com.pyjavabridge.event.EventSubscription;
import com.pyjavabridge.event.PendingEvent;
import com.pyjavabridge.facade.*;
import com.pyjavabridge.util.EntityGoneException;
import com.pyjavabridge.util.EnumValue;
import com.pyjavabridge.util.EntitySpawner;
import com.pyjavabridge.util.ObjectRegistry;

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.Sound;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.entity.Display;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.TextDisplay;
import org.bukkit.event.Event;
import org.bukkit.event.EventPriority;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.permissions.PermissionAttachment;
import org.bukkit.util.Transformation;
import org.bukkit.Color;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.joml.Vector3f;
import org.joml.Quaternionf;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.bukkit.event.Listener;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerQuitEvent;

public class BridgeInstance {
    private final PyJavaBridgePlugin plugin;
    private final String name;
    private final Path scriptPath;
    private final Path scriptsDir;
    private final Path runtimeDir;
    private final Gson gson = new Gson();
    private final ObjectRegistry registry = new ObjectRegistry();
    private final Map subscriptions = new ConcurrentHashMap<>();
    private final Map permissionAttachments = new ConcurrentHashMap<>();

    private static final Object UNHANDLED = new Object();

    private final Map pendingEvents = new ConcurrentHashMap<>();
    private final Object writeLock = new Object();

    private final BridgeSerializer serializer;
    private final EventDispatcher eventDispatcher;
    private final EntitySpawner entitySpawner;

    private final ChatFacade chatFacade = new ChatFacade();
    private final RaycastFacade raycastFacade = new RaycastFacade();
    private final ReflectFacade reflectFacade = new ReflectFacade();
    private final RegionFacade regionFacade = new RegionFacade();
    private final ParticleFacade particleFacade = new ParticleFacade();
    private final PermissionsFacade permissionsFacade;
    private final MetricsFacade metricsFacade;
    private final RefFacade refFacade;
    private final CommandsFacade commandsFacade;

    private ServerSocket serverSocket;
    private Socket socket;
    private DataInputStream reader;
    private DataOutputStream writer;
    private Thread bridgeThread;
    private Process pythonProcess;
    private volatile boolean running = false;
    private String authToken;
    private volatile CountDownLatch shutdownLatch;

    BridgeInstance(PyJavaBridgePlugin plugin, String name, Path scriptPath, Path scriptsDir, Path runtimeDir) {
        this.plugin = plugin;
        this.name = name;
        this.scriptPath = scriptPath;
        this.scriptsDir = scriptsDir;
        this.runtimeDir = runtimeDir;
        this.serializer = new BridgeSerializer(registry, gson, plugin);
        this.entitySpawner = new EntitySpawner(plugin.getLogger(), name);
        this.eventDispatcher = new EventDispatcher(plugin, serializer, name, pendingEvents, this::send, gson);
        this.permissionsFacade = new PermissionsFacade(plugin, permissionAttachments);
        this.metricsFacade = new MetricsFacade(plugin);
        this.refFacade = new RefFacade(this);
        this.commandsFacade = new CommandsFacade(plugin, this);

        Bukkit.getPluginManager().registerEvents(new Listener() {
            @EventHandler
            public void onPlayerQuit(PlayerQuitEvent event) {
                PermissionAttachment attachment = permissionAttachments.remove(event.getPlayer().getUniqueId());
                if (attachment != null) {
                    try {
                        event.getPlayer().removeAttachment(attachment);
                    } catch (Exception ignored) {
                    }
                }
            }
        }, plugin);
    }

    public boolean isRunning() {
        return running && writer != null;
    }

    public PyJavaBridgePlugin getPlugin() {
        return plugin;
    }

    public Gson getGson() {
        return gson;
    }

    Path getScriptPath() {
        return scriptPath;
    }

    public boolean hasSubscription(String eventName) {
        return subscriptions.containsKey(eventName);
    }

    void start() {
        running = true;
        authToken = UUID.randomUUID().toString();

        try {
            serverSocket = new ServerSocket(0, 1, InetAddress.getByName("127.0.0.1"));
            plugin.getLogger().info("[" + name + "] Bridge listening on 127.0.0.1:" + serverSocket.getLocalPort());
            startPythonProcess(serverSocket.getLocalPort());

        } catch (IOException e) {
            logError("Failed to start socket", e);
            return;
        }

        bridgeThread = new Thread(this::bridgeLoop, "PyJavaBridge-" + name);
        bridgeThread.start();
    }

    private volatile boolean shutdownStarted = false;

    void shutdown() {
        synchronized (writeLock) {
            if (shutdownStarted) return;
            shutdownStarted = true;
        }
        if (Bukkit.isPrimaryThread()) {
            new Thread(this::shutdownInternal, "PyJavaBridge-Shutdown-" + name).start();
        } else {
            shutdownInternal();
        }
    }

    private void shutdownInternal() {
        running = false;

        for (EventSubscription subscription : subscriptions.values()) {
            subscription.unregister();
        }
        subscriptions.clear();

        closeQuietly(socket);
        closeQuietly(serverSocket);
        closeQuietly(reader);
        closeQuietly(writer);

        if (pythonProcess != null) {
            pythonProcess.destroy();

            try {
                if (!pythonProcess.waitFor(2, java.util.concurrent.TimeUnit.SECONDS)) {
                    pythonProcess.destroyForcibly();
                }

            } catch (InterruptedException ignored) {
                Thread.currentThread().interrupt();
                pythonProcess.destroyForcibly();
            }
        }
    }

    private void bridgeLoop() {
        try {
            serverSocket.setSoTimeout(30_000);
            socket = serverSocket.accept();
            closeQuietly(serverSocket);
            serverSocket = null;
            plugin.getLogger().info("[" + name + "] Python connected");

            reader = new DataInputStream(socket.getInputStream());
            writer = new DataOutputStream(socket.getOutputStream());

            // Verify auth token
            int authLength = reader.readInt();
            if (authLength <= 0 || authLength > 4096) {
                plugin.getLogger().severe("[" + name + "] Invalid auth message size");
                return;
            }
            byte[] authPayload = new byte[authLength];
            reader.readFully(authPayload);
            JsonObject authMsg = JsonParser.parseString(new String(authPayload, StandardCharsets.UTF_8))
                    .getAsJsonObject();
            if (!"auth".equals(authMsg.has("type") ? authMsg.get("type").getAsString() : "")
                    || !authToken.equals(authMsg.has("token") ? authMsg.get("token").getAsString() : "")) {
                plugin.getLogger().severe("[" + name + "] Authentication failed");
                socket.close();
                return;
            }
            plugin.getLogger().info("[" + name + "] Authenticated");

            while (running) {
                int length;
                try {
                    length = reader.readInt();
                } catch (IOException eof) {
                    break;
                }
                if (length <= 0 || length > 16_777_216) {
                    plugin.getLogger().severe("[" + name + "] Invalid message length: " + length);
                    break;
                }
                byte[] payload = new byte[length];
                reader.readFully(payload);
                JsonObject message;
                try {
                    message = JsonParser.parseString(new String(payload, StandardCharsets.UTF_8))
                            .getAsJsonObject();
                } catch (Exception e) {
                    plugin.getLogger().severe("[" + name + "] Failed to parse message: " + e.getMessage());
                    continue;
                }
                handleMessage(message);
            }

        } catch (SocketTimeoutException e) {
            plugin.getLogger().warning("[" + name + "] Python process did not connect within 30s");

        } catch (IOException e) {
            if (running) {
                logError("Bridge socket error", e);
            }

        } finally {
            shutdown();
        }
    }

    private void handleMessage(JsonObject message) {
        String type = message.get("type").getAsString();

        switch (type) {
            case "subscribe" -> handleSubscribe(message);
            case "call" -> handleCall(message);
            case "call_batch" -> handleCallBatch(message);
            case "wait" -> handleWait(message);
            case "ready" -> Bukkit.getScheduler().runTaskLater(plugin,
                    () -> sendEvent("server_boot", new JsonObject()),
                    2L);
            case "event_done" -> handleEventDone(message);
            case "event_cancel" -> handleEventCancel(message);
            case "event_result" -> handleEventResult(message);
            case "register_command" -> handleRegisterCommand(message);
            case "release" -> handleRelease(message);
            case "shutdown_ack" -> {
                if (shutdownLatch != null) {
                    shutdownLatch.countDown();
                }
            }
            default -> sendError(message, "Unknown message type: " + type, null);
        }
    }

    private void handleWait(JsonObject message) {
        int id = message.get("id").getAsInt();

        long ticks = message.has("ticks") ? message.get("ticks").getAsLong() : 1L;

        Bukkit.getScheduler().runTaskLater(plugin, () -> {
            JsonObject response = new JsonObject();

            response.addProperty("type", "return");
            response.addProperty("id", id);
            response.add("result", gson.toJsonTree(null));

            send(response);
        }, ticks);
    }

    private void handleRegisterCommand(JsonObject message) {
        String commandName = message.get("name").getAsString();
        String permission = message.has("permission") ? message.get("permission").getAsString() : null;

        plugin.getLogger().info("[" + name + "] Registering command /" + commandName);
        plugin.registerScriptCommand(commandName, this, permission);
    }

    private void handleRelease(JsonObject message) {
        JsonElement handlesEl = message.get("handles");
        if (handlesEl != null && handlesEl.isJsonArray()) {
            List ids = new ArrayList<>();
            for (JsonElement el : handlesEl.getAsJsonArray()) {
                ids.add(el.getAsInt());
            }
            registry.releaseAll(ids);
        }
    }

    void sendShutdownEvent() {
        if (!running)
            return;
        try {
            shutdownLatch = new CountDownLatch(1);
            JsonObject msg = new JsonObject();
            msg.addProperty("type", "shutdown");
            send(msg);
            shutdownLatch.await(10, TimeUnit.SECONDS);
        } catch (Exception e) {
            plugin.getLogger().warning("[" + name + "] Shutdown wait interrupted");
        }
    }

    public Object handleKick(Player player, List args) {
        String reason = args.isEmpty() ? "" : String.valueOf(args.get(0));
        try {
            Method kick = player.getClass().getMethod("kick", Component.class);
            kick.invoke(player, Component.text(reason));
            return null;
        } catch (Exception ignored) {
        }
        try {
            Method kick = player.getClass().getMethod("kick", String.class);
            kick.invoke(player, reason);
            return null;
        } catch (Exception ignored) {
        }
        try {
            Method kickPlayer = player.getClass().getMethod("kickPlayer", String.class);
            kickPlayer.invoke(player, reason);
        } catch (Exception ignored) {
        }
        return null;
    }

    private void handleEventDone(JsonObject message) {
        int id = message.get("id").getAsInt();
        PendingEvent pending = pendingEvents.get(id);

        if (pending != null) {
            pending.latch.countDown();
        }
    }

    private void handleEventCancel(JsonObject message) {
        int id = message.get("id").getAsInt();
        PendingEvent pending = pendingEvents.get(id);

        if (pending != null) {
            pending.cancelRequested.set(true);
            pending.latch.countDown();
        }
    }

    private void handleEventResult(JsonObject message) {
        int id = message.get("id").getAsInt();
        PendingEvent pending = pendingEvents.get(id);

        if (pending == null) {
            return;
        }

        if (!message.has("result") || message.get("result").isJsonNull()) {
            return;
        }

        String resultType = message.has("result_type") ? message.get("result_type").getAsString() : null;
        if ("damage".equalsIgnoreCase(resultType)) {
            JsonElement result = message.get("result");
            if (result.isJsonPrimitive() && result.getAsJsonPrimitive().isNumber()) {
                pending.damageOverride = result.getAsDouble();
            }
            return;
        }

        if (resultType == null || "chat".equalsIgnoreCase(resultType)) {
            pending.chatOverride = message.get("result").getAsString();
        }
    }

    private void handleSubscribe(JsonObject message) {
        String eventName = message.get("event").getAsString();

        boolean oncePerTick = message.has("once_per_tick") && message.get("once_per_tick").getAsBoolean();
        long throttleMs = message.has("throttle_ms") ? message.get("throttle_ms").getAsLong() : 0L;
        EventPriority priority = EventPriority.NORMAL;
        if (message.has("priority")) {
            try {
                priority = EventPriority.valueOf(message.get("priority").getAsString().toUpperCase());
            } catch (IllegalArgumentException ignored) {
            }
        }

        if (eventName.equalsIgnoreCase("server_boot")) {
            return;
        }

        try {

            plugin.getLogger().info(
                    "[" + name + "] Subscribing to event " + eventName + " (oncePerTick=" + oncePerTick + ")");

            if (eventName.equalsIgnoreCase("block_explode")) {
                EventSubscription blockSub = new EventSubscription(plugin, this, eventName, oncePerTick,
                        priority, throttleMs, org.bukkit.event.block.BlockExplodeEvent.class);

                blockSub.register();
                subscriptions.put(eventName + "#block", blockSub);
                EventSubscription entitySub = new EventSubscription(plugin, this, eventName, oncePerTick,
                        priority, throttleMs, org.bukkit.event.entity.EntityExplodeEvent.class);

                entitySub.register();
                subscriptions.put(eventName + "#entity", entitySub);

            } else {
                EventSubscription subscription = new EventSubscription(plugin, this, eventName, oncePerTick,
                        priority, throttleMs);

                subscription.register();
                subscriptions.put(eventName, subscription);
            }

        } catch (Exception ex) {
            sendError(message, "Failed to subscribe to " + eventName, ex);
        }
    }

    private void handleCall(JsonObject message) {
        int id = message.get("id").getAsInt();

        CompletableFuture future = plugin.runOnMainThread(this, () -> invoke(message));

        future.whenComplete((result, error) -> {
            if (error != null) {
                Throwable cause = error instanceof java.util.concurrent.CompletionException
                        && error.getCause() != null ? error.getCause() : error;
                String errorMessage = cause.getMessage();
                if (errorMessage == null || errorMessage.isBlank()) {
                    errorMessage = cause.getClass().getSimpleName();
                }
                sendError(id, errorMessage, cause);

            } else {
                JsonObject response = new JsonObject();

                response.addProperty("type", "return");
                response.addProperty("id", id);
                response.add("result", serialize(result));

                send(response);
            }
        });
    }

    private void handleCallBatch(JsonObject message) {

        boolean atomic = message.has("atomic") && message.get("atomic").getAsBoolean();
        List calls = new ArrayList<>();

        if (message.has("messages")) {
            for (JsonElement element : message.getAsJsonArray("messages")) {
                if (element.isJsonObject()) {
                    calls.add(element.getAsJsonObject());
                }
            }
        }

        CompletableFuture future = plugin.runOnMainThread(this, () -> {
            if (atomic) {
                List responses = new ArrayList<>();
                List ids = new ArrayList<>();
                boolean failed = false;
                int failedId = -1;
                Exception failedEx = null;
                String failedMessage = null;

                for (JsonObject callMessage : calls) {
                    int id = callMessage.get("id").getAsInt();
                    ids.add(id);

                    if (failed) {
                        continue;
                    }

                    try {
                        Object result = invoke(callMessage);
                        JsonObject response = new JsonObject();

                        response.addProperty("type", "return");
                        response.addProperty("id", id);
                        response.add("result", serialize(result));

                        responses.add(response);

                    } catch (Exception ex) {
                        failed = true;
                        failedId = id;
                        failedEx = ex;
                        String messageText = ex.getMessage();
                        if (messageText == null || messageText.isBlank()) {
                            messageText = ex.getClass().getSimpleName();
                        }
                        failedMessage = messageText;
                    }
                }

                if (failed) {
                    for (int id : ids) {
                        if (id == failedId) {
                            sendError(id, failedMessage, failedEx);
                        } else {
                            sendError(id, "Atomic batch aborted", null, "ATOMIC_ABORT");
                        }
                    }
                } else {
                    for (JsonObject response : responses) {
                        send(response);
                    }
                }
                return null;
            }

            for (JsonObject callMessage : calls) {
                int id = callMessage.get("id").getAsInt();

                try {
                    Object result = invoke(callMessage);
                    JsonObject response = new JsonObject();

                    response.addProperty("type", "return");
                    response.addProperty("id", id);
                    response.add("result", serialize(result));

                    send(response);

                } catch (Exception ex) {
                    sendError(id, ex.getMessage(), ex);
                }
            }
            return null;
        });

        future.whenComplete((result, error) -> {
            if (error != null) {
                logError("Batch call failed", error);
            }
        });
    }

    private Object invoke(JsonObject message) throws Exception {
        String method = message.get("method").getAsString();

        JsonObject argsObj = message.has("args") ? message.getAsJsonObject("args") : new JsonObject();

        List args = new ArrayList<>();

        if (message.has("args_list")) {
            for (JsonElement element : message.getAsJsonArray("args_list")) {
                args.add(serializer.deserialize(element));
            }
        }

        Object target = resolveInvokeTarget(message, argsObj);

        if (target == null && "close".equals(method)) {
            return null;
        }

        validateTarget(target, message);

        // Convert coordinate list to Location for teleport
        if ("teleport".equals(method) && target instanceof Entity entity && args.size() == 1) {
            args = preprocessTeleportArgs(entity, args);
        }

        if ("getUniqueId".equals(method) && target instanceof Entity entity) {
            return entity.getUniqueId();
        }

        // Type-specific dispatch
        Object result = UNHANDLED;

        if (target instanceof World world) {
            result = invokeWorldMethod(world, method, args, argsObj);
        }

        if (result == UNHANDLED && target instanceof Block block) {
            result = invokeBlockMethod(block, method);
        }

        if (result == UNHANDLED && target instanceof org.bukkit.inventory.Inventory inv) {
            result = invokeInventoryMethod(inv, method);
        }

        if (result == UNHANDLED && target instanceof Player player) {
            result = invokePlayerMethod(player, method, args);
        }

        if (result == UNHANDLED && target instanceof ItemStack itemStack) {
            result = invokeItemStackMethod(itemStack, method, args);
        }

        if (result == UNHANDLED && target instanceof org.bukkit.Server server) {
            result = invokeServerMethod(server, method, args);
        }

        if (result == UNHANDLED && target instanceof Display) {
            result = invokeDisplayMethod(target, method, args);
        }

        if (result != UNHANDLED) {
            return result;
        }

        if ("get_attr".equals(method)) {
            return serializer.getField(target, message.get("field").getAsString());
        }
        if ("set_attr".equals(method)) {
            serializer.setField(target, message.get("field").getAsString(), serializer.deserialize(message.get("value")));
            return null;
        }

        return invokeReflective(target, method, args);
    }

    private Object resolveInvokeTarget(JsonObject message, JsonObject argsObj) throws Exception {
        if (message.has("handle")) {
            return registry.get(message.get("handle").getAsInt());
        } else if (message.has("target")) {
            return resolveTarget(message.get("target").getAsString(), argsObj);
        }
        throw new IllegalStateException("Missing target or handle");
    }

    private void validateTarget(Object target, JsonObject message) throws EntityGoneException {
        if (target == null) {
            String targetLabel = message.has("handle")
                    ? "handle " + message.get("handle").getAsInt()
                    : message.has("target") ? "target " + message.get("target").getAsString() : "unknown";
            throw new EntityGoneException("Target not found: " + targetLabel);
        }
        if (target instanceof Player player && !player.isOnline()) {
            throw new EntityGoneException("Player is no longer online");
        }
        if (target instanceof Entity entity) {
            if (entity.isDead()) {
                throw new EntityGoneException("Entity is no longer valid");
            }
            if (!entity.isValid() && !(entity instanceof Display)) {
                throw new EntityGoneException("Entity is no longer valid");
            }
        }
    }

    private List preprocessTeleportArgs(Entity entity, List args) {
        Object arg = args.get(0);
        if (arg instanceof List list && list.size() >= 3) {
            Double x = list.get(0) instanceof Number n ? n.doubleValue() : null;
            Double y = list.get(1) instanceof Number n ? n.doubleValue() : null;
            Double z = list.get(2) instanceof Number n ? n.doubleValue() : null;
            if (x != null && y != null && z != null) {
                float yaw = list.size() > 3 && list.get(3) instanceof Number n ? n.floatValue()
                        : entity.getLocation().getYaw();
                float pitch = list.size() > 4 && list.get(4) instanceof Number n ? n.floatValue()
                        : entity.getLocation().getPitch();
                return List.of(new Location(entity.getWorld(), x, y, z, yaw, pitch));
            }
        }
        return args;
    }

    private Object invokeWorldMethod(World world, String method, List args, JsonObject argsObj) throws Exception {
        if (args.size() == 2 && ("spawnEntity".equals(method) || "spawn".equals(method))) {
            Object locationObj = args.get(0);
            Object typeObj = args.get(1);
            if ("spawn".equals(method) && !(typeObj instanceof EnumValue)
                    && !(typeObj instanceof String) && !(typeObj instanceof EntityType)) {
                return UNHANDLED;
            }
            Map options = serializer.deserializeArgsObject(argsObj);
            return entitySpawner.spawnEntityWithOptions(world, locationObj, typeObj, options);
        }
        if ("spawnImagePixels".equals(method) && args.size() >= 2) {
            return entitySpawner.spawnImagePixels(world, args.get(0), args.get(1));
        }
        return UNHANDLED;
    }

    private Object invokeBlockMethod(Block block, String method) {
        if ("getInventory".equals(method)) {
            BlockState state = block.getState();
            return state instanceof InventoryHolder holder ? holder.getInventory() : null;
        }
        return UNHANDLED;
    }

    private Object invokeInventoryMethod(org.bukkit.inventory.Inventory inventory, String method) {
        if ("close".equals(method)) {
            try {
                for (org.bukkit.entity.HumanEntity viewer : new ArrayList<>(inventory.getViewers())) {
                    if (viewer != null) {
                        viewer.closeInventory();
                    }
                }
            } catch (Exception ignored) {
            }
            return null;
        }
        if ("getTitle".equals(method)) {
            try {
                Method getTitle = inventory.getClass().getMethod("getTitle");
                Object titleObj = getTitle.invoke(inventory);
                return titleObj != null ? titleObj.toString() : "";
            } catch (Exception ignored) {
                return "";
            }
        }
        return UNHANDLED;
    }

    private Object invokePlayerMethod(Player player, String method, List args) throws Exception {
        switch (method) {
            case "playSound" -> {
                Sound sound = resolveSound(args.isEmpty() ? null : args.get(0));
                float volume = args.size() > 1 && args.get(1) instanceof Number n ? n.floatValue() : 1.0f;
                float pitch = args.size() > 2 && args.get(2) instanceof Number n ? n.floatValue() : 1.0f;
                if (sound != null) {
                    player.playSound(player.getLocation(), sound, volume, pitch);
                }
                return null;
            }
            case "grantAdvancement", "revokeAdvancement" -> {
                Object keyObj = args.isEmpty() ? null : args.get(0);
                org.bukkit.advancement.Advancement advancement = null;
                if (keyObj instanceof org.bukkit.advancement.Advancement adv) {
                    advancement = adv;
                } else if (keyObj instanceof NamespacedKey key) {
                    advancement = Bukkit.getAdvancement(key);
                } else if (keyObj instanceof String text) {
                    NamespacedKey key = NamespacedKey.fromString(text);
                    if (key != null) {
                        advancement = Bukkit.getAdvancement(key);
                    }
                }
                if (advancement == null) {
                    throw new IllegalArgumentException("Advancement not found");
                }
                org.bukkit.advancement.AdvancementProgress progress = player.getAdvancementProgress(advancement);
                if ("grantAdvancement".equals(method)) {
                    for (String criterion : progress.getRemainingCriteria()) {
                        progress.awardCriteria(criterion);
                    }
                } else {
                    for (String criterion : progress.getAwardedCriteria()) {
                        progress.revokeCriteria(criterion);
                    }
                }
                return progress;
            }
            case "kick" -> {
                return handleKick(player, args);
            }
            case "setTabListHeaderFooter" -> {
                String header = !args.isEmpty() ? String.valueOf(args.get(0)) : "";
                String footer = args.size() > 1 ? String.valueOf(args.get(1)) : "";
                setTabListHeaderFooter(player, header, footer);
                return null;
            }
            case "setTabListHeader" -> {
                setTabListHeader(player, !args.isEmpty() ? String.valueOf(args.get(0)) : "");
                return null;
            }
            case "setTabListFooter" -> {
                setTabListFooter(player, !args.isEmpty() ? String.valueOf(args.get(0)) : "");
                return null;
            }
            case "getTabListHeader" -> {
                return getTabListHeader(player);
            }
            case "getTabListFooter" -> {
                return getTabListFooter(player);
            }
        }
        return UNHANDLED;
    }

    private Object invokeItemStackMethod(ItemStack itemStack, String method, List args) {
        ItemMeta meta = itemStack.getItemMeta();
        switch (method) {
            case "getName" -> {
                if (meta != null && meta.hasDisplayName()) {
                    return PlainTextComponentSerializer.plainText().serialize(meta.displayName());
                }
                return null;
            }
            case "setName" -> {
                if (meta != null && !args.isEmpty()) {
                    meta.displayName(Component.text(String.valueOf(args.get(0))));
                    itemStack.setItemMeta(meta);
                }
                return null;
            }
            case "getLore" -> {
                if (meta != null && meta.hasLore()) {
                    List lore = meta.lore();
                    if (lore == null) {
                        return List.of();
                    }
                    List loreText = new ArrayList<>();
                    for (Component component : lore) {
                        loreText.add(PlainTextComponentSerializer.plainText().serialize(component));
                    }
                    return loreText;
                }
                return List.of();
            }
            case "setLore" -> {
                if (meta != null && !args.isEmpty()) {
                    Object loreArg = args.get(0);
                    List loreComponents = new ArrayList<>();
                    if (loreArg instanceof List loreList) {
                        for (Object entry : loreList) {
                            if (entry != null) {
                                loreComponents.add(Component.text(entry.toString()));
                            }
                        }
                    }
                    meta.lore(loreComponents);
                    itemStack.setItemMeta(meta);
                }
                return null;
            }
            case "getCustomModelData" -> {
                if (meta != null && meta.hasCustomModelData()) {
                    return meta.getCustomModelData();
                }
                return null;
            }
            case "setCustomModelData" -> {
                if (meta != null && !args.isEmpty() && args.get(0) instanceof Number number) {
                    meta.setCustomModelData(number.intValue());
                    itemStack.setItemMeta(meta);
                }
                return null;
            }
            case "getAttributes" -> {
                return meta != null ? serializer.attributeList(meta) : List.of();
            }
            case "setAttributes" -> {
                if (meta != null && !args.isEmpty()) {
                    serializer.applyAttributes(meta, gson.toJsonTree(args.get(0)));
                    itemStack.setItemMeta(meta);
                }
                return null;
            }
            case "getNbt" -> {
                return itemStack.serialize();
            }
            case "setNbt" -> {
                if (!args.isEmpty()) {
                    ItemStack deserialized = serializer.deserializeItemFromNbt(gson.toJsonTree(args.get(0)));
                    if (deserialized != null) {
                        try {
                            Method setType = ItemStack.class.getMethod("setType", Material.class);
                            setType.invoke(itemStack, deserialized.getType());
                        } catch (Exception ignored) {
                        }
                        itemStack.setAmount(deserialized.getAmount());
                        if (deserialized.hasItemMeta()) {
                            itemStack.setItemMeta(deserialized.getItemMeta());
                        }
                    }
                }
                return null;
            }
        }
        return UNHANDLED;
    }

    private Object invokeServerMethod(org.bukkit.Server server, String method, List args) {
        if ("execute".equals(method) && !args.isEmpty()) {
            String commandLine = String.valueOf(args.get(0));
            if (commandLine.startsWith("/")) {
                commandLine = commandLine.substring(1);
            }
            return server.dispatchCommand(Bukkit.getConsoleSender(), commandLine);
        }
        if ("broadcastMessage".equals(method) && !args.isEmpty()) {
            plugin.getLogger().info("[broadcast] " + args.get(0));
        }
        return UNHANDLED;
    }

    private Object invokeDisplayMethod(Object target, String method, List args) {
        if (target instanceof TextDisplay textDisplay && "text".equals(method) && args.size() == 1) {
            if (args.get(0) instanceof String str) {
                textDisplay.text(str.contains("<")
                        ? MiniMessage.miniMessage().deserialize(str)
                        : Component.text(str));
                return null;
            }
        }
        if (target instanceof Display display && "setTransform".equals(method) && args.size() == 6) {
            float tx = args.get(0) instanceof Number n ? n.floatValue() : 0f;
            float ty = args.get(1) instanceof Number n ? n.floatValue() : 0f;
            float tz = args.get(2) instanceof Number n ? n.floatValue() : 0f;
            float sx = args.get(3) instanceof Number n ? n.floatValue() : 1f;
            float sy = args.get(4) instanceof Number n ? n.floatValue() : 1f;
            float sz = args.get(5) instanceof Number n ? n.floatValue() : 1f;
            Quaternionf identity = new Quaternionf(0, 0, 0, 1);
            display.setTransformation(new Transformation(
                    new Vector3f(tx, ty, tz), identity, new Vector3f(sx, sy, sz), new Quaternionf(identity)));
            return null;
        }
        if (target instanceof TextDisplay textDisplay && "setBackgroundColor".equals(method) && args.size() == 1) {
            if (args.get(0) instanceof Number number) {
                int argb = number.intValue();
                textDisplay.setBackgroundColor(Color.fromARGB(
                        (argb >> 24) & 0xFF, (argb >> 16) & 0xFF, (argb >> 8) & 0xFF, argb & 0xFF));
                return null;
            }
        }
        return UNHANDLED;
    }

    private Object invokeReflective(Object target, String method, List args) throws Exception {
        for (Method candidate : target.getClass().getMethods()) {
            if (!candidate.getName().equals(method) || candidate.getParameterCount() != args.size()) {
                continue;
            }
            Object[] converted = serializer.convertArgs(candidate.getParameterTypes(), args);
            if (converted != null) {
                try {
                    return candidate.invoke(target, converted);
                } catch (InvocationTargetException ex) {
                    Throwable cause = ex.getCause();
                    if (cause instanceof Exception exception) {
                        throw exception;
                    }
                    throw ex;
                }
            }
        }
        throw new NoSuchMethodException("Method not found: " + method + " on " + target.getClass().getName());
    }

    private Object resolveTarget(String targetName, JsonObject argsObj) throws Exception {
        return switch (targetName) {
            case "server" -> Bukkit.getServer();
            case "chat" -> chatFacade;
            case "raycast" -> raycastFacade;
            case "permissions" -> permissionsFacade;
            case "metrics" -> metricsFacade;
            case "ref" -> refFacade;
            case "reflect" -> reflectFacade;
            case "commands" -> commandsFacade;
            case "region" -> regionFacade;
            case "particle" -> particleFacade;
            default -> throw new IllegalArgumentException("Unknown target: " + targetName);
        };
    }

    private Sound resolveSound(Object arg) {
        if (arg instanceof Sound sound) {
            return sound;
        }
        String name = null;

        if (arg instanceof EnumValue enumValue) {
            name = enumValue.name;

        } else if (arg instanceof String text) {
            name = text;
        }

        if (name != null) {
            String keyText = name.toLowerCase();
            NamespacedKey key = keyText.contains(":")
                    ? NamespacedKey.fromString(keyText)
                    : NamespacedKey.minecraft(keyText);

            if (key != null) {
                try {
                    for (Field field : Registry.class.getFields()) {
                        if (!Registry.class.isAssignableFrom(field.getType())) {
                            continue;
                        }

                        String fieldName = field.getName().toLowerCase();

                        if (!fieldName.contains("sound")) {
                            continue;
                        }

                        Object registryObj = field.get(null);

                        if (registryObj instanceof Registry registry) {
                            Object value = registry.get(key);
                            if (value instanceof Sound sound) {
                                return sound;
                            }
                        }
                    }
                } catch (Exception ignored) {
                }
            }

            String enumName = name.toUpperCase().replace(':', '_').replace('.', '_');
            enumName = enumName.replaceAll("[^A-Z0-9_]+", "_");

            try {
                Method valueOf = Sound.class.getMethod("valueOf", String.class);
                Object soundObj = valueOf.invoke(null, enumName);
                if (soundObj instanceof Sound sound) {
                    return sound;
                }
            } catch (Exception ignored) {
            }
        }
        return null;
    }

    private String getTabListHeader(Player player) {
        return getTabListValue(player, true);
    }

    private String getTabListFooter(Player player) {
        return getTabListValue(player, false);
    }

    private String getTabListValue(Player player, boolean header) {
        Object value = null;
        String[] methodNames = header
                ? new String[] { "getPlayerListHeader", "playerListHeader" }
                : new String[] { "getPlayerListFooter", "playerListFooter" };

        for (String name : methodNames) {
            try {
                Method method = player.getClass().getMethod(name);
                value = method.invoke(player);
                break;
            } catch (Exception ignored) {
            }
        }

        if (value instanceof Component component) {
            return PlainTextComponentSerializer.plainText().serialize(component);
        }
        return value != null ? value.toString() : "";
    }

    private void setTabListHeader(Player player, String header) {
        if (tryTabListSetter(player, header, null, true)) {
            return;
        }
        Component headerComponent = Component.text(header == null ? "" : header);
        tryTabListSetter(player, headerComponent, null, true);
    }

    private void setTabListFooter(Player player, String footer) {
        if (tryTabListSetter(player, footer, null, false)) {
            return;
        }
        Component footerComponent = Component.text(footer == null ? "" : footer);
        tryTabListSetter(player, footerComponent, null, false);
    }

    private void setTabListHeaderFooter(Player player, String header, String footer) {
        String headerText = header == null ? "" : header;
        String footerText = footer == null ? "" : footer;

        if (tryTabListSetter(player, headerText, footerText, null)) {
            return;
        }

        Component headerComponent = Component.text(headerText);
        Component footerComponent = Component.text(footerText);

        if (tryTabListSetter(player, headerComponent, footerComponent, null)) {
            return;
        }

        setTabListHeader(player, headerText);
        setTabListFooter(player, footerText);
    }

    private boolean tryTabListSetter(Player player, Object header, Object footer, Boolean headerOnly) {
        List methods = new ArrayList<>();

        if (headerOnly == null) {
            methods.add("setPlayerListHeaderFooter");
            methods.add("sendPlayerListHeaderFooter");
            methods.add("sendPlayerListHeaderAndFooter");
        } else if (headerOnly) {
            methods.add("setPlayerListHeader");
            methods.add("sendPlayerListHeader");
        } else {
            methods.add("setPlayerListFooter");
            methods.add("sendPlayerListFooter");
        }

        Class headerType = header instanceof Component ? Component.class : String.class;
        Class footerType = footer instanceof Component ? Component.class : String.class;

        for (String name : methods) {
            try {
                if (headerOnly == null) {
                    Method method = player.getClass().getMethod(name, headerType, footerType);
                    method.invoke(player, header, footer);
                    return true;
                }

                Method method = player.getClass().getMethod(name, headerType);
                method.invoke(player, header);
                return true;

            } catch (Exception ignored) {
            }
        }
        return false;
    }

    public JsonElement serialize(Object value) {
        return serializer.serialize(value);
    }

    public Object resolveRef(String refType, String refId) {
        return serializer.resolveRef(refType, refId);
    }

    public Object[] convertArgs(Class[] parameterTypes, List args) {
        return serializer.convertArgs(parameterTypes, args);
    }

    public Object convertArg(Class parameterType, Object arg) {
        return serializer.convertArg(parameterType, arg);
    }

    public Map deserializeArgsObject(JsonObject argsObj) {
        return serializer.deserializeArgsObject(argsObj);
    }

    public Object getField(Object target, String field) throws Exception {
        return serializer.getField(target, field);
    }

    public void setField(Object target, String field, Object value) throws Exception {
        serializer.setField(target, field, value);
    }

    public void sendEvent(String eventName, JsonObject payload) {
        eventDispatcher.sendEvent(eventName, payload);
    }

    public void sendEvent(Event event, String eventName) {
        eventDispatcher.sendEvent(event, eventName);
    }

    public Entity spawnEntityWithOptions(World world, Object locationObj, Object typeObj,
            Map options) throws Exception {
        return entitySpawner.spawnEntityWithOptions(world, locationObj, typeObj, options);
    }

    public List spawnImagePixels(World world, Object locationObj, Object pixelsObj) throws Exception {
        return entitySpawner.spawnImagePixels(world, locationObj, pixelsObj);
    }

    public void send(JsonObject response) {
        if (writer == null) {
            return;
        }
        try {
            byte[] payload = gson.toJson(response).getBytes(StandardCharsets.UTF_8);
            synchronized (writeLock) {
                writer.writeInt(payload.length);
                writer.write(payload);
                writer.flush();
            }
        } catch (IOException e) {
            logError("Failed to send message", e);
        }
    }

    private void sendError(JsonObject message, String error, Exception ex) {
        int id = message.has("id") ? message.get("id").getAsInt() : -1;
        sendError(id, error, ex);
    }

    private void sendError(int id, String error, Throwable ex) {
        sendError(id, error, ex, null);
    }

    private void sendError(int id, String error, Throwable ex, String code) {
        JsonObject response = new JsonObject();
        response.addProperty("type", "error");
        response.addProperty("id", id);
        response.addProperty("message", error);
        if (code != null) {
            response.addProperty("code", code);
        }
        if (ex != null) {
            response.addProperty("details", ex.toString());
            if (ex instanceof EntityGoneException) {
                response.addProperty("code", "ENTITY_GONE");
            }
        }
        send(response);
    }

    void logError(String message, Throwable ex) {
        String detail = ex != null ? ex.getMessage() : "unknown";
        plugin.getLogger().severe("[" + name + "] " + message + ": " + detail);
        plugin.broadcastErrorToDebugPlayers("[" + name + "] " + message + ": " + detail);
    }

    private void startPythonProcess(int port) {
        List command = new ArrayList<>();

        String python = resolvePythonExecutable();

        command.add(python);
        command.add("-u");
        command.add(runtimeDir.resolve("runner.py").toAbsolutePath().toString());
        command.add(scriptPath.toAbsolutePath().toString());

        ProcessBuilder builder = new ProcessBuilder(command);

        builder.directory(scriptsDir.toFile());
        builder.redirectErrorStream(true);
        builder.redirectOutput(ProcessBuilder.Redirect.INHERIT);

        Map env = builder.environment();

        env.put("PYJAVABRIDGE_PORT", String.valueOf(port));
        env.put("PYJAVABRIDGE_TOKEN", authToken);
        env.put("PYJAVABRIDGE_RUNTIME", runtimeDir.toString());
        env.put("PYJAVABRIDGE_SCRIPT", scriptPath.toAbsolutePath().toString());

        boolean isWindows = System.getProperty("os.name", "").toLowerCase().contains("win");

        Path venvDir = scriptsDir.resolve(".venv");
        Path venvBinDir = isWindows ? venvDir.resolve("Scripts") : venvDir.resolve("bin");
        Path venvPython = isWindows ? venvBinDir.resolve("python.exe") : venvBinDir.resolve("python");

        if (Files.exists(venvPython)) {
            env.put("VIRTUAL_ENV", venvDir.toAbsolutePath().toString());
            String existingPath = env.getOrDefault("PATH", "");
            String venvBin = venvBinDir.toAbsolutePath().toString();
            if (!existingPath.startsWith(venvBin)) {
                env.put("PATH", venvBin + File.pathSeparator + existingPath);
            }
        }

        try {
            plugin.getLogger().info("[" + name + "] Launching python: " + String.join(" ", command));
            pythonProcess = builder.start();
        } catch (IOException e) {
            logError("Failed to start python", e);
        }
    }

    private String resolvePythonExecutable() {
        boolean isWindows = System.getProperty("os.name", "").toLowerCase().contains("win");

        Path venvDir = scriptsDir.resolve(".venv");
        Path venvPython = isWindows
                ? venvDir.resolve("Scripts").resolve("python.exe")
                : venvDir.resolve("bin").resolve("python");

        if (Files.exists(venvPython)) {
            Path absolute = venvPython.toAbsolutePath();
            if (Files.exists(absolute) && (isWindows || Files.isExecutable(absolute))) {
                return absolute.toString();
            }
        }
        return isWindows ? "python" : "python3";
    }

    private void closeQuietly(AutoCloseable closable) {
        if (closable == null) {
            return;
        }
        try {
            closable.close();
        } catch (Exception ignored) {
        }
    }
}
PyJavaBridge-2a/src/main/java/com/pyjavabridge/BridgeSerializer.java000066400000000000000000001162201514752343100256460ustar00rootroot00000000000000package com.pyjavabridge;

import com.pyjavabridge.util.EnumValue;
import com.pyjavabridge.util.ObjectRegistry;

import com.google.common.collect.Multimap;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.Registry;
import org.bukkit.attribute.Attribute;
import org.bukkit.attribute.AttributeModifier;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.data.BlockData;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.entity.Tameable;
import org.bukkit.entity.AnimalTamer;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.projectiles.BlockProjectileSource;
import org.bukkit.projectiles.ProjectileSource;
import org.bukkit.util.Vector;

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

public class BridgeSerializer {
    private final ObjectRegistry registry;
    private final Gson gson;
    private final PyJavaBridgePlugin plugin;

    static final Object CONVERSION_FAIL = new Object();

    public BridgeSerializer(ObjectRegistry registry, Gson gson, PyJavaBridgePlugin plugin) {
        this.registry = registry;
        this.gson = gson;
        this.plugin = plugin;
    }

    public JsonElement serialize(Object value) {
        return serialize(value, Collections.newSetFromMap(new java.util.IdentityHashMap<>()));
    }

    private JsonElement serialize(Object value, Set seen) {
        if (value == null) {
            return gson.toJsonTree(null);
        }

        if (value instanceof Number || value instanceof String || value instanceof Boolean) {
            return gson.toJsonTree(value);
        }

        if (value instanceof UUID uuid) {
            JsonObject obj = new JsonObject();
            obj.addProperty("__uuid__", uuid.toString());
            return obj;
        }

        if (value instanceof java.util.Optional optional) {
            return serialize(optional.orElse(null), seen);
        }

        if (value.getClass().isEnum()) {
            JsonObject obj = new JsonObject();
            obj.addProperty("__enum__", value.getClass().getName());
            obj.addProperty("name", ((Enum) value).name());
            return obj;
        }

        if (value instanceof List list) {
            return gson.toJsonTree(list.stream().map(item -> serialize(item, seen)).toList());
        }

        if (value instanceof Map map) {
            JsonObject obj = new JsonObject();

            for (Map.Entry entry : map.entrySet()) {
                obj.add(entry.getKey().toString(), serialize(entry.getValue(), seen));
            }

            return obj;
        }

        if (!seen.add(value)) {
            int handle = registry.register(value);
            JsonObject obj = new JsonObject();

            obj.addProperty("__handle__", handle);
            obj.addProperty("__type__", value.getClass().getSimpleName());

            JsonObject fields = new JsonObject();

            if (value instanceof org.bukkit.block.Block block) {
                fields.addProperty("x", block.getX());
                fields.addProperty("y", block.getY());
                fields.addProperty("z", block.getZ());
            }

            if (value instanceof org.bukkit.Location location) {
                fields.addProperty("x", location.getX());
                fields.addProperty("y", location.getY());
                fields.addProperty("z", location.getZ());
                fields.addProperty("yaw", location.getYaw());
                fields.addProperty("pitch", location.getPitch());
            }

            if (value instanceof org.bukkit.entity.Player player) {
                fields.addProperty("name", player.getName());
                fields.addProperty("uuid", player.getUniqueId().toString());
            }

            if (value instanceof org.bukkit.entity.Entity entity) {
                fields.addProperty("uuid", entity.getUniqueId().toString());
            }

            if (value instanceof org.bukkit.Chunk chunk) {
                fields.addProperty("x", chunk.getX());
                fields.addProperty("z", chunk.getZ());
            }

            if (fields.size() > 0) {
                obj.add("fields", fields);
            }
            return obj;
        }

        int handle = registry.register(value);
        JsonObject obj = new JsonObject();

        obj.addProperty("__handle__", handle);
        obj.addProperty("__type__", value.getClass().getSimpleName());

        JsonObject fields = new JsonObject();

        if (value instanceof org.bukkit.entity.Player player) {
            fields.addProperty("name", player.getName());
            fields.addProperty("uuid", player.getUniqueId().toString());
            fields.add("location", serialize(player.getLocation(), seen));
            fields.add("world", serialize(player.getWorld(), seen));
            fields.add("gameMode", serialize(player.getGameMode(), seen));
            fields.addProperty("health", player.getHealth());
            fields.addProperty("foodLevel", player.getFoodLevel());
            fields.add("inventory", serialize(player.getInventory(), seen));
        }

        if (value instanceof org.bukkit.entity.Entity entity) {
            fields.addProperty("uuid", entity.getUniqueId().toString());
            fields.add("type", serialize(entity.getType(), seen));
            fields.add("location", serialize(entity.getLocation(), seen));
            fields.add("world", serialize(entity.getWorld(), seen));
            fields.addProperty("is_projectile", entity instanceof Projectile);
            addAttributionFields(entity, fields, seen);
        }

        if (value instanceof org.bukkit.World world) {
            fields.addProperty("name", world.getName());
            fields.addProperty("uuid", world.getUID().toString());
            fields.add("environment", serialize(world.getEnvironment(), seen));
        }

        if (value instanceof org.bukkit.block.Block block) {
            fields.addProperty("x", block.getX());
            fields.addProperty("y", block.getY());
            fields.addProperty("z", block.getZ());
            fields.add("location", serialize(block.getLocation(), seen));
            fields.add("type", serialize(block.getType(), seen));
            fields.add("world", serialize(block.getWorld(), seen));

            BlockState state = block.getState();
            if (state instanceof InventoryHolder holder) {
                fields.add("inventory", serialize(holder.getInventory(), seen));
            }
        }

        if (value instanceof org.bukkit.Location location) {
            fields.addProperty("x", location.getX());
            fields.addProperty("y", location.getY());
            fields.addProperty("z", location.getZ());
            fields.addProperty("yaw", location.getYaw());
            fields.addProperty("pitch", location.getPitch());

            if (location.getWorld() != null) {
                fields.add("world", serialize(location.getWorld(), seen));
            }
        }
        if (value instanceof org.bukkit.Chunk chunk) {
            fields.addProperty("x", chunk.getX());
            fields.addProperty("z", chunk.getZ());
            fields.add("world", serialize(chunk.getWorld(), seen));
        }

        if (value instanceof org.bukkit.inventory.ItemStack itemStack) {
            fields.add("type", serialize(itemStack.getType(), seen));
            fields.addProperty("amount", itemStack.getAmount());
            ItemMeta meta = itemStack.getItemMeta();

            if (meta != null) {
                if (meta.hasDisplayName()) {
                    fields.addProperty("name",
                            PlainTextComponentSerializer.plainText().serialize(meta.displayName()));
                }
                if (meta.hasLore()) {
                    List lore = meta.lore();

                    if (lore != null) {
                        List loreText = new ArrayList<>();

                        for (Component component : lore) {
                            loreText.add(PlainTextComponentSerializer.plainText().serialize(component));
                        }

                        fields.add("lore", gson.toJsonTree(loreText));
                    }
                }

                if (meta.hasCustomModelData()) {
                    fields.addProperty("customModelData", meta.getCustomModelData());
                }

                JsonArray attributes = serializeAttributes(meta);
                if (attributes.size() > 0) {
                    fields.add("attributes", attributes);
                }
            }
            fields.add("nbt", serialize(itemStack.serialize(), seen));
        }

        if (value instanceof org.bukkit.potion.PotionEffect effect) {
            fields.add("type", serialize(effect.getType(), seen));
            fields.addProperty("duration", effect.getDuration());
            fields.addProperty("amplifier", effect.getAmplifier());
            fields.addProperty("ambient", effect.isAmbient());
            fields.addProperty("particles", effect.hasParticles());
            fields.addProperty("icon", effect.hasIcon());
        }

        if (value instanceof org.bukkit.inventory.Inventory inventory) {
            fields.addProperty("size", inventory.getSize());
            fields.add("contents", serialize(java.util.Arrays.asList(inventory.getContents()), seen));

            if (inventory.getHolder() != null) {
                fields.add("holder", serialize(inventory.getHolder(), seen));
            }

            try {
                Method getTitle = inventory.getClass().getMethod("getTitle");
                Object titleObj = getTitle.invoke(inventory);

                if (titleObj != null) {
                    fields.addProperty("title", titleObj.toString());
                }
            } catch (Exception ignored) {
            }
        }

        if (value instanceof org.bukkit.Server server) {
            fields.addProperty("name", server.getName());
            fields.addProperty("version", server.getVersion());
        }

        obj.add("fields", fields);
        return obj;
    }

    private void addAttributionFields(org.bukkit.entity.Entity entity, JsonObject fields, Set seen) {
        Object shooter = null;
        if (entity instanceof Projectile projectile) {
            shooter = projectile.getShooter();
        } else {
            shooter = tryInvokeNoArg(entity, "getShooter");
        }
        addAttribution("shooter", shooter, fields, seen);

        Object source = tryInvokeNoArg(entity, "getSource");
        addAttribution("source", source, fields, seen);

        Object owner = null;
        if (entity instanceof Tameable tameable) {
            fields.addProperty("is_tamed", tameable.isTamed());
            owner = tameable.getOwner();
        }
        if (owner == null) {
            owner = tryInvokeNoArg(entity, "getOwner");
        }
        if (owner == null) {
            owner = tryInvokeNoArg(entity, "getOwningPlayer");
        }
        if (owner == null) {
            owner = tryInvokeNoArg(entity, "getOwningEntity");
        }
        if (owner == null) {
            owner = tryInvokeNoArg(entity, "getSummoner");
        }
        addAttribution("owner", owner, fields, seen);
    }

    private void addAttribution(String key, Object source, JsonObject fields, Set seen) {
        if (source == null) {
            return;
        }
        if (fields.has(key)) {
            return;
        }

        Object resolved = source;
        if (source instanceof ProjectileSource projectileSource && !(source instanceof Entity)) {
            if (projectileSource instanceof BlockProjectileSource blockSource) {
                resolved = blockSource.getBlock();
            }
        }

        if ("source".equals(key) || "shooter".equals(key)) {
            if (resolved instanceof Entity sourceEntity) {
                fields.add(key, serialize(sourceEntity, seen));
            } else if (resolved instanceof org.bukkit.block.Block block) {
                fields.add(key, serialize(block, seen));
            }
            return;
        }

        if (resolved instanceof Entity sourceEntity) {
            fields.add(key, serialize(sourceEntity, seen));
            fields.addProperty(key + "_uuid", sourceEntity.getUniqueId().toString());
            if (sourceEntity instanceof Player player) {
                fields.addProperty(key + "_name", player.getName());
            } else {
                Object name = tryInvokeNoArg(sourceEntity, "getName");
                if (name instanceof String nameText && !nameText.isBlank()) {
                    fields.addProperty(key + "_name", nameText);
                }
            }
            return;
        }

        if (resolved instanceof org.bukkit.block.Block block) {
            fields.add(key, serialize(block, seen));
            return;
        }

        if (resolved instanceof AnimalTamer tamer) {
            fields.addProperty(key + "_uuid", tamer.getUniqueId().toString());
            if (tamer.getName() != null) {
                fields.addProperty(key + "_name", tamer.getName());
            }
            if (tamer instanceof Player player) {
                fields.add(key, serialize(player, seen));
            }
            return;
        }

        if (resolved instanceof UUID uuid) {
            fields.addProperty(key + "_uuid", uuid.toString());
            return;
        }

        if (resolved instanceof String nameText) {
            fields.addProperty(key + "_name", nameText);
        }
    }

    private Object tryInvokeNoArg(Object target, String methodName) {
        try {
            Method method = target.getClass().getMethod(methodName);
            if (method.getParameterCount() != 0) {
                return null;
            }
            return method.invoke(target);
        } catch (Exception ignored) {
            return null;
        }
    }

    public Object deserialize(JsonElement element) {
        if (element == null || element.isJsonNull()) {
            return null;
        }

        if (element.isJsonPrimitive()) {
            if (element.getAsJsonPrimitive().isBoolean()) {
                return element.getAsBoolean();
            }

            if (element.getAsJsonPrimitive().isNumber()) {
                return element.getAsNumber();
            }
            return element.getAsString();
        }

        if (element.isJsonArray()) {
            List list = new ArrayList<>();
            for (JsonElement child : element.getAsJsonArray()) {
                list.add(deserialize(child));
            }
            return list;
        }

        JsonObject obj = element.getAsJsonObject();

        if (obj.has("__handle__")) {
            int handle = obj.get("__handle__").getAsInt();
            return registry.get(handle);
        }

        if (obj.has("__ref__")) {
            JsonObject ref = obj.getAsJsonObject("__ref__");
            String refType = ref.has("type") ? ref.get("type").getAsString() : null;
            String refId = ref.has("id") ? ref.get("id").getAsString() : null;
            return resolveRef(refType, refId);
        }

        if (obj.has("__value__")) {
            return deserializeValueObject(obj);
        }

        if (obj.has("__uuid__")) {
            return UUID.fromString(obj.get("__uuid__").getAsString());
        }

        if (obj.has("__enum__")) {
            return new EnumValue(obj.get("__enum__").getAsString(), obj.get("name").getAsString());
        }
        return obj;
    }

    public Object resolveRef(String refType, String refId) {
        if (refType == null || refId == null) {
            return null;
        }

        return switch (refType.toLowerCase()) {
            case "player" -> {
                try {
                    yield Bukkit.getPlayer(UUID.fromString(refId));
                } catch (IllegalArgumentException ex) {
                    yield null;
                }
            }

            case "player_name" -> Bukkit.getPlayer(refId);

            case "player_inventory" -> {
                org.bukkit.entity.Player player = null;
                try {
                    player = Bukkit.getPlayer(UUID.fromString(refId));
                } catch (IllegalArgumentException ignored) {
                }
                if (player == null) {
                    player = Bukkit.getPlayer(refId);
                }
                yield player != null ? player.getInventory() : null;
            }

            case "entity" -> {
                try {
                    yield Bukkit.getEntity(UUID.fromString(refId));
                } catch (IllegalArgumentException ex) {
                    yield null;
                }
            }

            case "world" -> Bukkit.getWorld(refId);
            case "block" -> resolveBlockRef(refId);
            case "chunk" -> resolveChunkRef(refId);

            default -> null;
        };
    }

    private Object resolveBlockRef(String refId) {
        String[] parts = refId.split(":");
        if (parts.length < 4) {
            return null;
        }

        String worldName = parts[0];
        org.bukkit.World world = Bukkit.getWorld(worldName);

        if (world == null) {
            return null;
        }

        try {
            int x = Integer.parseInt(parts[1]);
            int y = Integer.parseInt(parts[2]);
            int z = Integer.parseInt(parts[3]);
            return world.getBlockAt(x, y, z);

        } catch (NumberFormatException ex) {
            return null;
        }
    }

    private Object resolveChunkRef(String refId) {
        String[] parts = refId.split(":");

        if (parts.length < 3) {
            return null;
        }

        String worldName = parts[0];
        org.bukkit.World world = Bukkit.getWorld(worldName);

        if (world == null) {
            return null;
        }

        try {
            int x = Integer.parseInt(parts[1]);
            int z = Integer.parseInt(parts[2]);
            return world.getChunkAt(x, z);

        } catch (NumberFormatException ex) {
            return null;
        }
    }

    private Object deserializeValueObject(JsonObject obj) {
        String valueType = obj.get("__value__").getAsString();
        JsonObject fields = obj.has("fields") ? obj.getAsJsonObject("fields") : new JsonObject();

        return switch (valueType) {

            case "Location" -> {
                double x = fields.has("x") ? fields.get("x").getAsDouble() : 0.0;
                double y = fields.has("y") ? fields.get("y").getAsDouble() : 0.0;
                double z = fields.has("z") ? fields.get("z").getAsDouble() : 0.0;

                float yaw = fields.has("yaw") ? fields.get("yaw").getAsFloat() : 0f;
                float pitch = fields.has("pitch") ? fields.get("pitch").getAsFloat() : 0f;

                org.bukkit.World world = null;

                if (fields.has("world")) {
                    Object worldObj = deserialize(fields.get("world"));

                    if (worldObj instanceof org.bukkit.World w) {
                        world = w;

                    } else if (worldObj instanceof String name) {
                        world = Bukkit.getWorld(name);
                    }
                }

                yield new Location(world, x, y, z, yaw, pitch);
            }

            case "Vector" -> {
                double x = fields.has("x") ? fields.get("x").getAsDouble() : 0.0;
                double y = fields.has("y") ? fields.get("y").getAsDouble() : 0.0;
                double z = fields.has("z") ? fields.get("z").getAsDouble() : 0.0;

                yield new Vector(x, y, z);
            }

            case "Item", "ItemStack" -> {
                Object typeObj = fields.has("type") ? deserialize(fields.get("type")) : null;
                Material material = null;

                if (typeObj instanceof EnumValue enumValue) {
                    material = Material.matchMaterial(enumValue.name);

                } else if (typeObj instanceof String text) {
                    material = Material.matchMaterial(text);
                }

                if (material == null) {
                    material = Material.AIR;
                }

                ItemStack stack = null;

                if (fields.has("nbt")) {
                    stack = deserializeItemFromNbt(fields.get("nbt"));
                }

                if (stack == null) {
                    int amount = fields.has("amount") ? fields.get("amount").getAsInt() : 1;
                    stack = new ItemStack(material, amount);
                }

                if (stack != null) {
                    ItemMeta meta = stack.getItemMeta();

                    if (meta != null) {
                        if (fields.has("name")) {
                            meta.displayName(Component.text(fields.get("name").getAsString()));
                        }

                        if (fields.has("lore") && fields.get("lore").isJsonArray()) {
                            List lore = new ArrayList<>();

                            for (JsonElement element : fields.getAsJsonArray("lore")) {
                                if (!element.isJsonNull()) {
                                    lore.add(Component.text(element.getAsString()));
                                }
                            }
                            meta.lore(lore);
                        }

                        if (fields.has("customModelData")) {
                            meta.setCustomModelData(fields.get("customModelData").getAsInt());
                        }

                        if (fields.has("attributes")) {
                            applyAttributes(meta, fields.get("attributes"));
                        }

                        stack.setItemMeta(meta);
                    }
                }

                yield stack;
            }

            case "ItemMeta" -> {
                Object typeObj = fields.has("type") ? deserialize(fields.get("type")) : null;
                Material material = null;

                if (typeObj instanceof EnumValue enumValue) {
                    material = Material.matchMaterial(enumValue.name);

                } else if (typeObj instanceof String text) {
                    material = Material.matchMaterial(text);
                }

                if (material == null) {
                    material = Material.STONE;
                }
                org.bukkit.inventory.meta.ItemMeta meta = Bukkit.getItemFactory().getItemMeta(material);

                if (meta == null) {
                    yield null;
                }

                if (fields.has("customModelData")) {
                    meta.setCustomModelData(fields.get("customModelData").getAsInt());
                }

                if (fields.has("lore") && fields.get("lore").isJsonArray()) {
                    List lore = new ArrayList<>();

                    for (JsonElement element : fields.getAsJsonArray("lore")) {
                        Object loreObj = deserialize(element);
                        if (loreObj != null) {
                            lore.add(Component.text(loreObj.toString()));
                        }
                    }
                    meta.lore(lore);
                }
                yield meta;
            }

            case "Effect" -> {
                Object typeObj = fields.has("type") ? deserialize(fields.get("type")) : null;
                org.bukkit.potion.PotionEffectType effectType = null;

                String keyName = null;

                if (typeObj instanceof EnumValue enumValue) {
                    keyName = enumValue.name;

                } else if (typeObj instanceof String text) {
                    keyName = text;
                }

                if (keyName != null) {
                    if (keyName.contains(":")) {
                        org.bukkit.NamespacedKey key = org.bukkit.NamespacedKey.fromString(keyName.toLowerCase());

                        if (key != null) {
                            effectType = org.bukkit.Registry.POTION_EFFECT_TYPE.get(key);
                        }

                    } else {
                        effectType = org.bukkit.Registry.POTION_EFFECT_TYPE
                                .get(org.bukkit.NamespacedKey.minecraft(keyName.toLowerCase()));
                    }
                }

                if (effectType == null) {
                    yield null;
                }

                int duration = fields.has("duration") ? fields.get("duration").getAsInt() : 0;
                int amplifier = fields.has("amplifier") ? fields.get("amplifier").getAsInt() : 0;

                boolean ambient = fields.has("ambient") && fields.get("ambient").getAsBoolean();
                boolean particles = !fields.has("particles") || fields.get("particles").getAsBoolean();
                boolean icon = !fields.has("icon") || fields.get("icon").getAsBoolean();

                yield new org.bukkit.potion.PotionEffect(effectType, duration, amplifier, ambient, particles, icon);
            }
            case "Inventory" -> {
                int size = fields.has("size") ? fields.get("size").getAsInt() : 9;
                String title = fields.has("title") ? fields.get("title").getAsString() : "";

                org.bukkit.inventory.Inventory inventory = Bukkit.createInventory(null, size,
                        Component.text(title));

                if (fields.has("contents") && fields.get("contents").isJsonArray()) {
                    int index = 0;

                    for (JsonElement element : fields.getAsJsonArray("contents")) {
                        Object itemObj = deserialize(element);

                        if (itemObj instanceof ItemStack itemStack) {
                            inventory.setItem(index, itemStack);
                        }

                        index++;
                        if (index >= size) {
                            break;
                        }
                    }
                }
                yield inventory;
            }
            case "Block" -> {
                org.bukkit.World world = null;
                if (fields.has("world")) {
                    Object worldObj = deserialize(fields.get("world"));

                    if (worldObj instanceof org.bukkit.World w) {
                        world = w;

                    } else if (worldObj instanceof String name) {
                        world = Bukkit.getWorld(name);
                    }
                }

                if (world == null) {
                    yield null;
                }

                int x = fields.has("x") ? fields.get("x").getAsInt() : 0;
                int y = fields.has("y") ? fields.get("y").getAsInt() : 0;
                int z = fields.has("z") ? fields.get("z").getAsInt() : 0;

                Block block = world.getBlockAt(x, y, z);

                if (fields.has("type")) {
                    Object typeObj = deserialize(fields.get("type"));
                    Material material = null;

                    if (typeObj instanceof EnumValue enumValue) {
                        material = Material.matchMaterial(enumValue.name);

                    } else if (typeObj instanceof String text) {
                        material = Material.matchMaterial(text);

                    }
                    if (material != null) {
                        block.setType(material);
                    }
                }
                yield block;
            }

            case "World" -> {
                String name = fields.has("name") ? fields.get("name").getAsString() : null;
                yield name != null ? Bukkit.getWorld(name) : null;
            }

            case "Entity" -> {
                String uuid = fields.has("uuid") ? fields.get("uuid").getAsString() : null;
                yield uuid != null ? resolveRef("entity", uuid) : null;
            }

            case "Player" -> {
                String uuid = fields.has("uuid") ? fields.get("uuid").getAsString() : null;
                yield uuid != null ? resolveRef("player", uuid) : null;
            }
            default -> obj;
        };
    }

    public Object[] convertArgs(Class[] parameterTypes, List args) {
        Object[] converted = new Object[parameterTypes.length];

        for (int i = 0; i < parameterTypes.length; i++) {
            Object arg = args.get(i);

            Class parameterType = parameterTypes[i];

            if (parameterType.isArray()) {
                Object arrayValue = convertArrayArg(parameterType, arg);

                if (arrayValue == CONVERSION_FAIL) {
                    return null;
                }

                converted[i] = arrayValue;
                continue;
            }

            Object value = convertArg(parameterType, arg);

            if (value == CONVERSION_FAIL) {
                return null;
            }
            converted[i] = value;
        }

        return converted;
    }

    private Object convertArrayArg(Class parameterType, Object arg) {
        if (arg == null) {
            return null;
        }

        if (parameterType.isInstance(arg)) {
            return arg;
        }
        Class componentType = parameterType.getComponentType();

        if (arg instanceof List list) {
            Object array = Array.newInstance(componentType, list.size());

            for (int index = 0; index < list.size(); index++) {
                Object element = list.get(index);
                Object convertedElement = convertArg(componentType, element);

                if (convertedElement == CONVERSION_FAIL) {
                    return CONVERSION_FAIL;
                }
                Array.set(array, index, convertedElement);
            }
            return array;
        }
        Object convertedElement = convertArg(componentType, arg);

        if (convertedElement == CONVERSION_FAIL) {
            return CONVERSION_FAIL;
        }

        Object array = Array.newInstance(componentType, 1);
        Array.set(array, 0, convertedElement);
        return array;

    }

    public Object convertArg(Class parameterType, Object arg) {
        if (arg == null) {
            return null;
        }

        if (arg instanceof Boolean) {
            if (parameterType == boolean.class || parameterType == Boolean.class) {
                return arg;
            }
            return CONVERSION_FAIL;
        }

        if (parameterType.isInstance(arg)) {
            return arg;
        }

        if (parameterType == int.class || parameterType == Integer.class) {
            return arg instanceof Number number ? number.intValue() : CONVERSION_FAIL;
        }

        if (parameterType == double.class || parameterType == Double.class) {
            return arg instanceof Number number ? number.doubleValue() : CONVERSION_FAIL;
        }

        if (parameterType == float.class || parameterType == Float.class) {
            return arg instanceof Number number ? number.floatValue() : CONVERSION_FAIL;
        }

        if (parameterType == long.class || parameterType == Long.class) {
            return arg instanceof Number number ? number.longValue() : CONVERSION_FAIL;
        }

        if (parameterType == boolean.class || parameterType == Boolean.class) {
            return arg;
        }

        if (parameterType.isEnum() && arg instanceof EnumValue enumValue) {
            @SuppressWarnings("unchecked")
            Class> enumClass = (Class>) parameterType;

            @SuppressWarnings({ "rawtypes", "unchecked" })

            Enum enumValueResolved = Enum.valueOf((Class) enumClass, enumValue.name);
            return enumValueResolved;
        }

        if (parameterType == UUID.class && arg instanceof UUID uuid) {
            return uuid;
        }

        if (Component.class.isAssignableFrom(parameterType) && arg instanceof String str) {
            return Component.text(str);
        }

        if (parameterType.isEnum() && arg instanceof String str) {
            try {
                @SuppressWarnings({ "rawtypes", "unchecked" })
                Enum enumVal = Enum.valueOf((Class) parameterType, str.toUpperCase());
                return enumVal;
            } catch (IllegalArgumentException e) {
                return CONVERSION_FAIL;
            }
        }

        if (BlockData.class.isAssignableFrom(parameterType)) {
            String matName = null;
            if (arg instanceof String str) {
                matName = str;
            } else if (arg instanceof EnumValue enumValue) {
                matName = enumValue.name;
            }
            if (matName != null) {
                try {
                    return Bukkit.createBlockData(Material.valueOf(matName.toUpperCase()));
                } catch (IllegalArgumentException e) {
                    return CONVERSION_FAIL;
                }
            }
        }

        return CONVERSION_FAIL;
    }

    public Map deserializeArgsObject(JsonObject argsObj) {
        Map options = new HashMap<>();

        if (argsObj != null) {
            for (Map.Entry entry : argsObj.entrySet()) {
                options.put(entry.getKey(), deserialize(entry.getValue()));
            }
        }

        return options;
    }

    public Object getField(Object target, String field) throws Exception {
        String getterName = "get" + capitalize(field);
        try {
            Method getter = target.getClass().getMethod(getterName);
            return getter.invoke(target);
        } catch (NoSuchMethodException ignored) {
        }
        String isName = "is" + capitalize(field);
        try {
            Method getter = target.getClass().getMethod(isName);
            return getter.invoke(target);
        } catch (NoSuchMethodException ignored) {
        }
        return target.getClass().getField(field).get(target);
    }

    public void setField(Object target, String field, Object value) throws Exception {
        String setterName = "set" + capitalize(field);
        for (Method method : target.getClass().getMethods()) {
            if (!method.getName().equals(setterName) || method.getParameterCount() != 1) {
                continue;
            }
            Object[] converted = convertArgs(method.getParameterTypes(), List.of(value));
            if (converted != null) {
                method.invoke(target, converted);
                return;
            }
        }
        target.getClass().getField(field).set(target, value);
    }

    JsonArray serializeAttributes(ItemMeta meta) {
        JsonArray array = new JsonArray();
        Multimap modifiers = meta.getAttributeModifiers();

        if (modifiers == null) {
            return array;
        }

        for (Map.Entry entry : modifiers.entries()) {
            Attribute attribute = entry.getKey();
            AttributeModifier modifier = entry.getValue();
            JsonObject obj = new JsonObject();

            if (attribute.getKey() != null) {
                obj.addProperty("attribute", attribute.getKey().toString());
            }

            if (modifier.getKey() != null) {
                obj.addProperty("key", modifier.getKey().toString());
            }

            obj.addProperty("amount", modifier.getAmount());
            obj.addProperty("operation", modifier.getOperation().name());
            array.add(obj);
        }
        return array;
    }

    void applyAttributes(ItemMeta meta, JsonElement attributesElement) {
        if (attributesElement == null || !attributesElement.isJsonArray()) {
            return;
        }
        meta.setAttributeModifiers(null);
        for (JsonElement element : attributesElement.getAsJsonArray()) {
            if (!element.isJsonObject()) {
                continue;
            }

            JsonObject obj = element.getAsJsonObject();
            String attributeKey = obj.has("attribute") ? obj.get("attribute").getAsString() : null;

            if (attributeKey == null) {
                continue;
            }

            NamespacedKey namespacedKey = NamespacedKey.fromString(attributeKey);
            if (namespacedKey == null) {
                continue;
            }

            Attribute attribute = Registry.ATTRIBUTE.get(namespacedKey);
            if (attribute == null) {
                continue;
            }

            NamespacedKey modifierKey = null;
            if (obj.has("key")) {
                modifierKey = NamespacedKey.fromString(obj.get("key").getAsString());
            }

            if (modifierKey == null) {
                modifierKey = new NamespacedKey(plugin, "attr_" + UUID.randomUUID());
            }

            double amount = obj.has("amount") ? obj.get("amount").getAsDouble() : 0.0;

            AttributeModifier.Operation operation = AttributeModifier.Operation.ADD_NUMBER;

            if (obj.has("operation")) {
                try {
                    operation = AttributeModifier.Operation.valueOf(obj.get("operation").getAsString());
                } catch (IllegalArgumentException ignored) {
                }
            }

            AttributeModifier modifier = new AttributeModifier(modifierKey, amount, operation);
            meta.addAttributeModifier(attribute, modifier);
        }
    }

    List> attributeList(ItemMeta meta) {
        List> list = new ArrayList<>();
        Multimap modifiers = meta.getAttributeModifiers();
        if (modifiers == null) {
            return list;
        }
        for (Map.Entry entry : modifiers.entries()) {
            Attribute attribute = entry.getKey();
            AttributeModifier modifier = entry.getValue();
            Map entryMap = new HashMap<>();
            if (attribute.getKey() != null) {
                entryMap.put("attribute", attribute.getKey().toString());
            }
            if (modifier.getKey() != null) {
                entryMap.put("key", modifier.getKey().toString());
            }
            entryMap.put("amount", modifier.getAmount());
            entryMap.put("operation", modifier.getOperation().name());
            list.add(entryMap);
        }
        return list;
    }

    ItemStack deserializeItemFromNbt(JsonElement nbtElement) {
        if (nbtElement == null || nbtElement.isJsonNull()) {
            return null;
        }
        if (!nbtElement.isJsonObject()) {
            return null;
        }
        @SuppressWarnings("unchecked")
        Map map = gson.fromJson(nbtElement, Map.class);
        try {
            return ItemStack.deserialize(map);
        } catch (Exception ex) {
            return null;
        }
    }

    private static String capitalize(String value) {
        if (value == null || value.isEmpty()) {
            return value;
        }
        return value.substring(0, 1).toUpperCase() + value.substring(1);
    }
}
PyJavaBridge-2a/src/main/java/com/pyjavabridge/EventDispatcher.java000066400000000000000000000266311514752343100255160ustar00rootroot00000000000000package com.pyjavabridge;

import com.pyjavabridge.event.CancelMode;
import com.pyjavabridge.event.PendingEvent;

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.event.Event;
import org.bukkit.event.block.BlockExplodeEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.InventoryView;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;

public class EventDispatcher {
    private final PyJavaBridgePlugin plugin;
    private final BridgeSerializer serializer;
    private final String name;
    private final Map pendingEvents;
    private final Consumer sender;
    private final Gson gson;

    EventDispatcher(PyJavaBridgePlugin plugin, BridgeSerializer serializer, String name,
                    Map pendingEvents, Consumer sender, Gson gson) {
        this.plugin = plugin;
        this.serializer = serializer;
        this.name = name;
        this.pendingEvents = pendingEvents;
        this.sender = sender;
        this.gson = gson;
    }

    public void sendEvent(String eventName, JsonObject payload) {
        JsonObject message = new JsonObject();
        message.addProperty("type", "event");
        message.addProperty("event", eventName);
        message.add("payload", payload);
        sender.accept(message);
    }

    public void sendEvent(Event event, String eventName) {
        if (eventName.equalsIgnoreCase("block_explode")) {
            if (event instanceof BlockExplodeEvent blockExplodeEvent) {
                handleBlockExplode(blockExplodeEvent.blockList(), event, eventName);
                return;
            }
            if (event instanceof EntityExplodeEvent entityExplodeEvent) {
                handleBlockExplode(entityExplodeEvent.blockList(), event, eventName);
                return;
            }
            return;
        }
        if (event instanceof EntityExplodeEvent && eventName.equalsIgnoreCase("entity_explode")) {
            JsonObject payload = baseEventPayload(event, eventName);
            dispatchCancellableEvent(event, eventName, payload, CancelMode.EVENT, 1000);
            return;
        }

        JsonObject payload = baseEventPayload(event, eventName);
        dispatchCancellableEvent(event, eventName, payload, CancelMode.EVENT, 1000);
    }

    private JsonObject baseEventPayload(Event event, String eventName) {
        JsonObject payload = new JsonObject();
        payload.add("event", serializer.serialize(event));
        tryAddPayload(payload, event, "player", "getPlayer", "getWhoClicked");
        tryAddPayload(payload, event, "block", "getBlock", "getClickedBlock");
        tryAddPayload(payload, event, "entity", "getEntity");
        tryAddPayload(payload, event, "damager", "getDamager");
        if (event instanceof EntityDamageEvent damageEvent) {
            payload.addProperty("damage", damageEvent.getDamage());
            payload.addProperty("final_damage", damageEvent.getFinalDamage());
            payload.add("damage_cause", serializer.serialize(damageEvent.getCause()));
        }
        tryAddPayload(payload, event, "location", "getLocation");
        tryAddPayload(payload, event, "world", "getWorld");
        tryAddPayload(payload, event, "item", "getItem");
        tryAddPayload(payload, event, "inventory", "getInventory");
        tryAddPayload(payload, event, "chunk", "getChunk");
        if (event instanceof InventoryClickEvent clickEvent) {
            InventoryView view = clickEvent.getView();
            String title = view != null ? getInventoryViewTitle(view) : "";
            org.bukkit.inventory.Inventory inventory = clickEvent.getClickedInventory();
            if (inventory == null && view != null) {
                inventory = view.getTopInventory();
            }
            if (inventory != null) {
                payload.add("inventory", serializeInventoryWithTitle(inventory, title));
            }
            payload.addProperty("slot", clickEvent.getSlot());
            payload.add("item", serializer.serialize(clickEvent.getCurrentItem()));
        }
        return payload;
    }

    private boolean dispatchCancellableEvent(Event event, String eventName, JsonObject payload,
            CancelMode cancelMode, long timeoutMs) {
        boolean cancellable = event instanceof org.bukkit.event.Cancellable;
        int eventId = -1;
        if (cancellable) {
            eventId = plugin.nextEventId();
            payload.addProperty("id", eventId);
            PendingEvent pending = new PendingEvent();
            pending.cancellable = (org.bukkit.event.Cancellable) event;
            pending.event = event;
            pending.id = eventId;
            pendingEvents.put(eventId, pending);
        }
        sendEvent(eventName, payload);
        if (!cancellable) {
            return false;
        }
        PendingEvent pending = pendingEvents.get(eventId);
        if (pending != null) {
            try {
                long deadline = System.currentTimeMillis() + timeoutMs;
                try {
                    while (System.currentTimeMillis() < deadline && pending.latch.getCount() > 0) {
                        plugin.drainMainThreadQueue();
                        pending.latch.await(5, java.util.concurrent.TimeUnit.MILLISECONDS);
                    }
                } catch (InterruptedException ignored) {
                    Thread.currentThread().interrupt();
                }
                boolean cancelRequested = pending.cancelRequested.get();
                if (pending.chatOverride != null && isChatEvent(pending.event)) {
                    pending.cancellable.setCancelled(true);
                    String message = pending.chatOverride;
                    Bukkit.getScheduler().runTask(plugin,
                            () -> Bukkit.getServer().broadcast(net.kyori.adventure.text.Component.text(message)));
                }
                if (pending.damageOverride != null && pending.event instanceof EntityDamageEvent damageEvent) {
                    damageEvent.setDamage(pending.damageOverride);
                }
                if (cancelRequested && cancelMode == CancelMode.EVENT) {
                    pending.cancellable.setCancelled(true);
                }
                if (pending.latch.getCount() > 0 && timeoutMs >= 100) {
                    plugin.getLogger().warning("[" + name + "] Event handler timed out for " + eventName);
                }
            } finally {
                pendingEvents.remove(eventId);
            }
        }
        return cancellable && ((org.bukkit.event.Cancellable) event).isCancelled();
    }

    @SuppressWarnings("deprecation")
    private boolean isChatEvent(Event event) {
        return event instanceof org.bukkit.event.player.AsyncPlayerChatEvent
                || event instanceof org.bukkit.event.player.PlayerChatEvent
                || event instanceof io.papermc.paper.event.player.AsyncChatEvent;
    }

    private void handleBlockExplode(List blocks, Event event, String eventName) {
        if (blocks.isEmpty()) {
            return;
        }
        List batch = new ArrayList<>();
        List payloads = new ArrayList<>();
        for (org.bukkit.block.Block block : blocks) {
            JsonObject payload = baseEventPayload(event, eventName);
            int eventId = plugin.nextEventId();
            payload.addProperty("id", eventId);
            payload.add("block", serializer.serialize(block));
            PendingEvent pending = new PendingEvent();
            pending.block = block;
            pending.id = eventId;
            pendingEvents.put(eventId, pending);
            batch.add(pending);
            payloads.add(payload);
        }
        sendBatch(eventName, payloads);
        long deadline = System.currentTimeMillis() + 100;
        try {
            while (System.currentTimeMillis() < deadline) {
                boolean allDone = true;
                for (PendingEvent pending : batch) {
                    if (pending.latch.getCount() > 0) {
                        allDone = false;
                        break;
                    }
                }
                if (allDone) {
                    break;
                }
                plugin.drainMainThreadQueue();
                Thread.sleep(2);
            }
        } catch (InterruptedException ignored) {
            Thread.currentThread().interrupt();
        }
        java.util.Iterator iterator = blocks.iterator();
        while (iterator.hasNext()) {
            org.bukkit.block.Block block = iterator.next();
            boolean cancel = false;
            for (PendingEvent pending : batch) {
                if (pending.block == block) {
                    cancel = pending.cancelRequested.get();
                    break;
                }
            }
            if (cancel) {
                iterator.remove();
            }
        }
        for (PendingEvent pending : batch) {
            pendingEvents.remove(pending.id);
        }
    }

    private void sendBatch(String eventName, List payloads) {
        JsonObject message = new JsonObject();
        message.addProperty("type", "event_batch");
        message.addProperty("event", eventName);
        message.add("payloads", gson.toJsonTree(payloads));
        sender.accept(message);
    }

    private void tryAddPayload(JsonObject payload, Event event, String key, String... methodNames) {
        for (String methodName : methodNames) {
            try {
                Method method = event.getClass().getMethod(methodName);
                Object value = method.invoke(event);
                if (value != null) {
                    payload.add(key, serializer.serialize(value));
                    return;
                }
            } catch (Exception ignored) {
            }
        }
    }

    private JsonElement serializeInventoryWithTitle(org.bukkit.inventory.Inventory inventory, String title) {
        JsonElement element = serializer.serialize(inventory);

        if (element != null && element.isJsonObject()) {
            JsonObject obj = element.getAsJsonObject();
            JsonObject fields = obj.has("fields") && obj.get("fields").isJsonObject()
                    ? obj.getAsJsonObject("fields")
                    : new JsonObject();

            fields.addProperty("title", title != null ? title : "");
            obj.add("fields", fields);
        }
        return element;
    }

    private String getInventoryViewTitle(InventoryView view) {
        if (view == null) {
            return "";
        }

        try {
            Component component = view.title();
            if (component != null) {
                return PlainTextComponentSerializer.plainText().serialize(component);
            }

        } catch (Exception ignored) {
        }

        try {
            Method getTitle = view.getClass().getMethod("getTitle");
            Object result = getTitle.invoke(view);
            if (result != null) {
                return result.toString();
            }

        } catch (Exception ignored) {
        }
        return "";
    }
}
PyJavaBridge-2a/src/main/java/com/pyjavabridge/PyJavaBridgePlugin.java000066400000000000000000000352121514752343100261070ustar00rootroot00000000000000package com.pyjavabridge;

import com.pyjavabridge.util.CallableTask;
import com.pyjavabridge.util.DebugManager;
import com.pyjavabridge.util.PlayerUuidResolver;

import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitTask;

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PyJavaBridgePlugin extends JavaPlugin {
    private final ConcurrentLinkedQueue mainThreadQueue = new ConcurrentLinkedQueue<>();
    private final Map instances = new ConcurrentHashMap<>();
    private final DebugManager debugManager = new DebugManager();
    private final PlayerUuidResolver uuidResolver = new PlayerUuidResolver();
    private Thread fileWatcherThread;
    private volatile boolean watchEnabled = false;

    private BukkitTask mainThreadPump;

    private long currentTick = 0L;
    private long lastTickNano = 0L;
    private double lastTickTimeMs = 0.0;

    private final AtomicInteger eventCounter = new AtomicInteger(1);

    @Override
    public void onEnable() {
        getCommand("bridge").setExecutor(this);
        getCommand("bridge").setTabCompleter(this);

        Path dataDir = getDataFolder().toPath();
        Path scriptsDir = dataDir.resolve("scripts");
        Path runtimeDir = dataDir.resolve("runtime");

        try {
            Files.createDirectories(scriptsDir);
            Files.createDirectories(runtimeDir);

            copyRuntimeResource("python/runner.py", runtimeDir.resolve("runner.py"));
            copyRuntimeResource("python/bridge.py", scriptsDir.resolve("bridge.py"));
            copyRuntimeResource("python/bridge.pyi", scriptsDir.resolve("bridge.pyi"));

            getLogger().info("PyJavaBridge runtime initialized at " + runtimeDir);
        } catch (IOException e) {
            getLogger().severe("Failed to initialize runtime: " + e.getMessage());
            return;
        }

        mainThreadPump = Bukkit.getScheduler().runTaskTimer(this, () -> {
            long now = System.nanoTime();

            if (lastTickNano != 0L) {
                lastTickTimeMs = (now - lastTickNano) / 1_000_000.0;
            }

            lastTickNano = now;
            currentTick++;

            Runnable task;

            while ((task = mainThreadQueue.poll()) != null) {
                try {
                    task.run();

                } catch (Exception ex) {
                    getLogger().severe("Main-thread task error: " + ex.getMessage());
                }
            }
        }, 1L, 1L);

        startScripts(scriptsDir, runtimeDir);
    }

    @Override
    public void onDisable() {
        stopFileWatcher();

        if (mainThreadPump != null) {
            mainThreadPump.cancel();
        }

        // Send shutdown events and wait
        for (BridgeInstance instance : instances.values()) {
            instance.sendShutdownEvent();
        }

        // Then shut down
        for (BridgeInstance instance : instances.values()) {
            instance.shutdown();
        }

        instances.clear();
    }

    private void startScripts(Path scriptsDir, Path runtimeDir) {
        try {
            getLogger().info("Scanning scripts in " + scriptsDir);

            Files.list(scriptsDir)
                    .filter(path -> path.toString().endsWith(".py"))
                    .filter(path -> !path.getFileName().toString().equals("bridge.py"))
                    .filter(path -> !path.getFileName().toString().equals("runner.py"))
                    .forEach(path -> startScript(path, scriptsDir, runtimeDir));

        } catch (IOException e) {
            getLogger().severe("Failed to list scripts: " + e.getMessage());
        }
    }

    private void startScript(Path scriptPath, Path scriptsDir, Path runtimeDir) {
        String scriptName = scriptPath.getFileName().toString();

        getLogger().info("Starting script: " + scriptName);

        BridgeInstance instance = new BridgeInstance(this, scriptName, scriptPath, scriptsDir, runtimeDir);

        instances.put(scriptName, instance);
        instance.start();
    }

    private void restartScript(String scriptName) {
        BridgeInstance existing = instances.get(scriptName);

        if (existing != null) {
            existing.shutdown();
        }

        Path scriptPath = getDataFolder().toPath().resolve("scripts").resolve(scriptName);

        if (Files.exists(scriptPath)) {
            startScript(scriptPath, getDataFolder().toPath().resolve("scripts"),
                    getDataFolder().toPath().resolve("runtime"));
        }
    }

    private void restartAllScripts() {
        for (BridgeInstance instance : instances.values()) {
            instance.shutdown();
        }

        instances.clear();
        startScripts(getDataFolder().toPath().resolve("scripts"), getDataFolder().toPath().resolve("runtime"));
    }

    public void registerScriptCommand(String name, BridgeInstance instance) {
        ScriptCommand.registerScriptCommand(name, instance, null, getLogger());
    }

    public void registerScriptCommand(String name, BridgeInstance instance, String permission) {
        ScriptCommand.registerScriptCommand(name, instance, permission, getLogger());
    }

    public UUID resolvePlayerUuidByName(String name) {
        return uuidResolver.resolvePlayerUuidByName(name);
    }

    private void copyRuntimeResource(String resourcePath, Path destination) throws IOException {
        try (InputStream input = getResource(resourcePath)) {
            if (input == null) {
                throw new IOException("Missing resource: " + resourcePath);
            }

            Files.copy(input, destination, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
        }
    }

    CompletableFuture runOnMainThread(BridgeInstance instance, CallableTask task) {
        CompletableFuture future = new CompletableFuture<>();

        mainThreadQueue.add(() -> {
            try {
                Object result = task.call();
                future.complete(result);

            } catch (Exception ex) {
                future.completeExceptionally(ex);
                instance.logError("Main-thread call failed", ex);
            }
        });
        return future;
    }

    void drainMainThreadQueue() {
        Runnable task;

        while ((task = mainThreadQueue.poll()) != null) {
            try {
                task.run();

            } catch (Exception ex) {
                getLogger().severe("Main-thread task error: " + ex.getMessage());
            }
        }
    }

    public long getCurrentTick() {
        return currentTick;
    }

    public double getLastTickTimeMs() {
        return lastTickTimeMs;
    }

    public int getQueueLen() {
        return mainThreadQueue.size();
    }

    private void startFileWatcher(Path scriptsDir) {
        if (fileWatcherThread != null && fileWatcherThread.isAlive()) {
            return;
        }
        watchEnabled = true;
        fileWatcherThread = new Thread(() -> {
            java.nio.file.WatchService watcher = null;
            try {
                watcher = java.nio.file.FileSystems.getDefault().newWatchService();
                scriptsDir.register(watcher,
                        java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY,
                        java.nio.file.StandardWatchEventKinds.ENTRY_CREATE);
                Map pending = new HashMap<>();
                while (watchEnabled) {
                    java.nio.file.WatchKey key = watcher.poll(200, java.util.concurrent.TimeUnit.MILLISECONDS);
                    if (key != null) {
                        for (java.nio.file.WatchEvent event : key.pollEvents()) {
                            Path changed = (Path) event.context();
                            if (changed == null) continue;
                            String filename = changed.getFileName().toString();
                            if (!filename.endsWith(".py")) continue;
                            if (filename.equals("bridge.py") || filename.equals("bridge.pyi") || filename.equals("runner.py")) continue;
                            pending.put(filename, System.currentTimeMillis());
                        }
                        key.reset();
                    }
                    long now = System.currentTimeMillis();
                    var it = pending.entrySet().iterator();
                    while (it.hasNext()) {
                        var entry = it.next();
                        if (now - entry.getValue() >= 1000) {
                            it.remove();
                            String scriptName = entry.getKey();
                            getLogger().info("[Watch] Auto-reloading: " + scriptName);
                            Bukkit.getScheduler().runTask(PyJavaBridgePlugin.this, () -> restartScript(scriptName));
                        }
                    }
                }
            } catch (Exception e) {
                if (watchEnabled) {
                    getLogger().warning("File watcher error: " + e.getMessage());
                }
            } finally {
                if (watcher != null) {
                    try {
                        watcher.close();
                    } catch (Exception ignored) {
                    }
                }
            }
        }, "PyJavaBridge-FileWatcher");
        fileWatcherThread.setDaemon(true);
        fileWatcherThread.start();
    }

    private void stopFileWatcher() {
        watchEnabled = false;
        if (fileWatcherThread != null) {
            fileWatcherThread.interrupt();
            fileWatcherThread = null;
        }
    }

    void addDebugPlayer(UUID playerId) {
        debugManager.addDebugPlayer(playerId);
    }

    void removeDebugPlayer(UUID playerId) {
        debugManager.removeDebugPlayer(playerId);
    }

    void broadcastErrorToDebugPlayers(String message) {
        debugManager.broadcastErrorToDebugPlayers(message);
    }

    public Set getDebugPlayerUuids() {
        return debugManager.getDebugPlayerUuids();
    }

    public boolean isDebugEnabled() {
        return debugManager.isDebugEnabled();
    }

    public int nextEventId() {
        return eventCounter.getAndIncrement();
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (args.length == 0) {
            sender.sendMessage("\u00a7eUsage: /bridge reload [