@adatechnology/game-floorplan-interactables 0.0.0-stage → 0.1.0

package/dist/index.global.js

@@ -0,0 +1,1392 @@
+"use strict";
+var GameFloorplanInteractables = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    ADAPTER_VERSION: () => ADAPTER_VERSION,
+    CHAIR_TABLES: () => CHAIR_TABLES,
+    CONTENT_BY_GROUP: () => CONTENT_BY_GROUP,
+    CONTENT_FALLBACK: () => CONTENT_FALLBACK,
+    CONTENT_MAP: () => CONTENT_MAP,
+    DINING_CHAIR_SIDE: () => DINING_CHAIR_SIDE,
+    DRAWER_GROUPS: () => DRAWER_GROUPS,
+    DRAWER_ITEMS: () => DRAWER_ITEMS,
+    FIXTURES_OF_POINT: () => FIXTURES_OF_POINT,
+    FROZEN_ITEMS: () => FROZEN_ITEMS,
+    FloorplanInteractables: () => FloorplanInteractables,
+    OBJECT_SUBSTITUTES: () => OBJECT_SUBSTITUTES,
+    OWN_TYPES: () => OWN_TYPES,
+    PREFERENCE: () => PREFERENCE,
+    TYPE_MAP: () => TYPE_MAP,
+    create: () => create,
+    createTranslator: () => createTranslator,
+    locales: () => locales,
+    mergeRegistry: () => mergeRegistry
+  });
+
+  // src/locale.ts
+  var en = {
+    "error.missingKit": "game-floorplan-interactables: create needs GameInteractables and GameInteractablesHousehold",
+    "error.unknownOwnType": "game-floorplan-interactables: unknown own type: {type}",
+    "warn.cylinderNoCabinet": "cylinder {id} under the counter has no kitchen cabinet to hide it",
+    "warn.cabinetNoDoor": "cabinet {cabinet} has no door for the cylinder {id}",
+    "warn.switchUnknownLamp": "switch {id} controls {lamp}, which does not exist",
+    "warn.pointNoObject": "point {id} ({kind}) has no object for {item}",
+    "warn.buildEmpty": "build returned nothing for {id}"
+  };
+  var ptBR = {
+    "error.missingKit": "game-floorplan-interactables: create precisa de GameInteractables e GameInteractablesHousehold",
+    "error.unknownOwnType": "game-floorplan-interactables: tipo pr\xF3prio desconhecido: {type}",
+    "warn.cylinderNoCabinet": "botij\xE3o {id} sob a bancada sem arm\xE1rio de cozinha para escond\xEA-lo",
+    "warn.cabinetNoDoor": "arm\xE1rio {cabinet} sem porta para o botij\xE3o {id}",
+    "warn.switchUnknownLamp": "interruptor {id} controla {lamp}, que n\xE3o existe",
+    "warn.pointNoObject": "ponto {id} ({kind}) sem objeto para {item}",
+    "warn.buildEmpty": "construir devolveu vazio para {id}"
+  };
+  var locales = { en, "pt-BR": ptBR };
+  function createTranslator(locale, table) {
+    const base = locale && /^pt/i.test(locale) ? ptBR : en;
+    const messages = { ...base, ...table ?? {} };
+    return (key, params) => (messages[key] ?? key).replace(/\{(\w+)\}/g, (_m, name) => params && params[name] !== void 0 ? String(params[name]) : `{${name}}`);
+  }
+
+  // src/tables.ts
+  var TYPE_MAP = Object.freeze({
+    fridge: { type: "fridge" },
+    // was `geladeira`
+    fridge_large: { type: "fridge" },
+    // was `geladeira2`
+    display_fridge_medium: { type: "fridge", variant: "steel" },
+    // was `geladeira_med`
+    display_fridge: { type: "fridge", variant: "steel" },
+    // was `refrig_exp`
+    freezer: { type: "fridge_compact" },
+    // was `freezer`
+    kitchen_cabinet: { compound: "sink" },
+    // was `armario_cozinha`
+    kitchen_cabinet_small: { compound: "sink" },
+    // was `armario_cozinha_p`
+    kitchen_cabinet_large: { compound: "sink" },
+    // was `armario_cozinha_g`
+    washbasin: { compound: "basin" },
+    // was `pia_b`
+    pedestal_basin: { compound: "basin" },
+    // was `pia_coluna`
+    wardrobe: { type: "wardrobe" },
+    // was `guarda`
+    wardrobe_small: { type: "wardrobe" },
+    // was `guarda_peq`
+    wardrobe_large: { type: "wardrobe" },
+    // was `guarda_g`
+    closet_wardrobe: { type: "wardrobe" },
+    // was `guarda_closet`
+    dresser: { type: "dresser" },
+    // was `comoda`
+    nightstand: { type: "nightstand" },
+    // was `criado`
+    pantry: { type: "pantry" },
+    // was `despensa`
+    laundry_cabinet: { type: "pantry" },
+    // was `armario_lav`
+    china_cabinet: { type: "pantry" },
+    // was `cristaleira`
+    filing_cabinet: { type: "dresser" },
+    // was `arquivo`
+    console_table: { type: "dresser" },
+    // was `aparador_c`
+    tv_unit: { type: "kitchen_cabinet_base" },
+    // was `rack`
+    tv_unit_small: { type: "kitchen_cabinet_base" },
+    // was `rack_peq`
+    tv_unit_large: { type: "kitchen_cabinet_base" },
+    // was `rack_grande`
+    stove: { type: "stove" },
+    // was `fogao`
+    stove_4burner: { type: "stove" },
+    // was `fogao4`
+    cooking_gas_cylinder: { type: "gas_bottle", dim: "none" },
+    // was `botijao_gas`
+    gas_cylinder: { type: "gas_bottle", dim: "none" },
+    // was `botijao`
+    tv: { type: "tv" },
+    // was `tv`
+    tv_large: { type: "tv" },
+    // was `tv_grande`
+    microwave: { type: "microwave" },
+    // was `microondas`
+    washing_machine: { type: "washing_machine" },
+    // was `maquina`
+    shower: { type: "shower", dim: "wd" },
+    // was `box`
+    shower_large: { type: "shower", dim: "wd" },
+    // was `box_g`
+    toilet: { type: "toilet", dim: "wd" },
+    // was `vaso`
+    laundry_tub: { type: "utility_sink", dim: "wd" },
+    // was `tanque`
+    sofa_2seat: { type: "sofa" },
+    // was `sofa2`
+    sofa_3seat: { type: "sofa" },
+    // was `sofa3`
+    sofa_l: { type: "sofa" },
+    // was `sofa_l`
+    sofa_xl: { type: "sofa" },
+    // was `sofa_xl`
+    armchair: { type: "armchair" },
+    // was `poltrona`
+    armchair_high: { type: "armchair" },
+    // was `poltrona_alta`
+    stool: { type: "dining_chair" },
+    // was `banqueta`
+    camp_chair: { type: "camp_chair", dim: "wd" },
+    // was `cadeira_camping`
+    rocking_chair: { type: "armchair" },
+    // was `cadeira_balanco`
+    rustic_sink: { compound: "rustic_sink" },
+    // was `pia_rustica`: the sink of the cabin or shack: the basin the whole width, no cabinet under it; a wall cabinet only if there is `overhead` content
+    improvised_bed: { type: "bed_single", dim: "wd" },
+    // was `cama_improvisada`
+    log_bench: { type: "bench", dim: "wd" },
+    // was `banco_tronco`
+    plank_shelf: { type: "pantry", variant: "garage" },
+    // was `prateleira_tabua`
+    sideboard: { type: "dresser" },
+    // was `aparador`
+    buffet: { type: "dresser" },
+    // was `bufe`
+    single_bed: { type: "bed_single", dim: "wd" },
+    // was `cama_solteiro`
+    double_bed: { type: "bed_double", dim: "wd" },
+    // was `cama_casal`
+    queen_bed: { type: "bed_double", dim: "wd" },
+    // was `cama_queen`
+    king_bed: { type: "bed_double", dim: "wd" },
+    // was `cama_king`
+    bench: { type: "bench", dim: "wd" },
+    // was `banco`
+    garden_bench: { type: "bench", dim: "wd" },
+    // was `banco_jardim`
+    waiting_bench: { type: "bench", dim: "wd" },
+    // was `espera`
+    blinds: { type: "blinds" },
+    // was `persiana`
+    curtain: { type: "curtain" },
+    // was `cortina`
+    trash_bin: { type: "trash_bin" },
+    // was `lixeira`
+    outdoor_bin: { type: "wheelie_bin" },
+    // was `lixeira_ext`
+    mailbox: { type: "mailbox", dim: "none" },
+    // was `caixa_correio`: the household draws the box on its post: position and rotation only
+    doghouse: { type: "dog_house" },
+    // was `casinha_cachorro`
+    bbq_grill: { type: "bbq", dim: "wd" },
+    // was `churrasqueira`
+    bbq_simple: { type: "bbq", dim: "wd" },
+    // was `churrasqueira_simples`
+    clothesline: { type: "clothesline", dim: "wh" },
+    // was `varal`
+    tool_shelf: { type: "pantry", variant: "garage" },
+    // was `estante_ferr`
+    workbench: { type: "pantry", variant: "garage" },
+    // was `bancada_ferr`
+    // rural houses and campsite (types of the household pack: rural and camp)
+    bunk_bed: { type: "bunk_bed", dim: "wd" },
+    // was `beliche`
+    wood_stove: { type: "wood_stove", dim: "wd" },
+    // was `fogao_lenha`: the flue rises to the chimney height (cabin); the fireplace is handled in `planSimple` (it moves and changes height)
+    fireplace: { type: "fireplace", dim: "w" },
+    // was `lareira`
+    outhouse: { type: "outhouse", dim: "wdh" },
+    // was `privada`
+    well: { type: "well", dim: "none" },
+    // was `poco`
+    cooler: { type: "cooler", dim: "wd" },
+    // was `cooler`
+    campfire: { type: "campfire", dim: "wd" },
+    // was `fogueira`
+    camp_stove: { type: "camp_stove", dim: "wd" },
+    // was `fogareiro`
+    camp_gas_canister: { type: "gas_canister", dim: "none" },
+    // was `botijao_camping`
+    camp_table: { type: "camp_table", dim: "wdh" },
+    // was `mesa_camping`
+    // kerosene/gas lanterns: a `lamp` device without electricity (the grid does not matter); the ceiling one is the `hanging` variant
+    oil_lamp: { type: "lantern_lamp", dim: "x" },
+    // was `lampiao`
+    camp_lantern: { type: "lantern_lamp", dim: "x" },
+    // was `lampiao_camping`
+    ceiling_oil_lamp: { type: "lantern_lamp", variant: "hanging", dim: "x" },
+    // was `lampiao_teto`
+    // lamps: objects of the adapter (the kit has no lamp mesh; the house renderer draws the fixture)
+    ceiling_light: { type: "lamp", watts: 15 },
+    // was `plafon`
+    pendant: { type: "lamp", watts: 20 },
+    // was `pendente`
+    track_spot: { type: "lamp", watts: 10 },
+    // was `spot_trilho`
+    chandelier: { type: "lamp", watts: 60 },
+    // was `lustre`
+    floor_lamp: { type: "lamp", watts: 12 },
+    // was `luminaria`
+    table_lamp: { type: "lamp", watts: 9 }
+    // was `abajur`
+  });
+  var CHAIR_TABLES = Object.freeze({
+    dining_table: "dining",
+    // was `mesa`
+    dining_table_small: "dining",
+    // was `mesa_peq`
+    dining_table_round: "dining",
+    // was `mesa_red`
+    dining_table_large: "dining",
+    // was `mesa_grande`
+    gourmet_table: "dining",
+    // was `mesa_gourmet`
+    gourmet_table_small: "dining",
+    // was `mesa_gourmet_peq`
+    outdoor_table: "dining",
+    // was `mesa_ext`
+    office_desk: "office",
+    // was `mesa_escr`
+    office_desk_large: "office",
+    // was `mesa_escr_g`
+    desk: "office"
+    // was `escrivaninha`
+  });
+  var DINING_CHAIR_SIDE = 0.45;
+  var CONTENT_MAP = Object.freeze({
+    // food
+    sugar: "sugar",
+    // was `acucar`
+    rice: "rice",
+    // was `arroz`
+    biscuits: "biscuits",
+    // was `biscoito`
+    coffee: "coffee",
+    // was `cafe`
+    raw_beef: "frozen_meat",
+    // was `carne`
+    packed_meat: "frozen_meat",
+    // was `carne`
+    flour: "flour",
+    // was `farinha`
+    beans: "beans",
+    // was `feijao`
+    apple: "apple",
+    // was `fruta`
+    fruit: "apple",
+    // was `fruta`
+    yogurt: "yogurt",
+    // was `iogurte`
+    canned_food: "canned_food",
+    // was `lata_atum`
+    canned_tuna: "canned_food",
+    // was `lata_atum`
+    canned_corn_and_peas: "canned_food",
+    // was `lata_milho`
+    canned_corn: "canned_food",
+    // was `lata_milho`
+    milk_carton: "milk_carton",
+    // was `leite`
+    pasta: "pasta",
+    // was `macarrao`
+    cooking_oil: "cooking_oil",
+    // was `oleo`
+    eggs: "eggs",
+    // was `ovos`
+    cheese: "cheese",
+    // was `queijo`
+    leftover_meal: "bowl",
+    // was `sobras`
+    leftovers: "bowl",
+    // was `sobras`
+    ice_cream: "ice_cream",
+    // was `sorvete`
+    seasoning: "salt",
+    // was `tempero`
+    spices: "salt",
+    // was `tempero`
+    // water and drink
+    water_jug_5l: "water_bottle",
+    // was `agua_galao`
+    water_jug: "water_bottle",
+    // was `agua_galao`
+    water_bottle: "water_bottle",
+    // was `agua_garrafa`
+    soda_can: "soda_can",
+    // was `refrigerante`
+    soda: "soda_can",
+    // was `refrigerante`
+    // medicine
+    alcohol_70: "alcohol_70",
+    // was `alcool`
+    rubbing_alcohol: "alcohol_70",
+    // was `alcool`
+    adhesive_bandages: "bandage",
+    // was `curativo`
+    bandages: "bandage",
+    // was `curativo`
+    insulin: "first_aid_kit",
+    // was `insulina`
+    painkillers: "painkillers",
+    // was `paracetamol`
+    painkiller: "painkillers",
+    // was `paracetamol`
+    maintenance_medication: "painkillers",
+    // was `remedio`
+    medicine: "painkillers",
+    // was `remedio`
+    // cleaning and hygiene
+    bleach: "bleach",
+    // was `agua_sanitaria`
+    disinfectant: "bleach",
+    // was `desinfetante`
+    detergent: "detergent",
+    // was `detergente`
+    dish_soap: "detergent",
+    // was `detergente`
+    toothbrush: "toothbrush",
+    // was `escova_dente`
+    sponge: "sponge",
+    // was `esponja`
+    rubber_gloves: "sponge",
+    // was `luvas`
+    toilet_paper: "toilet_paper",
+    // was `papel_higienico`
+    laundry_powder: "detergent",
+    // was `sabao_po`
+    washing_powder: "detergent",
+    // was `sabao_po`
+    soap: "soap",
+    // was `sabonete`
+    shampoo: "shampoo",
+    // was `shampoo`
+    // clothes
+    jeans: "jeans",
+    // was `calca`
+    trousers: "jeans",
+    // was `calca`
+    tshirt: "tshirt",
+    // was `camisa`
+    shirt: "tshirt",
+    // was `camisa`
+    t_shirt: "tshirt",
+    // was `camiseta`
+    jacket: "jacket",
+    // was `casaco`
+    coat: "jacket",
+    // was `casaco`
+    blanket: "blanket",
+    // was `cobertor`
+    socks: "socks",
+    // was `meias`
+    underwear: "underwear",
+    // was `roupa_intima`
+    sneakers: "sneakers",
+    // was `sapato`
+    shoes: "sneakers",
+    // was `sapato`
+    // utensils
+    cup: "cup",
+    // was `caneca`
+    mug: "cup",
+    // was `caneca`
+    plate: "plate",
+    // was `prato`
+    china_plates: "plate",
+    // was `prato`
+    plates: "plate",
+    // was `prato`
+    wine_glass: "cup",
+    // was `taca`
+    wine_glasses: "cup",
+    // was `taca`
+    pot: "pot",
+    // was `panela`
+    // tools and electronics
+    pliers: "screwdriver",
+    // was `alicate`
+    bucket: "paint_can",
+    // was `balde`
+    cable_bundle: "phone_charger",
+    // was `cabos`
+    cables: "phone_charger",
+    // was `cabos`
+    pen: "pen",
+    // was `caneta`
+    phone_charger: "phone_charger",
+    // was `carregador`
+    charger: "phone_charger",
+    // was `carregador`
+    screwdriver: "screwdriver",
+    // was `chave_fenda`
+    house_key: "wallet",
+    // was `chaves`
+    keys: "wallet",
+    // was `chaves`
+    remote_control: "batteries",
+    // was `controle_remoto`
+    rope: "rope",
+    // was `corda`
+    electrical_tape: "duct_tape",
+    // was `fita_isolante`
+    insulating_tape: "duct_tape",
+    // was `fita_isolante`
+    flashlight: "flashlight",
+    // was `lanterna`
+    backpack: "backpack",
+    // was `mochila`
+    eyeglasses: "wallet",
+    // was `oculos`
+    glasses: "wallet",
+    // was `oculos`
+    screws: "duct_tape",
+    // was `parafusos`
+    batteries: "batteries",
+    // was `pilhas`
+    nails: "duct_tape",
+    // was `pregos`
+    // improvised weapons
+    knife: "knife",
+    // was `faca`
+    kitchen_knife: "knife",
+    // was `faca`
+    stapler: "scissors",
+    // was `grampeador`
+    hammer: "hammer",
+    // was `martelo`
+    handsaw: "hammer",
+    // was `serrote`
+    hand_saw: "hammer",
+    // was `serrote`
+    scissors: "scissors",
+    // was `tesoura`
+    broom: "rope",
+    // was `vassoura`
+    // papers
+    letter: "letter",
+    // was `carta`
+    bill: "bill",
+    // was `conta`
+    documents: "documents",
+    // was `documento`
+    dvd: "notebook",
+    // was `dvd`
+    dvds: "notebook",
+    // was `dvd`
+    book: "notebook",
+    // was `livro`
+    // trash
+    food_packaging: "plastic_bag",
+    // was `embalagem`
+    packaging: "plastic_bag",
+    // was `embalagem`
+    paint_can: "paint_can",
+    // was `lata_tinta`
+    empty_can: "empty_can",
+    // was `lata_vazia`
+    flyer: "flyer",
+    // was `panfleto`
+    crumpled_paper: "crumpled_paper",
+    // was `papel_amassado`
+    trash_bag: "plastic_bag",
+    // was `saco_lixo`
+    full_trash_bag: "plastic_bag"
+    // was `saco_lixo_cheio`
+  });
+  var CONTENT_BY_GROUP = Object.freeze({
+    food: "canned_food",
+    // was `comida`
+    water: "water_bottle",
+    // was `agua`
+    medicine: "painkillers",
+    // was `remedio`
+    tool: "duct_tape",
+    // was `ferramenta`
+    improvised_weapon: "hammer",
+    // was `arma_improvisada`
+    clothes: "tshirt",
+    // was `roupa`
+    document: "documents",
+    // was `documento`
+    cleaning: "detergent",
+    // was `limpeza`
+    trash: "crumpled_paper",
+    // was `lixo`
+    utensil: "plate"
+    // was `utensilio`
+  });
+  var CONTENT_FALLBACK = "crumpled_paper";
+  var FROZEN_ITEMS = Object.freeze(["ice_cream", "frozen_meat"]);
+  var DRAWER_ITEMS = Object.freeze(["underwear", "socks"]);
+  var DRAWER_GROUPS = Object.freeze(["improvised_weapon", "tool"]);
+  var OBJECT_SUBSTITUTES = Object.freeze({ mailbox: ["flyer", "postcard", "letter"] });
+  var FIXTURES_OF_POINT = Object.freeze({
+    tap: ["tap"],
+    // was `torneira`
+    shower: ["shower"],
+    // was `chuveiro`
+    flush: ["flush"],
+    // was `descarga`
+    tub: ["tap", "basin"],
+    // was `tanque`
+    machine: ["inlet"]
+    // was `maquina`
+  });
+  var OWN_TYPES = Object.freeze({ lamp: true, gas_piped: true });
+
+  // src/adapter.ts
+  var ADAPTER_VERSION = "0.3.0";
+  var r3 = (n) => Math.round(n * 1e3) / 1e3;
+  function mergeRegistry(base, extra) {
+    const out = { ...base };
+    if (extra) {
+      for (const [key, value] of Object.entries(extra)) {
+        if (value == null) delete out[key];
+        else out[key] = value;
+      }
+    }
+    return out;
+  }
+  var PREFERENCE = Object.freeze({
+    fridge: (s, c) => c.frozen(s) ? ["freezer", "fridge"] : ["fridge", "freezer"],
+    fridge_compact: (s, c) => c.frozen(s) ? ["freezer", "fridge"] : ["fridge", "freezer"],
+    kitchen_cabinet_base: (s, c) => DRAWER_GROUPS.includes(c.group(s)) ? ["drawer", "cupboard"] : ["cupboard", "drawer"],
+    wardrobe: (s, c) => c.drawerItem(s) ? ["drawer_1", "drawer_2", "drawer_3", "shelves"] : ["shelves", "drawer_1", "drawer_2", "drawer_3"]
+  });
+  function create(options = {}) {
+    const opts = options || {};
+    const GI = opts.GameInteractables;
+    const HH = opts.GameInteractablesHousehold;
+    const locale = opts.locale || "pt-BR";
+    const msg = createTranslator(locale, opts.messages);
+    if (!GI || !HH) throw new Error(msg("error.missingKit"));
+    const region = opts.region || "br";
+    const hh = HH.createHousehold({ locale, region });
+    const householdTypes = new Set(hh.types.map((t) => t.id));
+    const worlds = /* @__PURE__ */ new WeakMap();
+    const typeMap = mergeRegistry(TYPE_MAP, opts.typeMap);
+    const contentMap = mergeRegistry(CONTENT_MAP, opts.contentMap);
+    const contentByGroup = mergeRegistry(CONTENT_BY_GROUP, opts.contentByGroup);
+    const chairTables = mergeRegistry(CHAIR_TABLES, opts.chairTables);
+    const fixturesOfPoint = mergeRegistry(FIXTURES_OF_POINT, opts.fixturesOfPoint);
+    const substitutes = mergeRegistry(OBJECT_SUBSTITUTES, opts.substitutes);
+    const preference = mergeRegistry(PREFERENCE, opts.preference);
+    const ownTypes = mergeRegistry(OWN_TYPES, opts.ownTypes);
+    const frozenItems = new Set(opts.frozenItems ?? FROZEN_ITEMS);
+    const drawerItems = new Set(opts.drawerItems ?? DRAWER_ITEMS);
+    const chairSide = opts.chairSide ?? DINING_CHAIR_SIDE;
+    const contentFallback = opts.contentFallback ?? CONTENT_FALLBACK;
+    const seedKey = (id) => {
+      if (!opts.seedKey) return id;
+      const key = opts.seedKey(id);
+      return key == null ? id : key;
+    };
+    function conv(o) {
+      return {
+        x: (u) => r3(o.ox + u),
+        z: (v) => r3(o.oz + o.inw * v),
+        ry: (fu, fv) => r3(Math.atan2(fu, o.inw * fv)),
+        // local offset (lx, lz) of an object with rotation ry -> offset in the world (same convention as three.js)
+        off: (ry, lx, lz) => [Math.cos(ry) * lx + Math.sin(ry) * lz, -Math.sin(ry) * lx + Math.cos(ry) * lz]
+      };
+    }
+    function floorYOf(res, o, floor) {
+      if (floor == null || floor < 0) return o.base;
+      const f = (res.floors || []).find((x) => x.index === floor);
+      return r3(o.base + (f ? f.y0 : 0));
+    }
+    function colorOf(res, color) {
+      if (color == null) return void 0;
+      if (typeof color === "number") return color;
+      const v = res.colors && res.colors[color];
+      return typeof v === "number" ? v : void 0;
+    }
+    function paletteOf(res) {
+      const c = res.colors || {};
+      const p = {};
+      if (c.wood != null) p.wood = c.wood;
+      if (c.fabric_main != null) p.fabric_main = c.fabric_main;
+      if (c.fabric_accent != null) p.fabric_accent = c.fabric_accent;
+      if (c.metal != null) p.metal = c.metal;
+      return p;
+    }
+    function lightsOfState(res) {
+      const electrical = res.utilities && res.utilities.electrical;
+      return res.state !== "abandoned" && !!electrical && electrical.mode !== "offgrid";
+    }
+    function initialLight(res, popts, id, entry) {
+      const v = popts && popts.lightsOn;
+      if (typeof v === "function") return !!v(id, entry);
+      if (typeof v === "boolean") return v;
+      return !!(popts && popts.night) && lightsOfState(res);
+    }
+    const stackGroup = (s) => s.group ?? (opts.groupOf ? opts.groupOf(s.itemId) : null) ?? null;
+    const preferenceContext = {
+      frozen: (s) => frozenItems.has(s.itemId),
+      group: stackGroup,
+      drawerItem: (s) => drawerItems.has(s.itemId)
+    };
+    const itemOfContent = (c) => {
+      const id = contentMap[c.itemId] || (hh.items[c.itemId] ? c.itemId : null) || contentByGroup[stackGroup(c)] || contentFallback;
+      return hh.items[id] ? id : contentFallback;
+    };
+    const volume = (d) => d.size[0] * d.size[1] * d.size[2];
+    const candidates = (id, objectType) => {
+      const def = hh.items[id];
+      const siblings = Object.values(hh.items).filter((i) => i.category === def.category && i.id !== id).sort((a, b) => volume(a) - volume(b) || (a.id < b.id ? -1 : 1));
+      return [id].concat(siblings.map((i) => i.id), substitutes[objectType] || []);
+    };
+    function distribute(type, probeItem, stacks) {
+      const spec = hh.build(type, probeItem, HH.createRecorder().api);
+      const conts = spec.containers || [];
+      const contents = {};
+      for (const c of conts) contents[c.id] = c.slots.map(() => null);
+      const rejected = [];
+      const pref = preference[type];
+      for (const p of stacks || []) {
+        const original = itemOfContent(p);
+        const order = (pref ? pref(p, preferenceContext) : []).concat(conts.map((c) => c.id));
+        let placed = false;
+        for (const id of candidates(original, type)) {
+          const def = hh.items[id];
+          const qty = Math.max(1, Math.min(p.count || 1, def && def.stack || 1));
+          for (const cid of order) {
+            const c = conts.find((x) => x.id === cid);
+            if (!c) continue;
+            for (let i = 0; i < c.slots.length && !placed; i++) {
+              if (contents[cid][i] || !GI.fitsSlot(id, c.slots[i], hh.items)) continue;
+              const data = { source: p.itemId, group: p.group, pickable: p.pickable !== false };
+              if (id !== original) data.substituteFor = original;
+              contents[cid][i] = { type: id, qty, data };
+              placed = true;
+            }
+            if (placed) break;
+          }
+          if (placed) break;
+        }
+        if (!placed) rejected.push(p);
+      }
+      return { contents, rejected };
+    }
+    function plan(res, popts = {}) {
+      popts = popts || {};
+      const o = { ox: popts.originX || 0, oz: popts.originZ || 0, inw: popts.inw || 1, base: popts.base || 0 };
+      const K = conv(o);
+      const floorSel = popts.floor;
+      const externals = popts.externals !== false;
+      const seed = popts.seed != null ? popts.seed : res.seed;
+      const palette = paletteOf(res);
+      const onFloor = (f, outdoor) => floorSel == null || f === floorSel || (outdoor || f < 0) && externals;
+      const utilities = res.utilities || {};
+      const electrical = utilities.electrical || null;
+      const circuits = electrical && electrical.circuits || [];
+      const contents = res.contents || {};
+      const result = {
+        version: ADAPTER_VERSION,
+        template: res.template,
+        seed: res.seed,
+        floor: floorSel == null ? null : floorSel,
+        items: [],
+        outlets: [],
+        // ids of the wall_socket entries
+        switches: [],
+        // ids of the wall_switch entries
+        lights: [],
+        // ids of the lamps (inside and outside)
+        lanterns: [],
+        // ids of the lanterns (lantern_lamp): kerosene/gas light, no grid
+        canisters: [],
+        // ids of the small camping cylinders (gas_canister)
+        serviceEntrance: null,
+        panel: null,
+        // id of the electrical_panel entry (distribution board)
+        meter: null,
+        // id of the power_meter entry (meter box on the facade or the pillar)
+        conduits: [],
+        cylinders: [],
+        // { id, stove, place }
+        stoves: [],
+        fixtures: [],
+        // { object, fixture, global, point, pointKind }
+        points: {},
+        // global fixture -> point of the plumbing
+        mapped: [],
+        // ids of furniture of the plan that became objects of the kit (the renderer does not need to draw them)
+        chairs: [],
+        // ids of the chairs the adapter put around the tables (origin = the table, which the renderer keeps drawing)
+        unmapped: {},
+        // "category/type" -> count
+        discarded: 0,
+        // stacks of content that fit no slot
+        warnings: [],
+        origin: { x: o.ox, z: o.oz, inw: o.inw, base: o.base }
+      };
+      const byOrigin = /* @__PURE__ */ new Map();
+      const seedOf = (id) => GI.hashString(String(seed) + ":" + seedKey(id));
+      function push(e) {
+        result.items.push(e);
+        if (!byOrigin.has(e.origin)) byOrigin.set(e.origin, []);
+        byOrigin.get(e.origin).push(e);
+        return e;
+      }
+      function baseItem(m) {
+        const item = {
+          x: K.x(m.x),
+          z: K.z(m.z),
+          ry: m.frontU != null ? K.ry(m.frontU, m.frontV) : r3(m.ry || 0),
+          w: m.w,
+          d: m.d,
+          h: m.h,
+          y: m.y || 0,
+          seed: seedOf(m.id),
+          palette
+        };
+        const color = colorOf(res, m.color);
+        if (color != null) item.color = color;
+        return item;
+      }
+      function entry(id, type, item, origin, floor, extra) {
+        return Object.assign({ id, type, item, origin, floor, floorY: floorYOf(res, o, floor), connections: {} }, extra || {});
+      }
+      function store(targets, stacks) {
+        let rest = stacks || [];
+        for (const [type, item] of targets) {
+          const d = distribute(type, item, rest);
+          item.contents = Object.assign(item.contents || {}, d.contents);
+          rest = d.rejected;
+        }
+        result.discarded += rest.length;
+      }
+      const hidden = [];
+      function distRect(c, x, z) {
+        const dx = x - c.item.x;
+        const dz = z - c.item.z;
+        const s = Math.sin(c.item.ry);
+        const co = Math.cos(c.item.ry);
+        const lx = dx * co - dz * s;
+        const lz = dx * s + dz * co;
+        return Math.hypot(Math.max(Math.abs(lx) - (c.item.w || 0) / 2, 0), Math.max(Math.abs(lz) - (c.item.d || 0) / 2, 0));
+      }
+      function hideCylinders() {
+        for (const b of hidden) {
+          let target = null;
+          for (const c2 of result.items) {
+            if (c2.type !== "kitchen_cabinet_base" || c2.floor !== b.floor) continue;
+            const dist = distRect(c2, b.item.x, b.item.z);
+            if (!target || dist < target.dist) target = { c: c2, dist };
+          }
+          if (!target) {
+            result.warnings.push(msg("warn.cylinderNoCabinet", { id: b.id }));
+            continue;
+          }
+          const c = target.c;
+          const spec = hh.build(c.type, c.item, HH.createRecorder().api);
+          const sn = Math.sin(c.item.ry);
+          const cs = Math.cos(c.item.ry);
+          let door = null;
+          for (const it of spec.interactions || []) {
+            const pt = it.action && it.action.do === "toggle_part" ? (spec.parts || []).find((q) => q.id === it.action.part) : null;
+            if (!pt || pt.motion.kind !== "hinge") continue;
+            const wx = c.item.x + it.pos[0] * cs + it.pos[2] * sn;
+            const wz = c.item.z - it.pos[0] * sn + it.pos[2] * cs;
+            const dist = Math.hypot(wx - b.item.x, wz - b.item.z);
+            if (!door || dist < door.dist) door = { id: pt.id, dist };
+          }
+          if (!door) {
+            result.warnings.push(msg("warn.cabinetNoDoor", { cabinet: c.id, id: b.id }));
+            continue;
+          }
+          b.item.requires = { object: c.id, part: door.id };
+        }
+      }
+      function initialLanternLight(id, e) {
+        const v = popts.lightsOn;
+        if (typeof v === "function") return !!v(id, e);
+        if (typeof v === "boolean") return v;
+        return !!popts.night && res.state !== "abandoned";
+      }
+      const chimney = res.structureExtras && res.structureExtras.chimney || null;
+      const firstOfType = (type) => (res.items || []).find((m) => typeMap[m.type] && typeMap[m.type].type === type);
+      function chimneyOf(m, role) {
+        if (!chimney) return null;
+        const named = role === "fireplace" ? chimney.fireplace : chimney.stove;
+        if (named != null) return named === m.id ? chimney : null;
+        const first = firstOfType(role === "fireplace" ? "fireplace" : "wood_stove");
+        return chimney.kind === (role === "fireplace" ? "fireplace" : "flue") && first && first.id === m.id ? chimney : null;
+      }
+      const chimneyHeight = (ch) => ch.height != null ? ch.height : ch.top;
+      const campStove = firstOfType("camp_stove");
+      const campCylinder = firstOfType("gas_canister");
+      function planFireplace(m, e, item) {
+        const def = hh.types.find((t) => t.id === "fireplace");
+        const lack = (def.d - m.d) / 2;
+        item.x = r3(item.x + Math.sin(item.ry) * lack);
+        item.z = r3(item.z + Math.cos(item.ry) * lack);
+        const room = (res.rooms || []).find((c) => c.id === m.room && c.floor === m.floor);
+        const f = (res.floors || []).find((x) => x.index === m.floor);
+        item.h = r3(room && room.ceiling || f && f.ceiling || 2.6);
+        const ch = chimneyOf(m, "fireplace");
+        if (ch) {
+          if (ch.material === "stone") item.variant = "stone";
+          const cx = K.x((ch.aabb[0] + ch.aabb[2]) / 2);
+          const cz = K.z((ch.aabb[1] + ch.aabb[3]) / 2);
+          e.connections.chimneyTop = [cx, r3(o.base + chimneyHeight(ch)), cz];
+        }
+      }
+      function planSimple(m, map) {
+        const item = baseItem(m);
+        const dim = map.dim === "none" ? "" : map.dim || "wdh";
+        for (const k of ["w", "d", "h"]) if (dim.indexOf(k) < 0) delete item[k];
+        if (map.dim === "none") delete item.y;
+        if (map.variant) item.variant = map.variant;
+        if (map.type === "tv") item.d = Math.max(item.d || 0, 0.2);
+        const e = entry(m.id, map.type, item, m.id, m.floor);
+        if (contents[m.id]) store([[map.type, item]], contents[m.id]);
+        if (m.outlet) e.connections.outlet = m.outlet;
+        if (map.type === "shower") e.connections.shower = m.showerHeater || { electric: false };
+        if (map.type === "stove") {
+          result.stoves.push(e.id);
+          e.connections.gas = m.gas || "cylinder";
+          e.connections.cylinder = m.cylinder || null;
+        }
+        if (map.type === "gas_bottle") result.cylinders.push({ id: e.id, stove: m.link || null, place: m.placement || null });
+        if (map.type === "gas_canister") {
+          result.canisters.push(e.id);
+          if (campCylinder && campCylinder.id === m.id && campStove) result.cylinders.push({ id: e.id, stove: campStove.id, place: null });
+        }
+        if (map.type === "wood_stove") {
+          const ch = chimneyOf(m, "stove");
+          if (ch && chimneyHeight(ch)) {
+            const f = (res.floors || []).find((x) => x.index === m.floor);
+            const high = r3(chimneyHeight(ch) - (f ? f.y0 : 0) - (m.y || 0));
+            item.h = high;
+            item.flueHeight = high;
+          }
+        }
+        if (map.type === "fireplace") planFireplace(m, e, item);
+        if (map.type === "lantern_lamp") {
+          e.lit = initialLanternLight(m.id, e);
+          item.on = e.lit;
+          result.lanterns.push(e.id);
+        }
+        if (map.type === "gas_bottle" && m.placement === "under_counter") hidden.push(e);
+        push(e);
+      }
+      function planCompound(m, kind) {
+        const ry = m.frontU != null ? K.ry(m.frontU, m.frontV) : r3(m.ry || 0);
+        const cx = K.x(m.x);
+        const cz = K.z(m.z);
+        const part = (id, type, w, d, h, y, lx, lz) => {
+          const [dx, dz] = K.off(ry, lx, lz);
+          const item = baseItem(m);
+          item.x = r3(cx + dx);
+          item.z = r3(cz + dz);
+          item.ry = ry;
+          item.w = r3(w);
+          item.d = r3(d);
+          item.h = r3(h);
+          item.y = y;
+          item.seed = seedOf(id);
+          return entry(id, type, item, m.id, m.floor);
+        };
+        const list = [];
+        const overhead = contents[m.id + "#overhead"];
+        if (kind === "rustic_sink") {
+          const dd = Math.max(m.d, 0.56);
+          const basin = part(m.id, "sink_kitchen", m.w, dd, m.h + 0.3, 0, 0, -(dd - m.d) / 2);
+          list.push(basin);
+          const over = overhead || [];
+          if (m.overhead !== false && over.length) {
+            const wall = part(m.id + "#overhead", "kitchen_cabinet_wall", m.w, 0.35, 0.6, 1.55, 0, -(m.d / 2) + 0.175);
+            store([["kitchen_cabinet_wall", wall.item]], over);
+            list.push(wall);
+          }
+          if (contents[m.id]) store([["sink_kitchen", basin.item]], contents[m.id]);
+          if (m.outlet) basin.connections.outlet = m.outlet;
+        } else if (kind === "sink") {
+          const width = m.w;
+          const basinW = width >= 1.5 ? 1 : Math.max(0.6, Math.min(0.8, width - 0.3));
+          const rest = r3(width - basinW);
+          const left = seedOf(m.id) % 2 === 0;
+          const sink = part(m.id, "sink_kitchen", basinW, m.d, m.h + 0.25, 0, left ? -(width / 2) + basinW / 2 : width / 2 - basinW / 2, 0);
+          list.push(sink);
+          let cabinet = null;
+          if (rest >= 0.35) {
+            cabinet = part(m.id + "#cabinet", "kitchen_cabinet_base", rest, m.d, m.h, 0, left ? width / 2 - rest / 2 : -(width / 2) + rest / 2, 0);
+            list.push(cabinet);
+          }
+          if (contents[m.id]) store(cabinet ? [["kitchen_cabinet_base", cabinet.item], ["sink_kitchen", sink.item]] : [["sink_kitchen", sink.item]], contents[m.id]);
+          if (m.overhead !== false) {
+            const wall = part(m.id + "#overhead", "kitchen_cabinet_wall", width, 0.35, 0.6, 1.55, 0, -(m.d / 2) + 0.175);
+            store([["kitchen_cabinet_wall", wall.item]], overhead || []);
+            list.push(wall);
+          }
+          if (m.outlet) sink.connections.outlet = m.outlet;
+        } else {
+          const basin = part(m.id, "sink_bathroom", m.w, m.d, m.h + 0.2, 0, 0, 0);
+          list.push(basin);
+          if (contents[m.id]) {
+            if (contents[m.id].length) {
+              const cabinet = part(m.id + "#cabinet", "bathroom_cabinet", Math.max(0.45, Math.min(0.6, m.w)), 0.15, 0.75, 1.3, 0, -(m.d / 2) + 0.075);
+              list.push(cabinet);
+              store([["bathroom_cabinet", cabinet.item], ["sink_bathroom", basin.item]], contents[m.id]);
+            } else {
+              store([["sink_bathroom", basin.item]], []);
+            }
+          }
+        }
+        for (const e of list) push(e);
+      }
+      function circuitOfLight(id) {
+        const direct = circuits.find((c) => (c.lamps || []).indexOf(id) >= 0);
+        if (direct) return direct.id;
+        const sw = (electrical && electrical.switches || []).find((s) => (s.controls || []).indexOf(id) >= 0);
+        const viaSwitch = sw && circuits.find((c) => (c.switches || []).indexOf(sw.id) >= 0);
+        return viaSwitch ? viaSwitch.id : "standalone_circuit";
+      }
+      function planLamp(m, map) {
+        const item = baseItem(m);
+        delete item.palette;
+        const e = entry(m.id, "lamp", item, m.id, m.floor, { watts: map.watts });
+        e.connections.circuit = circuitOfLight(m.id);
+        e.lit = initialLight(res, popts, m.id, e);
+        push(e);
+        result.lights.push(e.id);
+      }
+      for (const m of res.items || []) {
+        if (!onFloor(m.floor, m.outdoor)) continue;
+        const map = typeMap[m.type];
+        if (!map) {
+          const k = m.category + "/" + m.type;
+          result.unmapped[k] = (result.unmapped[k] || 0) + 1;
+          continue;
+        }
+        result.mapped.push(m.id);
+        if (map.type === "lamp") planLamp(m, map);
+        else if (map.compound) planCompound(m, map.compound);
+        else planSimple(m, map);
+      }
+      result.chairs = [];
+      if (opts.chairs !== false && popts.chairs !== false) {
+        const blocked = blockedOf(res, { originX: o.ox, originZ: o.oz, inw: o.inw });
+        const floorKind = (q) => !q.decor && !q.flat && (q.y || 0) < 0.9 && q.aabb;
+        const placed = [];
+        const free = (m, cu, cv, half) => {
+          const a = [cu - half + 0.03, cv - half + 0.03, cu + half - 0.03, cv + half - 0.03];
+          for (const [dx, dz] of [[-1, -1], [1, -1], [-1, 1], [1, 1], [0, 0]]) if (blocked(K.x(cu + dx * half * 0.9), K.z(cv + dz * half * 0.9), m.floor)) return false;
+          for (const q of res.items || []) {
+            if (q === m || !floorKind(q) || q.floor !== m.floor && !(q.outdoor && m.outdoor)) continue;
+            if (a[0] < q.aabb[2] && a[2] > q.aabb[0] && a[1] < q.aabb[3] && a[3] > q.aabb[1]) return false;
+          }
+          for (const c of placed) if (a[0] < c[2] && a[2] > c[0] && a[1] < c[3] && a[3] > c[1] && c[4] === m.floor) return false;
+          placed.push([a[0], a[1], a[2], a[3], m.floor]);
+          return true;
+        };
+        for (const m of res.items || []) {
+          const mode = chairTables[m.type];
+          if (!mode || !onFloor(m.floor, m.outdoor) || m.frontU == null) continue;
+          const f = [m.frontU, m.frontV];
+          const pp = [-m.frontV, m.frontU];
+          const seats = [];
+          if (mode === "dining") {
+            const n = Math.max(1, Math.min(3, Math.floor((m.w - 0.1) / 0.55)));
+            for (const side of [1, -1]) {
+              for (let i = 0; i < n; i++) seats.push([(i - (n - 1) / 2) * (m.w / n), side * (m.d / 2 + 0.17), [-side * f[0], -side * f[1]]]);
+            }
+            if (m.w >= 1.6) for (const side of [1, -1]) seats.push([side * (m.w / 2 + 0.17), 0, [-side * pp[0], -side * pp[1]]]);
+          } else {
+            seats.push([0, m.d / 2 + 0.2, [-f[0], -f[1]]]);
+          }
+          seats.forEach((lg, i) => {
+            const cu = r3(m.x + pp[0] * lg[0] + f[0] * lg[1]);
+            const cv = r3(m.z + pp[1] * lg[0] + f[1] * lg[1]);
+            const half = mode === "dining" ? chairSide / 2 : 0.3;
+            if (!free(m, cu, cv, half)) return;
+            const id = m.id + "#chair" + (i + 1);
+            const item = { x: K.x(cu), z: K.z(cv), ry: K.ry(lg[2][0], lg[2][1]), seed: seedOf(id), palette };
+            if (mode !== "dining") {
+              item.w = 0.6;
+              item.d = 0.6;
+              item.h = 0.95;
+            }
+            const e = push(entry(id, mode === "dining" ? "dining_chair" : "armchair", item, m.id, m.floor));
+            result.chairs.push(e.id);
+          });
+        }
+      }
+      function conduit(id, pts, floor) {
+        const x0 = K.x(pts[0][0]);
+        const z0 = K.z(pts[0][1]);
+        const item = {
+          x: x0,
+          z: z0,
+          ry: 0,
+          seed: seedOf(id),
+          // the points of the plan already have the absolute y of the world: the object stays on the base ground and not on the floor of the storey
+          points: pts.map((p) => [r3(K.x(p[0]) - x0), p[2], r3(K.z(p[1]) - z0)])
+        };
+        const e = entry(id, "conduit_run", item, id, floor);
+        e.floorY = o.base;
+        push(e);
+        result.conduits.push(e.id);
+      }
+      if (electrical) {
+        for (const l of electrical.outdoorLamps || []) {
+          if (!onFloor(-1, true)) continue;
+          const e = entry(l.id, "lamp", { x: K.x(l.u), z: K.z(l.v), ry: 0, y: l.y, seed: seedOf(l.id) }, l.id, -1, { watts: 15 });
+          e.connections.circuit = circuitOfLight(l.id);
+          e.lit = initialLight(res, popts, l.id, e);
+          push(e);
+          result.lights.push(e.id);
+        }
+        for (const t of electrical.outlets || []) {
+          if (!onFloor(t.floor, false)) continue;
+          const c = circuits.find((x) => (x.outlets || []).indexOf(t.id) >= 0);
+          const item = { x: K.x(t.u), z: K.z(t.v), ry: K.ry(t.frontU, t.frontV), y: t.y, seed: seedOf(t.id) };
+          if (c) item.circuit = c.id;
+          const e = entry(t.id, "wall_socket", item, t.id, t.floor);
+          e.connections.circuit = c ? c.id : null;
+          push(e);
+          result.outlets.push(e.id);
+        }
+        const lights = new Set(result.lights);
+        for (const s of electrical.switches || []) {
+          if (!onFloor(s.floor, false)) continue;
+          const item = { x: K.x(s.u), z: K.z(s.v), ry: K.ry(s.frontU, s.frontV), y: s.y, seed: seedOf(s.id) };
+          item.controls = (s.controls || []).map((id) => id + ":lamp");
+          const e = entry(s.id, "wall_switch", item, s.id, s.floor);
+          e.connections.controls = (s.controls || []).slice();
+          e.lit = e.connections.controls.some((id) => (result.items.find((x) => x.id === id) || {}).lit === true);
+          if (floorSel == null) {
+            for (const id of s.controls || []) if (!lights.has(id)) result.warnings.push(msg("warn.switchUnknownLamp", { id: s.id, lamp: id }));
+          }
+          push(e);
+          result.switches.push(e.id);
+        }
+        const ee = electrical.serviceEntrance;
+        if (ee && ee.pole && onFloor(-1, true)) {
+          const drop = ee.drop || [];
+          const end = drop.length ? drop[drop.length - 1] : [ee.pole.u, ee.pole.v, 2.6];
+          const px = K.x(ee.pole.u);
+          const pz = K.z(ee.pole.v);
+          const item = {
+            x: px,
+            z: pz,
+            ry: 0,
+            h: ee.pole.h,
+            seed: seedOf("service_entrance"),
+            // point where the drop reaches the house, in local coordinates of the pole (absolute y)
+            house: [r3(K.x(end[0]) - px), end[2], r3(K.z(end[1]) - pz)]
+          };
+          if (ee.tap || electrical.mode === "tap") item.variant = "gato";
+          const e = entry("service_entrance", "service_entrance", item, "service_entrance", -1);
+          push(e);
+          result.serviceEntrance = e.id;
+          if (ee.descent && ee.descent.length > 1) conduit("conduit_descent", ee.descent, -1);
+        }
+        const q = electrical.panel;
+        if (q && onFloor(q.floor, false)) {
+          const hdq = 0.06;
+          const ryq = K.ry(q.frontU, q.frontV);
+          const item = {
+            x: r3(K.x(q.u) + Math.sin(ryq) * hdq),
+            z: r3(K.z(q.v) + Math.cos(ryq) * hdq),
+            ry: ryq,
+            y: q.y,
+            seed: seedOf("panel"),
+            circuits: circuits.map((c) => ({ id: c.id, label: c.room }))
+          };
+          if (!item.circuits.length) delete item.circuits;
+          const e = entry("panel", "electrical_panel", item, "panel", q.floor);
+          push(e);
+          result.panel = e.id;
+        }
+        const med = ee && ee.meter;
+        if (med && onFloor(-1, true)) {
+          const hdm = 0.08;
+          const item = { x: K.x(med.u), z: r3(K.z(med.v) - o.inw * hdm), ry: K.ry(0, -1), y: med.y, seed: seedOf("meter") };
+          const e = entry("meter", "power_meter", item, "meter", -1);
+          push(e);
+          result.meter = e.id;
+        }
+        for (const ed of electrical.conduits || []) {
+          if (!ed.exposed || !ed.points || ed.points.length < 2) continue;
+          const circ = circuits.find((c) => c.id === ed.circuit);
+          const floor = circ ? circ.floor : 0;
+          if (!onFloor(floor, false)) continue;
+          conduit(ed.id, ed.points, floor);
+        }
+      }
+      const piped = result.items.filter((e) => e.type === "stove" && e.connections.gas === "piped");
+      if (piped.length) {
+        const med = utilities.gas && utilities.gas.meter;
+        const ref = med ? { x: K.x(med.u), z: K.z(med.v), y: med.y || 1 } : { x: piped[0].item.x, z: piped[0].item.z, y: 0.3 };
+        const e = entry("piped_gas", "gas_piped", { x: ref.x, z: ref.z, ry: 0, y: ref.y, seed: seedOf("piped_gas") }, "piped_gas", piped[0].floor);
+        e.floorY = o.base;
+        push(e);
+        for (const f of piped) f.connections.fuel = "piped_gas:gas";
+      }
+      for (const b of result.cylinders) {
+        const stove = result.items.find((e) => e.id === b.stove);
+        if (stove) stove.connections.fuel = b.id + ":gas";
+      }
+      const plumbing = utilities.plumbing;
+      if (plumbing) {
+        const isCabinet = (t) => t === "kitchen_cabinet_base" || t === "kitchen_cabinet_wall" || t === "bathroom_cabinet";
+        for (const p of plumbing.points || []) {
+          const target = (byOrigin.get(p.item) || []).filter((e) => !isCabinet(e.type))[0];
+          if (!target) {
+            if (floorSel == null) result.warnings.push(msg("warn.pointNoObject", { id: p.id, kind: p.kind, item: p.item }));
+            continue;
+          }
+          target.point = p.id;
+          target.connections.flowLpm = p.flowLpm;
+          for (const f of fixturesOfPoint[p.kind] || []) {
+            result.fixtures.push({ object: target.id, fixture: f, global: target.id + ":" + f, point: p.id, pointKind: p.kind });
+            result.points[target.id + ":" + f] = p.id;
+          }
+        }
+      }
+      hideCylinders();
+      return result;
+    }
+    function ownSpec(entry) {
+      if (entry.type === "lamp") {
+        const dev = { id: "lamp", kind: "lamp", watts: entry.watts || 15, on: !!entry.lit };
+        if (entry.connections.circuit) dev.circuit = entry.connections.circuit;
+        return { type: "lamp", devices: [dev] };
+      }
+      if (entry.type === "gas_piped") return { type: "gas_piped", fuels: [{ id: "gas", kind: "gas", capacity: 1e3, level: 1e3 }] };
+      throw new Error(msg("error.unknownOwnType", { type: entry.type }));
+    }
+    function connect(entry, spec) {
+      const L = entry.connections || {};
+      if (entry.type === "wall_switch") {
+        for (const p of spec.parts || []) if (p.id === "rocker") p.t0 = entry.lit ? 1 : 0;
+      }
+      if (entry.type !== "shower") {
+        for (const dv of spec.devices || []) if (L.outlet && dv.socket === "auto") dv.socket = L.outlet + ":socket";
+      } else {
+        const sh = L.shower || {};
+        const heater = (spec.devices || []).find((d) => d.id === "heater");
+        if (heater && sh.electric === false) {
+          spec.devices = spec.devices.filter((d) => d !== heater);
+          for (const f of spec.fixtures || []) if (f.heater === "heater") delete f.heater;
+        } else if (heater) {
+          if (sh.powerW) heater.watts = sh.powerW;
+          if (L.outletCircuit) heater.circuit = L.outletCircuit;
+        }
+      }
+      if ((entry.type === "stove" || entry.type === "camp_stove") && L.fuel) {
+        for (const b of spec.burners || []) if (b.fuel === "auto") b.fuel = L.fuel;
+      }
+      if (entry.type === "fireplace" && L.chimneyTop) {
+        const it = entry.item;
+        const dx = L.chimneyTop[0] - it.x;
+        const dz = L.chimneyTop[2] - it.z;
+        const lx = Math.cos(it.ry) * dx - Math.sin(it.ry) * dz;
+        const lz = Math.sin(it.ry) * dx + Math.cos(it.ry) * dz;
+        for (const em of spec.emitters || []) if (em.kind === "smoke") em.pos = [r3(lx), r3(L.chimneyTop[1] - entry.floorY + 0.02), r3(lz)];
+      }
+      if (entry.type === "washing_machine" && entry.point) {
+        spec.fixtures = spec.fixtures || [];
+        const inlet = spec.fixtures.find((f) => f.id === "inlet");
+        if (inlet) {
+          if (L.flowLpm) inlet.flow = L.flowLpm;
+          inlet.tank = "auto";
+        } else {
+          spec.fixtures.push({ id: "inlet", kind: "hose", outlet: [0, 0.3, -(entry.item.d || 0.6) / 2], flow: L.flowLpm || 8, tank: "auto" });
+        }
+      }
+      return spec;
+    }
+    function createWorld(res, copts = {}) {
+      copts = copts || {};
+      const info = { points: /* @__PURE__ */ new Map(), water: copts.water || null, lightsOn: copts.lightsOn };
+      const electrical = res.utilities && res.utilities.electrical;
+      const world = GI.createWorld({
+        locale,
+        strings: hh.strings,
+        items: hh.items,
+        loot: hh.loot,
+        seed: copts.seed != null ? copts.seed : res.seed,
+        // no grid: the cabin and the off-grid campsite have no service entrance, sockets or electric lamps (lanterns do not need a grid)
+        grid: copts.grid != null ? !!copts.grid : !!electrical && electrical.mode !== "offgrid",
+        onEvent: copts.onEvent,
+        canInteract: copts.canInteract,
+        waterSupply: {
+          draw(fixtureId, l) {
+            if (!info.water) return l;
+            const point = info.points.get(fixtureId);
+            return point == null ? l : info.water.consume(point, l);
+          }
+        }
+      });
+      worlds.set(world, info);
+      return world;
+    }
+    function pointOf(world, fixtureId) {
+      const info = worlds.get(world);
+      return info ? info.points.get(fixtureId) : void 0;
+    }
+    function blockedOf(res, bopts = {}) {
+      bopts = bopts || {};
+      const ox = bopts.originX || 0;
+      const oz = bopts.originZ || 0;
+      const inw = bopts.inw || 1;
+      const margin = bopts.margin != null ? bopts.margin : 0.02;
+      const segs = (res.walls || []).map((p) => {
+        const e = Math.max(0, p.thickness / 2 - margin);
+        const u0 = Math.min(p.u0, p.u1) - (p.axis === "u" ? 0 : e);
+        const u1 = Math.max(p.u0, p.u1) + (p.axis === "u" ? 0 : e);
+        const v0 = Math.min(p.v0, p.v1) - (p.axis === "v" ? 0 : e);
+        const v1 = Math.max(p.v0, p.v1) + (p.axis === "v" ? 0 : e);
+        const za = oz + inw * v0;
+        const zb = oz + inw * v1;
+        return { floor: p.floor, x0: ox + u0, x1: ox + u1, z0: Math.min(za, zb), z1: Math.max(za, zb) };
+      });
+      const CELL = 0.5;
+      const grid = /* @__PURE__ */ new Map();
+      const key = (a, i, j) => (a * 4096 + (i + 2048)) * 4096 + (j + 2048);
+      for (const s of segs) {
+        for (let i = Math.floor(s.x0 / CELL); i <= Math.floor(s.x1 / CELL); i++) {
+          for (let j = Math.floor(s.z0 / CELL); j <= Math.floor(s.z1 / CELL); j++) {
+            const k = key(s.floor, i, j);
+            if (!grid.has(k)) grid.set(k, []);
+            grid.get(k).push(s);
+          }
+        }
+      }
+      return function blocked(x, z, floor) {
+        const a = floor == null || floor < 0 ? 0 : floor;
+        const list = grid.get(key(a, Math.floor(x / CELL), Math.floor(z / CELL)));
+        if (!list) return false;
+        for (const s of list) if (x > s.x0 && x < s.x1 && z > s.z0 && z < s.z1) return true;
+        return false;
+      };
+    }
+    function add(world, planned, aopts = {}) {
+      aopts = aopts || {};
+      const info = worlds.get(world);
+      const build = aopts.build || ((type, item) => hh.build(type, item, HH.createRecorder().api));
+      const isBlocked = aopts.isBlocked || null;
+      const out = { added: 0, parts: [], hinges: {}, moved: {}, warnings: [] };
+      const override = aopts.lightsOn !== void 0 ? aopts.lightsOn : info && info.lightsOn;
+      if (override !== void 0) {
+        for (const e of planned.items) if (e.type === "lamp") e.lit = typeof override === "function" ? !!override(e.id, e) : !!override;
+        for (const e of planned.items) if (e.type === "lantern_lamp") e.lit = typeof override === "function" ? !!override(e.id, e) : !!override;
+        for (const e of planned.items) if (e.type === "wall_switch") e.lit = (e.connections.controls || []).some((id) => (planned.items.find((x) => x.id === id) || {}).lit === true);
+      }
+      for (const e of planned.items) if (e.type === "lantern_lamp") e.item.on = !!e.lit;
+      let scratch = null;
+      function probe(e, hinge, setback) {
+        if (!scratch) scratch = GI.createWorld({ locale, strings: hh.strings, items: hh.items, loot: hh.loot, grid: false });
+        const it = e.item;
+        const x = it.x + Math.sin(it.ry) * setback;
+        const z = it.z + Math.cos(it.ry) * setback;
+        const spec = hh.build(e.type, Object.assign({}, it, { hinge }), HH.createRecorder().api);
+        scratch.add("__probe", spec, { x, y: e.floorY, z, ry: it.ry });
+        const blocks = (px, pz) => isBlocked(px, pz, e.floor);
+        let sum = 0;
+        let min = 1;
+        let n = 0;
+        for (const p of spec.parts || []) {
+          if (p.motion.kind !== "hinge" || !(p.bounds || p.sweep)) continue;
+          const t = scratch.fitSweep("__probe", p.id, blocks);
+          sum += t;
+          min = Math.min(min, t);
+          n++;
+        }
+        scratch.remove("__probe");
+        return { sum, min, n };
+      }
+      const better = (a, b) => a.sum > b.sum + 1e-9 || Math.abs(a.sum - b.sum) <= 1e-9 && a.min > b.min + 1e-9;
+      function fitDoors(e) {
+        if (!isBlocked || !householdTypes.has(e.type)) return;
+        const standard = probe(e, void 0, 0);
+        if (!standard.n || standard.min >= 1) return;
+        let bestSide;
+        let m = standard;
+        for (const side of ["left", "right"]) {
+          const r = probe(e, side, 0);
+          if (better(r, m)) {
+            m = r;
+            bestSide = side;
+          }
+        }
+        if (bestSide) {
+          e.item.hinge = bestSide;
+          out.hinges[e.id] = bestSide;
+        }
+        if (m.min >= 1) return;
+        let target = { setback: 0, r: m };
+        for (const setback of [0.01, 0.02, 0.03, 0.04]) {
+          const r = probe(e, bestSide, setback);
+          if (better(r, target.r)) target = { setback, r };
+          if (r.min >= 1) break;
+        }
+        if (target.setback > 0 && target.r.sum > m.sum + 0.2) {
+          e.item.x = r3(e.item.x + Math.sin(e.item.ry) * target.setback);
+          e.item.z = r3(e.item.z + Math.cos(e.item.ry) * target.setback);
+          e.moved = target.setback;
+          out.moved[e.id] = target.setback;
+        }
+      }
+      for (const e of planned.items) {
+        if (e.type !== "shower" || !e.connections.outlet) continue;
+        const t = planned.items.find((x) => x.id === e.connections.outlet);
+        if (t && t.connections.circuit) e.connections.outletCircuit = t.connections.circuit;
+      }
+      for (const e of planned.items) {
+        let spec;
+        if (ownTypes[e.type]) {
+          spec = ownSpec(e);
+        } else {
+          fitDoors(e);
+          spec = build(e.type, e.item);
+          if (!spec) {
+            out.warnings.push(msg("warn.buildEmpty", { id: e.id }));
+            continue;
+          }
+        }
+        connect(e, spec);
+        world.add(e.id, spec, { x: e.item.x, y: e.floorY, z: e.item.z, ry: e.item.ry });
+        out.added++;
+        if (!isBlocked) continue;
+        for (const p of spec.parts || []) {
+          if (!(p.bounds || p.sweep)) continue;
+          const t = world.fitSweep(e.id, p.id, (x, z) => isBlocked(x, z, e.floor));
+          if (t < 1) out.parts.push({ object: e.id, part: p.id, t });
+        }
+      }
+      if (info) for (const f of planned.fixtures) info.points.set(f.global, f.point);
+      return out;
+    }
+    return { version: ADAPTER_VERSION, household: hh, plan, createWorld, add, blockedOf, pointOf, ownSpec, registries: { typeMap, contentMap, contentByGroup, chairTables, fixturesOfPoint, substitutes, preference, ownTypes } };
+  }
+
+  // src/index.ts
+  var FloorplanInteractables = { version: ADAPTER_VERSION, create, TYPE_MAP, CONTENT_MAP, CONTENT_BY_GROUP, CHAIR_TABLES, PREFERENCE, mergeRegistry };
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map